parseman 0.46.0 → 0.47.0

package/dist/compiler/codegen.d.ts

@@ -1,334 +0,0 @@
-/**
- * Compile a Combinator<T> definition tree into an optimized JavaScript function.
- *
- * Design: every sub-emitter uses early-return on failure. Fallible contexts
- * (optional, sepBy loops, many loops) use labeled blocks so early-exit is a
- * `break <label>` rather than an IIFE return — no function call, no result
- * object allocation per node.
- */
-import type { Combinator, FirstSet, ParseResult, ParseContext, ParseError } from '../types.ts';
-import { type HostMode } from '../cst/host-mode.ts';
-import { type DuplicationWarnLevel } from '../analysis/duplication.ts';
-/**
- * A rule's LEADING first-set as a fuse-resolvable recipe.
- *
- * A recipe is a UNION of ORDERED CHAINS (`alts`). Each chain is the leading-term
- * sequence of one alternative; `fusedBody()` resolves it left-to-right against the
- * WINNING rules, UNIONING each segment's first-set and STOPPING after the first
- * segment that is not nullable. A segment is either
- *   - a concrete first-set (`set`) with its build-time-known `nullable` flag, or
- *   - a rule REFERENCE (`ref`) whose first-set AND nullability are resolved at fuse
- *     time (`nullable` is a conservative placeholder until then).
- *
- * Why the ORDER + per-segment nullability matter (the bug this shape fixes): a rule
- * like `sequence(g.CssAstSyntaxStatementAtRuleName, prelude, ';')` leads with a
- * cross-artifact ref. At compile time that ref's nullability is unknown, so a flat
- * "concrete chars + ref names" recipe would conservatively treat it as nullable and
- * union the FOLLOWING terms' first-sets — and the prelude's first-set is `any` (a
- * `scanTo`), collapsing the whole recipe to `any` and losing first-char dispatch.
- * Keeping the leading chain ordered lets fuse-time resolution see the ref is actually
- * NON-nullable and STOP — so the arm gates on `{@}`, exactly as a grammar-local
- * `regex(/@…/)` would. Grammar authors had to hand-copy those recognizers to work
- * around this; the ordered chain removes the need.
- *
- * Soundness: the resolved set is always a SUPERSET of the rule's true first chars.
- * An unknown/opaque construct contributes its shallow `_meta.firstSet`; a ref whose
- * nullability can't be resolved defaults to nullable (keep unioning — never drops a
- * valid first char).
- */
-export type FirstSetSeg = {
-    set: FirstSet;
-    nullable: boolean;
-    ref?: string;
-};
-export type FirstSetRecipe = {
-    alts: FirstSetSeg[][];
-};
-export declare function leadingFirstSetRecipe(p: Combinator<unknown>, seen?: Set<Combinator<unknown>>): FirstSetRecipe;
-import { type GrammarCoveragePlan } from './grammar-coverage-ids.ts';
-import { type GrammarReflection } from '../cst/reflection.ts';
-/**
- * Runtime prelude helper for the structural-node capture gate. Answers "does the
- * injected `_ctx.build` host read its (n+1)th positional arg?" — `.length` alone
- * under-counts with rest/default params and can't see through a bound fn, so a
- * rest/default param or an `arguments` reference forces full capture (output-safe).
- * Plain positional and bound-native hosts (the common case) trust `.length`.
- * Emitted (memoized on `_ctx._pmCapTL`/`_pmCapST`) wherever a structural node()
- * arity-gates host capture; shared, un-namespaced, mirrors `_EMPTY_TL` placement.
- */
-export declare const HOST_READS_DECL = "const _hostReads = (b, n) => { if (b === undefined) return false; let s; try { s = Function.prototype.toString.call(b) } catch (e) { return true } if (/\\barguments\\b/.test(s)) return true; const m = /^[^(]*\\(([\\s\\S]*?)\\)/.exec(s); if (m && /\\.\\.\\.|=/.test(m[1])) return true; return b.length > n }";
-/**
- * Raw-children coercion, hoisted out of every node site.
- *
- * The `rawChildren` entry for a produced value is either the value itself (when it
- * is already a tagged CST thing) or a synthesized leaf. Inlined, that test plus the
- * leaf literal is ~300 bytes emitted PER `node()` site — measured at 2.6% of
- * `example/css`, 7.1% of `probe/node-scale-32`, 11.2% of `probe/trivia-off`.
- *
- * Allocation behaviour is preserved exactly, which is why `span` is the last
- * parameter and may be absent:
- *  - line-tracked grammars already hold their span in a local, so they pass it and
- *    nothing extra is allocated;
- *  - untracked grammars pass nothing and the `{ start, end }` literal is built
- *    INSIDE, on the fallback branch only — exactly where the inline form built it.
- * Passing the literal as an argument instead would have allocated a span on the
- * fast path, which is the one thing this hoist must not do.
- */
-export declare const RAW_ENTRY_DECL = "const _rawEntry = (v, input, s, e, span) => (typeof v === 'object' && v !== null && (v._tag === 'node' || v._tag === 'leaf' || v._tag === 'parseError')) ? v : { _tag: 'leaf', value: typeof v === 'string' ? v : (typeof v === 'object' && v !== null ? input.slice(s, e) : ''), span: span ?? { start: s, end: e } }";
-export declare const LINE_TRACK_DECL = "const _trackLines = (_ctx, input, start, end) => { const from = _ctx._lineScannedTo ?? 0; if (end <= from) return; for (let i = from; i < end; i++) if (input.charCodeAt(i) === 10) _ctx._lineStarts.push(i + 1); _ctx._lineScannedTo = end }";
-export declare const LINE_SPAN_DECL: string;
-/** Begin capturing regexes that fall back to `RegExp.exec` (didn't lower). */
-export declare function beginLoweringCapture(): void;
-/** Stop capturing and return the un-lowered regex sources seen since begin. */
-export declare function endLoweringCapture(): string[];
-/** One emitted function whose inline budget was spent, and what it cost. */
-export type InlineCapSite = {
-    /** The emitted function that hit the budget. */
-    fn: string;
-    /** Approximate combinator nodes in the ref body that became a call instead. */
-    nodes: number;
-};
-/** Begin collecting inline-cap sites. */
-export declare function beginInlineCapCapture(): void;
-/** Stop collecting and return the sites, in emission order (deterministic). */
-export declare function endInlineCapCapture(): InlineCapSite[];
-/**
- * One line per capped function, in the shape the degradation formatter uses so the two
- * read alike. Says exactly what happened and exactly what to do about it, because a
- * diagnostic that does neither is noise.
- */
-export declare function formatInlineCapSites(sites: readonly InlineCapSite[], max: number): string[];
-export declare function firstSetCond(codeVar: string, fs: FirstSet): string;
-export declare function __setForceDisjointIf(on: boolean): void;
-export declare function __setForceNoSharedPrefix(on: boolean): void;
-export { assertHostModeCompatible, FUSED_HOST_MODE, FUSED_HOST_ELIDED } from '../cst/host-mode.ts';
-export type { HostMode } from '../cst/host-mode.ts';
-export type CompiledParser<T> = {
-    parse(input: string, pos?: number): ParseResult<T>;
-    /** Like parse(), but with a caller-supplied ParseContext (e.g. `_triviaLog` for CST grammars). */
-    parseWithContext(input: string, ctx: ParseContext, pos?: number): ParseResult<T>;
-    /**
-     * Like parse(), but activates the error-collection channel. Recovery points
-     * (expect()) collect their ParseErrors into result.errors instead of only
-     * embedding them as values. Always returns ParseOk — top-level failures are
-     * still ParseFail.
-     */
-    parseWithErrors(input: string, pos?: number): ParseResult<T> & {
-        errors: ParseError[];
-    };
-    /** The generated source (for inspection / future source maps) */
-    source: string;
-    /**
-     * A self-contained JS expression (IIFE) that evaluates to a parse function.
-     * Safe to inline directly into transformed source — no external references
-     * except for runtime-fallback parsers embedded via closures.
-     * Returns null if the parser cannot be fully inlined (e.g. contains user
-     * closures that can't be serialized).
-     */
-    inlineExpression: string | null;
-    /** Present only when compiled with `{ coverage: true }`. */
-    coverageDefinitions?: readonly import('./grammar-coverage-ids.ts').GrammarCoverageDefinition[];
-};
-/**
- * INLINE EXPANSION CAP — a bound on how much one emitted function may grow by pasting
- * single-use ref bodies into it.
- *
- * The decision procedure, in one sentence: **each emitted function gets a budget of
- * `INLINE_MAX_NODES` combinator nodes of inlined single-use refs; once it is spent, the
- * remaining single-use refs in that function become named functions and are called.**
- *
- * What this limits, precisely. `emitLazy` inlines a ref that is used ONCE and is not
- * recursive, because hoisting a function nobody else calls is pure overhead. That is
- * correct per ref and unbounded in aggregate: a rule whose body is a chain of
- * single-use helpers expands transitively, and the expansion has no ceiling that a
- * grammar author can see or predict. This is NOT the identity-keyed hoisting of a
- * MULTIPLY-referenced subtree (`HOIST_MIN_SUBTREE` above) — that already works, and a
- * shared object referenced 1 or 38 times emits flat. Conflating the two is what made
- * the size problem look like a duplication problem.
- *
- * Why a per-function budget rather than a per-ref size limit or a whole-artifact budget:
- *  - a per-ref limit bounds each paste but not the transitive total, which is the
- *    quantity that actually grows;
- *  - a whole-artifact budget needs an eviction order, and any order that depends on
- *    which function was compiled first is a decision the author cannot predict;
- *  - a per-function budget needs no eviction order at all. Emission order within one
- *    function is the grammar's own left-to-right order, so "the refs after the budget
- *    runs out" is stable and explainable.
- *
- * Charge unit is `subtreeSizes` — the same approximate node count `HOIST_MIN_SUBTREE`
- * uses, so the two policies are denominated in one currency.
- *
- * The default is measured, not chosen by taste: see `bench/size/inline-cap.md` for the
- * size/speed sweep this number came from.
- */
-export declare const INLINE_MAX_NODES = 1000;
-/**
- * Resolve the cap: explicit option wins, then `PARSEMAN_MAX_INLINE`, then the default.
- * The escape hatch is deliberately explicit and OFF by default — a grammar that really
- * wants unbounded inlining sets `Infinity` and says so, rather than discovering that a
- * silent policy took it away. Read ONCE per compile and stored on the ctx, so a single
- * compile can never observe two different values.
- */
-export declare function resolveInlineMax(explicit?: number): number;
-/**
- * Dependency manifest for the linkable form: for each rule in the map, the set
- * of OTHER rule names its body references (by name). A referenced rule is a
- * boundary — we record the edge and do NOT descend into it (its own deps are its
- * own entry). Used by the linker for à la carte dep-closure selection and the
- * compose-time name-closure check (every referenced name must resolve in the
- * final set). Self-references are included (a recursive rule depends on itself).
- */
-export declare function ruleDependencies(ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>): Map<string, string[]>;
-/**
- * Compile a combinator tree into an optimized parse function at runtime.
- *
- * Uses `new Function` internally, so it will fail in environments with a strict
- * Content Security Policy that omits `'unsafe-eval'`. Prefer the interpreter or
- * macro build plugin in those cases.
- *
- * @see https://www.greadme.com/blog/security/what-is-content-security-policy-complete-guide
- */
-/**
- * The `duplication` compile option. A bare level is shorthand for `{ level }`; the
- * object form adds the `accept` allowlist (finding ids acknowledged as intentional)
- * and the ranking knobs.
- *
- * DEFAULT IS `'off'`, unlike gating. An ungated hot choice is a cliff with no other
- * symptom; a duplicated subtree is a maintenance cost the author may have chosen.
- * More to the point, most findings here are CANDIDATES that need an AST check
- * before they are applied — a diagnostic that prints "candidate, verify" on every
- * build teaches people to stop reading it. Run it deliberately (a lint script, a
- * review pass, `PARSEMAN_DUPLICATION=warn`), not on every compile.
- */
-export type DuplicationOption = DuplicationWarnLevel | {
-    level?: DuplicationWarnLevel;
-    accept?: Iterable<string>;
-    minSize?: number;
-    maxFindings?: number;
-    entryName?: string;
-};
-export declare function compile<T>(combinator: Combinator<T>, mapFnSources?: string[], opts?: {
-    recovery?: boolean;
-    hostMode?: HostMode;
-    coverage?: boolean;
-    duplication?: DuplicationOption;
-    trackLines?: boolean;
-    maxInline?: number;
-}): CompiledParser<T>;
-export declare function compileRuleMap(ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>, opts?: {
-    trivia?: Combinator<unknown>;
-    scanSkip?: Combinator<unknown>[];
-    recovery?: boolean;
-    hostMode?: HostMode;
-    trackLines?: boolean;
-    coverage?: boolean;
-    duplication?: DuplicationOption;
-    maxInline?: number;
-}): {
-    keys: string[];
-    replacement: string;
-    hostMode: HostMode;
-    hostBranchElided: boolean;
-    reflection: GrammarReflection;
-    coverageDefinitions?: readonly import('./grammar-coverage-ids.ts').GrammarCoverageDefinition[];
-} | null;
-/**
- * The linkable form of a rule map (RULE_ABI_PLAN §3): the same compiled rule
- * bodies as `compileRuleMap`, but returned as **splice-able pieces** under a
- * namespace `ns` so multiple independently-compiled maps fuse into one scope
- * (see `fuseRules`). `ns` MUST be non-empty and unique per artifact (the caller
- * derives it — module identity in the macro, a counter in `compile()`).
- *
- *   prelude  — namespaced hoisted decls (regexes, expected, `_mf`/`_build`, and
- *              private `_pf` helper fns). Sentinels / `_EMPTY_TL`
- *              are NOT here — they are SHARED, emitted once by the linker.
- *   ruleFns  — name → `function _r_<Name>(…) { … }` source (the composition
- *              surface; siblings call these by name).
- *   wrappers — name → public `(input,pos,ctx) => ParseResult` wrapper source.
- *   deps     — name → referenced rule names (from `ruleDependencies`).
- *
- * Returns null on the same "can't inline" conditions as `compileRuleMap`.
- */
-export type LinkablePieces = {
-    /**
-     * The parseman version that produced this artifact (the ARTIFACT VERSION LOCK; see
-     * `src/version.ts`). REQUIRED — `compileLinkable` always stamps it. `fusedBody`
-     * refuses to link a piece whose stamp differs from the linking parseman OR is absent
-     * (a stale pre-invariant artifact, whose recipe/pieces shape is unsupported).
-     * Artifacts are version-locked; the format carries no cross-version back-compat.
-     */
-    v: string;
-    ns: string;
-    keys: string[];
-    prelude: string[];
-    ruleFns: Map<string, string>;
-    wrappers: Map<string, string>;
-    /**
-     * Per-rule first-set (this artifact's own rules). fusedBody() uses the WINNING
-     * artifact's entry to resolve `/*@FS:rule:codevar@*​/true` dispatch placeholders
-     * emitted for rule-ref choice arms — sound under compose override.
-     */
-    firstSets: Map<string, FirstSet>;
-    /**
-     * Per-rule nullability (does the rule match the empty string?). `fusedBody()`
-     * reads it when resolving an ordered-chain recipe segment that REFERENCES this
-     * rule: a non-nullable ref terminates the leading chain (stop unioning the tail),
-     * a nullable one lets it continue. Optional/absent → treated as nullable (the safe
-     * default: keep unioning, never drop a valid first char).
-     */
-    nullable?: Map<string, boolean>;
-    /**
-     * Per-rule LEADING first-set recipe — a union of ordered leading-term chains.
-     * `fusedBody()` fixpoint-resolves the leading ref names over the WINNING rules so a
-     * `sequence(ref, …)`-led arm/node dispatches on the ref's real first char —
-     * matching a monolithic compile — instead of degrading to always-try because the
-     * ref baked `any`. Optional (absent for hand-built pieces → `any`, always try).
-     */
-    firstSetRecipes?: Map<string, FirstSetRecipe>;
-    deps: Map<string, string[]>;
-    needsEmptyTl: boolean;
-    needsHostReads: boolean;
-    needsRawEntry: boolean;
-    /** Compile-time host mode this piece was lowered for ('ast' when absent). */
-    hostMode?: HostMode;
-    /** Set when a direct builder's positioned-CST branch was omitted. */
-    hostBranchElided?: boolean;
-    /** True when this piece contains any direct `node(..., build)` reduction. */
-    hasDirectBuilders?: boolean;
-    /** True only when this piece has no direct builder or callback-based semantics. */
-    isRecognitionOnly?: boolean;
-    /** Per-rule CST node reflection for grammar-aware visitors. */
-    nodeMeta: Map<string, GrammarReflection>;
-    /**
-     * Transform (`_mf`) / build (`_build`) callback FUNCTIONS, injected into the
-     * fused scope via `_env` when their SOURCE isn't available (runtime `compile()`
-     * mode). Empty when the callbacks were inlined from source (macro mode). Keyed
-     * for `_env` as `<ns>mf` / `<ns>build`.
-     */
-    mfFns: ReadonlyArray<(...args: unknown[]) => unknown>;
-    buildFns: ReadonlyArray<(...args: unknown[]) => unknown>;
-};
-export declare function compileLinkable(ruleMapArg: ReadonlyArray<readonly [string, Combinator<unknown>]>, ns: string, opts?: {
-    trivia?: Combinator<unknown>;
-    scanSkip?: Combinator<unknown>[];
-    recovery?: boolean;
-    hostMode?: HostMode;
-    trackLines?: boolean;
-    captureTerminals?: boolean;
-    coverage?: GrammarCoveragePlan;
-    duplication?: DuplicationOption;
-    maxInline?: number;
-}): LinkablePieces | null;
-/**
- * Does this rule map reference a rule it doesn't define — a NAMED `ref` (`g.Foo`)
- * that never got `.define()`d? That is the SHARED-SHAPE signature: the grammar is a
- * shape with a hole, so it can't be inlined as a standalone parser, but it IS
- * linkable (`compileLinkable` emits a by-name `_r_Foo` call for the hole, bound at
- * fuse time). Callers use this to tell that case apart from a genuine
- * "couldn't compile, fall back to the interpreter".
- *
- * A `rules()` map's own `Object.entries` also leaks accessed-but-undefined names as
- * top-level entries, so both the entry values AND their bodies are scanned.
- */
-export declare function hasExternalRuleRef(ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>): boolean;
-//# sourceMappingURL=codegen.d.ts.map

