CPANscan

Algorithm::QuadTree::XS is a high-performance XS (C) backend for the Algorithm::QuadTree family that gives you a drop-in, compatible replacement for the pure-Perl implementation and is used automatically when available. It provides the same quadtree API so you can index and query 2D shapes like rectangles and circles without changing your code, while delivering much faster insert and search operations and dramatically reduced tree-clearing time in recent releases. If your application needs spatial indexing or collision-style queries and the pure-Perl version feels slow, this module provides a straightforward way to get a significant speedup with minimal fuss.

Algorithm::QuadTree is a pure-Perl spatial index that stores rectangular and circular objects in a hierarchical quadtree so you can rapidly find everything that intersects a given rectangular or circular region. You create the tree by giving map bounds and depth, add objects (as rectangles or circles) with add, and then use getEnclosedObjects to retrieve items that overlap a query area; objects can be removed or the whole tree cleared and you can set a window and scale to support zoomed views. The module uses a pure-Perl backend by default but will use an optional XS backend if installed for better performance. It is handy for fast region queries and simple collision detection in canvases or map-like data, and note that you are responsible for providing unique object identifiers if you need them to be distinct.

SPVM::Time::Piece is a compact, feature rich date and time class for SPVM that makes common time handling tasks simple and familiar. You create objects from the epoch, localtime or gmtime, parse strings with strptime and format output with strftime or built in helpers like datetime and cdate. It gives easy access to components such as year, month, day, hour, minute and second and provides weekday, yearday, timezone offset, Julian and modified Julian dates and leap year checks. The module supports arithmetic and comparisons including add, subtract, add_months, add_years and truncate to units like day or hour, and you can clone instances when you need safe copies. If you need a straightforward, Perl style toolkit for manipulating and formatting dates and times in SPVM this module covers the essentials.

SPVM::Time::Local is a compact utility for SPVM programs that converts Sys::Time::Tm objects back into Unix epoch seconds, offering timegm to reverse gmtime and timelocal to reverse localtime. It is useful when you need to reconstruct an epoch timestamp from a broken‑down time structure provided by Sys->gmtime or Sys->localtime, and it enforces a defined Sys::Time::Tm argument or it throws an exception. The module is intentionally small and focused, relies on recent SPVM and SPVM::Sys releases for compatibility, is MIT licensed, and recent releases added MSVC support and portability improvements.

SPVM::Unicode::Normalize provides simple static methods to normalize UTF-8 text in SPVM programs using the standard Unicode forms NFC, NFD, NFKC, and NFKD. It is a port of Perl's Unicode::Normalize and calls the native utf8proc library for efficient, standards-compliant normalization so you get consistent string representations for comparison, storage, or display. Each method returns a normalized UTF-8 string and will throw an exception if you pass an undefined value or if the underlying utf8proc call fails. Use this module when you need reliable Unicode normalization in SPVM code.

SPVM::Unicode is a compact utility library that provides low-level Unicode helpers for SPVM programs, making it easy to read and manipulate Unicode data without wrestling with encoding details. It can parse UTF-8 strings into Unicode code points, test whether a code point is a valid Unicode scalar value, convert a code point back to a UTF-8 character, and convert whole strings between UTF-8, UTF-16 and UTF-32 representations. The uchar method reads a code point from a UTF-8 string by reference to an offset and advances that offset, returning -1 at end of string and the ERROR_INVALID_UTF8 value (-2) for malformed input, and uchar_to_utf8 returns undef for invalid code points; note that uchar will throw an exception if the offset reference is undefined. Recent updates switched to using raw utf8proc for improved handling and added MSVC support while bumping SPVM version requirements. If you need straightforward, well maintained conversions and code point operations in SPVM, this module is a practical choice.

exact::me is a tiny extension for the exact pragma that exports a single convenience function, me(), which returns the full path to the running program and can expand relative paths based on the program's directory. Call me() with no arguments to get a canonical path to $0, give it a relative path beginning with "." to resolve against the program's directory, or give a bare relative path to have it searched for at or above the program directory. It is intended as a lightweight helper when your script needs to locate resources or compute file paths relative to its own location and can be used either via exact's extension syntax or by loading exact::me directly. The module is small, permissively licensed under Artistic 2.0, and maintained on CPAN and GitHub; recent changes are minor maintenance updates such as metadata and policy tweaks.

