CPANscan

Getopt::Long::Bash is a small Bash library that brings the convenience of Perl's Getopt::Long to shell scripts so you can declare all your options in one associative array and get long and short flags, bundled short options, GNU-style flexible ordering, multi-value arrays and key/value maps, built-in type and regex validation, automatic help text, callbacks, passthru for wrapper scripts, and support for git-style subcommands. It targets Bash 4.2 or later, installs from CPAN or by downloading the single getoptlong.sh file, and is simple to drop into existing scripts to replace brittle getopts logic. The project is MIT licensed and recent releases added a negative-alias syntax using ~ for option negation plus several bug fixes and improved documentation.

WWW::Shodan::API is a Perl wrapper for the Shodan REST API that makes it easy to query Shodan from scripts and applications. It exposes straightforward methods to search the Shodan index, fetch host and service banners, run on-demand scans, manage network alerts and notifiers, look up DNS and domain information, and retrieve account and API plan details, returning native Perl data structures ready for automation or analysis. You create a client with your Shodan API key and call methods like search, host_ip, scan, create_alert or resolve_dns, keeping in mind that some searches consume query credits and features depend on your API plan. A recent refactor improved the internal request handling to support GET, POST, PUT and DELETE with JSON and form payloads and added many endpoints and helpers for facets, scans, alerts, notifiers, directory queries and HTTP header inspection, making the module more feature complete and flexible for security monitoring and integration tasks.

Dist::Zilla::Plugin::PPPort is a small Dist::Zilla plugin that inserts a Devel::PPPort header into your distribution so XS code and other C-level extensions can compile against older Perl releases. It writes a ppport.h file by default but lets you choose a different filename and choose the packaging style used for the default name, and you can specify the minimum Devel::PPPort version or force replacing any existing file. If you build and release modules that include native code and need backward compatibility across Perl versions, this plugin automates bundling the portability shims your users will need.

Inline::Module helps Perl authors package C or C++ code with their CPAN distributions without having to learn XS by providing Makefile hooks and small generated "stub" modules that let you write Inline::C or Inline::CPP code directly inside your Perl modules. You enable it from Makefile.PL with a postamble that names the module and optional settings, and it can automatically generate and update stub modules for development, manage the temporary .inline build cache, and by default bundle the necessary Inline support modules under your distribution's inc/ so end users can build smoothly. The module is primarily useful if you want to ship a Perl extension that embeds C/C++ via Inline and prefer a simpler workflow than raw XS, and recent releases added an option to disable bundling of Inline dependencies and improved automatic stub generation and build layout.

Module::Manifest::Skip helps CPAN authors and packaging tools manage MANIFEST.SKIP files by creating and updating a sensible, shared baseline of file-patterns that should be excluded from distributions. It ships with a canonical skip list but preserves any custom header in your existing MANIFEST.SKIP and lets you add or remove patterns from Perl or the command line, so packaging frameworks like Module::Install can keep your skips up to date without copying the whole list. The module is maintained to work with modern packaging practices and recent updates refreshed metadata and test coverage for compatibility with current tooling.

Chandra::EPUB is a lightweight EPUB reader written in Perl on top of the Chandra toolkit that opens and displays EPUB files in a GUI window, lets you navigate chapters, and renders embedded CSS and images. You can create an instance with new or call the convenience open method, supply optional width, height and title to control the display, and call run to start the reader, and the module also exposes load_epub and extract_body for programmatic access to book contents and XHTML body fragments if you want to integrate or process content yourself. This is the initial 0.01 release, aimed at providing a simple, usable reader and a foundation for further development, and issues or feature requests can be reported via CPAN's RT; the module is distributed under the Artistic License 2.0.