package/dist/compiler/codegen.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/compiler/codegen.ts"],"names":[],"mappings":"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"}

package/dist/compiler/inline-build.d.ts

@@ -1,11 +0,0 @@
-import type { ParserDef } from '../types.ts';
-/**
- * When a node() build is a thin `mk(type, …)` wrapper, emit the object literal
- * at the call site instead of `_build[n](…)`.
- */
-export declare function analyzeMkInlineBuild(def: Extract<ParserDef, {
-    tag: 'node';
-}>): string | null;
-/** Object literal matching `stub-build.ts` `mk()` without the function call. */
-export declare function emitInlineMkNodeExpr(type: string, chV: string, rawV: string, spanExpr: string, tlV: string): string;
-//# sourceMappingURL=inline-build.d.ts.map

package/dist/compiler/inline-build.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inline-build.d.ts","sourceRoot":"","sources":["../../src/compiler/inline-build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AA+D5C;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,MAAM,GAAG,IAAI,CAmB5F;AAeD,gFAAgF;AAChF,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,GACV,MAAM,CAER"}

package/dist/compiler/inline-callback.d.ts

@@ -1,21 +0,0 @@
-/** Source text for a transform callback — macro `fnSrc` or arrow `toString()`. */
-export declare function transformFnSource(fn: Function, fnSrc?: string | null): string | null;
-/** `s => expr` / `() => expr` when expr only uses the param (+ builtins). */
-export declare function tryInlineUnaryTransform(src: string, valueVar: string): string | null;
-/** Parse `[a, , c]` destructuring slots (null = ignore). */
-export declare function parseArrayDestructure(pattern: string, arity: number): (string | null)[];
-/**
- * `([x, y]) => body` — substitute destructure names with sequence value vars.
- * Caller must ensure body only references slotted params (+ builtins).
- */
-export declare function tryInlineDestructureTransform(src: string, valueVars: string[]): string | null;
-/**
- * `([, tail]) => tail` / `([_, tail]) => tail` over dispatch().
- *
- * This is a codegen-only proof that the public `[selector, tail]` pair is not
- * observed, so dispatch may return the selected branch value directly. It is
- * intentionally narrower than general destructuring inlining: public dispatch
- * semantics stay unchanged unless the immediate transform discards the selector.
- */
-export declare function isDispatchTailOnlyTransform(src: string): boolean;
-//# sourceMappingURL=inline-callback.d.ts.map

