CPANscan

OpenSearch::Client::Hash is a compact helper for generating password hashes that are directly compatible with the OpenSearch security plugin, offering BCrypt, Argon2 and PBKDF2 output formats. It exposes simple methods to derive a hash from a plaintext password and lets you adjust parameters so the output matches your OpenSearch configuration, for example bcrypt minor/version and rounds, Argon2 type, memory, iterations and key length, and PBKDF2 function, length and iterations. Use it when you need to create hashed passwords to store in OpenSearch user records instead of keeping plaintext credentials. Be aware that generated hashes must match your cluster's security settings to be accepted, for example bcrypt passwords are limited to 72 characters and cannot include null bytes, and Argon2 or PBKDF2 hashes require the corresponding algorithm and version settings. This initial release adds support for all three hashing schemes.

Map::Tube::Plugin::FuzzyFind is a small add-on for Map::Tube that makes it easy to locate tube stations or lines even when the user types partial, misspelled, or phonetically similar names. It installs as a Moo role into Map::Tube::* classes and exposes a fuzzy_find method that accepts a search pattern and options to target lines or stations, pick matching strategies and limit results. Multiple matching algorithms are supported, from simple exact, starts-with and substring tests to regexes, phonetic encodings (Soundex, Metaphone, Koeln, Daitch‑Motokoff), trigram comparisons and edit distances like Levenshtein and Jaro‑Winkler, and results are returned as Map::Tube Line or Node objects ordered by similarity when applicable. You can control how loose the match should be, cap the number of results, and use scalar or list context to get one or many matches. If you build search features or user interfaces around Map::Tube and need tolerant, user-friendly name lookup, this module is a direct, drop-in solution. A recent update added a list_fuzzy_matchers method to show available algorithms and made minor documentation improvements.

EV::ClickHouse is an asynchronous ClickHouse client for Perl that plugs into the EV event loop and implements both the HTTP and native TCP protocols in XS so you do not need an external ClickHouse client library. It gives you TLS, gzip and LZ4 compression, parameterized queries, external in-memory tables, streaming result blocks and safe inserts including nested types on the native wire, plus convenience helpers for idempotent, async and batched inserts and an insert_streamer optimized for ETL. The client offers URI-based connections, auto-reconnect with exponential backoff, multi-host failover, keepalive pings, per-query and connection-level settings, progress and query-complete hooks, and a built-in connection pool with hedged and fan-out query modes for lower tail latency. It decodes a wide range of ClickHouse types with opt-in decoding for DateTime, Decimal and Enum and supports named-row mode, a synchronous-feeling iterate pull over streaming results, health probes, schema introspection and mutation waiting helpers. Requires Perl 5.14+, EV and zlib, with optional OpenSSL and liblz4, and notes that DNS resolution is blocking unless EV::cares is installed, making this a strong choice for high-throughput, evented ClickHouse access from Perl for ingestion, exports, dashboards and ETL.

File::ContentStore provides a content-addressable file store that saves space by turning files with identical contents into hard links named by their content digest, making it easy to deduplicate large collections such as photos or backups. You create a store pointing at an existing directory and then call link_file or link_dir to have files hashed and hard linked into the store; duplicates are made to share the same inode so disk usage is reduced and changes to one aliased file affect all aliases. The module uses a configurable digest algorithm, splits digest names into subdirectories for scalability, and defaults to checking for collisions and making content files read only to avoid accidental modification. It only links files on the same filesystem and offers a file_callback hook for progress reporting and an fsck method to find empty dirs, orphaned content, corrupted files and symlinks. If you only need a one-time dedupe you can remove the store after linking, or keep it for incremental deduplication over time.

GraphQL::Houtou is an XS-backed GraphQL parser and high-performance execution toolkit for Perl that gives you a canonical Perl AST and a native VM for running compiled query programs. It is designed for real web apps and makes batching simple with a bundled DataLoader and an on_stall hook that collapses N+1 database lookups while still returning a synchronous response to callers. You can render responses directly as UTF-8 JSON bytes inside the XS lane to avoid building Perl data structures, expose a one-line PSGI endpoint with optional GraphiQL, and create persisted artifacts for maximum throughput either as fixed native bundles or as compiled programs for variable-bearing queries. Runtimes can be built for async promise-based resolvers or for a strict synchronous fast lane and include configurable cost limits and program caching for production safety. The module focuses on throughput and efficiency and reports large benchmark gains over pure Perl implementations. Current limitations in the 0.01 profile include no subscription execution or streaming transports, only POST for the PSGI adapter, recognition of only Promise::XS promises, fixed native bundles not supporting GraphQL variables, and no support for Perl ithreads, so use process-based concurrency for parallelism.

