CPANscan

Business::ISBN::Data is a companion data package for Business::ISBN that provides the official ISBN range and publisher code information derived from the ISBN Agency's RangeMessage.xml, so Business::ISBN can validate, parse, and format ISBNs correctly. The module is normally loaded automatically by Business::ISBN and ships with a copy of RangeMessage.xml while also falling back to built‑in data or a RangeMessage.xml found in the current directory, and you can point it at an alternate file by setting the ISBN_RANGE_MESSAGE environment variable before loading Business::ISBN. Note that the data structure changed to address an ISBN‑13 prefix bug so you should use Business::ISBN 3.005 or later. The data are updated frequently and available on GitHub, and a recent fix stopped unintended autovivification of ISBN_RANGE_MESSAGE to avoid accidental creation of that variable.

Org::Parser is a Perl module that reads Emacs Org-mode files and turns them into a structured Org::Document tree so you can programmatically inspect headlines, lists, tables, timestamps, links, drawers and other Org elements. It accepts input as a string, array of lines, filehandle or filename and offers a parse_file helper that can optionally cache parsed results to speed up repeated reads, while the resulting document provides walk-style traversal and element methods for querying and manipulation. The parser is regex-based and aimed at being "good enough" for handling real notes and todo files rather than being a drop-in replacement for Emacs parsing, and it will die on syntax errors so you get immediate feedback. Recent updates added a document attribute to ignore unknown drawers along with a bugfix that correctly passes that option through, and a companion command-line utility in a separate distribution helps with debugging and inspection.

Chandra::Markdown is a small helper for Chandra apps that converts Markdown into safe, styled HTML and can inject that output straight into your app's webview. It defaults to GitHub Flavored Markdown so you get tables, task lists, autolinks and other GFM features, and it can optionally syntax highlight fenced code blocks and inject a built‑in stylesheet for token colors and layout. It also offers utilities to scan a directory of .md files, register routes for each document, build a searchable index and return a navigation HTML fragment, plus a search_widget that registers a handler and emits a search input you can embed in your layout. Constructor flags let you toggle GFM, hard breaks, highlighting, target element id and CSS injection. If you are building documentation pages, blogs or other content-driven screens inside a Chandra application this module makes rendering, routing and client-side search simple to set up.

Markdown::Simple is a fast XS-based Perl module that converts Markdown into HTML with GitHub Flavored Markdown as the default and easy options to toggle strict CommonMark or individual features like tables, strikethrough, task lists, autolinks, raw-HTML handling and soft line breaks. You can use the simple functional call for one-off conversions or create a Markdown::Simple object to reuse the native parser arena when rendering many documents for better performance. There is also a strip_markdown helper to produce plain text without losing scan-readable list and table structure. Recent releases added SIMD-accelerated code paths for speed and a new highlight option that leverages the Eshu library to syntax-highlight fenced code blocks when a language tag is present.

PDF::Make is a comprehensive Perl toolkit for creating, parsing, and editing PDF documents. It offers a high-level, chainable Builder API that handles page management, coordinate translation, word wrapping, and font metrics so you can assemble reports, forms, and image-rich pages quickly, and it also exposes a low-level XS API for direct manipulation of PDF objects and content streams when you need full control. The distribution includes support for standard and TrueType fonts, JPEG/PNG images, annotations, interactive AcroForm fields, encryption and digital signatures, optional content layers, attachments, redaction and metadata sanitisation, tagged PDF structure for accessibility, watermarks, linearisation for fast web view, and tools to extract text, annotations, forms, and tables from existing PDFs. Runtime dependencies are minimal. The most recent update improves the Builder layout engine by switching row rendering to a flex-based layout for both width distribution and height calculation and adds an example that demonstrates weighted columns, auto height, gaps, and mixed font sizes. Use PDF::Make when you want a Perl-native way to build, inspect, or modify PDFs ranging from simple generated reports to complex, spec-level document editing.