package/dist/compiler/inline-callback.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inline-callback.d.ts","sourceRoot":"","sources":["../../src/compiler/inline-callback.ts"],"names":[],"mappings":"AASA,kFAAkF;AAClF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAKpF;AA4BD,6EAA6E;AAC7E,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAWpF;AAED,4DAA4D;AAC5D,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAQvF;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EAAE,GAClB,MAAM,GAAG,IAAI,CAaf;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAMhE"}

package/dist/compiler/line-index.d.ts

@@ -1,2 +0,0 @@
-export * from '../line-index.ts';
-//# sourceMappingURL=line-index.d.ts.map

package/dist/compiler/line-index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"line-index.d.ts","sourceRoot":"","sources":["../../src/compiler/line-index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA"}

package/dist/compiler/module-hoist.d.ts

@@ -1,106 +0,0 @@
-/**
- * MODULE-LEVEL HOIST OF BYTE-IDENTICAL FUSED DECLARATIONS
- * ======================================================
- *
- * Every `compose()` / `composeLeaf()` in a module lowers to its OWN self-contained
- * IIFE (`emitFusedSource` → `/* @__PURE__ *​/ (() => { … })()`). A module that
- * publishes N variants of one grammar — the jess shape: shared recognition pieces
- * plus N leaves differing only in `hostMode` / `trackLines` — therefore emits the
- * recognition piece's rule functions N times, under the SAME namespaced names,
- * in N sibling scopes. The namespace is content-addressed, so those N copies are
- * byte-identical: `probe/variants-4` emits 5 `_r_` rule functions, four of which
- * have exactly one distinct body across all four IIFEs.
- *
- * Measured on the committed size probe (bench/size/probe.ts), byte-identical
- * declaration text available for dedup:
- *
- *   probe/variants-2   41,446 B generated   9,557 B duplicated (23.1%)
- *   probe/variants-4   82,058 B generated  29,286 B duplicated (35.7%)
- *
- * This module collects the top-level declarations of every fused IIFE in one
- * module, decides which are safe to emit ONCE at module scope, and rewrites each
- * IIFE to drop its copy.
- *
- * THE CORRECTNESS PROBLEM, AND WHY THE DECISION IS KEYED ON THE NAME
- * -----------------------------------------------------------------
- * `_pfFail` is an identity sentinel: a rule function signals failure by returning
- * it and every caller tests `v === _pfFail`. Each IIFE declares its own
- * `const _pfFail = {}`, so today the producer and the consumer are always the same
- * object. A PARTIAL hoist breaks that: if some scopes read the module-level
- * sentinel while others keep a local one, a rule that FAILED returns object A and
- * its caller compares against object B — the test is false, and the failure is
- * read as a SUCCESS carrying the value `{}`. Silent wrong output, the worst class
- * of bug this compiler can have.
- *
- * So the hoist decision is made per DECLARED NAME, not per occurrence:
- *
- *   a name is hoistable only if EVERY declaration of that name anywhere in the
- *   module is byte-identical,
- *
- * and when it is, EVERY occurrence is removed and one copy is emitted at module
- * scope. A mixed state is unrepresentable: there is no code path that removes one
- * occurrence and keeps another. If two scopes ever disagreed about `_pfFail`'s
- * text, the name would have two distinct texts, would fail the uniformity test,
- * and NO scope would hoist it. `test/unit/module-hoist.test.ts` asserts both
- * directions.
- *
- * `_pfEnd` (`let _pfEnd`) is a single-slot out-parameter and is safe to share
- * unconditionally: the write is the last statement before a rule function returns
- * (src/compiler/codegen.ts, `pushNamedFnDecl` — `_pfEnd = <end>` immediately
- * precedes `return <value>`) and the read is the next statement at the call site
- * (`emitNamedFnCall` — `const _pfe = _pfEnd` immediately follows the sentinel
- * test). Nothing user-controlled runs between the write and the read, so even a
- * builder that re-enters another grammar cannot observe a stale slot: the nested
- * parse completes entirely before the outer write.
- *
- * FREE-VARIABLE FIXPOINT
- * ----------------------
- * A hoisted declaration must not reference anything that stayed IIFE-local. Every
- * top-level name of every IIFE is known here (the declarations ARE the input), so
- * a hoisted text is rejected if it mentions any name that is not itself hoisted,
- * iterated to a fixpoint. Reference detection is a `\bNAME\b` scan over the
- * declaration text: that over-approximates (it also matches inside strings and
- * comments), and over-approximation is the safe direction — it only ever blocks a
- * hoist, never permits an unsound one.
- *
- * This also disposes of the un-namespaced `_wcf<N>` hazard. `withCtx` names its
- * wrapper `_wcf${namedParsers.size}` with no namespace prefix, so two different
- * artifacts can both declare `_wcf0` with DIFFERENT bodies. Such a name has two
- * distinct texts, so it is not hoistable, and by the fixpoint nothing that
- * references it is hoistable either.
- *
- * SCOPE
- * -----
- * Hoisting is sound only because every macro replacement is made from the
- * plugin's top-level `for (const stmt of body)` loop — the call sites are all
- * module-level statements, so an IIFE's free variables can only resolve to
- * module-level bindings, which are still in scope at module level. The prelude is
- * inserted at the START of the earliest top-level statement that carries a
- * replacement, which is never earlier than the earliest IIFE, so no binding those
- * declarations already depended on moves out of scope.
- */
-/** Non-global marker test, for asking whether a generated replacement claimed any
- *  declarations (a `/g` regex would carry `lastIndex` between calls). */
-export declare const HOIST_MARKER_PROBE: RegExp;
-/** The names a generated top-level declaration binds. */
-export declare function declaredNames(text: string): string[];
-export type HoistResult = {
-    /** Declarations to emit ONCE at module scope, in first-claim order. Empty when
-     *  nothing qualified. Ends with a newline when non-empty. */
-    prelude: string;
-    /** Replace every marker in a generated source string with either nothing (the
-     *  declaration was hoisted) or its original text (it was not). */
-    resolve(src: string): string;
-    /** Diagnostics: bytes removed from the IIFEs, minus the bytes re-emitted once. */
-    savedBytes: number;
-    /** Names emitted at module scope. */
-    hoistedNames: string[];
-};
-export type ModuleHoist = {
-    /** Register one fused IIFE's top-level declarations; returns the marker lines to
-     *  emit in their place. */
-    claim(decls: readonly string[]): string[];
-    finalize(): HoistResult;
-};
-export declare function createModuleHoist(): ModuleHoist;
-//# sourceMappingURL=module-hoist.d.ts.map