Tstregex is a compact Perl module and command-line utility for debugging regular expressions by finding the longest partial match and pinpointing the exact token and character where a pattern stops matching. It pre-parses common regex delimiters and modifiers, then uses a "nibbling" strategy to decompose your pattern and iteratively test sub-patterns so it can display the matching portion, the failing token, and a visual marker aligned with the regex. The CLI offers a diagnostic mode that highlights the rejected substring and reports execution time to help spot pathological backtracking or ReDoS issues, while the library API (tstregex_init_desc, tstregex, and accessors for match length and fail token) makes it easy to integrate into scripts or test harnesses. The module is cross-platform and was cleaned up for production use; recent updates removed an internal debug helper in favor of a separate Devel::perlXdb extension. Licensed under Artistic 2, Tstregex is useful for developers who want a lightweight, automated way to understand why a Perl regex fails without stepping through the engine by hand.

EV::Nats is an asynchronous, high-performance NATS client for Perl that hooks into the EV event loop and implements the protocol in XS with no external C library dependency. It provides the full NATS feature set including publish and headered publish, subscribe with wildcards and queue groups, request/reply with automatic inboxes, automatic reconnect with state restoration, TCP and Unix sockets, optional TLS and NKey/JWT auth when built with OpenSSL, and helpers for batching, graceful drain, and per-connection stats. The implementation focuses on throughput and low overhead with write coalescing and allocation-free publish paths, and higher-level integrations are available for JetStream, Key-Value and ObjectStore. Note the module uses blocking DNS resolution via getaddrinfo for name lookups and you must not let the EV::Nats object be destroyed while a callback is still running. If you want a fast, event-driven NATS client in Perl for high-throughput or low-latency messaging, EV::Nats is a strong choice.

Data::Deque::Shared provides a high-performance, lock-free double-ended queue implemented in shared memory for Linux and designed for multi-producer, multi-consumer workloads. It comes in two concrete flavors: an Int variant for 64-bit integers and a Str variant that stores fixed-size byte/UTF-8 slots, and supports anonymous, file-backed or memfd-backed mappings so different processes can attach to the same queue. Operations include non-blocking push/pop at both ends plus blocking variants with timeouts, and the implementation uses futexes and atomic CAS updates to avoid heavyweight locks while still offering safe concurrency and real-world robustness. The module exposes size and capacity, per-queue statistics, eventfd notification, and a concurrency-safe drain method that can recover slots left by crashed producers; recent fixes addressed hangs when peers are killed and further hardened recovery behavior. It requires 64-bit Perl and capacities are limited to 2^31 slots or less, with string slots using a fixed maximum length so you should choose sizes carefully. Backing files are created with secure permissions by default and constructors croak on failure so misuse is unlikely to silently corrupt data.

Data::DDSketch::Shared is a shared-memory implementation of DDSketch that compactly records a stream of numeric observations and gives any quantile estimate to within a configurable relative error (default 1%). It is aimed at long-tailed, wide-dynamic-range metrics such as request latencies where relative accuracy matters across the entire range. The sketch places values into logarithmic buckets so percentiles are guaranteed to be within alpha of the true value while using a fixed amount of memory. It supports negative values and exact zeros, tracks exact count, min and max, and keeps a running sum and mean. Multiple processes can feed and read a single sketch via a backing file, an anonymous mapping inherited across fork, or a memfd, and two sketches with the same parameters can be merged. You control accuracy and memory via alpha and num_buckets (defaults 0.01 and 2048) and can add single values or batches, query quantiles, median, mean, count and stats, and manage the backing store. The implementation uses a futex-based write-preferring rwlock with dead-process recovery for crash safety but has known caveats described by the author: a crash can leave scalar aggregates ahead of bucket updates so quantile(1.0) may temporarily return undef until the next update, and extreme concurrent reader counts above 1024 can prevent writer recovery in rare crash scenarios. Linux-only and requires 64-bit Perl. Initial release 0.01 (2026-07-22).