Layout::Flex is a fast C/XS implementation of the CSS Flexible Box layout algorithm for Perl that computes exact positions and sizes for a list of items inside a container. You give it container dimensions and item descriptors and it returns an ordered list of [x, y, w, h] rectangles ready for rendering or further processing. It supports row and column directions, single-line and multi-line wrapping, justify and align behaviors, per-item margins, min/max constraints, gap between items and lines, and per-item grow and shrink factors. For content-driven layouts you can supply a built-in approximate measurer or a custom callback that returns natural widths and heights, and items that need text wrapping can trigger a second measurement pass once their final width is known. The engine follows CSS flexbox semantics including align_content distribution of wrapped lines and always reports the content box excluding margins. This module is useful when you need programmatic, CSS-like layout in Perl applications such as GUI toolkits, PDF or image composition, or custom rendering pipelines.

Map::Tube::Plugin::Graph is a Moo role that plugs into Map::Tube classes to turn tube network data into GraphViz graphs and ready-to-use images, letting you produce full network maps or per-line diagrams in formats like PNG, SVG, PDF or raw DOT. You can extract a Graph object for analysis or visualization with as_graph, or use render/as_png/as_image to produce binary files or base64-encoded images and to write output to disk, with control over output format and layout engine. The module relies on GraphViz2 and the system GraphViz tools, and it also exposes helper methods to list available drivers and formats on your machine. The recent 1.1.0 release modernizes the API with a flexible render() call, safer automatic output naming, GraphViz capability introspection, and tidy wrappers for as_png and as_image, while bumping the minimum Perl requirement and adding explicit dependencies for reliable environment detection. If you need to visualize or export tube networks programmatically this module provides a straightforward bridge from Map::Tube data to GraphViz-powered diagrams.

MojoX::Authentication is a compact, opinionated helper for adding authentication to Mojolicious web applications, providing ready-made flows for local logins (in-memory or SQLite) and SAML 2.0 single sign on. It wraps common tasks such as wiring up Mojolicious::Plugin::Authentication, injecting the current user into the stash, handling credential-based login and logout, and initiating and finishing SAML2 SSO, with sensible defaults like looking for username and password parameters and stashing the user as "user". The module expects a simple model object and assumes a single identity provider for SAML, so it is best suited to developers who want a batteries-included, easy path to add authentication rather than a fully generic framework. Documentation is light but an example app demonstrates usage, the minimum Perl version is 5.24, and recent updates include refactoring and stricter error behavior on creation in version 0.004.

CPAN::Maker is a command line tool for Perl authors that turns a simple YAML "buildspec" into a complete CPAN distribution tarball, handling file staging, dependency resolution, Makefile.PL generation and the standard build steps so you do not need external bash scripts. It can validate buildspec files against a JSON schema for CI, preview or emit a Makefile.PL, and generate cpanfile dependency manifests from plain text lists, and it exposes options to control version pinning, test execution, cleanup of the temporary build area and output location. The workflow is declarative and reproducible, making CPAN::Maker a good fit for module maintainers who want an automated, schema-validated way to package and publish Perl distributions.

App::Codit is a lightweight, Perl/Tk-based integrated development environment built for Perl developers who prefer an editor written in Perl. It provides a multi-document interface with syntax highlighting, code folding, smart undo/redo, auto-indent, auto-brackets and completion, plus bookmarks, snippets and a configurable GUI. Codit is plugin-driven, shipping plugins for Console, FileBrowser, Git, Pod viewing, search and replace, sessions and more, and it is fully configurable via a settings window and command-line options. Because it uses Tk::CodeText and Tk::AppWindow it runs on systems that support Perl/Tk and is a good fit if you want a customizable, extensible editor implemented entirely in Perl. The recent 0.20 release improved compatibility with newer Tk::FileBrowser versions and includes several plugin fixes, making it easier to run with updated Tk components.

