@stll/regex-set-wasm 0.1.1

package/dist/wasm.d.mts

@@ -0,0 +1,117 @@
+//#region src/core.d.ts
+type NativeBinding = {
+  RegexSet: new (patterns: string[], options?: NativeOptions | undefined | null) => NativeRegexSetInstance;
+  _uax29Boundaries: (haystack: Buffer) => number[];
+};
+type NativeOptions = {
+  wholeWords?: boolean | undefined;
+  unicodeBoundaries?: boolean | undefined;
+};
+type NativeRegexSetInstance = {
+  patternCount: number;
+  isMatch(haystack: string): boolean;
+  _isMatchBuf(haystack: Buffer): boolean;
+  _findIterPacked(haystack: string): Uint32Array;
+  _findIterPackedBuf(haystack: Buffer): Uint32Array;
+  whichMatch(haystack: string): number[];
+  replaceAll(haystack: string, replacements: string[]): string;
+};
+/** Set the native backend. Must be called once
+ *  before any class constructor. */
+/** Options for constructing a RegexSet. */
+type Options = {
+  /**
+   * Only match whole words. Wraps each pattern
+   * with `\b...\b`.
+   * @default false
+   */
+  wholeWords?: boolean;
+  /**
+   * Use Unicode word boundaries. When `true`,
+   * `\b` treats accented letters, CJK, etc. as
+   * word characters (correct for non-English text).
+   * When `false` (default), `\b` uses ASCII
+   * semantics matching JS `RegExp` behavior.
+   *
+   * Zero performance overhead in either mode;
+   * boundaries are verified inline per match.
+   * Automatically uses UAX#29 segmentation for
+   * Thai/CJK/Lao/Khmer/Myanmar text.
+   * @default true
+   */
+  unicodeBoundaries?: boolean;
+  /**
+   * Case-insensitive matching. Wraps each pattern
+   * with `(?i-u:...)` for ASCII case folding.
+   * Uses `-u` to prevent DFA state explosion from
+   * Unicode case tables.
+   *
+   * Edge `\b`/`\B` boundaries and leading bare-flag
+   * prefixes (e.g. `(?m)`, `(?m-s)`) are extracted
+   * before wrapping so they remain outside the `-u`
+   * scope, preserving `unicodeBoundaries` semantics.
+   * Patterns already containing any `(?{flags}-u`
+   * group (from RegExp `/i`, inline `(?i)`, or
+   * `scopeInlineFlags`) are not double-wrapped.
+   * @default false
+   */
+  caseInsensitive?: boolean;
+};
+/** A named pattern entry. */
+type NamedPattern = {
+  /** The regex pattern (string or RegExp). */pattern: string | RegExp; /** Optional name for this pattern. */
+  name?: string;
+};
+/** A pattern entry: string, RegExp, or named. */
+type PatternEntry = string | RegExp | NamedPattern;
+/** A single match result. */
+type Match = {
+  /** Index of the pattern that matched. */pattern: number; /** Start UTF-16 code unit offset. */
+  start: number; /** End offset (exclusive). */
+  end: number; /** The matched text. */
+  text: string; /** Pattern name (if provided at construction). */
+  name?: string;
+};
+/**
+ * Multi-pattern regex matcher.
+ *
+ * Compiles multiple regex patterns into a single
+ * automaton. Guaranteed O(m * n); no catastrophic
+ * backtracking. Uses Rust regex syntax for string
+ * patterns (no lookaheads/backreferences).
+ *
+ * @example
+ * ```ts
+ * // Simple
+ * new RegexSet([/\d{8}/, "\\+?\\d{9,12}"]);
+ *
+ * // Named
+ * new RegexSet([
+ *   { pattern: /\d{8}/, name: "ico" },
+ *   { pattern: /\d{2}\.\d{2}\.\d{4}/, name: "date" },
+ * ]);
+ * // match.name === "date"
+ * ```
+ */
+declare class RegexSet {
+  private _inner;
+  private _names;
+  private _hasNames;
+  constructor(patterns: PatternEntry[], options?: Options);
+  /** Number of patterns. */
+  get patternCount(): number;
+  /** Returns `true` if any pattern matches. */
+  isMatch(haystack: string): boolean;
+  /** Find all non-overlapping matches. */
+  findIter(haystack: string): Match[];
+  /** Which pattern indices matched (not where). */
+  whichMatch(haystack: string): number[];
+  /**
+   * Replace all non-overlapping matches.
+   * `replacements[i]` replaces pattern `i`.
+   */
+  replaceAll(haystack: string, replacements: string[]): string;
+}
+//#endregion
+export { type Match, type NamedPattern, type NativeBinding, type Options, type PatternEntry, RegexSet };
+//# sourceMappingURL=wasm.d.mts.map

package/dist/wasm.mjs