package/dist/compiler/module-hoist.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"module-hoist.d.ts","sourceRoot":"","sources":["../../src/compiler/module-hoist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AASH;yEACyE;AACzE,eAAO,MAAM,kBAAkB,QAAsB,CAAA;AAWrD,yDAAyD;AACzD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAOpD;AAED,MAAM,MAAM,WAAW,GAAG;IACxB;iEAC6D;IAC7D,OAAO,EAAE,MAAM,CAAA;IACf;sEACkE;IAClE,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAA;IAClB,qCAAqC;IACrC,YAAY,EAAE,MAAM,EAAE,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB;+BAC2B;IAC3B,KAAK,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAAA;IACzC,QAAQ,IAAI,WAAW,CAAA;CACxB,CAAA;AAED,wBAAgB,iBAAiB,IAAI,WAAW,CAkF/C"}

package/dist/compiler/scannable-run.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scannable-run.d.ts","sourceRoot":"","sources":["../../src/compiler/scannable-run.ts"],"names":[],"mappings":"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"}

package/dist/compiler/scannable-terminal.d.ts

@@ -1,23 +0,0 @@
-/**
- * Lower scannable regex shapes to tight `charCodeAt` scan loops for terminal
- * `regex()` combinators (PERF_IDEAS §8). Trivia uses the SAME match core via
- * `scannable-run.ts` (`emitShapeMatch`); this module is just the terminal
- * wrapper: run the shared match, fail when it doesn't match, then slice the
- * value. Keeping one match core means terminal and trivia can never disagree on
- * what an incomplete token (unclosed string/comment) means.
- */
-import { type ScanShape } from './scannable-run.ts';
-export type ScanEmitCtx = {
-    ind: string;
-    pos: string;
-    valueVar: string;
-    /** Emit `if (cond) { failLine }` lines (no trailing blank). */
-    failIf: (cond: string) => string[];
-    fresh: (prefix?: string) => string;
-};
-/** Emit stmts for one terminal regex match, or null when the shape is unsupported. */
-export declare function emitScannableTerminal(shape: ScanShape, c: ScanEmitCtx): {
-    stmts: string[];
-    endVar: string;
-} | null;
-//# sourceMappingURL=scannable-terminal.d.ts.map