exact::lib is a lightweight extension for the exact loader that makes it easy to add directories to Perl's @INC at compile time. By default it looks for a lib directory in the program's directory or the nearest ancestor and adds it to @INC. You can supply a space separated list of paths in the exact extension syntax. Absolute paths are inserted directly at the front of @INC. Relative paths that do not start with a dot are searched for at the program directory and upward through parent directories and the first match is added. Relative paths that begin with a dot are resolved relative to the program directory and added as absolute paths. Paths with spaces can be escaped with backslashes. Use it via use exact -lib or use exact 'lib(...)' or load it directly with use exact::lib to keep local or custom libraries available without changing PERL5LIB or environment settings.

exact::fun is a small extension for the exact framework that imports Function::Parameters into your namespace so you can write clear, named-parameter function and method declarations like fun and method with typed or defaulted parameter lists. You enable it through exact with use exact -fun or directly with use exact::fun, and you may opt to import the modifier helpers that come with Function::Parameters via use exact 'fun(mod)' or pull in Class::Method::Modifiers helpers with use exact 'fun(cmm)'. It is aimed at Perl developers who prefer concise, readable function and method signatures and want that style integrated into the exact environment. Recent releases updated the import mechanism to use Import::Into and adjusted the import signature to match exact v1.23, and a later update added a security policy.

exact::conf is a lightweight extension for the exact framework that integrates Config::App to provide cascading, merged application configuration. It exports a single conf function which returns a Config::App object so you can call conf->get('key') to read settings. You can load it via exact's extension interface or directly and you can disable Config::App's default file discovery by passing a false value, for example conf(0), and then specify your own configuration file at runtime. The module is a thin convenience layer that saves you from wiring Config::App into exact yourself.

exact::cli is a compact extension that brings the Util::CommandLine toolkit into the exact framework so you can add familiar command-line option parsing, usage output and POD-driven help to exact-based scripts. It is normally used via exact's extension interface, for example use exact -cli, -conf, -noutf8, but you can also load it directly with use exact::cli which will load exact with default options. The module imports common helpers like options, pod2usage and readmode and exposes singleton and podhelp helpers, noting that singleton and podhelp run at runtime rather than during import as they do in Util::CommandLine. If you are writing Perl command-line tools on top of exact and want a straightforward way to reuse proven argument parsing and help behavior, exact::cli provides that integration while deferring detailed behavior to the underlying Util::CommandLine documentation.

exact::class is a lightweight extension for the exact framework that makes it easy to build simple hash-based Perl classes with a fluent, chainable API inspired by Mojo::Base and Role::Tiny. You can enable it via use exact -class or use exact::class directly and then declare attributes with has or class_has, supply defaults or lazy code refs with attr, and construct objects with new. It also provides tap for injecting side effects into method chains, with to compose roles at compile time, and with_roles to create a new role-composed class or rebless an object at runtime while supporting a +Role shorthand. Class::Method::Modifiers is injected so you can use before, around, and after modifiers. Note that redefinitions are silent so last definition wins, and exact::class handles role composition slightly differently than Role::Tiny with the class taking precedence over role attributes in conflicts. The recent release only updates the author email and otherwise continues to focus on stable, minimalist class utilities.

exact is a compact "pseudo pragma" that lets you replace a long pile of common header lines with a single use exact call and sensible modern defaults. By default it turns on strict and warnings, enables current feature bundles while silencing experimental warnings, sets UTF-8 for source and standard handles, chooses C3 method resolution order, enables filehandle methods, imports common Carp helpers, provides try/catch support (via native features or Syntax::Keyword::Try or Try::Tiny), brings in PerlX::Maybe helpers, and autocleans your namespace. Every behavior can be tweaked or disabled with simple import flags and you can request specific feature bundles or a Perl version. exact is extensible through exact::YourThing plugins that can receive arguments and can also manage inheritance for parent modules. It also exposes utility methods like monkey_patch, add_isa, export/exportable and small helpers deat and deattry, making it a handy way to reduce boilerplate and standardize modern Perl setup across scripts and modules.

