trilean-regex 1.0.0 → 1.0.2

package/README.md

@@ -1,5 +1,7 @@
 # trilean-regex
 
+[![GitHub](https://img.shields.io/badge/GitHub-181717?logo=github&logoColor=white)](https://github.com/ExaDev/trilean) [![npm](https://img.shields.io/badge/npm-CB3837?logo=npm&logoColor=white)](https://www.npmjs.com/package/trilean-regex) [![Release](https://img.shields.io/github/v/release/ExaDev/trilean?filter=trilean-regex@*&label=release)](https://github.com/ExaDev/trilean/releases?q=trilean-regex%40) [![CI](https://img.shields.io/github/actions/workflow/status/ExaDev/trilean/ci.yml?branch=main)](https://github.com/ExaDev/trilean/actions)
+
 A portable regular-expression grammar -- a true regular language, with its own parser and a Thompson-construction reference matcher -- so a pattern means the same thing wherever it runs: in process here, and pushed down to a database's own engine by [`trilean-sql`](../trilean-sql).
 
 ## Why a new grammar

package/dist/matcher.cjs

@@ -68,8 +68,7 @@ function matchesNfa(nfa, input) {
 * Parses `pattern` (this package's grammar; see README.md) and compiles it to a reference matcher.
 *
 * 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.
+* @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
 */
 function compilePattern(pattern) {
 	const nfa = require_nfa.compileToNfa(require_parser.parseRegex(pattern));
@@ -77,8 +76,7 @@ function compilePattern(pattern) {
 }
 /**
 * 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.
+* @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
 */
 function testPattern(pattern, input) {
 	return compilePattern(pattern).test(input);

package/dist/matcher.d.cts

@@ -17,14 +17,12 @@ interface CompiledPattern {
  * Parses `pattern` (this package's grammar; see README.md) and compiles it to a reference matcher.
  *
  * 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.
+ * @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
  */
 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.
+ * @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
  */
 declare function testPattern(pattern: string, input: string): boolean;
 //#endregion

package/dist/matcher.d.ts

@@ -17,14 +17,12 @@ interface CompiledPattern {
  * Parses `pattern` (this package's grammar; see README.md) and compiles it to a reference matcher.
  *
  * 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.
+ * @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
  */
 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.
+ * @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
  */
 declare function testPattern(pattern: string, input: string): boolean;
 //#endregion

package/dist/matcher.js

@@ -67,8 +67,7 @@ function matchesNfa(nfa, input) {
 * Parses `pattern` (this package's grammar; see README.md) and compiles it to a reference matcher.
 *
 * 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.
+* @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
 */
 function compilePattern(pattern) {
 	const nfa = compileToNfa(parseRegex(pattern));
@@ -76,8 +75,7 @@ function compilePattern(pattern) {
 }
 /**
 * 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.
+* @throws `RegexParseError` if `pattern` is not a valid pattern in this grammar.
 */
 function testPattern(pattern, input) {
 	return compilePattern(pattern).test(input);

package/dist/parser.cjs

@@ -316,8 +316,7 @@ var Parser = class {
 * Parses a pattern in this package's grammar (see README.md) into a `RegexNode` AST.
 *
 * 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.
+* @throws `RegexParseError` if `pattern` is not a complete, valid pattern in this grammar.
 */
 function parseRegex(pattern) {
 	const parser = new Parser(pattern);

package/dist/parser.d.cts

@@ -4,8 +4,7 @@ import { d as RegexNode } from "./ast-D8HLFxxv.cjs";
  * Parses a pattern in this package's grammar (see README.md) into a `RegexNode` AST.
  *
  * 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.
+ * @throws `RegexParseError` if `pattern` is not a complete, valid pattern in this grammar.
  */
 declare function parseRegex(pattern: string): RegexNode;
 //#endregion

package/dist/parser.d.ts

@@ -4,8 +4,7 @@ import { d as RegexNode } from "./ast-D8HLFxxv.js";
  * Parses a pattern in this package's grammar (see README.md) into a `RegexNode` AST.
  *
  * 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.
+ * @throws `RegexParseError` if `pattern` is not a complete, valid pattern in this grammar.
  */
 declare function parseRegex(pattern: string): RegexNode;
 //#endregion

package/dist/parser.js

@@ -315,8 +315,7 @@ var Parser = class {
 * Parses a pattern in this package's grammar (see README.md) into a `RegexNode` AST.
 *
 * 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.
+* @throws `RegexParseError` if `pattern` is not a complete, valid pattern in this grammar.
 */
 function parseRegex(pattern) {
 	const parser = new Parser(pattern);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trilean-regex",
-  "version": "1.0.0",
+  "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": {
@@ -74,7 +74,7 @@
   ],
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
-    "@exadev/eslint-config": "^2.10.2",
+    "@exadev/eslint-config": "2.12.1",
     "@types/node": "^26.4.0",
     "@vitest/coverage-v8": "^4.1.11",
     "eslint": "^10.9.1",