api #

CLI arguments container. Positional arguments stored in _, named flags/options as string keys. Produced by argv_parse or external parsers (mri, minimist, etc.).

Extracts alias mappings and canonical keys from a zod schema's metadata.

Useful for consumers building custom tooling (help generators, conflict detection, etc.). Results are cached per schema (WeakMap).

Note: Returns copies of the cached data to prevent mutation of internal cache.

Validates parsed CLI args against a zod schema.

Handles CLI-specific concerns before validation: 1. Validates schema (cached) - returns error if alias conflicts exist 2. Expands aliases defined in schema .meta({aliases: ['v']}) 3. Strips alias keys (required for strictObject schemas) 4. Validates with zod 5. After validation, syncs no- prefixed boolean flags with their base keys

Schema analysis is cached per schema (WeakMap) for performance.

Serializes Args to CLI string array for subprocess forwarding.

Handles CLI conventions: - Positionals first, then flags - Single-char keys get single dash, multi-char get double dash - Boolean true becomes bare flag, false is skipped - undefined values are skipped - no- prefixed keys skipped when base key is truthy (avoid contradiction) - When schema provided, extracts aliases and prefers shortest form

Schema analysis is cached per schema (WeakMap) for performance.

Validates a zod schema for CLI arg usage.

Checks for: - Alias conflicts with canonical keys - Duplicate aliases across different keys

Results are cached per schema (WeakMap). Safe to call multiple times.

Result of alias extraction from a schema. Includes canonical keys for downstream conflict detection.

Schema description for help text generation. Not used by args_parse/args_serialize directly - provided for consumers building CLI help output.

Parses raw CLI argv array into an Args object.

A lightweight, dependency-free alternative to mri/minimist with compatible behavior.

Features: - --flag → {flag: true} - --flag value → {flag: 'value'} or {flag: 123} (numeric coercion) - --flag=value → equals syntax - --flag= → {flag: ''} (empty string, differs from mri which returns true) - -f → {f: true} (short flag) - -f value → {f: 'value'} - -abc → {a: true, b: true, c: true} (combined short flags) - -abc value → {a: true, b: true, c: 'value'} (last flag gets value) - --no-flag → {flag: false} (negation prefix) - -- → stops flag parsing, rest become positionals - Positionals collected in _ array - Repeated flags become arrays

Intentional differences from mri: - --flag= returns '' (mri returns true) - --flag= next returns {flag: '', _: ['next']} (mri takes next as the value) - ---flag returns {'-flag': true} (mri strips all dashes) - ['--flag', ''] preserves '' (mri coerces to 0) - --__proto__ works as a normal key (mri silently fails)

The returned object uses Object.create(null) to prevent prototype pollution and allow any key name including __proto__ and constructor.

Value types supported in CLI arguments.

Async semaphore for concurrency limiting.

With Infinity permits, acquire() always resolves immediately.

Attaches an uncaughtException handler to the default registry.

Benchmark class for measuring and comparing function performance.

Compare benchmark results against the stored baseline.

Format a baseline comparison result as a human-readable string.

Format a baseline comparison result as JSON for programmatic consumption.

Load the current baseline from disk.

Save benchmark results as the current baseline.

Format results as JSON.

Format results as a Markdown table with key metrics. All times use the same unit for easy comparison.

Format results as grouped Markdown tables with headers between groups.

Format a number with fixed decimal places and thousands separators.

Format results as an ASCII table with percentiles, min/max, and relative performance. All times use the same unit for easy comparison.

Format results as a grouped table with visual separators between groups.

Compare two benchmark results for statistical significance. Uses Welch's t-test (handles unequal variances) and Cohen's d effect size.

Warmup function by running it multiple times. Detects whether the function is async based on return value.

Schema for the complete baseline file.

Options for comparing against a baseline.

Result of comparing current results against a baseline.

Schema for a single benchmark entry in the baseline.

Options for loading a baseline.

Options for saving a baseline.

Comparison result for a single task.

Options for benchmark comparison.

Result from comparing two benchmark stats.

Configuration options for a benchmark suite.

Options for table formatting.

A group definition for organizing benchmark results.

Result from running a single benchmark task.

Complete statistical analysis of timing measurements. Includes outlier detection, descriptive statistics, and performance metrics. All timing values are in nanoseconds.

Minimal stats interface for comparison. This allows comparing stats from different sources (e.g., loaded baselines).

A benchmark task to execute.

Resolves when the BLAKE3 WASM module is initialized and ready. Initialization starts eagerly on import. Idempotent — safe to await multiple times. In Node.js/Deno (sync init), this resolves immediately.

Builds a map of statically resolvable const bindings from a Svelte AST.

Scans top-level const variable declarations in both instance and module scripts. For each declarator with a plain Identifier pattern and a statically evaluable initializer, adds the binding to the map. Processes declarations in source order so that chained references resolve: const a = 'x'; const b = a; maps b to 'x'.

Skips destructuring patterns, let/var declarations, and declarations whose initializers reference dynamic values.

Returns n bounded to min and max.

Compares two map entries for sorting purposes. If the key is a string, it uses localeCompare for comparison. For other types, it uses >.

Component prop information for Svelte components.

Kept distinct from ParameterInfo despite structural similarity. Component props are named attributes with different semantics: no positional order when passing (<Foo {a} {b} /> = <Foo {b} {a} />), support two-way binding via $bindable rune.

A single branch in a conditional chain extracted from nested ternary expressions.

Configures the module-level styling function for colored output.

Returns the count of graphemes in a string, the individually rendered characters.

Useful for fast counting when .length is not available.

Creates a string id generator function, outputting ${name}_${count} by default.