Tk::ListBrowser is a canvas-based, chameleon list widget for Perl/Tk that can present items as a single-column list, multi-column rows or columns, a horizontal bar, an HList or a Tree and supports images and multiline text. It offers sortable headers and side columns, per-item data and column items, keyboard and mouse navigation, on-the-fly filtering, configurable selection modes and options to control cell sizing, wrapping and text layout. You interact with it through simple methods to add, hide, show, sort and refresh entries and to create headers or side columns, making it a handy choice for building rich list views in desktop Tk apps. It is aimed at small to medium sized lists (a few hundred entries) and the author notes that custom fonts and very large lists will slow refresh and updates. Recent releases tightened up anchor and selection drawing in multi-column setups, improved header handling and added finer control over item drawing and refresh behavior.

Schedule::Cron is a lightweight cron-style scheduler for Perl that runs inside a single long‑running program and calls Perl subroutines on a crontab-like schedule. It understands common crontab syntax and Vixie extensions, supports an optional seconds field, lets you load crontab files or add entries dynamically, and can dispatch either a default handler or a per-job subroutine with arbitrary arguments or evaled argument lists. You can run jobs in forked child processes or in the main process with controls to skip overdue jobs, catch exceptions, and receive an after_job callback. The module also offers hooks for custom logging, process title control, custom sleep handling, daemonization with pid file, and a global timeshift feature. Note that daylight saving time changes are handled in a best-effort way and behavior during the fallback hour is platform dependent, as documented by the author. The recent release updates a DST-related test to use America/Los_Angeles.

Test::Mockingbird is an advanced mocking toolkit for Perl test suites that makes it easy to replace or wrap methods, record calls, inject fake dependencies, intercept constructors, verify call order, and work with async Future-based stubs via the companion Async module. It supports both shorthand and longhand target syntax, stacked LIFO mock layers, scoped guards that automatically restore on scope exit, and a set of convenience helpers for fixed returns, exceptions, sequences and one-shot mocks, plus diagnose_mocks/diagnose_mocks_pretty to inspect active layers and restore_all to clean up. The recent 0.12 release adds before, after and around wrappers so you can run hooks before or after the original or receive the original coderef to implement call-through behaviour cleanly and predictably. The author documents a few practical limitations such as spy() emitting prototype-mismatch warnings when wrapping prototyped subs and Package->can sometimes appearing truthy for auto-vivified but non-callable stubs, with recommended workarounds in the documentation.

Email::Abuse::Investigator is a tool for analysts and security teams that inspects the raw source of suspected spam or phishing messages and extracts the facts you need to file abuse reports. It parses RFC‑2822 messages, walks the Received headers to find the likely originating IP and its owner, pulls every http/https URL from text and HTML parts and resolves their hosts, and gathers domain intelligence from mailto links, From/Reply-To/DKIM/List‑Unsubscribe/Message‑ID fields including WHOIS/RDAP, MX, NS and registrar details so you can identify who to contact. The module produces analyst-facing plain text reports and compact abuse-report bodies ready to send, collates email and web‑form recipients, computes a heuristic risk score with flagged issues, follows common cloud-storage and shortener redirect cloakers when LWP::UserAgent is available, and supports IPv6 and cross‑message caching via CHI to avoid repeated lookups. Optional modules such as Net::DNS, LWP::UserAgent, Domain::PublicSuffix, AnyEvent::DNS and CHI greatly improve accuracy and performance. Known limitations documented by the author include no automatic charset conversion, a hand‑rolled MIME parser that is not fully RFC conformant, IPv4‑only CIDR matching for trusted_relays, lack of WHOIS rate‑limit handling, and non thread‑safe global cache and no live DMARC TXT lookups. In the recent 0.14 release the provider abuse table was expanded to cover Google Translate cloaker hosts and Google Workspace SMTP domains so those hosts now resolve to actionable abuse@google.com contacts and unresolved_contacts() handling was corrected, making it easier to identify and report Google‑hosted cloaked phishing pages.