Time::ParseDate is a mature Perl utility that turns a wide range of human and machine date/time strings into epoch seconds so you can work with them programmatically. It understands many absolute formats such as ISO, month names and numeric forms, a rich set of relative expressions like "next Tuesday", "2 months", or "+3 secs", and recognizes times, timezones and optional fractional seconds. Parsing behavior is configurable with options to prefer UK dates, require whole-string matches, allow fuzzy matches, choose past or future for ambiguous dates and more. On success it returns seconds since Jan 1, 1970 or undef on failure and in list context it also returns leftover text or an error message. The module is actively maintained and recently added support for trailing Z or z as UTC in ISO 8601 timestamps, making it more compatible with modern timestamp formats.

Eshu is a fast, XS-powered tool for normalizing leading indentation in C, Perl and XS source files by tracking nesting and rewriting only the whitespace at the start of each line while leaving the rest of the code untouched. It understands language-specific constructs that affect indentation including C strings, comments and preprocessor directives, Perl heredocs, regexes and pod sections, and XS dual-mode files with XSUB boundaries and labels. The module exposes simple entry points to fix C, Perl or XS text or to auto-dispatch by language, and it can detect language from a filename. You can choose tabs or spaces and set the indentation width, and there is an option to indent preprocessor directives when desired. Eshu is implemented in C for single-pass speed and ships with a command line utility for in-place fixing, diffs, CI checks or stdin/stdout processing, making it a practical choice for keeping mixed-language codebases consistently indented.

Email::Abuse::Investigator is a Perl module that turns a raw spam or phishing message into actionable intelligence by parsing headers and bodies to identify the likely originating IPv4 address, extract all HTTP/HTTPS links and contact domains, resolve hostnames to IPs, and query RDAP/WHOIS to find network owners and abuse contacts. It collates MX and NS data, parses DKIM and list-unsubscribe headers, flags recently registered or lookalike domains, and produces a weighted risk assessment plus both an analyst-friendly full report and a compact, send-ready abuse report with deduplicated recipient addresses. The analyser is configurable with timeouts and trusted-relay exclusions and caches results per parsed message to avoid repeated lookups. It is designed to help security teams and abuse desks quickly determine who to contact and what evidence to include when reporting malicious mail. Note that the module extracts only IPv4 addresses, is not thread-safe, and WHOIS timeouts may be unreliable on some platforms such as Windows.

Alien::libwebsockets makes the libwebsockets C library easy to use from Perl by either finding an existing system installation or downloading and building a configured copy for you. It integrates with Perl build tools such as ExtUtils::MakeMaker and exposes compiler flags and linker settings so your XS or XS-dependent distribution can link against libwebsockets without manual setup. When it builds from source it enables libev, SSL, zlib, and the permessage-deflate extension to provide a fully featured runtime. A helper method, has_extensions, checks whether permessage-deflate support is present by looking for the relevant symbols, but that check is only reliable for installs the module built itself and may report false for untracked system libraries.

Amazon::Credentials is a Perl helper that finds and returns AWS credentials by walking a configurable chain of sources such as environment variables, container credential endpoints, EC2 instance metadata (IMDSv2), OIDC web‑identity tokens, and local ~/.aws profile files. It lets you control the search order and timeouts, disable metadata lookups for local or CI use, and supports SSO and role-based flows, plus convenience methods to format, check expiration, and refresh temporary credentials. The module can cache credentials and will try to encrypt or obfuscate them using Crypt::CBC with optional custom passkey, cipher, or encrypt/decrypt hooks, and it offers burn‑after‑read behavior when caching is disabled to reduce exposure. Debugging and logging are configurable with safeguards to avoid printing secrets, and a small CLI is provided for quick use. Note that it will not automatically assume roles defined only in profile files and it has not been tested on Windows.

Multi::Dispatch adds two new keywords, multi and multimethod, so you can write multiply dispatched Perl subroutines and methods that pick the right implementation automatically from richly featured signatures. You declare multiple variants of the same sub or method and the dispatcher chooses the best match by arity, type or class tests, value or :where clauses, destructured array or hash patterns, aliased and code parameters, literal matches, permuted argument orders, and more, and you can also use :before variants and next::variant to redispatch or adapt arguments. Multimethods integrate with inheritance and Object::Pad and can be declared as per-class with :common, and the module provides lexical debugging and annotation flags plus mechanisms to import or export variant sets between packages. It requires Perl 5.22 or later and several CPAN modules and the author notes a few practical limits, for example some interaction quirks with Object::Pad roles and that its PPR-based parsing may conflict with other keyword-adding modules. If you want declarative, pattern-rich overloading of subroutine behavior based on argument shapes or types, this module brings it to Perl cleanly and efficiently.

