trilean-regex 1.0.2 → 1.0.4

package/dist/errors.d.cts

@@ -4,10 +4,9 @@
  *
  * This is the only error this package's parser ever throws. There is no partial-AST return, no best-effort fallback -- a pattern either parses completely into a `RegexNode` or this is thrown, matching the "clear parse error, not a fuzzy runtime failure" goal a portable grammar exists for in the first place.
  */
-declare class RegexParseError extends Error {
+export declare class RegexParseError extends Error {
   readonly pattern: string;
   readonly index: number;
   constructor(pattern: string, index: number, reason: string);
 }
-//#endregion
-export { RegexParseError };
+//#endregion

package/dist/errors.d.ts

@@ -4,10 +4,9 @@
  *
  * This is the only error this package's parser ever throws. There is no partial-AST return, no best-effort fallback -- a pattern either parses completely into a `RegexNode` or this is thrown, matching the "clear parse error, not a fuzzy runtime failure" goal a portable grammar exists for in the first place.
  */
-declare class RegexParseError extends Error {
+export declare class RegexParseError extends Error {
   readonly pattern: string;
   readonly index: number;
   constructor(pattern: string, index: number, reason: string);
 }
-//#endregion
-export { RegexParseError };
+//#endregion

package/dist/matcher.d.cts

@@ -7,9 +7,9 @@ import { CompiledNfa } from "./nfa.cjs";
  *
  * Runs in O(length x states) time and allocates no more than two small state sets at a time, regardless of the pattern's shape -- there is no exponential blow-up for any input this compiles, which is the whole reason this package builds an automaton instead of calling a backtracking engine.
  */
-declare function matchesNfa(nfa: CompiledNfa, input: string): boolean;
+export declare function matchesNfa(nfa: CompiledNfa, input: string): boolean;
 /** A parsed and compiled pattern, ready to test any number of inputs without re-parsing or re-compiling. */
-interface CompiledPattern {
+export interface CompiledPattern {
   /** Whether any substring of `input` matches this pattern -- see `matchesNfa`. */
   test: (input: string) => boolean;
 }
@@ -19,11 +19,10 @@ interface CompiledPattern {
  * Prefer this over `testPattern` when the same pattern will be tested against more than one input: it parses and compiles exactly once, and the returned `CompiledPattern.test` is then only the O(length x states) simulation.
  * @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
  */
-declare function compilePattern(pattern: string): CompiledPattern;
+export declare function compilePattern(pattern: string): CompiledPattern;
 /**
  * Parses `pattern` and tests it against `input` in one call. Equivalent to `compilePattern(pattern).test(input)`, and exactly as cheap for a single test -- prefer `compilePattern` instead when the same pattern will be reused, so the parse and compile steps happen once rather than once per input.
  * @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
  */
-declare function testPattern(pattern: string, input: string): boolean;
-//#endregion
-export { CompiledPattern, compilePattern, matchesNfa, testPattern };
+export declare function testPattern(pattern: string, input: string): boolean;
+//#endregion

package/dist/matcher.d.ts

@@ -7,9 +7,9 @@ import { CompiledNfa } from "./nfa.js";
  *
  * Runs in O(length x states) time and allocates no more than two small state sets at a time, regardless of the pattern's shape -- there is no exponential blow-up for any input this compiles, which is the whole reason this package builds an automaton instead of calling a backtracking engine.
  */
-declare function matchesNfa(nfa: CompiledNfa, input: string): boolean;
+export declare function matchesNfa(nfa: CompiledNfa, input: string): boolean;
 /** A parsed and compiled pattern, ready to test any number of inputs without re-parsing or re-compiling. */
-interface CompiledPattern {
+export interface CompiledPattern {
   /** Whether any substring of `input` matches this pattern -- see `matchesNfa`. */
   test: (input: string) => boolean;
 }
@@ -19,11 +19,10 @@ interface CompiledPattern {
  * Prefer this over `testPattern` when the same pattern will be tested against more than one input: it parses and compiles exactly once, and the returned `CompiledPattern.test` is then only the O(length x states) simulation.
  * @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
  */
-declare function compilePattern(pattern: string): CompiledPattern;
+export declare function compilePattern(pattern: string): CompiledPattern;
 /**
  * Parses `pattern` and tests it against `input` in one call. Equivalent to `compilePattern(pattern).test(input)`, and exactly as cheap for a single test -- prefer `compilePattern` instead when the same pattern will be reused, so the parse and compile steps happen once rather than once per input.
  * @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
  */
-declare function testPattern(pattern: string, input: string): boolean;
-//#endregion
-export { CompiledPattern, compilePattern, matchesNfa, testPattern };
+export declare function testPattern(pattern: string, input: string): boolean;
+//#endregion

package/dist/nfa.d.cts

@@ -6,7 +6,7 @@ type CharTest = (codeUnit: number) => boolean;
  *
  * `anchorStart`/`anchorEnd` are what let `^`/`$` live anywhere in the pattern -- inside a group, inside an alternation branch -- rather than only at the very start or end of the whole pattern text: they are ordinary epsilon transitions that the closure walk additionally gates on the absolute string position, so `^`'s condition ("this position is index 0 of the whole input") is checked at the moment the automaton would step through it, not baked into where `^` was allowed to appear syntactically.
  */
-type NfaState = {
+export type NfaState = {
   kind: "char";
   test: CharTest;
   to: number;
@@ -23,12 +23,11 @@ type NfaState = {
 } | {
   kind: "match";
 };
-interface CompiledNfa {
+export interface CompiledNfa {
   readonly states: readonly NfaState[];
   readonly start: number;
   readonly matchState: number;
 }
 /** Compiles a `RegexNode` AST into a Thompson-construction NFA, ready for `matchesNfa` (see `matcher.ts`) to simulate. Construction is linear in the size of the AST -- bounded repetition is the only node kind that can multiply state count beyond that, by exactly the multiple its own bound names, which is a property of what `{n,m}` means rather than of this algorithm. */
-declare function compileToNfa(node: RegexNode): CompiledNfa;
-//#endregion
-export { CompiledNfa, NfaState, compileToNfa };
+export declare function compileToNfa(node: RegexNode): CompiledNfa;
+//#endregion

package/dist/nfa.d.ts

@@ -6,7 +6,7 @@ type CharTest = (codeUnit: number) => boolean;
  *
  * `anchorStart`/`anchorEnd` are what let `^`/`$` live anywhere in the pattern -- inside a group, inside an alternation branch -- rather than only at the very start or end of the whole pattern text: they are ordinary epsilon transitions that the closure walk additionally gates on the absolute string position, so `^`'s condition ("this position is index 0 of the whole input") is checked at the moment the automaton would step through it, not baked into where `^` was allowed to appear syntactically.
  */
-type NfaState = {
+export type NfaState = {
   kind: "char";
   test: CharTest;
   to: number;
@@ -23,12 +23,11 @@ type NfaState = {
 } | {
   kind: "match";
 };
-interface CompiledNfa {
+export interface CompiledNfa {
   readonly states: readonly NfaState[];
   readonly start: number;
   readonly matchState: number;
 }
 /** Compiles a `RegexNode` AST into a Thompson-construction NFA, ready for `matchesNfa` (see `matcher.ts`) to simulate. Construction is linear in the size of the AST -- bounded repetition is the only node kind that can multiply state count beyond that, by exactly the multiple its own bound names, which is a property of what `{n,m}` means rather than of this algorithm. */
-declare function compileToNfa(node: RegexNode): CompiledNfa;
-//#endregion
-export { CompiledNfa, NfaState, compileToNfa };
+export declare function compileToNfa(node: RegexNode): CompiledNfa;
+//#endregion

package/dist/parser.d.cts

@@ -6,6 +6,5 @@ import { d as RegexNode } from "./ast-D8HLFxxv.cjs";
  * Never returns a partial result: a pattern either parses completely, with nothing left over, or this throws `RegexParseError` naming exactly where parsing could not proceed.
  * @throws `RegexParseError` if `pattern` is not a complete, valid pattern in this grammar.
  */
-declare function parseRegex(pattern: string): RegexNode;
-//#endregion
-export { parseRegex };
+export declare function parseRegex(pattern: string): RegexNode;
+//#endregion

package/dist/parser.d.ts

@@ -6,6 +6,5 @@ import { d as RegexNode } from "./ast-D8HLFxxv.js";
  * Never returns a partial result: a pattern either parses completely, with nothing left over, or this throws `RegexParseError` naming exactly where parsing could not proceed.
  * @throws `RegexParseError` if `pattern` is not a complete, valid pattern in this grammar.
  */
-declare function parseRegex(pattern: string): RegexNode;
-//#endregion
-export { parseRegex };
+export declare function parseRegex(pattern: string): RegexNode;
+//#endregion

package/dist/shorthand-classes.d.cts

@@ -1,8 +1,7 @@
 import { a as CharClassNode } from "./ast-D8HLFxxv.cjs";
 //#region src/shorthand-classes.d.ts
 /** The letter each shorthand class is written with, case distinguishing the positive form (`d`, `w`, `s`) from its negation (`D`, `W`, `S`). */
-type ShorthandClassLetter = "d" | "D" | "w" | "W" | "s" | "S";
+export type ShorthandClassLetter = "d" | "D" | "w" | "W" | "s" | "S";
 /** Expands a shorthand class letter (`d`/`D`/`w`/`W`/`s`/`S`) to the `CharClassNode` it stands for. Uppercase negates the corresponding lowercase letter's ranges rather than owning a separate range table, since a shorthand class and its negation are the same set by definition. */
-declare function expandShorthandClass(letter: ShorthandClassLetter): CharClassNode;
-//#endregion
-export { ShorthandClassLetter, expandShorthandClass };
+export declare function expandShorthandClass(letter: ShorthandClassLetter): CharClassNode;
+//#endregion

package/dist/shorthand-classes.d.ts

@@ -1,8 +1,7 @@
 import { a as CharClassNode } from "./ast-D8HLFxxv.js";
 //#region src/shorthand-classes.d.ts
 /** The letter each shorthand class is written with, case distinguishing the positive form (`d`, `w`, `s`) from its negation (`D`, `W`, `S`). */
-type ShorthandClassLetter = "d" | "D" | "w" | "W" | "s" | "S";
+export type ShorthandClassLetter = "d" | "D" | "w" | "W" | "s" | "S";
 /** Expands a shorthand class letter (`d`/`D`/`w`/`W`/`s`/`S`) to the `CharClassNode` it stands for. Uppercase negates the corresponding lowercase letter's ranges rather than owning a separate range table, since a shorthand class and its negation are the same set by definition. */
-declare function expandShorthandClass(letter: ShorthandClassLetter): CharClassNode;
-//#endregion
-export { ShorthandClassLetter, expandShorthandClass };
+export declare function expandShorthandClass(letter: ShorthandClassLetter): CharClassNode;
+//#endregion

package/package.json

@@ -1,17 +1,30 @@
 {
   "name": "trilean-regex",
-  "version": "1.0.2",
   "description": "A portable regular-expression grammar -- a true regular language, with a Thompson-construction reference matcher -- so a pattern means the same thing in process and wherever trilean-sql can push it down to a database's own engine.",
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ExaDev/trilean.git",
-    "directory": "packages/trilean-regex"
-  },
-  "homepage": "https://github.com/ExaDev/trilean/tree/main/packages/trilean-regex",
+  "version": "1.0.4",
   "bugs": {
     "url": "https://github.com/ExaDev/trilean/issues"
   },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@exadev/eslint-config": "3.0.0",
+    "@types/node": "^26.4.0",
+    "@vitest/coverage-v8": "^5.0.0",
+    "eslint": "^10.9.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.6",
+    "globals": "^17.11.0",
+    "prettier": "^3.9.6",
+    "publint": "^0.3.24",
+    "tsdown": "^0.23.0",
+    "turbo": "^2.10.12",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.68.0",
+    "vitest": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
   "exports": {
     ".": {
       "types": {
@@ -30,63 +43,50 @@
       "require": "./dist/*.cjs"
     }
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
+  "homepage": "https://github.com/ExaDev/trilean/tree/main/packages/trilean-regex",
+  "keywords": [
+    "finite-automaton",
+    "isomorphic",
+    "nfa",
+    "parser",
+    "regex",
+    "regular-expression",
+    "regular-language",
+    "trilean"
+  ],
+  "license": "MIT",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "publishConfig": {
     "access": "public",
     "provenance": true,
     "registry": "https://registry.npmjs.org/"
   },
-  "sideEffects": false,
-  "engines": {
-    "node": ">=20"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExaDev/trilean.git",
+    "directory": "packages/trilean-regex"
   },
-  "license": "MIT",
   "scripts": {
-    "build": "turbo run _build",
     "_build": "tsdown",
-    "lint": "turbo run _lint",
     "_lint": "eslint . --fix --cache --max-warnings 0",
-    "typecheck": "turbo run _typecheck _typecheck:attw",
+    "_prepush": "true",
+    "_test": "vitest run --project unit",
+    "_test:coverage": "vitest run --project unit --coverage",
     "_typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.node.json",
     "_typecheck:attw": "attw --pack",
+    "build": "turbo run _build",
+    "lint": "turbo run _lint",
+    "prepublishOnly": "pnpm run lint && pnpm run typecheck && pnpm run test && pnpm run build && publint && attw --pack",
+    "prepush": "turbo run _prepush",
     "test": "turbo run _test",
-    "_test": "vitest run --project unit",
     "test:coverage": "turbo run _test:coverage",
-    "_test:coverage": "vitest run --project unit --coverage",
-    "prepush": "turbo run _prepush",
-    "_prepush": "true",
-    "prepublishOnly": "pnpm run lint && pnpm run typecheck && pnpm run test && pnpm run build && publint && attw --pack"
+    "typecheck": "turbo run _typecheck _typecheck:attw"
   },
-  "keywords": [
-    "regex",
-    "regular-expression",
-    "regular-language",
-    "finite-automaton",
-    "nfa",
-    "parser",
-    "trilean",
-    "isomorphic"
-  ],
-  "devDependencies": {
-    "@arethetypeswrong/cli": "^0.18.5",
-    "@exadev/eslint-config": "2.12.1",
-    "@types/node": "^26.4.0",
-    "@vitest/coverage-v8": "^4.1.11",
-    "eslint": "^10.9.1",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.6",
-    "globals": "^17.11.0",
-    "prettier": "^3.9.6",
-    "publint": "^0.3.24",
-    "tsdown": "^0.22.14",
-    "turbo": "^2.10.12",
-    "typescript": "^6.0.3",
-    "typescript-eslint": "^8.68.0",
-    "vitest": "^4.1.11"
-  }
+  "sideEffects": false,
+  "type": "module",
+  "types": "./dist/index.d.ts"
 }