@@ -0,0 +1,341 @@
+import native from "@stll/regex-set-wasm32-wasi";
+//#region src/core.ts
+let binding;
+/** Set the native backend. Must be called once
+*  before any class constructor. */
+const initBinding = (b) => {
+	binding = b;
+};
+function unpack(packed, haystack, names) {
+	const len = packed.length;
+	const matches = new Array(len / 3);
+	for (let i = 0, j = 0; i < len; i += 3, j++) {
+		const idx = packed[i];
+		const s = packed[i + 1];
+		const e = packed[i + 2];
+		if (idx === void 0 || s === void 0 || e === void 0) throw new Error(`Corrupt packed match data at offset ${i}`);
+		const m = {
+			pattern: idx,
+			start: s,
+			end: e,
+			text: haystack.slice(s, e)
+		};
+		if (names && names[idx] !== void 0) m.name = names[idx];
+		matches[j] = m;
+	}
+	return matches;
+}
+/**
+* Replace unescaped `\b` and `\B` with their
+* ASCII-only equivalents `(?-u:\b)` / `(?-u:\B)`.
+* Skips character classes `[...]` (where `\b` means
+* backspace) and escaped backslashes `\\b`.
+*/
+function asciiBoundaries(src) {
+	let result = "";
+	let inClass = false;
+	let i = 0;
+	while (i < src.length) if (src.charAt(i) === "\\" && i + 1 < src.length) {
+		const next = src.charAt(i + 1);
+		if (!inClass && (next === "b" || next === "B")) {
+			result += `(?-u:\\${next})`;
+			i += 2;
+		} else {
+			result += src.charAt(i) + src.charAt(i + 1);
+			i += 2;
+		}
+	} else {
+		if (src.charAt(i) === "[") inClass = true;
+		if (src.charAt(i) === "]") inClass = false;
+		result += src.charAt(i);
+		i++;
+	}
+	return result;
+}
+/**
+* Convert a RegExp to Rust regex syntax string.
+*/
+function regexpToRust(re) {
+	let flags = "";
+	if (re.flags.includes("i")) flags += "i";
+	if (re.flags.includes("m")) flags += "m";
+	if (re.flags.includes("s")) flags += "s";
+	if (!flags) return re.source;
+	if (!flags.includes("i")) return `(?${flags})${re.source}`;
+	let src = re.source;
+	let leading = "";
+	let trailing = "";
+	if (src.startsWith("\\b")) {
+		leading = "\\b";
+		src = src.slice(2);
+	} else if (src.startsWith("\\B")) {
+		leading = "\\B";
+		src = src.slice(2);
+	}
+	if (src.length >= 2) {
+		const last = src.charAt(src.length - 1);
+		if (last === "b" || last === "B") {
+			let bs = 0;
+			let k = src.length - 2;
+			while (k >= 0 && src.charAt(k) === "\\") {
+				bs++;
+				k--;
+			}
+			if (bs > 0 && bs % 2 === 1) {
+				trailing = "\\" + last;
+				src = src.slice(0, -2);
+			}
+		}
+	}
+	const uFlag = needsAsciiMode(src) && !hasNonAscii(src) ? "-u" : "";
+	return `${leading}(?${flags}${uFlag}:${src})${trailing}`;
+}
+/**
+* Check if content uses character class shortcuts
+* (\w, \W, \d, \D, \s, \S, \b, \B) that have
+* Unicode-aware versions. Only these benefit from
+* -u (ASCII-only mode). Literal strings like
+* "dollars" produce identical DFAs with or without
+* -u, so skipping -u for them is zero-cost.
+*/
+function needsAsciiMode(s) {
+	return /\\[wWdDsSbB]/.test(s);
+}
+/**
+* Check if a string contains non-ASCII characters.
+* When true, -u MUST NOT be added: regex-automata
+* rejects (?-u) alongside non-ASCII content like
+* [ACDE] or literal zlotych.
+*/
+function hasNonAscii(s) {
+	for (let i = 0; i < s.length; i++) if (s.charCodeAt(i) > 127) return true;
+	return false;
+}
+/**
+* Convert inline (?i) flags to (?i-u) for ASCII
+* case folding. Handles bare and scoped groups.
+*
+* Bare (?i) at the start of a pattern is converted
+* to a scoped group (?i-u:...) with edge \b pulled
+* outside, matching the RegExp path behaviour. This
+* prevents -u from affecting \b word boundary
+* semantics (which should remain Unicode when
+* unicodeBoundaries is true).
+*
+* NOTE: -u also disables Unicode character classes
+* (\w, \d, \s become ASCII-only), matching the
+* behaviour of regexpToRust() for /i RegExps.
+*/
+function scopeInlineFlags(src) {
+	const leadingBare = src.match(/^\(\?([ims]+)(?:-([imsu]+))?\)/);
+	const enableGroup = leadingBare?.[1];
+	if (leadingBare && enableGroup?.includes("i")) {
+		const enable = enableGroup;
+		const disable = leadingBare[2] ?? "";
+		let rest = src.slice(leadingBare[0].length);
+		let leading = "";
+		let trailing = "";
+		if (rest.startsWith("\\b")) {
+			leading = "\\b";
+			rest = rest.slice(2);
+		} else if (rest.startsWith("\\B")) {
+			leading = "\\B";
+			rest = rest.slice(2);
+		}
+		if (rest.length >= 2) {
+			const last = rest.charAt(rest.length - 1);
+			if (last === "b" || last === "B") {
+				let bs = 0;
+				let k = rest.length - 2;
+				while (k >= 0 && rest.charAt(k) === "\\") {
+					bs++;
+					k--;
+				}
+				if (bs > 0 && bs % 2 === 1) {
+					trailing = "\\" + last;
+					rest = rest.slice(0, -2);
+				}
+			}
+		}
+		const inner = scopeInnerFlags(rest);
+		const merged = needsAsciiMode(rest) && !hasNonAscii(rest) && !disable.includes("u") ? disable + "u" : disable;
+		const disablePart = merged ? `-${merged}` : "";
+		return `${leading}(?${enable}${disablePart}:${inner})${trailing}`;
+	}
+	return scopeInnerFlags(src);
+}
+/**
+* Replace inline (?i) / (?i:...) groups with -u
+* variants. Does not handle leading bare flags
+* (that's done by scopeInlineFlags above).
+*/
+function scopeInnerFlags(src) {
+	let result = "";
+	let inClass = false;
+	let i = 0;
+	while (i < src.length) {
+		if (src[i] === "\\" && i + 1 < src.length) {
+			result += src.charAt(i) + src.charAt(i + 1);
+			i += 2;
+			continue;
+		}
+		if (src.charAt(i) === "[") inClass = true;
+		if (src.charAt(i) === "]") inClass = false;
+		if (!inClass && src.charAt(i) === "(" && src.charAt(i + 1) === "?") {
+			let j = i + 2;
+			let enable = "";
+			while (j < src.length && "ims".includes(src.charAt(j))) {
+				enable += src.charAt(j);
+				j++;
+			}
+			let disable = "";
+			if (j < src.length && src.charAt(j) === "-") {
+				j++;
+				while (j < src.length && "imsu".includes(src.charAt(j))) {
+					disable += src.charAt(j);
+					j++;
+				}
+			}
+			if (enable.length > 0 && (src.charAt(j) === ")" || src.charAt(j) === ":")) {
+				if (enable.includes("i")) if (disable.length > 0) result += `(?${enable}-${disable}${src.charAt(j)}`;
+				else result += `(?${enable}${src.charAt(j)}`;
+				else if (disable.length > 0) result += `(?${enable}-${disable}${src.charAt(j)}`;
+				else result += `(?${enable}${src.charAt(j)}`;
+				i = j + 1;
+				continue;
+			}
+		}
+		result += src.charAt(i);
+		i++;
+	}
+	return result;
+}
+/**
+* Normalize a pattern entry to { pattern, name }.
+*/
+function normalizeEntry(p, i) {
+	if (typeof p === "string") return {
+		pattern: scopeInlineFlags(p),
+		name: void 0
+	};
+	if (p instanceof RegExp) return {
+		pattern: regexpToRust(p),
+		name: void 0
+	};
+	if (typeof p === "object" && p !== null && "pattern" in p) {
+		if (typeof p.pattern !== "string" && !(p.pattern instanceof RegExp)) throw new TypeError(`Pattern at index ${i}: "pattern" field must be a string or RegExp`);
+		const inner = p.pattern instanceof RegExp ? { pattern: regexpToRust(p.pattern) } : { pattern: scopeInlineFlags(p.pattern) };
+		if (p.name !== void 0 && typeof p.name !== "string") throw new TypeError(`Pattern at index ${i}: "name" field must be a string`);
+		return {
+			pattern: inner.pattern,
+			name: p.name
+		};
+	}
+	throw new TypeError(`Pattern at index ${i} must be a string, RegExp, or { pattern, name }`);
+}
+/**
+* Multi-pattern regex matcher.
+*
+* Compiles multiple regex patterns into a single
+* automaton. Guaranteed O(m * n); no catastrophic
+* backtracking. Uses Rust regex syntax for string
+* patterns (no lookaheads/backreferences).
+*
+* @example
+* ```ts
+* // Simple
+* new RegexSet([/\d{8}/, "\\+?\\d{9,12}"]);
+*
+* // Named
+* new RegexSet([
+*   { pattern: /\d{8}/, name: "ico" },
+*   { pattern: /\d{2}\.\d{2}\.\d{4}/, name: "date" },
+* ]);
+* // match.name === "date"
+* ```
+*/
+var RegexSet = class {
+	_inner;
+	_names;
+	_hasNames;
+	constructor(patterns, options) {
+		const entries = patterns.map(normalizeEntry);
+		this._names = entries.map((e) => e.name);
+		this._hasNames = entries.some((e) => e.name !== void 0);
+		const unicode = options?.unicodeBoundaries ?? true;
+		const ci = options?.caseInsensitive ?? false;
+		let processed = entries.map((e) => e.pattern);
+		if (ci) processed = processed.map((p) => {
+			if (/^(?:\\[bB]|\(\?[ims]+(?:-[imsu]+)?\))*\(\?[ims]*i[ims]*(?:-[imsu]+)?[:(]/.test(p)) return p;
+			let src = p;
+			let flagPrefix = "";
+			const bareFlagMatch = src.match(/^\(\?[ims]+(?:-[imsu]+)?\)/);
+			if (bareFlagMatch) {
+				flagPrefix = bareFlagMatch[0];
+				src = src.slice(flagPrefix.length);
+			}
+			let leading = "";
+			let trailing = "";
+			if (src.startsWith("\\b")) {
+				leading = "\\b";
+				src = src.slice(2);
+			} else if (src.startsWith("\\B")) {
+				leading = "\\B";
+				src = src.slice(2);
+			}
+			if (src.length >= 2) {
+				const last = src.charAt(src.length - 1);
+				if (last === "b" || last === "B") {
+					let bs = 0;
+					let k = src.length - 2;
+					while (k >= 0 && src.charAt(k) === "\\") {
+						bs++;
+						k--;
+					}
+					if (bs > 0 && bs % 2 === 1) {
+						trailing = "\\" + last;
+						src = src.slice(0, -2);
+					}
+				}
+			}
+			const uFlag = needsAsciiMode(src) && !hasNonAscii(src) ? "-u" : "";
+			return `${flagPrefix}${leading}(?i${uFlag}:${src})${trailing}`;
+		});
+		if (!unicode) processed = processed.map(asciiBoundaries);
+		const nativeOpts = options ? {
+			wholeWords: options.wholeWords,
+			unicodeBoundaries: options.unicodeBoundaries
+		} : void 0;
+		this._inner = new binding.RegexSet(processed, nativeOpts);
+	}
+	/** Number of patterns. */
+	get patternCount() {
+		return this._inner.patternCount;
+	}
+	/** Returns `true` if any pattern matches. */
+	isMatch(haystack) {
+		return this._inner._isMatchBuf(Buffer.from(haystack));
+	}
+	/** Find all non-overlapping matches. */
+	findIter(haystack) {
+		return unpack(this._inner._findIterPackedBuf(Buffer.from(haystack)), haystack, this._hasNames ? this._names : null);
+	}
+	/** Which pattern indices matched (not where). */
+	whichMatch(haystack) {
+		return this._inner.whichMatch(haystack);
+	}
+	/**
+	* Replace all non-overlapping matches.
+	* `replacements[i]` replaces pattern `i`.
+	*/
+	replaceAll(haystack, replacements) {
+		return this._inner.replaceAll(haystack, replacements);
+	}
+};
+//#endregion
+//#region src/wasm.ts
+initBinding(native);
+//#endregion
+export { RegexSet };
+
+//# sourceMappingURL=wasm.mjs.map

package/dist/wasm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm.mjs","names":[],"sources":["../../src/core.ts","../../src/wasm.ts"],"sourcesContent":["/* Shared core: types, helpers, and the RegexSet\n * class that uses a late-bound native backend\n * (NAPI-RS or WASM).\n * Call initBinding() before constructing classes. */\n\n// -- Native binding types --------------------------------\n\nexport type NativeBinding = {\n  RegexSet: new (\n    patterns: string[],\n    options?: NativeOptions | undefined | null,\n  ) => NativeRegexSetInstance;\n  _uax29Boundaries: (haystack: Buffer) => number[];\n};\n\ntype NativeOptions = {\n  wholeWords?: boolean | undefined;\n  unicodeBoundaries?: boolean | undefined;\n};\n\ntype NativeRegexSetInstance = {\n  patternCount: number;\n  isMatch(haystack: string): boolean;\n  _isMatchBuf(haystack: Buffer): boolean;\n  _findIterPacked(haystack: string): Uint32Array;\n  _findIterPackedBuf(haystack: Buffer): Uint32Array;\n  whichMatch(haystack: string): number[];\n  replaceAll(\n    haystack: string,\n    replacements: string[],\n  ): string;\n};\n\n// -- Late-bound native binding ---------------------------\n\nlet binding: NativeBinding;\n\n/** Set the native backend. Must be called once\n *  before any class constructor. */\nexport const initBinding = (b: NativeBinding) => {\n  binding = b;\n};\n\n// -- Public types ----------------------------------------\n\n/** Options for constructing a RegexSet. */\nexport type Options = {\n  /**\n   * Only match whole words. Wraps each pattern\n   * with `\\b...\\b`.\n   * @default false\n   */\n  wholeWords?: boolean;\n  /**\n   * Use Unicode word boundaries. When `true`,\n   * `\\b` treats accented letters, CJK, etc. as\n   * word characters (correct for non-English text).\n   * When `false` (default), `\\b` uses ASCII\n   * semantics matching JS `RegExp` behavior.\n   *\n   * Zero performance overhead in either mode;\n   * boundaries are verified inline per match.\n   * Automatically uses UAX#29 segmentation for\n   * Thai/CJK/Lao/Khmer/Myanmar text.\n   * @default true\n   */\n  unicodeBoundaries?: boolean;\n  /**\n   * Case-insensitive matching. Wraps each pattern\n   * with `(?i-u:...)` for ASCII case folding.\n   * Uses `-u` to prevent DFA state explosion from\n   * Unicode case tables.\n   *\n   * Edge `\\b`/`\\B` boundaries and leading bare-flag\n   * prefixes (e.g. `(?m)`, `(?m-s)`) are extracted\n   * before wrapping so they remain outside the `-u`\n   * scope, preserving `unicodeBoundaries` semantics.\n   * Patterns already containing any `(?{flags}-u`\n   * group (from RegExp `/i`, inline `(?i)`, or\n   * `scopeInlineFlags`) are not double-wrapped.\n   * @default false\n   */\n  caseInsensitive?: boolean;\n};\n\n/** A named pattern entry. */\nexport type NamedPattern = {\n  /** The regex pattern (string or RegExp). */\n  pattern: string | RegExp;\n  /** Optional name for this pattern. */\n  name?: string;\n};\n\n/** A pattern entry: string, RegExp, or named. */\nexport type PatternEntry = string | RegExp | NamedPattern;\n\n/** A single match result. */\nexport type Match = {\n  /** Index of the pattern that matched. */\n  pattern: number;\n  /** Start UTF-16 code unit offset. */\n  start: number;\n  /** End offset (exclusive). */\n  end: number;\n  /** The matched text. */\n  text: string;\n  /** Pattern name (if provided at construction). */\n  name?: string;\n};\n\n// -- Unpack helper ---------------------------------------\n\nfunction unpack(\n  packed: Uint32Array,\n  haystack: string,\n  names: (string | undefined)[] | null,\n): Match[] {\n  const len = packed.length;\n  // eslint-disable-next-line unicorn/no-new-array\n  const matches = new Array<Match>(len / 3);\n  for (let i = 0, j = 0; i < len; i += 3, j++) {\n    const idx = packed[i];\n    const s = packed[i + 1];\n    const e = packed[i + 2];\n    if (\n      idx === undefined ||\n      s === undefined ||\n      e === undefined\n    ) {\n      throw new Error(\n        `Corrupt packed match data at offset ${i}`,\n      );\n    }\n    const m: Match = {\n      pattern: idx,\n      start: s,\n      end: e,\n      text: haystack.slice(s, e),\n    };\n    if (names && names[idx] !== undefined)\n      m.name = names[idx];\n    matches[j] = m;\n  }\n  return matches;\n}\n\n// -- Regex flag helpers ----------------------------------\n\n/**\n * Replace unescaped `\\b` and `\\B` with their\n * ASCII-only equivalents `(?-u:\\b)` / `(?-u:\\B)`.\n * Skips character classes `[...]` (where `\\b` means\n * backspace) and escaped backslashes `\\\\b`.\n */\nfunction asciiBoundaries(src: string): string {\n  let result = \"\";\n  let inClass = false;\n  let i = 0;\n  while (i < src.length) {\n    if (src.charAt(i) === \"\\\\\" && i + 1 < src.length) {\n      const next = src.charAt(i + 1);\n      if (!inClass && (next === \"b\" || next === \"B\")) {\n        result += `(?-u:\\\\${next})`;\n        i += 2;\n      } else {\n        // escaped char (including \\\\) -- emit as-is\n        result += src.charAt(i) + src.charAt(i + 1);\n        i += 2;\n      }\n    } else {\n      if (src.charAt(i) === \"[\") inClass = true;\n      if (src.charAt(i) === \"]\") inClass = false;\n      result += src.charAt(i);\n      i++;\n    }\n  }\n  return result;\n}\n\n/**\n * Convert a RegExp to Rust regex syntax string.\n */\nfunction regexpToRust(re: RegExp): string {\n  let flags = \"\";\n  if (re.flags.includes(\"i\")) flags += \"i\";\n  if (re.flags.includes(\"m\")) flags += \"m\";\n  if (re.flags.includes(\"s\")) flags += \"s\";\n\n  // JS RegExp objects can't contain inline (?i) in\n  // .source -- it's a SyntaxError. No need to run\n  // scopeInlineFlags here; it only matters for\n  // string patterns (handled in normalizeEntry).\n  if (!flags) {\n    return re.source;\n  }\n\n  if (!flags.includes(\"i\")) {\n    return `(?${flags})${re.source}`;\n  }\n\n  let src = re.source;\n  let leading = \"\";\n  let trailing = \"\";\n\n  if (src.startsWith(\"\\\\b\")) {\n    leading = \"\\\\b\";\n    src = src.slice(2);\n  } else if (src.startsWith(\"\\\\B\")) {\n    leading = \"\\\\B\";\n    src = src.slice(2);\n  }\n  if (src.length >= 2) {\n    const last = src.charAt(src.length - 1);\n    if (last === \"b\" || last === \"B\") {\n      let bs = 0;\n      let k = src.length - 2;\n      while (k >= 0 && src.charAt(k) === \"\\\\\") {\n        bs++;\n        k--;\n      }\n      if (bs > 0 && bs % 2 === 1) {\n        trailing = \"\\\\\" + last;\n        src = src.slice(0, -2);\n      }\n    }\n  }\n\n  const uFlag =\n    needsAsciiMode(src) && !hasNonAscii(src) ? \"-u\" : \"\";\n  return `${leading}(?${flags}${uFlag}:${src})${trailing}`;\n}\n\n/**\n * Check if content uses character class shortcuts\n * (\\w, \\W, \\d, \\D, \\s, \\S, \\b, \\B) that have\n * Unicode-aware versions. Only these benefit from\n * -u (ASCII-only mode). Literal strings like\n * \"dollars\" produce identical DFAs with or without\n * -u, so skipping -u for them is zero-cost.\n */\nfunction needsAsciiMode(s: string): boolean {\n  return /\\\\[wWdDsSbB]/.test(s);\n}\n\n/**\n * Check if a string contains non-ASCII characters.\n * When true, -u MUST NOT be added: regex-automata\n * rejects (?-u) alongside non-ASCII content like\n * [ACDE] or literal zlotych.\n */\nfunction hasNonAscii(s: string): boolean {\n  for (let i = 0; i < s.length; i++) {\n    if (s.charCodeAt(i) > 127) return true;\n  }\n  return false;\n}\n\n/**\n * Convert inline (?i) flags to (?i-u) for ASCII\n * case folding. Handles bare and scoped groups.\n *\n * Bare (?i) at the start of a pattern is converted\n * to a scoped group (?i-u:...) with edge \\b pulled\n * outside, matching the RegExp path behaviour. This\n * prevents -u from affecting \\b word boundary\n * semantics (which should remain Unicode when\n * unicodeBoundaries is true).\n *\n * NOTE: -u also disables Unicode character classes\n * (\\w, \\d, \\s become ASCII-only), matching the\n * behaviour of regexpToRust() for /i RegExps.\n */\nfunction scopeInlineFlags(src: string): string {\n  // Handle bare (?i...) at the start: convert to\n  // scoped (?i-u:...) with edge \\b/\\B outside.\n  const leadingBare = src.match(\n    /^\\(\\?([ims]+)(?:-([imsu]+))?\\)/,\n  );\n  const enableGroup = leadingBare?.[1];\n  if (leadingBare && enableGroup?.includes(\"i\")) {\n    const enable = enableGroup;\n    const disable = leadingBare[2] ?? \"\";\n    let rest = src.slice(leadingBare[0].length);\n\n    // Strip edge \\b/\\B\n    let leading = \"\";\n    let trailing = \"\";\n    if (rest.startsWith(\"\\\\b\")) {\n      leading = \"\\\\b\";\n      rest = rest.slice(2);\n    } else if (rest.startsWith(\"\\\\B\")) {\n      leading = \"\\\\B\";\n      rest = rest.slice(2);\n    }\n    if (rest.length >= 2) {\n      const last = rest.charAt(rest.length - 1);\n      if (last === \"b\" || last === \"B\") {\n        let bs = 0;\n        let k = rest.length - 2;\n        while (k >= 0 && rest.charAt(k) === \"\\\\\") {\n          bs++;\n          k--;\n        }\n        if (bs > 0 && bs % 2 === 1) {\n          trailing = \"\\\\\" + last;\n          rest = rest.slice(0, -2);\n        }\n      }\n    }\n\n    // Scope the flags and recurse for any nested\n    // inline flags in the content.\n    const inner = scopeInnerFlags(rest);\n    // Only add -u when content uses char class\n    // shortcuts (\\w, \\d, \\s) that benefit from it.\n    const addU =\n      needsAsciiMode(rest) &&\n      !hasNonAscii(rest) &&\n      !disable.includes(\"u\");\n    const merged = addU ? disable + \"u\" : disable;\n    const disablePart = merged ? `-${merged}` : \"\";\n    return `${leading}(?${enable}${disablePart}:${inner})${trailing}`;\n  }\n\n  return scopeInnerFlags(src);\n}\n\n/**\n * Replace inline (?i) / (?i:...) groups with -u\n * variants. Does not handle leading bare flags\n * (that's done by scopeInlineFlags above).\n */\nfunction scopeInnerFlags(src: string): string {\n  let result = \"\";\n  let inClass = false;\n  let i = 0;\n  while (i < src.length) {\n    if (src[i] === \"\\\\\" && i + 1 < src.length) {\n      result += src.charAt(i) + src.charAt(i + 1);\n      i += 2;\n      continue;\n    }\n    if (src.charAt(i) === \"[\") inClass = true;\n    if (src.charAt(i) === \"]\") inClass = false;\n    if (\n      !inClass &&\n      src.charAt(i) === \"(\" &&\n      src.charAt(i + 1) === \"?\"\n    ) {\n      let j = i + 2;\n      let enable = \"\";\n      while (\n        j < src.length &&\n        \"ims\".includes(src.charAt(j))\n      ) {\n        enable += src.charAt(j);\n        j++;\n      }\n      // Handle disable part: (?i-s) or (?i-s:...)\n      let disable = \"\";\n      if (j < src.length && src.charAt(j) === \"-\") {\n        j++; // skip -\n        while (\n          j < src.length &&\n          \"imsu\".includes(src.charAt(j))\n        ) {\n          disable += src.charAt(j);\n          j++;\n        }\n      }\n      if (\n        enable.length > 0 &&\n        (src.charAt(j) === \")\" || src.charAt(j) === \":\")\n      ) {\n        if (enable.includes(\"i\")) {\n          // For scoped groups (?i:content), don't add\n          // -u: literal strings produce identical DFAs\n          // with or without -u, and -u breaks when\n          // the overall pattern has non-ASCII chars.\n          // For bare flags (?i), the -u would apply to\n          // the rest of the pattern which might have\n          // \\w/\\d -- but bare flags are handled by\n          // scopeInlineFlags, not here.\n          if (disable.length > 0) {\n            result += `(?${enable}-${disable}${src.charAt(j)}`;\n          } else {\n            result += `(?${enable}${src.charAt(j)}`;\n          }\n        } else if (disable.length > 0) {\n          result += `(?${enable}-${disable}${src.charAt(j)}`;\n        } else {\n          result += `(?${enable}${src.charAt(j)}`;\n        }\n        i = j + 1;\n        continue;\n      }\n    }\n    result += src.charAt(i);\n    i++;\n  }\n  return result;\n}\n\n// -- Pattern normalization -------------------------------\n\ntype NormalizedEntry = {\n  pattern: string;\n  name: string | undefined;\n};\n\n/**\n * Normalize a pattern entry to { pattern, name }.\n */\nfunction normalizeEntry(\n  p: PatternEntry,\n  i: number,\n): NormalizedEntry {\n  if (typeof p === \"string\") {\n    return {\n      pattern: scopeInlineFlags(p),\n      name: undefined,\n    };\n  }\n  if (p instanceof RegExp) {\n    return {\n      pattern: regexpToRust(p),\n      name: undefined,\n    };\n  }\n  if (\n    typeof p === \"object\" &&\n    p !== null &&\n    \"pattern\" in p\n  ) {\n    if (\n      typeof p.pattern !== \"string\" &&\n      !(p.pattern instanceof RegExp)\n    ) {\n      throw new TypeError(\n        `Pattern at index ${i}: \"pattern\" ` +\n          \"field must be a string or RegExp\",\n      );\n    }\n    const inner =\n      p.pattern instanceof RegExp\n        ? { pattern: regexpToRust(p.pattern) }\n        : {\n            pattern: scopeInlineFlags(p.pattern),\n          };\n    if (\n      p.name !== undefined &&\n      typeof p.name !== \"string\"\n    ) {\n      throw new TypeError(\n        `Pattern at index ${i}: \"name\" ` +\n          \"field must be a string\",\n      );\n    }\n    return {\n      pattern: inner.pattern,\n      name: p.name,\n    };\n  }\n  throw new TypeError(\n    `Pattern at index ${i} must be a string, ` +\n      \"RegExp, or { pattern, name }\",\n  );\n}\n\n// -- RegexSet class --------------------------------------\n\n/**\n * Multi-pattern regex matcher.\n *\n * Compiles multiple regex patterns into a single\n * automaton. Guaranteed O(m * n); no catastrophic\n * backtracking. Uses Rust regex syntax for string\n * patterns (no lookaheads/backreferences).\n *\n * @example\n * ```ts\n * // Simple\n * new RegexSet([/\\d{8}/, \"\\\\+?\\\\d{9,12}\"]);\n *\n * // Named\n * new RegexSet([\n *   { pattern: /\\d{8}/, name: \"ico\" },\n *   { pattern: /\\d{2}\\.\\d{2}\\.\\d{4}/, name: \"date\" },\n * ]);\n * // match.name === \"date\"\n * ```\n */\nexport class RegexSet {\n  private _inner: NativeRegexSetInstance;\n  private _names: (string | undefined)[];\n  private _hasNames: boolean;\n\n  constructor(patterns: PatternEntry[], options?: Options) {\n    const entries = patterns.map(normalizeEntry);\n    this._names = entries.map((e) => e.name);\n    this._hasNames = entries.some(\n      (e) => e.name !== undefined,\n    );\n\n    const unicode = options?.unicodeBoundaries ?? true;\n    const ci = options?.caseInsensitive ?? false;\n\n    let processed = entries.map((e) => e.pattern);\n\n    // Wrap with (?i-u:...) for case-insensitive\n    // matching. Edge \\b/\\B are extracted first so\n    // they stay outside the -u scope (preserving\n    // Unicode word boundary semantics).\n    if (ci) {\n      processed = processed.map((p) => {\n        // Skip patterns already wrapped by\n        // regexpToRust or scopeInlineFlags.\n        if (\n          /^(?:\\\\[bB]|\\(\\?[ims]+(?:-[imsu]+)?\\))*\\(\\?[ims]*i[ims]*(?:-[imsu]+)?[:(]/.test(\n            p,\n          )\n        )\n          return p;\n        // Strip leading bare-flag prefix (e.g. (?m),\n        // (?ms)) before extracting edge \\b.\n        let src = p;\n        let flagPrefix = \"\";\n        const bareFlagMatch = src.match(\n          /^\\(\\?[ims]+(?:-[imsu]+)?\\)/,\n        );\n        if (bareFlagMatch) {\n          flagPrefix = bareFlagMatch[0];\n          src = src.slice(flagPrefix.length);\n        }\n        // Extract edge \\b/\\B\n        let leading = \"\";\n        let trailing = \"\";\n        if (src.startsWith(\"\\\\b\")) {\n          leading = \"\\\\b\";\n          src = src.slice(2);\n        } else if (src.startsWith(\"\\\\B\")) {\n          leading = \"\\\\B\";\n          src = src.slice(2);\n        }\n        if (src.length >= 2) {\n          const last = src.charAt(src.length - 1);\n          if (last === \"b\" || last === \"B\") {\n            let bs = 0;\n            let k = src.length - 2;\n            while (k >= 0 && src.charAt(k) === \"\\\\\") {\n              bs++;\n              k--;\n            }\n            if (bs > 0 && bs % 2 === 1) {\n              trailing = \"\\\\\" + last;\n              src = src.slice(0, -2);\n            }\n          }\n        }\n        const uFlag =\n          needsAsciiMode(src) && !hasNonAscii(src)\n            ? \"-u\"\n            : \"\";\n        return `${flagPrefix}${leading}(?i${uFlag}:${src})${trailing}`;\n      });\n    }\n\n    if (!unicode) {\n      processed = processed.map(asciiBoundaries);\n    }\n\n    // Strip JS-only options before passing to native\n    const nativeOpts: NativeOptions | undefined = options\n      ? {\n          wholeWords: options.wholeWords,\n          unicodeBoundaries: options.unicodeBoundaries,\n        }\n      : undefined;\n\n    this._inner = new binding.RegexSet(\n      processed,\n      nativeOpts,\n    );\n  }\n\n  /** Number of patterns. */\n  get patternCount(): number {\n    return this._inner.patternCount;\n  }\n\n  /** Returns `true` if any pattern matches. */\n  isMatch(haystack: string): boolean {\n    return this._inner._isMatchBuf(Buffer.from(haystack));\n  }\n\n  /** Find all non-overlapping matches. */\n  findIter(haystack: string): Match[] {\n    return unpack(\n      this._inner._findIterPackedBuf(Buffer.from(haystack)),\n      haystack,\n      this._hasNames ? this._names : null,\n    );\n  }\n\n  /** Which pattern indices matched (not where). */\n  whichMatch(haystack: string): number[] {\n    return this._inner.whichMatch(haystack);\n  }\n\n  /**\n   * Replace all non-overlapping matches.\n   * `replacements[i]` replaces pattern `i`.\n   */\n  replaceAll(\n    haystack: string,\n    replacements: string[],\n  ): string {\n    return this._inner.replaceAll(haystack, replacements);\n  }\n}\n","/* Browser/WASM entry point -- loads the WASM binding\n * from the sub-package and re-exports the public API\n * through the shared core. */\n\nimport native from \"@stll/regex-set-wasm32-wasi\";\n\nimport { initBinding, type NativeBinding } from \"./core\";\n\ninitBinding(native as unknown as NativeBinding);\n\nexport { RegexSet } from \"./core\";\n\nexport type {\n  Match,\n  NamedPattern,\n  NativeBinding,\n  Options,\n  PatternEntry,\n} from \"./core\";\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@stll/regex-set-wasm",
+  "version": "0.1.1",
+  "description": "Multi-pattern regex for browsers via WebAssembly. Same API as @stll/regex-set.",
+  "keywords": [
+    "multi-pattern",
+    "napi-rs",
+    "regex",
+    "regex-set",
+    "rust",
+    "wasm"
+  ],
+  "homepage": "https://github.com/stella/regex-set#readme",
+  "bugs": {
+    "url": "https://github.com/stella/regex-set/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stella/regex-set"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "module": "dist/wasm.mjs",
+  "types": "dist/wasm.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/wasm.d.mts",
+      "import": "./dist/wasm.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "dependencies": {
+    "@stll/regex-set-wasm32-wasi": "0.0.3"
+  }
+}