Util::CommandLine is a small convenience library for Perl command-line programs that wraps common utilities into an easy-to-use interface. It gives you an options() helper that builds on Getopt::Long and Pod::Usage to parse arguments, return a hashref of settings, and automatically wire up local POD-driven help and man flags. If you only need help/man handling there is podhelp, and pod2usage is re-exported for manual control. The module also exposes readmode from Term::ReadKey for hidden or raw input and a singleton helper that uses Proc::PID::File to prevent multiple instances of long-running scripts. If you write cron jobs, small CLI tools, or interactive scripts and want a lightweight, tested shortcut for parsing, help text and single-instance checks, this module collects those common tasks into a tidy package.

Unit::Duration is a Perl module for parsing, normalizing and converting human‑readable time durations using fully customizable unit tables. It turns inputs like "4d 6h 4d 3h" into a canonical form, can compress values so they carry up into larger units, and can return numeric totals in any unit such as hours or days. You define how units relate to each other via a table so the module can model work-time conventions like an 8‑hour day or a 5‑day week or any other custom calendar, and you can control output formatting such as letter/short/long labels, spacing, and pluralization. The API is simple: instantiate with new, normalize strings with canonicalize, convert totals with sum_as, and manage tables with set_table and get_table_string/get_table_structure. This is useful for project management, scheduling, timesheet processing, and any situation where durations need consistent, customizable representation.

Time::DoAfter is a small Perl singleton that helps you pace work by ensuring a named action does not run until a configured interval has passed since its last run. You register actions by label along with either a fixed wait time or a two-element range and then call do to execute the action; the module will delay the call as needed so each invocation begins at least the configured interval after the previous one. It supports multiple concurrent labels so you can independently rate limit different hosts or job types, records a history of runs, and provides methods to read and set last-run times, adjust wait values, and get or replace a label's subroutine. Range waits are chosen randomly between the endpoints and do returns the actual time waited. The module is lightweight, handy for throttling web requests or pacing periodic tasks, and uses Time::HiRes for accurate timing.

Sub::Versions makes it easy to maintain multiple versions of the same Perl subroutine by letting you tag subs with attributes like :v1 or :v2 and automatically wiring symbol table entries so the plain method name calls the highest-numbered version while explicit versioned names like simple_method_v2 are injected for direct access. You can invoke an older implementation via the attribute name on the invocant, for example $obj->v1->simple_method, or select a version by constraint with subver('>= 42', 'method')->(), and version labels must be of the form vN where only the relative ordering matters. It is aimed at straightforward API evolution and backward compatibility in classes and modules, and you should be aware that defining a manual method name that matches an injected versioned name will trigger a redefinition warning. Recent maintenance releases added a security policy and updated the author contact information.

SQL::Abstract::Complete is a Perl helper for programmatically building full SELECT statements from simple Perl data structures, extending SQL::Abstract to make joins, aliases, GROUP BY, HAVING, ORDER BY and pagination easy to express. You pass it an arrayref describing tables and joins, an arrayref of fields or expressions, a WHERE hashref in the same style as SQL::Abstract, and an options hashref for group_by, having, order_by and rows/page or limit, and it returns a ready-to-run SQL string plus bind values. It also offers a part_join option to control how the SQL fragments are concatenated for easier reading. This module is useful if you want to generate complex, parameterized SELECTs in Perl without hand-crafting SQL, and it otherwise inherits behavior from SQL::Abstract so that existing SQL::Abstract knowledge applies.