Data::CountingBloomFilter::Shared provides a Linux-only, 64-bit-Perl shared-memory counting Bloom filter so multiple processes can efficiently track approximate set membership, delete entries, and read an occurrence estimate without storing the items themselves. It uses 4-bit counters instead of bits so you can add, remove, and call count_of to get a 0..15 estimate, with counters saturating at 15 which caps counts and can prevent full removal of heavily added items. Membership queries are one-sided so items you have added will never be missed but false positives are possible at a tunable rate, and the module derives optimal hash and table sizes from your requested capacity and false-positive target. The table can be an anonymous mapping inherited across fork, a file-backed mapping for cross-process sharing, or a memfd passed between processes, and mutations are protected by a futex-based write-preferring lock with dead-process recovery. The API is simple: constructors (including new_memfd and new_from_fd), add, add_many, contains, count_of, remove, merge, clear, and various introspection and lifecycle helpers. Note that items are treated as bytes so wide characters must be encoded first and that removing items you did not add can cause false negatives for others due to shared counters. The initial release also fixes a use-after-free bug in merge when passed tied or magic arguments.

Data::CountMinSketch::Shared provides a compact, fixed-size Count-Min sketch that multiple Linux processes can share via a backing file, memfd, or an inherited anonymous mapping so you can track approximate frequencies across producers and consumers without storing keys. You add items or batches and query estimated counts that never fall below the true count and exceed it by at most epsilon times the grand total with probability at most delta, which makes it useful for finding heavy hitters or approximate tallies in streams too large to count exactly. The sketch stores only a small matrix of 64-bit counters driven by XXH3 hashes, supports merging two sketches with identical geometry, and uses a futex-based lock with dead-process recovery to remain robust across crashes. Note that it is Linux-only and requires 64-bit Perl, you must pass byte strings (wide characters croak), and individual counters wrap at 2^64 on add while merge saturates at the max value. Recent releases tightened on-disk security by defaulting newly created backing files to mode 0600 and moved to a new on-disk format that refuses older files, and a merge-related bug was fixed.

Data::Buffer::Shared provides fast, file-backed shared-memory buffers on Linux for 64-bit Perl, letting multiple processes efficiently share typed arrays of integers, floats or fixed-length strings with a fixed capacity and predictable memory layout. It offers lock-free atomic single-element get/set and a full suite of atomic integer operations for counters, seqlock-guarded bulk reads and write-locked bulk writes, a futex-based read/write lock that recovers from crashed holders, optional eventfd-based cross-process notifications, and constructors for file-backed, anonymous and memfd-backed mappings. The module is presized and does not grow, exposes raw pointers and zero-copy scalar views for FFI or high-performance use, and includes explicit locking primitives for batch updates; the documentation also calls out a rare reader-slot exhaustion edge case if you mount more than 1024 concurrent reader processes. Recent releases include robustness and security hardening and an on-disk format change in 0.06 that is incompatible with 0.05 files, so existing mappings must be recreated after upgrading.

Data::BloomFilter::Shared is a Linux-only, 64-bit-Perl module that provides a compact, shared-memory Bloom filter so multiple processes can record and test membership with a tunable false-positive rate (default 1%). It stores only a bit array and supports anonymous mappings inherited across fork, file-backed mappings, and memfd descriptors so unrelated processes can share the same filter; common uses are cross-process deduplication and fast "have I seen this before" checks. The API is simple: add items (including bulk adds), test membership, merge two filters of identical geometry into the union, clear the filter, and read estimates and stats. Writes are coordinated with a futex-based rwlock that includes dead-process recovery and backing files are created owner-only by default for safety. Note that the module croaks on wide-character strings so you must encode non-byte data first. Also be aware that the 0.04 release changed the on-disk format to v2 and will refuse older 0.03 files, so recreate any existing filters when upgrading.

Lemonldap::NG::Portal is the authentication and portal component of the Lemonldap::NG Web‑SSO system that makes it easy to add single sign‑on, authentication, authorization and accounting headers to protect web applications with minimal changes. It runs as a PSGI/Plack application and is built around a modular plugin system that loads authentication, user database and ancillary modules at initialization so you can use LDAP, CAS, remote or custom backends without changing your apps. Incoming requests are routed through a small processing pipeline that handles Ajax responses, redirects and template rendering while exposing a stable request object and read‑only configuration API for plugin authors. Recent improvements added multi and remote auth and userDB drivers, a pluggable password module, a notification subsystem and a double session mechanism to increase flexibility and security.