TOON is a small, pure-Perl encoder and decoder that gives you a JSON-like interface for the Token-Oriented Object Notation format, making it easy to serialize and parse Perl scalars, arrays and hashes into a readable TOON text form and back. It implements a pragmatic subset of TOON with support for null, true, false, numbers, JSON-style quoted strings, arrays using [ ... ] and objects using { key: value }, including bareword keys matching common identifier rules. You can use it as an object via TOON->new to enable options like pretty printing, canonical (sorted-key) output and configurable indentation, or use the functional helpers encode_toon, decode_toon, to_toon and from_toon for convenience, and parsing errors raise TOON::Error exceptions. Because this is a starter implementation written entirely in Perl it is lightweight and easy to integrate for basic TOON needs without external dependencies and this release is the initial 0.0.1 publication.

Data::HashMap::Shared implements very fast, file-backed shared-memory hash maps for Linux running 64-bit Perl, letting multiple processes open the same mmap file and share data with minimal locking. It ships as a family of type-specialized variants (integer-to-integer, string-to-string, mixed types, etc.) so lookups, atomic increments and compare-and-swap operations are implemented with native, low-overhead storage for peak throughput. The module uses futex-based locks and a seqlock-style fast read path so reads are effectively lock-free when LRU and TTL are disabled, and it adds optional features like per-key TTLs, an LRU clock eviction policy that avoids write contention, an arena for string storage with small-string inline storage, sharded maps for parallel writes, cursor-safe iteration and a keyword API for the absolute fastest call path. It also includes crash-detection and recovery of stale writers via PID tracking though cross-container PID namespaces are not supported, and it exposes rich diagnostics and file management tools. The recent 0.02 release notably expands the API with atomic swap/CAS, queue-style pop/shift/drain, batch set/get, TTL/LRU controls and stats, introduces lock-free clock/second-chance LRU reads, inline small-string nodes, SSE2 probe acceleration, a faster monotonic clock for TTLs and C-level sharding for parallelism, making it a strong choice when you need extremely fast, concurrent, cross-process shared hash tables on Linux.

Net::WebSocket::EVx is a lightweight Perl wrapper around the Wslay WebSocket library that plugs into the EV event loop to provide nonblocking WebSocket client and server I/O. It expects you to perform the HTTP/WebSocket handshake yourself and then hands a nonblocking filehandle to the module, after which you get callback hooks for complete messages, frame starts, frame chunks, frame ends and connection close events, plus APIs to queue messages, send fragmented streams, control read/write activity and wait for send-queue drain. The module adds support for RSV bits used by extensions such as permessage-deflate so you can implement compressed transfers, and it offers buffering control to stream large binary payloads without holding them all in memory. It is a fork of the older Net::WebSocket::EV that uses Alien::Wslay under the hood, and recent work focused on that switch, adding RSV support, hardening the XS layer and expanding tests. If you need an event-driven, high-performance WebSocket layer in Perl and are comfortable handling the initial handshake and nonblocking sockets, this module is a good fit.

Alien::Wslay is a small Alien::Base-based helper that makes the Wslay C library available to Perl build systems by discovering an installed copy or downloading and installing it from the project GitHub. It prefers system packages named libwslay1 and libwslay-dev when they exist, and otherwise fetches the latest release from the Wslay repository. The module exposes standard Alien::Base methods such as cflags, libs, and dynamic_libs so XS modules or other compiled extensions can obtain the correct compiler and linker flags. This lets you easily declare or bundle a dependency on Wslay in a Perl distribution, and the upstream Wslay is distributed under the MIT license.