Termbox::PP is a compact, pure-Perl implementation of the Termbox terminal UI library that makes it easy to build text-mode interfaces without XS or external C libraries. It gives you a simple, cell-based back buffer for drawing text and attributes, functions to initialize and restore the terminal, helpers to print formatted UTF-8 text, and event objects for keyboard, mouse and resize handling so you can write a single-threaded render loop that responds to user input. The module aims to mirror the termbox2 API while staying small and portable, works out of the box on Unix with core Perl and can be used on Windows with the usual console support libraries, and it exposes utility routines for Unicode handling, color modes and low-level raw output when needed. The project is still evolving so expect occasional API tweaks, and recent updates have restored Windows Virtual Terminal support, improved Unicode width handling and performance, and fixed a few export and initialization edge cases.

YAML is a Perl module that provides simple Load and Dump functions to read and write YAML, the human-readable data serialization format, converting between YAML documents and Perl data structures. It handles mappings, sequences, scalars, aliases, multi-document streams, optional preservation of key order via YAML::Node, and even experimental support for code references and typeglobs, plus convenience helpers for files and an interactive YAML shell. This distribution is the original, Perl-native YAML implementation and is handy for producing readable dumps and working with YAML in scripts, but the author cautions that it is old, has known bugs and limited maintenance and recommends newer alternatives such as YAML::PP or YAML::PP::LibYAML for most production use.

Business::NAB is a lightweight top-level Perl namespace for working with National Australia Bank interchange file formats, not a standalone tool but a hub that exposes focused modules for creating and parsing BPAY batches and remittances, Direct Entry payments/returns/reports, NAI/BAI2 account information files, and XML acknowledgements, along with a small type library. It lets Perl apps handle NAB-specific file interchange without making you implement the record formats yourself. Recent updates (0.06) improved robustness by guarding against rare rounding errors and preventing partial file writes, and earlier releases added account-number padding to match bank expectations. The code is free under the same terms as Perl and development happens on GitHub if you want to report issues or contribute.

CPAN::Maker::Bootstrapper is a command-line scaffold that creates a ready-to-build Perl CPAN distribution with one command by installing a managed Makefile, a prefilled buildspec.yml, .pm.in/.pl.in source stubs, tests, and supporting make snippets and then running make to produce a distributable tarball. It is aimed at developers who want a reproducible, local build system that enforces good practices out of the box such as dependency scanning, syntax checks, perltidy and perlcritic gates, modulino support, and an upgrade-safe extension point via project.mk so you can customize builds without touching the managed Makefile. It also bundles AI-assisted workflows tied to the Anthropic Claude API for iterative code and POD reviews, annotation-driven review rounds, and LLM-generated release notes and changelogs, with prompt profiles and dry-run token estimates to control cost. The importer can bring existing .pm, .pl and test files into a new project and the CI builder helper and workflow targets make it easy to reproduce builds in Docker or GitHub Actions. Note that import and stub modes are mutually exclusive, imported files are copied as “.in” sources and are not auto-tidied, the importer relies on package declarations to place modules under lib, and inter-module build-order issues may require declaring dependencies in project.mk. Recent releases have refined release-notes generation and LLM tooling and added features such as an ExtraFiles role and other improvements to the build and prompt handling.

CLI::Simple is a lightweight, object-oriented base class for building modulino-style command line Perl tools that need options, subcommands and positional arguments. It uses Getopt::Long parsing and auto-generates getters for options and extra properties, integrates with Log::Log4perl including per-command log levels, and supports an optional role-based architecture driven by a YAML manifest so you can split commands into Role::Tiny roles and scaffold a CPAN-ready project. The module ships useful internal commands and helpers such as -dump-spec, -scaffold and -generate-completion for bash completions, a create-modulino helper, customizable help sections and optional pager output, and it keeps lifecycle and validation explicit via a simple init/run flow so you stay in control. The design favors minimal dependencies and pragmatic features like option and command aliases, custom error handlers and easy defaults. Recent updates add an automatic color appender for logging and make Term::ANSIColor an optional recommended dependency so you can get colored log output without forcing a hard dependency.