Lemonldap::NG::Manager is the browser-based administration front end for the Lemonldap::NG Web-SSO system. It runs a Perl REST server and serves an AngularJS JavaScript UI so operators can edit and build configurations, explore active sessions, view notifications and manage second-factor authentication from a single web console. The app is PSGI/Plack compatible so it works with CGI, FastCGI and other launchers and is configured via lemonldap-ng.ini or options passed to run(). The REST API is documented in the source tree and this modern manager replaces the older SOAP interface, making it a practical, centralized tool for administering Lemonldap::NG deployments.

Lemonldap::NG::Handler is the Apache protection module for the Lemonldap::NG Web Single Sign‑On system that sits in front of your web apps to enforce access rules, handle SSO sessions and redirects, and connect Apache/mod_perl with the Lemonldap::NG authorization and authentication features. This distribution is simply an alias for Lemonldap::NG::Handler::ApacheMP2 and is the component you install when you want server‑side protection and session handling at the Apache layer. Recent improvements in the project include POST‑based login flows for applications that cannot use standard redirects, an AuthBasic backend using SOAP, improved Perl logging, and a double‑session mechanism to separate secured and nonsecured sessions. The module is GPL licensed and maintained by the LemonLDAP::NG team; use the project issue tracker to report bugs or request features.

Lemonldap::NG::Common is the shared utility library for the Lemonldap::NG Web single sign-on suite, providing the common code and helpers used by the Manager, Portal, and Handler components so you do not have to reimplement basic features across the project. It bundles logging and syslog wrappers, SOAP and WSDL helpers, utility routines used in access rules, and support for LDAP-backed storage of sessions and configuration plus a Crypt object and an API to adjust Apache user context, making it useful if you are deploying or extending Lemonldap::NG. Recent updates added a SOAP wrapper and WSDL builder, Apache2::Log and syslog wrappers, setApacheUser support, LDAP storage backends, and shared rule libraries, and the package is distributed under the GNU GPL.

Data::SortedSet::Shared provides a Redis-like sorted set that lives in shared memory so multiple processes can read and update the same ordered collection without an external server. Members are 64-bit integers and carry double scores, ties are broken by member id, and the implementation combines an order-statistics B+tree with a fast member-to-score index so common operations are fast: score lookups and existence checks are constant time while rank, range, pop and updates are logarithmic and ranges scan sequentially. You can back the set with a file, create an anonymous mapping to be shared across forked children, or use a memfd to hand the object to unrelated processes, and a companion Data::SortedSet::Shared::Strings class offers string-keyed sets via interned ids. The module exposes convenient APIs for adding, incrementing, ranged queries, popping min/max, iteration, and an eventfd-based notification mechanism for waiters, and it includes stats, sync, and unlink helpers. It requires Linux and 64-bit Perl and uses a futex rwlock that recovers if a lock holder dies, but note that recovery fixes locking only and a writer killed mid-mutation can leave the B+tree inconsistent and there is an unlikely reader-slot exhaustion edge case described in the docs. If you need a high-performance, in-process shared sorted index for leaderboards, priority queues, or cross-process rank queries, this module is a good fit.

Data::PubSub::Shared provides a fast interprocess publish/subscribe channel built on shared memory for Linux 64-bit Perl. Publishers write into a fixed-size ring buffer while each subscriber keeps its own read cursor so messages are broadcast instead of consumed. Integer variants (Int, Int32, Int16) use lock-free atomic publishes for very high throughput and compact memory use while the Str variant stores variable-length messages in an arena and serializes publishers with a mutex. The module supports file-backed, anonymous, or memfd mappings, futex-based blocking waits, eventfd notifications for event-loop integration, batch operations and per-subscriber overflow counting. The ring overwrites old data when full and slow subscribers are auto-reset to the oldest available position with lost messages accounted in overflow stats. Use the integer types for counters, timestamps and small event IDs and use Str for log lines or JSON when you need arbitrary bytes and can accept a capped message size and serialized publishers. Note that it is Linux-only, requires 64-bit Perl, and clearing a ring while lock-free publishes are in flight can cause brief duplicate or stalled deliveries.