NKC::Transform::MARC2BIBFRAME is a small utility class for converting MARC bibliographic records into BIBFRAME XML using versioned XSLT stylesheets. You create an object with new and can choose the transformation version or supply a custom XSLT file, then call transform to get a BIBFRAME XML string suitable for downstream processing or ingestion. The module wraps XML::LibXML and XML::LibXSLT and exposes a simple version method so you can pick among provided transforms, currently including 2.5.0, 2.9.0, 2.10.0 and the newly added 3.0.0. It is part of the NKC::Transform family, is open source on GitHub, and is handy for libraries and projects that need a straightforward, scriptable MARC-to-BIBFRAME conversion step.

NKC::Transform::BIBFRAME2MARC is a compact Perl utility for converting BIBFRAME bibliographic data into MARC XML by applying packaged XSLT transformations. You create an object, optionally pick a transformation version, and call transform with your BIBFRAME XML to receive MARC XML as a string. The module uses XML::LibXML and XML::LibXSLT under the hood and ships with versioned XSLT files so you can target specific mapping rules. This is useful for library software developers and cataloging workflows that need reliable, scriptable conversions between linked‑data BIBFRAME and legacy MARC formats. Recent releases added newer transformation sets including a 3.0.0 mapping and accompanying tests, and a small packaging fix.

Chandra is a lightweight Perl wrapper around the webview-c library that lets you build cross-platform desktop UIs with HTML, CSS and JavaScript from Perl. It supports macOS, Linux and Windows and provides a simple API to open a webview window with a title, URL or data URI, size and optional developer tools, plus a callback mechanism so JavaScript can invoke Perl code. You can run it in a single blocking call for simple apps or control the event loop manually with init, loop and terminate for more complex behavior, and you can execute JavaScript at runtime with eval_js or update the window title with set_title. The module is experimental and currently alpha quality, includes example apps demonstrating JS-to-Perl binding and bidirectional communication, and is distributed under the MIT license.

Lingua::ZHO::Word2Num converts Chinese number words into numeric values, making it easy to extract integers from text for scripts, data extraction, or simple NLP tasks. It handles whole numbers from 0 up to 999,999,999,999 and expects UTF-8 input. The main function w2n returns the numeric value or undef when the text cannot be converted, and a helper ordinal2cardinal can turn ordinal forms into cardinal forms before conversion. The module is part of the Lingua suite and is lightweight and straightforward to call from Perl. Recent updates improved documentation and test coverage, fixed ordinal roundtrip issues, and added explicit UTF-8 encoding declarations in the POD.

Lingua::ZHO::Num2Word converts numeric values into Chinese cardinal words, supporting decimal numbers and five output styles named traditional, simplified, big5, gb and pinyin so you can get either Chinese characters or romanized output. You can use it in object form with new, parse and get_string or as the convenience function number_to_zh, and you can change the output encoding with the charset method; note that traditional and simplified forms are returned as Unicode strings and require Perl 5.6 or later. The module handles numbers from 0 up to but not including one trillion. A recent notable change is that the package and its legacy Num2Word modules were renamed and consolidated under the canonical Lingua::ZHO::Num2Word namespace.

Lingua::YID::Word2Num is a compact Perl module for turning Yiddish numerals written in Hebrew script into integer values. It expects UTF-8 input that follows the YIVO orthography and converts whole numbers in the range 0 to 999,999,999. The module exposes w2n for parsing numeric words and ordinal2cardinal for converting ordinal word forms back into their cardinal equivalents, returning undef when the input is not recognized. Recent updates improved POD and test coverage as part of a larger multilingual Lingua suite and fixed several ordinal and cardinal parsing issues. The module is actively maintained and is available under the Artistic 2.0 or BSD 2-Clause license.

Lingua::YID::Num2Word converts whole numbers into their written Yiddish form using Hebrew script and YIVO orthography, handling values from 0 up to 999,999,999 and producing UTF-8 text output. It provides straightforward functions to generate cardinal and ordinal spellings, with ordinals accounting for irregular forms and correct suffixes, and returns undef for numbers outside the supported range. A capabilities() call reports which conversion types are available, and the module is light to drop into applications that need programmatic Yiddish numerals. The recent release added Yiddish to the Lingua suite, tightened test coverage, and improved ordinal handling across multiple languages.