Mojolicious::Plugin::ToolkitRenderer makes it easy to use the Template Toolkit inside Mojolicious applications by adding a "tt" template handler and a render_tt helper so you can render Template Toolkit templates from controllers or inline in your app. It passes a config hash directly to Template::Toolkit for full control, and provides plugin-specific settings to name an inline template key, expose the Mojolicious controller into templates, and supply a custom error handler. You can also supply a context callback to define Template Toolkit vmethods or filters, so you get the usual Template Toolkit power while integrating cleanly with Mojolicious views and paths. This module is a good fit if you prefer Template Toolkit for rendering in Mojolicious apps and want simple integration and error customization, and recent releases have tightened security policy and modernized Perl version requirements.

Mojolicious::Plugin::CaptchaPNG is a lightweight Mojolicious plugin that generates PNG image CAPTCHAs and validates user responses, serving an image route (default /captcha) and storing the answer in the session while providing controller helpers like get_captcha_value, set_captcha_value, check_captcha_value and clear_captcha_value. It uses GD::Image to render text from a required TTF font and offers many appearance and behavior options such as image size, font size, rotation, noise, colors, custom value generators and display formatting. The plugin expects Mojolicious 9.39 or newer with encrypted sessions and will warn if your app secrets lack entropy, and it also provides hooks to supply custom encrypt and decrypt routines; recent releases have strengthened randomness by using Crypt::URandom and added security guidance. Use this module when you want an easy to configure, server‑side CAPTCHA solution embedded directly into a Mojolicious application without relying on external services.

Mojolicious::Plugin::CSRF is a lightweight plugin that helps protect Mojolicious web applications from Cross Site Request Forgery by generating a session-backed token and validating it against a form field, URL parameter, or request header for state-changing requests. It exposes a csrf helper to get or delete the token, build token-aware URLs, set up responses, and run the check which by default raises a Mojo::Exception on failure and can call your custom success or failure handlers. The plugin can be hooked into the request lifecycle to automatically insert hidden token fields into HTML forms and is highly configurable, including custom token generators, header and parameter names, which HTTP methods and paths to check, and custom hooks. The author emphasizes that it is effective when used correctly. Recent releases improved cryptographic randomness by adopting Crypt::URandom and added a security policy to address CPANSec recommendations.

MojoX::Log::Dispatch::Simple is a small adapter that lets you replace Mojolicious' built-in Mojo::Log with a Log::Dispatch (or Log::Dispatch-like) logger while preserving the logging methods and levels Mojolicious expects. It maps between the two systems' level names, provides is_* checks, and can install convenient controller helpers so you can call $c->debug or $c->info directly while the actual output is handled by your Log::Dispatch setup. You can supply a format_cb to control how recent log entries appear on Mojolicious error pages, tune how many entries are kept with max_history_size, and still manipulate the underlying Log::Dispatch object after construction. The module is intentionally simple and flexible, and recent updates removed forced UTF-8 encoding and added a security policy while keeping compatibility fixes for newer Mojolicious releases.

Business::BR::NFSe is a lightweight Perl client for Brazil's national NFSe REST API that lets your application issue and retrieve municipal service invoices (NFS-e) directly from the government's Emissor Nacional. It aims to cover the common 80 percent of use cases with minimal code so it is easy to drop into existing scripts. You instantiate it with provider defaults and an ICP-Brasil certificate and private key in PEM form, call emitir with required fields such as series, sequential DPS number, issue date, taker ID (CPF, CNPJ or foreign marker), service codes, description and amount, and receive an HTTP::Tiny-style response that includes the invoice access key on success. A danfse method returns the printable PDF bytes for a given access key. Note that this module only issues service invoices (NFS-e) and not product invoices (NFe), documentation is provided in Portuguese, and this is the initial 0.01 release.

App::Dest provides a simple command line tool called "dest" for managing deployment state in development projects, letting you write and run small deploy, verify, and revert scripts as named actions. You initialize a project, tell dest which directories to watch, and create action sets (each action is a trio of deploy, revert, and verify files) so you can deploy, revert, verify, diff, and synchronize your working environment with the codebase as branches change. It supports declaring dependencies via a dest.prereq marker, running action files through local wrappers called dest.wrap, dry runs, and a watch file you can commit so teammates can initialize the same set of watched paths. Dest is designed for development and reproducing historical states rather than full production provisioning, and is inspired by Sqitch for database-style change management.