Data::MinHash::Shared implements a compact, shared-memory MinHash sketch for estimating Jaccard similarity between sets in a fixed amount of memory and with safe concurrent access from multiple processes. You create a sketch with a chosen number of registers k, fold elements in by hashing them once, and estimate similarity as the fraction of registers that agree so accuracy improves predictably as k grows. The sketch lives in a shared mapping backed by a file, an inherited anonymous mapping across fork, or a memfd that can be reopened in another process, and supports add, merge, export of raw registers, and on-disk syncing while guarding mutations with a futex-based rwlock and dead-process recovery. The recent release adds b-bit MinHash support so you can export very compact signatures and compare snapshots cheaply using only the low b bits per register, trading a small correction for much lower storage and bandwidth. Note that the module is Linux-only, requires 64-bit Perl, treats elements as raw bytes so wide characters must be encoded first, and has documented corner cases such as PID reuse and extreme reader counts that are unlikely in normal use.

Data::IntervalTree::Shared is a fast, shared-memory index for integer intervals that lets multiple processes answer containment and overlap queries without scanning every interval. It stores signed 64-bit endpoints and a user 64-bit id per interval, supports appending intervals and then performs fast stabbing and overlap searches by bulk-building a balanced tree on first query so queries run in roughly O(log n + k) time. The index is designed for practical uses like scheduling and calendar conflict detection, IP range ownership lookup, and genomic feature overlap. Multiple processes can share the same index via a backing file, an inherited anonymous mapping after fork, or a memfd passed between processes, and a futex-based read/write lock with dead-process recovery protects mutation and query concurrency. The module is Linux-only and requires 64-bit Perl, the index has a fixed capacity set at creation and will croak if you exceed it, and crash safety preserves consistency up to the last completed operation while noting rare corner cases such as PID reuse not being detected and potential writer blocking if more than 1024 concurrent readers produce a crashed slotless reader.

Data::Fenwick2D::Shared implements a two-dimensional Fenwick tree in shared memory so multiple Linux processes can efficiently update and query a fixed rows-by-cols grid of signed 64-bit integers. It supports atomic point updates and fast rectangle-sum queries in O(log rows * log cols) time, making it useful for cumulative-frequency tables, running heatmaps, image area sums, and other grid-based counters. The grid can be backed by a file, an anonymous mapping inherited across fork, or a memfd passed between processes, and queries take only a read lock so many readers run concurrently while a futex-based write-preferring rwlock with dead-process recovery protects writers. Values and totals are native 64-bit integers and wrap on overflow, and the implementation requires Linux and 64-bit Perl. A few practical limits are documented such as possible writer blocking if more than 1024 concurrent reader processes crash while holding read locks and the lack of PID-reuse detection on recovery, but these are rare in normal use. This is the initial release.

Data::CuckooFilter::Shared implements a compact, fixed-size cuckoo filter in shared memory for Linux so multiple processes can efficiently share an approximate membership set that supports add, contains, and remove. It stores 16-bit fingerprints rather than the items themselves so memory use scales with configured capacity, not item size, and for items you actually added contains returns true while the false positive rate is very small. The table is sized from a user capacity and uses four 16-bit slots per bucket, supports counting up to eight copies of an item, and add returns false only when the table is full so failed inserts are a true no-op. The mapping can be a backing file, an anonymous mapping inherited across fork, or a memfd passed between processes, and a futex read/write lock with dead-process recovery lets many processes safely add, remove, and test concurrently. Important caveats are that remove must only be used on items you added because fingerprint collisions can delete the wrong entry and corrupt counts, wide characters must be encoded to bytes before use, and a writer killed mid-eviction can leave the table in a state that permits a false negative so recreate the filter if that matters. The module is Linux-only, requires 64-bit Perl, and provides introspection, sync, unlink, and memfd helpers for sharing and lifecycle management.

Data::BitSet::Shared provides a fixed-size bitset that lives in shared memory on 64-bit Linux, letting multiple processes read and update individual bits without locks. It exposes file-backed, anonymous (fork-inherited), memfd and attach-by-fd constructors so you can share a bitmap across processes for flags, membership tracking, bloom-filter storage or resource allocation. Per-bit operations are atomic and lock-free using CAS on 64-bit words, so set, clear, test and toggle are fast and safe to run concurrently, and there are helper queries like count, first_set and stringification plus bulk fill and zero operations for whole-bitset changes. Note that full-word bulk stores are not safe to call at the same time as per-bit CAS operations on the same words. Backing files are created with owner-only permissions by default to improve security and a recent release also hardened robustness and fixed a few argument and memory-pointer handling issues while adding memfd improvements.

Cucumber::TagExpressions is a lightweight Perl parser and evaluator for the tag filter syntax used in Cucumber/Gherkin. It turns a human readable expression like "@fast and not @wip" into an ExpressionNode object and lets you call evaluate with a scenario's tags to get a true or false answer, so you can easily select which scenarios to run in custom runners or tooling. The module is MIT licensed and is based on the prior Ruby cucumber-tag-expressions library.

