parseman 0.19.0 → 0.20.0

package/dist/regex/classes.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Low-level regex char-class primitives, shared by every hand-rolled regex
+ * analysis in the codebase — the interpreter's first-set walker
+ * (`./first-set.ts`), `regex()`'s short-scan fast path, and codegen's scannable
+ * lowering (`../compiler/scannable-run.ts`). Kept dependency-free (no combinator,
+ * no codegen imports) so it lands in even the leanest interpreter bundle.
+ *
+ * Everything here parses a regex STRUCTURE to code-point ranges; nothing encodes
+ * a specific byte meaning ("this is whitespace"). `\d`/`\w` lower to their ASCII
+ * ranges (correct for the default, non-`u` engine); `\s` uses the fixed
+ * `SPACE_RANGES` set (unaffected by the `u` flag).
+ */
+/** Single-char escapes whose code point is fixed regardless of context. */
+export declare const CLASS_ESCAPES: Record<string, number>;
+/**
+ * `\s`'s code-point set per the spec's `WhiteSpace` + `LineTerminator`
+ * productions — TAB/LF/VT/FF/CR, SPACE, NBSP, and the Unicode `Zs` space
+ * separators. Fixed regardless of the `u` flag, so always safe to lower.
+ */
+export declare const SPACE_RANGES: Array<[number, number]>;
+/**
+ * ASCII code-point ranges for the shorthand classes we lower. `\d`/`\w` are
+ * ASCII-only in the default (non-`u`) engine; `\s` maps to `SPACE_RANGES`.
+ */
+export declare function shorthandRanges(ch: 'd' | 'w' | 's'): Array<[number, number]>;
+/** `\uXXXX` at `body[i]` → its code point and the index past it, or null. */
+export declare function readUnicodeEscape(body: string, i: number): {
+    cp: number;
+    next: number;
+} | null;
+/**
+ * Parse a regex char-class body (the chars BETWEEN `[` and `]`, negation `^`
+ * already stripped by the caller) to code-point ranges. `\d`/`\w`/`\s` expand to
+ * their ranges; `\uXXXX` and the fixed single-char escapes resolve to their code
+ * point; any other letter escape (`\D`, `\W`, `\S`, `\b`, …) returns null rather
+ * than being mis-read as a literal letter, so callers fall back to a safe
+ * over-approximation instead of a wrong set.
+ */
+export declare function parseClassRanges(body: string): Array<[number, number]> | null;
+//# sourceMappingURL=classes.d.ts.map

package/dist/regex/classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classes.d.ts","sourceRoot":"","sources":["../../src/regex/classes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAgD,CAAA;AAEjG;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAGhD,CAAA;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAQ5E;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAK9F;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAyC7E"}

package/dist/regex/first-set.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Hand-rolled first-set analysis for `regex()` terminals — the interpreter's
+ * replacement for the old `regexp-tree`-backed analyzer (~264 KB). A `regex()`
+ * terminal's first-set is used ONLY to let `choice()` do first-char dispatch
+ * (see `choice.ts`); it is never consulted for whether a match succeeds. So this
+ * analyzer only has to be SOUND as an OVER-approximation: every char the pattern
+ * can actually start with must be in the returned set. Any construct it can't
+ * pin down widens to `any()` (— "could start with anything" —), which only
+ * disables a dispatch fast path, never changes a parse. Under-approximating
+ * (dropping a real start char) WOULD be a bug: dispatch would skip a matching
+ * arm. The soundness fuzz test (`test/unit/regex-first-set.test.ts`) checks this
+ * against the real `RegExp` engine as an oracle.
+ *
+ * It parses the regex into a tiny AST (single-char matchers, sequence,
+ * alternation, repetition, zero-width) reusing the shared char-class primitives
+ * in `./classes.ts`, then walks the AST unioning first-sets through the nullable
+ * prefix — the same shape the `regexp-tree` walker used.
+ *
+ * Note: flags are not consulted (matching the prior `regexp-tree` seam, which
+ * parsed `/${source}/` with no flags), so an `/i` pattern's first-set is its
+ * literal-case set. Sound for dispatch because the interpreter's `/i` regex arms
+ * are compared case-sensitively at the same seam.
+ */
+import type { FirstSet } from '../types.ts';
+/**
+ * Compute a regex terminal's first-set and newline-start flag from its SOURCE
+ * (no delimiters, no flags). Over-approximates: an unparseable pattern degrades
+ * to `{ any, canMatchNewline: true }` — the same conservative value the prior
+ * `regexp-tree` seam returned on a parse failure.
+ */
+export declare function firstSetFromRegex(source: string): {
+    firstSet: FirstSet;
+    canMatchNewline: boolean;
+};
+//# sourceMappingURL=first-set.d.ts.map

package/dist/regex/first-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-set.d.ts","sourceRoot":"","sources":["../../src/regex/first-set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAqQ3C;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAalG"}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "parseman",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "packageManager": "pnpm@10.15.1",
-  "description": "Parser combinators that compile to optimized JavaScript \u2014 use as a library or as a build-time macro",
+  "description": "Parser combinators that compile to optimized JavaScript — use as a library or as a build-time macro",
   "type": "module",
   "author": "Matthew Dean <matthew-dean@users.noreply.github.com>",
   "repository": {
@@ -95,7 +95,6 @@
     "magic-string": "~0.30.21",
     "oxc-parser": "~0.137.0",
     "oxc-resolver": "~11.23.0",
-    "regexp-tree": "~0.1.27",
     "unplugin": "~3.0.0"
   }
 }

package/dist/combinators/regex-analyze.d.ts

@@ -1,6 +0,0 @@
-import type { FirstSet } from '../types.ts';
-export declare function firstSetFromRegex(pattern: string): {
-    firstSet: FirstSet;
-    canMatchNewline: boolean;
-};
-//# sourceMappingURL=regex-analyze.d.ts.map

package/dist/combinators/regex-analyze.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"regex-analyze.d.ts","sourceRoot":"","sources":["../../src/combinators/regex-analyze.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAG3C,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAOnG"}