package/dist/compiler/scannable-terminal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scannable-terminal.d.ts","sourceRoot":"","sources":["../../src/compiler/scannable-terminal.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,KAAK,SAAS,EAAkB,MAAM,oBAAoB,CAAA;AAEnE,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,MAAM,CAAA;IAChB,+DAA+D;IAC/D,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAAE,CAAA;IAClC,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;CACnC,CAAA;AAED,sFAAsF;AACtF,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,EAChB,CAAC,EAAE,WAAW,GACb;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAO5C"}

package/dist/compiler/trivia-fast-path.d.ts

@@ -1,38 +0,0 @@
-import type { Combinator } from '../types.ts';
-import type { LabeledTriviaSpec } from '../cst/trivia-kinds.ts';
-import { type ScanShape } from './scannable-run.ts';
-/**
- * A trivia parser that lowers to a hand-rolled char-scan loop: `oneOrMore(choice(
- * …))` (or `many`, min≥1) where EVERY arm is a scannable shape (a `[X]+` run, a
- * `<lit>[^X]*` open-until-terminator, or a `<open>(?:…)*<close>` delimited token
- * — see scannable-run.ts). Returns the per-arm shapes, or a single-element list
- * for a bare scannable regex, or null (→ caller falls back to the regex/generic
- * trivia path). A single alternation regex is NOT scannable (one exec matches one
- * arm per call, defeating the loop).
- */
-export declare function analyzeTriviaFastPath(trivia: Combinator<unknown>): ScanShape[] | null;
-/** Emit a specialized `_tfN` that skips (unlabeled) trivia via a char-scan loop. */
-export declare function buildFastTriviaFnDecl(fnName: string, shapes: ScanShape[]): string;
-/**
- * A LABELED trivia parser whose every arm is scannable → per-arm shape + kind
- * index, or null. Same recognition as analyzeTriviaFastPath, but keyed by the
- * label table so the fast loop can log each chunk's category. It accepts any
- * structurally scannable arm set / arm count; labels do not affect recognition.
- */
-export declare function analyzeLabeledScannableRun(trivia: Combinator<unknown>): Array<{
-    shape: ScanShape;
-    kindIndex: number;
-    label: string;
-}> | null;
-/** Emit a labeled scannable trivia `_tfN`: char-scan loop with per-chunk kind capture. */
-export declare function buildLabeledScannableTriviaFnDecl(fnName: string, arms: ReadonlyArray<{
-    shape: ScanShape;
-    kindIndex: number;
-    label: string;
-}>): string;
-/** Labeled trivia with regex arms — per-chunk kind capture in compiled output. */
-export declare function buildLabeledRegexTriviaFnDecl(fnName: string, spec: LabeledTriviaSpec, reNames: string[]): string;
-export declare function labeledTriviaRegexArms(trivia: Combinator<unknown>): LabeledTriviaSpec | null;
-/** Labeled trivia via per-arm runtime parsers (non-regex or mixed arms). */
-export declare function buildLabeledRuntimeTriviaFnDecl(fnName: string, spec: LabeledTriviaSpec, rpStartIndex: number): string;
-//# sourceMappingURL=trivia-fast-path.d.ts.map

package/dist/compiler/trivia-fast-path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trivia-fast-path.d.ts","sourceRoot":"","sources":["../../src/compiler/trivia-fast-path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAG/D,OAAO,EAAE,KAAK,SAAS,EAAgE,MAAM,oBAAoB,CAAA;AAgCjH;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,EAAE,GAAG,IAAI,CAyBrF;AA2BD,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,CASjF;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAC1B,KAAK,CAAC;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,CAWtE;AAED,0FAA0F;AAC1F,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,aAAa,CAAC;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,GAC1E,MAAM,CAeR;AAED,kFAAkF;AAClF,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EAAE,GAChB,MAAM,CAmCR;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,iBAAiB,GAAG,IAAI,CAO5F;AAED,4EAA4E;AAC5E,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,iBAAiB,EACvB,YAAY,EAAE,MAAM,GACnB,MAAM,CAkCR"}