CallBackery is an application framework that wires a Mojolicious web engine to a ready-made frontend framework so you can build appliance-style web user interfaces quickly. It centralizes configuration, database access, RPC dispatch and security headers and exposes convenient attributes for config files, a pluggable database backend, RPC controller and initial documentation index so the server side can drive a Qooxdoo frontend. The module is aimed at developers who want a batteries-included backend for interactive web apps and it includes sensible defaults such as an etc/callbackery.cfg config file with an override via the CALLBACKERY_CONF environment variable. Recent work modernized the RPC layer to JSON‑RPC 2.0 and improved session expiry handling and frontend error/ retry behavior, plus ongoing frontend bug fixes to form loading and triggers. The distribution is released under the GNU GPL.

Sys::OsRelease::Lite is a lightweight Perl helper that reads the standard /etc/os-release file and exposes the operating system and distribution metadata to your scripts in a simple, consistent way. It provides a singleton interface with ready-made accessors for common fields like id, id_like, version_id and pretty_name, plus generic methods to list, check and fetch any discovered attributes, and a platform helper that maps common ID_LIKE values to familiar platform names. The module keeps dependencies minimal so it is suitable for use in system scripts, installers and containers and it will fall back to Perl's native osname if no os-release file is found. Recent changes added a Sys::OsRelease::Lite packaging variant to maintain compatibility with older Perls before 5.22 and adjusted the Lite delivery for CPAN, making the same functionality available on legacy systems.

Sys::OsRelease is a lightweight Perl helper for reading the standard /etc/os-release file used by Linux and BSD to identify the operating system and distribution. It provides a singleton-based interface with convenient read-only accessors like id(), id_like(), name() and many more, plus generic methods such as get(), has_attr(), found_attrs() and platform() to return a normalized platform name. The module keeps minimal dependencies and supports both class-style and object-style usage so scripts can easily detect OS type for configuration, packaging or installation logic. It requires Perl 5.22 or newer and a repackaged Sys::OsRelease::Lite exists for older Perl versions.

Perl::Dist::APPerl delivers APPerl, a single-file portable Perl runtime that runs the same binary across multiple x86_64 operating systems and can carry Perl modules and scripts inside the executable as a ZIP filesystem. Using the apperlm command you can create and manage build configurations, build from an existing APPerl or compile Perl and the Cosmopolitan libc from scratch for static builds that support XS extensions, and include CPAN distributions by pointing apperlm at tarballs or folders. At runtime APPerl can dispatch embedded scripts by path, by an environment variable, or by argv[0] so you can ship standalone Perl applications, bundle a consistent interpreter for teams, or carry Perl on a USB drive without installing anything. It also supports debugging features like syscall tracing and function tracing and notes that building from source requires Linux. Recent releases added official builds for Perl 5.42 and 5.44 along with a variety of build and test fixes to improve compatibility.

Getopt::Class is a lightweight wrapper around Getopt::Long that lets you declare a dictionary of typed command‑line options and group them into named classes so you can collect, validate and access related sets of options for different features of your program. You define each option with type, aliases, defaults and validation rules and the module converts parsed values into convenient typed objects (scalars, booleans, arrays, files, URIs, datetimes, hashes) that you can access as hash keys or as methods. It supports mirrored enable/disable and with/without forms, required and regexp checks, action callbacks, and class-level helpers to extract only the values relevant to a given feature, and it reports structured errors instead of dying. If you build command line tools that expose multiple feature areas or need richer validation and objectified option values, Getopt::Class simplifies wiring Getopt::Long into that workflow. The module is mature and actively maintained with a recent v1.2.0 release and updated dependencies.

Pod::Man converts Perl's POD documentation into *roff using the man macros so you can produce standard Unix manual pages viewable with man or nroff. You can run it via the pod2man script or use it as a parser object to read POD from files, strings, or filehandles and write formatted output to a file, handle, or string. The module defaults to UTF-8 output and provides options to control headers, footers, section number, output encoding, quote characters, and optional "guesswork" rules that simplify common Perl documentation patterns. On modern systems that use groff or mandoc UTF-8 output renders correctly but very old troff/nroff implementations may not support Unicode and Pod::Man offers a legacy "roff" mode for backward compatibility at the cost of poor non‑ASCII rendering. Note that some *roff quirks remain, such as sentence spacing and the treatment of hyphens and quotes, which Pod::Man handles conservatively to preserve command names and copy/paste behavior. Pod::Man is included in Perl core and is actively maintained.