MojoX::Linda is a small, opinionated command-line wrapper around the Mojolicious development server morbo that tries to guess sensible defaults so you can start a development server with minimal fuss. It supplies a linda CLI for selecting the application, production mode, morbo backend, listen addresses, files or directories to watch, and verbosity, and when you leave options out it will try to autodetect a Mojolicious app in the current directory, pick the first open port between 3000 and 3999, and load settings from Config::App under mojolicious/linda with command-line flags taking precedence. The module is useful for developers who want a quick, hassle-reducing way to run morbo, but the author cautions that its heuristics can be overenthusiastic. Recent releases added a security policy and fixed configuration-loading quirks.

MojoX::ConfigAppStart is a tiny helper for launching Mojolicious web applications using settings from a Config::App configuration, so you can bootstrap your app with convention rather than boilerplate. It picks the Config::App environment from MOJO_MODE or PLACK_ENV and falls back to "development", which makes running under morbo or hypnotoad work as you would expect. The module exposes a single start method that calls Mojolicious::Commands->start_app using a default control module of Application::Control or a module name you provide. Use this when you want a simple, predictable way to start a Mojolicious app that follows your Config::App environment.

Log::Dispatch::Email::Mailer is a Log::Dispatch::Email subclass that sends log messages via Email::Mailer, making it easy to turn Log::Dispatch alerts into real email notifications. It supports simple text emails, HTML messages, attachments and template-driven content so you can craft rich, branded alerts. By default messages are buffered and sent together when the logger is flushed or destroyed, but buffering can be disabled to send each log line immediately. You can also pass in your own Email::Mailer object to control transport options such as SMTP. When using templates the module provides the template with a "message" string of joined log lines and a "messages" arrayref of individual entries. Use this module when you want flexible, templated email alerts from a Perl logging setup.

Lingua::ManagementSpeak is a Perl module that generates realistic-sounding managerial filler text and complete mock documents for use as lorem ipsum for technical content. It can produce individual words from template meta-words, full sentences, paragraphs, bulleted lists, headers, and an entire document tree with nested heading levels, and it returns simple Perl data structures so you can format or post-process the output however you like. You can drive the output with short meta-strings that map to categories like noun, verb, adjective, phrase, or conditional inserts such as maybe_1/4_noun, or use higher-level methods to generate bodies and documents with configurable paragraph and bullet parameters. There is also a to_html helper that converts a body or document into basic HTML, but the author notes it is simple and may not validate against W3C rules so it is best for quick previews rather than production web pages.

Geo::GoogleEarth::AutoTour converts GPS Track or Path exports (KML/KMZ) into Google Earth camera Tours so you can replay a recorded route as a smooth fly‑through. You feed it a KML string or a KMZ filehandle and the main tour() function produces KML for a Tour and can write a KMZ suitable for loading in Google Earth. The module includes helpers to unpack and pack KMZ, parse Track or Path coordinates, and build tours from point lists while letting you tune camera tilt, playback speed, trimming at start or end, gaps between points, initial move and wait times, and altitude adjustments or modes. It is aimed at anyone who wants to turn logged GPS tracks into a realistic animated view in Google Earth, with sane defaults for typical use and options for pilots, travelers, and mapping hobbyists who need more control. Recent maintenance releases have focused on test and infrastructure updates and adding a security policy and minor fixes.

Finance::Google::Portfolio is a compact Perl helper for interacting with Google Finance portfolios by automating the web interface rather than using an official API. It can log in with a Google username and password, fetch the contents of one of your numbered portfolios, add basic transactions such as buys or sells, and update the portfolio watchlist by setting a space separated list of symbols. Returned portfolio data is a Perl data structure you can inspect to get holdings and other details, and transaction calls accept common fields like symbol, shares, price, commission, date and optional notes. Because Google deprecated its Finance API this module relies on web scraping and requires HTTPS/SSL support in LWP, and the author warns that the code is minimally tested and has little error handling so it is not suitable for production or mission critical use.