Creates a counter constructor function, starting at 0.

Creates an object with a promise and its resolve/reject handlers.

Seeded pseudo-random number generator. DO NOT USE when security matters, use webcrypto APIs instead.

Seeded pseudo-random number generator using the Xoshiro128** algorithm. DO NOT USE when security matters, use webcrypto APIs instead.

Tracks elapsed time in milliseconds.

Minimum shape for a DAG node.

Result for a single node.

Options for running a DAG.

Result of a DAG execution.

Generate TypeScript import statement for a declaration.

Format declaration name with generic parameters for display.

Metadata for an exported declaration (function, type, class, component, etc.).

Extracted from TypeScript source and JSDoc/TSDoc comments at build time.

The kind of exported declaration.

Deep equality comparison that checks both structure and type.

Key behaviors:

- Compares by constructor to prevent type confusion (security: {} ≠ [], {} ≠ new Map(), new ClassA() ≠ new ClassB()) - Prevents asymmetry bugs: deep_equal(a, b) always equals deep_equal(b, a) - Compares only enumerable own properties (ignores prototypes, symbols, non-enumerable) - Special handling for: Date (timestamp), Number/Boolean (boxed primitives), Error (message/name) - Promises always return false (cannot be meaningfully compared) - Maps/Sets compare by reference for object keys/values

A deferred object with a promise and its resolve/reject handlers.

Removes leading and trailing spaces from each line of a string.

Converts a serialized cache string to a FetchValueCache.

Kills a child process and returns the result.

Kills all processes in the default registry.

Options for killing processes.

Generate a line-based diff between two strings using LCS algorithm.

Line diff result

Runs a function on each item with controlled concurrency. Like map_concurrent but doesn't collect results (more efficient for side effects).

Effect size magnitude interpretation (Cohen's d).

Frozen empty object with no properties, good for options default values.

Adds the substring ensured to the end of the source string if it's not already present.

Adds the substring ensured to the start of the source string if it's not already present.

Escapes a string for use inside a single-quoted JS string literal.

Uses a single-pass regex replacement to escape backslashes, single quotes, newlines, carriage returns, and Unicode line/paragraph separators.

Escapes a string for literal matching in a RegExp.

Escapes text for safe embedding in Svelte template markup.

Uses a single-pass regex replacement to avoid corruption that occurs with sequential .replace() calls (where the second replace matches characters introduced by the first).

Escapes four characters: - { → {'{'} and } → {'}'} — prevents Svelte expression interpretation - < → < — prevents HTML/Svelte tag interpretation - & → & — prevents HTML entity interpretation

The & escaping is necessary because runtime MdzNodeView.svelte renders text with {node.content} (a Svelte expression), which auto-escapes & to &. The preprocessor emits raw template text where & is NOT auto-escaped, so manual escaping is required to match the runtime behavior.

Recursively evaluates an expression AST node to a static string value.

Handles string Literal, TemplateLiteral (including interpolations when all expressions resolve), BinaryExpression with +, and Identifier lookup via an optional bindings map built by build_static_bindings. Returns null for dynamic expressions, non-string literals, or unsupported node types.

Extracts a static string value from a Svelte attribute value AST node.

Handles three forms: - Boolean true (bare attribute like inline) -- returns null. - Array with a single Text node (quoted attribute like content="text") -- returns the text data. - ExpressionTag (expression like content={'text'}) -- delegates to evaluate_static_expr.

Returns null for null literals, mixed arrays, dynamic expressions, and non-string values.

Specializes fetch with some slightly different behavior and additional features:

- throws on ratelimit errors to mitigate unintentional abuse - optional parse function called on the return value - optional cache (different from the browser cache, the caller can serialize it so e.g. dev setups can avoid hitting the network) - optional simplified API for authorization and data types (you can still provide headers directly)

Unlike fetch, this throws on ratelimits (status code 429) to halt whatever is happpening in its tracks to avoid accidental abuse, but returns a Result in all other cases. Handling ratelimit headers with more sophistication gets tricky because behavior differs across services. (e.g. Mastodon returns an ISO string for x-ratelimit-reset, but GitHub returns Date.now()/1000, and other services may do whatever, or even use a different header)

It's also stateless to avoid the complexity and bugs, so we don't try to track x-ratelimit-remaining per domain.

If the value is cached, only the cached safe subset of the headers are returned. (currently just etag and last-modified) Otherwise the full res.headers are included.

A filter function for file paths only.

Filter diff to only include lines within N lines of context around changes.

Finds an attribute by name on a component AST node.

Iterates the node's attributes array and returns the first Attribute node whose name matches. Skips SpreadAttribute, directive, and other node types.

Finds the position to insert new import statements within a script block.

Returns the end position of the last ImportDeclaration, or the start of the script body content if no imports exist.

The Flavored and Branded type helpers add varying degrees of nominal typing to other types. This is especially useful with primitives like strings and numbers.

Formats a byte count as a human-readable string.

Format a diff for display.

Format a number with fixed decimal places and thousands separators.

Formats a URL by removing 'https://', 'www.', and trailing slashes. Notably it does not remove 'http://', so the user can see that it's insecure.

Format options for diff output.

Decodes a hex string to a Uint8Array. Whitespace is stripped before parsing. Returns null for invalid hex.

Empties a directory, recursively by default. If should_remove is provided, only entries where it returns true are removed.

Checks if a file or directory exists.

Generate a formatted diff between two strings.

Combines diff_lines, filter_diff_context, and format_diff for convenience. Returns null if content is binary.

Generates indented import statement lines from an import map.

Default imports produce import Name from 'path'; lines. Named imports are grouped by path into import {a, b} from 'path'; lines.