trilean-regex 0.0.0 → 1.0.0

package/dist/shorthand-classes.cjs

@@ -0,0 +1,74 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/shorthand-classes.ts
+function codeOf(char) {
+	return char.charCodeAt(0);
+}
+function range(fromChar, toChar) {
+	return {
+		from: codeOf(fromChar),
+		to: codeOf(toChar)
+	};
+}
+function single(char) {
+	const codeUnit = codeOf(char);
+	return {
+		from: codeUnit,
+		to: codeUnit
+	};
+}
+/** `\d` -- the ASCII digits `0`-`9`. Fixed, not locale- or engine-dependent: a shorthand's whole purpose here is to expand to the same ranges regardless of which dialect a `trilean-sql` compiler is targeting, so its expansion is a constant this package owns rather than a delegation to the host's own `RegExp` notion of "digit". */
+const DIGIT_RANGES = [range("0", "9")];
+/** `\w` -- ASCII letters, digits, and underscore. The ECMAScript definition of "word character" without the `u`/`unicode` flag, which is the one this grammar's non-Unicode-scalar code-unit model corresponds to. */
+const WORD_RANGES = [
+	range("A", "Z"),
+	range("a", "z"),
+	range("0", "9"),
+	single("_")
+];
+/** `\s` -- the ASCII whitespace characters ECMAScript's `\s` matches outside the `u` flag's extra Unicode space separators: space, tab, newline, carriage return, form feed, vertical tab. */
+const SPACE_RANGES = [
+	single(" "),
+	single("	"),
+	single("\n"),
+	single("\r"),
+	single("\f"),
+	single("\v")
+];
+/** 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. */
+function expandShorthandClass(letter) {
+	switch (letter) {
+		case "d": return {
+			kind: "charClass",
+			negated: false,
+			ranges: DIGIT_RANGES
+		};
+		case "D": return {
+			kind: "charClass",
+			negated: true,
+			ranges: DIGIT_RANGES
+		};
+		case "w": return {
+			kind: "charClass",
+			negated: false,
+			ranges: WORD_RANGES
+		};
+		case "W": return {
+			kind: "charClass",
+			negated: true,
+			ranges: WORD_RANGES
+		};
+		case "s": return {
+			kind: "charClass",
+			negated: false,
+			ranges: SPACE_RANGES
+		};
+		case "S": return {
+			kind: "charClass",
+			negated: true,
+			ranges: SPACE_RANGES
+		};
+		default: throw new Error("unreachable shorthand class letter");
+	}
+}
+//#endregion
+exports.expandShorthandClass = expandShorthandClass;

package/dist/shorthand-classes.d.cts

@@ -0,0 +1,8 @@
+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";
+/** 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 };

package/dist/shorthand-classes.d.ts

@@ -0,0 +1,8 @@
+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";
+/** 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 };

package/dist/shorthand-classes.js

@@ -0,0 +1,73 @@
+//#region src/shorthand-classes.ts
+function codeOf(char) {
+	return char.charCodeAt(0);
+}
+function range(fromChar, toChar) {
+	return {
+		from: codeOf(fromChar),
+		to: codeOf(toChar)
+	};
+}
+function single(char) {
+	const codeUnit = codeOf(char);
+	return {
+		from: codeUnit,
+		to: codeUnit
+	};
+}
+/** `\d` -- the ASCII digits `0`-`9`. Fixed, not locale- or engine-dependent: a shorthand's whole purpose here is to expand to the same ranges regardless of which dialect a `trilean-sql` compiler is targeting, so its expansion is a constant this package owns rather than a delegation to the host's own `RegExp` notion of "digit". */
+const DIGIT_RANGES = [range("0", "9")];
+/** `\w` -- ASCII letters, digits, and underscore. The ECMAScript definition of "word character" without the `u`/`unicode` flag, which is the one this grammar's non-Unicode-scalar code-unit model corresponds to. */
+const WORD_RANGES = [
+	range("A", "Z"),
+	range("a", "z"),
+	range("0", "9"),
+	single("_")
+];
+/** `\s` -- the ASCII whitespace characters ECMAScript's `\s` matches outside the `u` flag's extra Unicode space separators: space, tab, newline, carriage return, form feed, vertical tab. */
+const SPACE_RANGES = [
+	single(" "),
+	single("	"),
+	single("\n"),
+	single("\r"),
+	single("\f"),
+	single("\v")
+];
+/** 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. */
+function expandShorthandClass(letter) {
+	switch (letter) {
+		case "d": return {
+			kind: "charClass",
+			negated: false,
+			ranges: DIGIT_RANGES
+		};
+		case "D": return {
+			kind: "charClass",
+			negated: true,
+			ranges: DIGIT_RANGES
+		};
+		case "w": return {
+			kind: "charClass",
+			negated: false,
+			ranges: WORD_RANGES
+		};
+		case "W": return {
+			kind: "charClass",
+			negated: true,
+			ranges: WORD_RANGES
+		};
+		case "s": return {
+			kind: "charClass",
+			negated: false,
+			ranges: SPACE_RANGES
+		};
+		case "S": return {
+			kind: "charClass",
+			negated: true,
+			ranges: SPACE_RANGES
+		};
+		default: throw new Error("unreachable shorthand class letter");
+	}
+}
+//#endregion
+export { expandShorthandClass };

package/package.json

@@ -1,5 +1,92 @@
 {
   "name": "trilean-regex",
-  "version": "0.0.0",
-  "private": false
+  "version": "1.0.0",
+  "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",
+  "bugs": {
+    "url": "https://github.com/ExaDev/trilean/issues"
+  },
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.ts",
+        "require": "./dist/index.d.cts"
+      },
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./*": {
+      "types": {
+        "import": "./dist/*.d.ts",
+        "require": "./dist/*.d.cts"
+      },
+      "import": "./dist/*.js",
+      "require": "./dist/*.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "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",
+    "_typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.node.json",
+    "_typecheck:attw": "attw --pack",
+    "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"
+  },
+  "keywords": [
+    "regex",
+    "regular-expression",
+    "regular-language",
+    "finite-automaton",
+    "nfa",
+    "parser",
+    "trilean",
+    "isomorphic"
+  ],
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@exadev/eslint-config": "^2.10.2",
+    "@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"
+  }
 }