Lingua::VIE::Word2Num is a Perl module that converts Vietnamese number words into integer values. It accepts UTF-8 input and handles whole numbers from 0 up to 999,999,999 via the w2n function, returning the numeric value or undef when the text cannot be recognized. The distribution also includes an ordinal2cardinal helper to map ordinal words back to cardinal forms and exposes an internal parser object for advanced use. This module is useful for developers working on Vietnamese text processing, natural language parsing, form handling, or speech-to-text postprocessing where extracting numeric values is needed.

Lingua::VIE::Num2Word converts integers into their written Vietnamese forms, producing UTF-8 text and handling whole numbers from 0 up to 999,999,999. It exposes num2vie_cardinal to return cardinal words and num2vie_ordinal to produce ordinals by prepending "thứ" to the cardinal form, with special handling for first and fourth. The cardinal function returns undef for numbers outside the supported range and a capabilities() function reports what conversions the module supports. The two conversion functions can be exported and the module is provided under either the Artistic License 2.0 or the BSD 2-Clause License.

Lingua::UKR::Word2Num converts Ukrainian number words written in Cyrillic (UTF-8) into numeric values, making it useful for text processing, form parsing, or simple natural language tasks. It handles whole numbers from 0 up to 999,999,999 and provides w2n which returns the numeric value or undef when the input cannot be recognized. It also offers ordinal2cardinal to convert Ukrainian ordinal forms back to cardinal words by reversing gender and case inflections, so you can normalize phrases like "first" or "third" into their base numeric forms. An internal parser object is available for advanced use and the module is distributed under permissive Artistic 2.0 or BSD 2-clause licensing.

Lingua::UKR::Num2Word is a Perl module that converts whole numbers into their written Ukrainian form. It supports integers from 0 up to 999,999,999 and provides a num2ukr_cardinal function that returns the Ukrainian text for a given number or undef if the number is outside the supported range. The module also exposes a num2ukr_ordinal export and a capabilities function that reports which conversion types are available. Use it when you need human-readable Ukrainian number names for things like reports, invoices, or localized user interfaces.

Lingua::UIG::Word2Num converts Uyghur number words written in Arabic script into integers, handling whole numbers from 0 up to 999,999,999, and exposes a simple w2n function that returns the numeric value or undef when conversion fails. It is useful if you need to extract or normalize numeric amounts from Uyghur text for data processing, form handling, or lightweight natural language tasks and it ships with an internal parser object for advanced uses. The module is free software under standard Perl-friendly licenses. Recent releases are part of a broader multi-language effort and the project update added support for a set of additional languages in the distribution, signaling ongoing maintenance and expansion.

Lingua::UIG::Num2Word is a small Perl module that converts whole numbers into their written Uyghur form using Arabic script and UTF-8 encoding. It provides a single exportable function, num2uig_cardinal, that returns the spelled-out string for integers from 0 up to 999,999,999 and returns undef for numbers outside that range. The module also exposes a capabilities function for introspection, making it easy to integrate into localization, reporting, or text-generation tasks where Uyghur number words are needed. The recent release added this Uyghur implementation to the Lingua suite and improved documentation and test coverage.

Lingua::TUR::Word2Num is a Perl module for turning Turkish number words into numeric values, suitable for text parsing and data extraction tasks that need to interpret numbers in Turkish text. It accepts UTF-8 input and converts whole numbers from 0 up to 999,999,999 using the w2n function, returning undef when the text cannot be recognised. The module also offers ordinal2cardinal to strip Turkish ordinal suffixes and restore base cardinal forms when needed. This is a lightweight, ready-to-use tool for scripts and applications that need to understand written Turkish numerals, and a recent update fixed ordinal roundtrip behavior across multiple languages and corrected certain cardinal parsers.