OpenAPI::Modern is a Perl library that validates HTTP requests and responses against an OpenAPI v3.0, v3.1 or v3.2 document and returns a detailed JSON::Schema::Modern::Result describing any errors and the deserialized request or response data. It loads your OpenAPI description, uses the JSON::Schema::Modern evaluator to resolve $ref and schema dialects, and provides convenient methods such as validate_request, validate_response, find_path_item and recursive_get so you can map an incoming Mojo, Plack, Catalyst or Dancer2 message to the right operation and check parameters, headers, cookies, querystrings and bodies against the spec. The module bundles up-to-date metaschemas and media-type decoders, supports type coercion and optional default-population of missing values, and can be cached or serialized for faster startup in preforked deployments. Note that some less common features are not yet implemented, multipart messages are unsupported and the module does not itself enforce Authorization schemes, so for best results parse network messages into Mojolicious objects before validating. The most recent release fixes path matching for URIs containing URL-escaped characters and improves restoration of cached documents and format handlers after deserializing an OpenAPI::Modern object.

mb.pm is a single-file Perl tool that makes it easy to write and run Perl scripts containing multibyte literal text in many legacy encodings as well as UTF-8 and WTF-8, by transpiling MBCS source into safe octet-oriented Perl or by providing a runtime mb:: API for selective codepoint-aware operations. It supports Big5, Big5-HKSCS, EUC-JP, EUC-TW, GB18030, GBK, Shift_JIS / CP932, UHC, Johab, HP-15 and others, automatically escapes problematic multibyte sequences that collide with ASCII metacharacters, and rewrites regular expressions and character classes so they behave sensibly for multibyte codepoints while leaving traditional byte-oriented builtins unchanged. You can use it as a source filter on modern Perls, as a modulino wrapper (perl mb.pm script.pl) for older Perls, or call mb:: routines at runtime to get codepoint semantics where needed, and it also includes helpers for Windows globbing and filename handling. The author notes some tradeoffs and limits, for example the modulino wrapper path writes a transpiled .oo file and there are intentional omissions such as full Unicode property support and non ASCII casing, plus a few platform-specific quirks, but for anyone maintaining or writing Perl that must work with MBCS source text or porting JPerl-era scripts this module is highly practical.

CBOR::Free is a fast XS-based Perl library for encoding and decoding CBOR data, aimed at making compact binary data interchange easy from Perl. It converts common Perl values to CBOR and back, supports tagged values, Types::Serialiser booleans, optional preservation of shared or circular references, and several string-encoding modes so you can choose how text and binary data are represented. Decoding yields UTF-8-decoded Perl strings for CBOR text and undecoded scalars for binary, and the module will warn or throw on invalid or extra input so you get predictable error handling. Be aware that floating point behavior depends on your Perl build and that integer handling follows CBOR and Perl limits, so very large integers or non-IEEE floating types may need special handling. The distribution is experimental and its interface may change, but it is lightweight, performs competitively with other CBOR and binary serializers, and is licensed under the same terms as Perl.

JQ::Lite is a pure-Perl implementation of a jq-like JSON query engine that lets you run familiar dot-notation filters and pipelines from Perl code or the bundled jq-lite command-line tool without installing external binaries or XS modules. It supports traversal, optional-safe key access, array flattening and indexing, boolean filtering, pipe-style chaining, mapping/reduction helpers, many jq-compatible built-in functions, and an interactive REPL, and it returns native Perl scalars, arrayrefs, and hashrefs for further processing. The module is especially useful in minimal, locked-down, containerized, or air-gapped environments where the jq binary cannot be installed but jq-style querying is needed, and it can use JSON::PP by default with optional faster decoders if available. In the current 2.48 release the author fixed comparison handling for values produced by piped filters and restored reliable access to object fields named "count", improving correctness for chained queries.