Net::SNMP::QueryEngine::AnyEvent is a lightweight AnyEvent-based client for the snmp-query-engine daemon that lets Perl programs perform non‑blocking, multiplexed SNMP queries and manage per-destination options via simple callback APIs. It provides get, gettable, info, dest_info, setopt and the newer getopt calls, plus utility methods like when_done and wait for integrating with an event loop. The client queues requests while the daemon connection is down and will retry connecting automatically by default, calling request callbacks with failure if an in‑flight query was lost; you can customize reconnect timing or disable reconnects. Version 1.1.0 adds on_connect and on_disconnect constructor callbacks so you can react to connection events and re-establish per-destination state, and introduces the getopt method for querying destination options. This module is a good fit when you need asynchronous SNMP access in an AnyEvent application and already use or can deploy an snmp-query-engine daemon.

EV::Pg is a non‑blocking PostgreSQL client for Perl that plugs libpq into the EV event loop so your database I/O never blocks the rest of an evented application. It exposes a familiar async API for parameterized queries, prepared statements, pipeline mode, COPY IN/OUT, LISTEN/NOTIFY, single‑row and chunked row delivery, async cancel when supported by libpq, protocol tracing, and a handful of handy utilities for quoting and bytea handling. Use it when you need high throughput or low latency inside an EV‑based program and want direct libpq behavior without spawning threads or blocking the loop. It requires libpq >= 14 and EV and will enable newer features automatically when linked against libpq >= 17. Recent 0.08 fixes address skip_pending accounting bugs and a segfault when a custom EV loop is freed before the EV::Pg object, and they improve result metadata handling.

EV::MariaDB is an asynchronous MariaDB/MySQL client that plugs into the EV event loop and uses MariaDB Connector/C's non‑blocking API to perform connects, queries, and prepared statements without blocking your program. It supports pipelined queries for high throughput, server-side prepared statements with automatic buffer handling, row‑by‑row streaming for very large result sets, async transaction and connection control, BLOB/TEXT streaming, and optional UTF‑8/utf8mb4 handling so Perl strings round‑trip correctly. The API is callback driven and distinguishes simple pipelinable queries from exclusive operations like prepare/execute or streaming reads so you can batch many queries safely while preserving correctness for stateful commands. Convenience features include column metadata, escape routines, and graceful async close. Be aware it is not safe to share a connection across Perl ithreads so use one interpreter thread or separate processes per thread. Recent fixes harden statement handle validation to avoid use‑after‑free bugs and segfaults, ensure the object holds the EV loop reference to prevent dangling pointers with custom loops, and make change_user with an undef database preserve the current database.

CryptX is a full-featured Perl cryptography distribution that bundles the LibTomCrypt library and exposes a large family of focused modules for hashing, symmetric and stream ciphers, authenticated encryption (AEAD), MACs, secure random generation, public-key operations, key derivation and ASN.1 helpers. It acts as the top-level documentation hub rather than a single API, so you pick the concrete modules you need such as Crypt::AuthEnc::ChaCha20Poly1305 for modern AEAD, Crypt::Digest for hashes, Crypt::PRNG for secure randoms, or Crypt::PK::Ed25519 and Crypt::PK::X25519 for modern public-key work. The distribution also ships Math::BigInt::LTM, a big-integer backend used internally, and includes diagnostic helpers that report how the bundled LibTomCrypt was built. Recent updates introduced AES-GCMSIV support plus ARIA cipher, the SM3 digest and KMAC, and an updated LibTomCrypt bundle, making this a good choice if you want a broad, actively maintained cryptographic toolkit for Perl with many modern algorithm choices.

Perl::Critic::TooMuchCode is an add-on for Perl::Critic that hunts down trivial dead code and no-op constructs that bloat maintenance and obscure intent. It adds configurable policies to flag things like unused imports and constants, duplicate subroutines and duplicate literal values, unnecessary include statements, overly large code or try blocks, excessive colons and redundant or extra strictures so you can catch cleanup opportunities during linting or in CI. Recent releases improved duplicate-literal reporting to show the literal itself and refined duplicate-sub handling to allow multiple BEGIN, UNITCHECK, CHECK, INIT and END blocks. The module is maintained by Kang-min Liu and is distributed under the MIT license.