@aglyn/shared-util-tools 1.0.0-beta.143

package/src/lib/linear-regex.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/shared/util/tools/src/lib/linear-regex.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * A linear-time regular-expression engine (SEC-M8 / AGL-1881), for patterns\n * someone other than the platform wrote that run where every tenant renders:\n * host redirect rules, and the conditions a component or layout property\n * declares (AGL-2893).\n *\n * WHY THIS EXISTS\n *\n * Redirect regexes are attacker-authored (any `author` on a paid site can\n * write `source` straight to Firestore — the console's validation is not a\n * control) and they execute on the tenant render path, in the Node process\n * shared by every tenant. `RegExp.prototype.exec` is a backtracking matcher,\n * so a pattern like `(a|a|aa)+` against `\"aaaa…a!\"` costs exponential time:\n * measured at 59 s for a 9-character pattern and a 27-character path, and it\n * keeps doubling from there. That is a multi-tenant denial of service. A\n * property condition's pattern is the same hazard with a wider door: it can\n * arrive from a marketplace listing, and it runs on every page that places\n * the component and in the console of everyone who installed it.\n *\n * Three heuristics have been tried and bypassed (AGL-505 star height, a\n * length cap, nesting limits). A shape heuristic can never be sound: deciding\n * whether an arbitrary backtracking regex is safe is the same problem as\n * bounding its search tree. So this module does not inspect patterns for\n * dangerous shapes. It removes the backtracking engine.\n *\n * HOW IT IS LINEAR BY CONSTRUCTION\n *\n * The pattern is parsed into an AST, compiled to a small NFA bytecode, and\n * executed by a Thompson/Pike simulation: instead of trying one path at a\n * time and backtracking, it advances *all* live NFA states one input\n * character at a time, deduplicated by program counter. Each of the\n * `programLength` states is visited at most once per input character, so the\n * worst case is exactly `O(inputLength × programLength)` — there is no input\n * that makes it exponential, because there is no search tree to explode.\n *\n * Thread priority ordering, and cutting lower-priority threads when a match\n * is found, reproduce JavaScript's leftmost-first (greedy/lazy) semantics and\n * its capture-group results, so ordinary patterns behave exactly as they did.\n *\n * `new RegExp` is never called on the pattern. Constructs that cannot be\n * simulated in linear time — backreferences and lookaround — are not merely\n * rejected by a checker that might have a hole; there is no instruction that\n * could execute them, and the parser has no production that accepts them.\n *\n * WHAT THIS DOES NOT DO\n *\n * It is not a general-purpose RegExp replacement. It implements the subset\n * documented in `UNSUPPORTED_SYNTAX` below and nothing else, and it makes no\n * attempt at unicode mode or `lastIndex`. Of the flags, `i`, `m`, `s` and `y`\n * mean what they mean to a fresh `RegExp`'s `test` (see {@link FLAG_CHARS});\n * `g` and `d` change nothing a match answers, so they are accepted and have\n * no effect; `u` and `v` are refused.\n */\n\n/**\n * Syntax deliberately outside the supported subset. Each entry is a\n * construct that either cannot be simulated in linear time at all\n * (backreferences, lookaround) or that is simply not implemented. Word\n * boundaries are the exception `compileLinearTest` makes: it reads them, and\n * `compileLinearPattern`, which redirect rules are held to, does not.\n */\nexport const UNSUPPORTED_SYNTAX = [\n  'lookahead `(?=…)` / `(?!…)`',\n  'lookbehind `(?<=…)` / `(?<!…)`',\n  'backreferences `\\\\1`…`\\\\9`, `\\\\k<name>`',\n  'named groups `(?<name>…)`',\n  'word boundaries `\\\\b` / `\\\\B`',\n  'unicode property escapes `\\\\p{…}` / `\\\\P{…}`',\n  'inline flags and other `(?…)` groups',\n  'negated shorthands (`\\\\D`, `\\\\W`, `\\\\S`) inside a `[…]` class',\n] as const\n\n/**\n * Ceiling on compiled program size. Bounded repeats are expanded (`a{3}`\n * becomes three copies), so this is what stops `(\\d{99}){99}` from turning a\n * short pattern into a huge program.\n *\n * This is a resource bound, not a shape heuristic: execution is already\n * linear in program length, so bounding the program bounds total work at\n * `MAX_PROGRAM_LENGTH × inputLength` ≈ 1000 × 500 = 5×10^5 state visits in\n * the absolute worst case — a few milliseconds, and flat in the input rather\n * than exponential. Nothing about *which* patterns are dangerous is being\n * guessed here; every accepted pattern is already safe.\n */\nconst MAX_PROGRAM_LENGTH = 1000\n\n/** Largest bounded-repeat count accepted, e.g. the `99` in `a{2,99}`. */\nconst MAX_REPEAT_COUNT = 100\n\n/** Largest capture-group count. Destinations only substitute `$1`…`$9`. */\nconst MAX_CAPTURE_GROUPS = 20\n\n// ---------------------------------------------------------------------------\n// AST\n// ---------------------------------------------------------------------------\n\ntype Node =\n  | { t: 'empty' }\n  | { t: 'alt'; options: Node[] }\n  | { t: 'cat'; items: Node[] }\n  | { t: 'rep'; node: Node; min: number; max: number; greedy: boolean }\n  | { t: 'char'; c: number }\n  | { t: 'class'; ranges: number[]; negated: boolean }\n  | { t: 'any' }\n  | { t: 'assertStart' }\n  | { t: 'assertEnd' }\n  /** `\\b`, or `\\B` when negated — parsed only for `compileLinearTest`. */\n  | { t: 'wordBoundary'; negated: boolean }\n  | { t: 'group'; index: number; node: Node }\n\n/** Thrown for any pattern outside the supported subset. Never escapes. */\nclass PatternError extends Error {}\n\n// ---------------------------------------------------------------------------\n// Flags\n// ---------------------------------------------------------------------------\n\n/** What a pattern's flags ask of a match. */\ninterface Flags {\n  /** `i`: characters compare by their case-folded form. */\n  ignoreCase: boolean\n  /** `m`: `^` and `$` also hold beside a line terminator. */\n  multiline: boolean\n  /** `s`: `.` matches a line terminator too. */\n  dotAll: boolean\n  /** `y`: a match starts at the beginning of the input or not at all. */\n  sticky: boolean\n}\n\n/**\n * The flags a pattern may carry, as the characters `RegExp` spells them.\n * `g` and `d` are here because a fresh `RegExp`'s `test` answers the same\n * with them as without; `u` and `v` are not, because unicode mode is not\n * implemented.\n */\nexport const FLAG_CHARS = 'dgimsy'\n\n/** A pattern with no flags — what every redirect rule is compiled with. */\nconst NO_FLAGS: Flags = {\n  ignoreCase: false,\n  multiline: false,\n  dotAll: false,\n  sticky: false,\n}\n\n/** Reads a flags string, refusing what `RegExp` would and what is unsupported. */\nfunction parseFlags(flags: string): Flags {\n  const seen = new Set<string>()\n  for (const flag of flags) {\n    if (flag === 'u' || flag === 'v') {\n      throw new PatternError(`the ${flag} flag is not supported`)\n    }\n    if (!FLAG_CHARS.includes(flag)) {\n      throw new PatternError(`\"${flag}\" is not a pattern flag`)\n    }\n    if (seen.has(flag)) throw new PatternError(`the ${flag} flag is repeated`)\n    seen.add(flag)\n  }\n  return {\n    ignoreCase: seen.has('i'),\n    multiline: seen.has('m'),\n    dotAll: seen.has('s'),\n    sticky: seen.has('y'),\n  }\n}\n\n/**\n * One UTF-16 code unit case-folded the way `RegExp` folds it without the `u`\n * flag (ECMAScript `Canonicalize`): to its upper case, unless that is more\n * than one unit, or would carry a non-ASCII character into ASCII.\n */\nfunction canonicalize(code: number): number {\n  const upper = String.fromCharCode(code).toUpperCase()\n  if (upper.length !== 1) return code\n  const folded = upper.charCodeAt(0)\n  return code >= 128 && folded < 128 ? code : folded\n}\n\n/**\n * Every code unit whose case-folded form is another, with that form, as flat\n * `[unit, folded, …]` pairs in unit order. Built once, on the first pattern\n * that asks for `i`.\n */\nlet foldedUnits: number[] | undefined\nfunction unitsThatFold(): number[] {\n  if (!foldedUnits) {\n    foldedUnits = []\n    for (let unit = 0; unit <= 0xffff; unit++) {\n      const folded = canonicalize(unit)\n      if (folded !== unit) foldedUnits.push(unit, folded)\n    }\n  }\n  return foldedUnits\n}\n\n/**\n * A class's ranges with the case-folded form of every member added, so that\n * testing an input's folded form against them asks what `RegExp` asks: is\n * there a member whose folded form this is. Every folded form folds to\n * itself, so the members left as written are never an input's folded form\n * unless they already fold to themselves.\n */\nfunction foldRanges(ranges: number[]): number[] {\n  const units = unitsThatFold()\n  const added = new Set<number>()\n  for (let i = 0; i < ranges.length; i += 2) {\n    const lo = ranges[i]\n    const hi = Math.min(ranges[i + 1], 0xffff)\n    for (let j = 0; j < units.length; j += 2) {\n      if (units[j] > hi) break\n      const folded = units[j + 1]\n      if (units[j] >= lo && !rangesContain(ranges, folded)) added.add(folded)\n    }\n  }\n  if (!added.size) return ranges\n  // Adjacent folded forms merge into one range, so `[a-z]` gains `A-Z` as\n  // one pair rather than twenty-six.\n  const merged: number[] = []\n  for (const code of [...added].sort((a, b) => a - b)) {\n    if (merged.length && merged[merged.length - 1] === code - 1) {\n      merged[merged.length - 1] = code\n    } else {\n      merged.push(code, code)\n    }\n  }\n  return [...ranges, ...merged]\n}\n\n// ---------------------------------------------------------------------------\n// Character-class helpers\n// ---------------------------------------------------------------------------\n\nconst DIGIT_RANGES = [0x30, 0x39]\nconst WORD_RANGES = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a]\nconst SPACE_RANGES = [\n  0x09, 0x0d, 0x20, 0x20, 0xa0, 0xa0, 0x1680, 0x1680, 0x2000, 0x200a, 0x2028,\n  0x2029, 0x202f, 0x202f, 0x205f, 0x205f, 0x3000, 0x3000, 0xfeff, 0xfeff,\n]\n\n/** `.` matches anything but a line terminator (no `s` flag), as in JS. */\nconst isLineTerminator = (code: number) =>\n  code === 0x0a || code === 0x0d || code === 0x2028 || code === 0x2029\n\n/** Ranges are stored as flat `[lo, hi, lo, hi, …]` pairs. */\nfunction rangesContain(ranges: number[], code: number): boolean {\n  for (let i = 0; i < ranges.length; i += 2) {\n    if (code >= ranges[i] && code <= ranges[i + 1]) return true\n  }\n  return false\n}\n\n/** The single-character escapes JS gives a non-literal meaning. */\nfunction controlEscape(ch: string): number | null {\n  switch (ch) {\n    case 'n':\n      return 0x0a\n    case 'r':\n      return 0x0d\n    case 't':\n      return 0x09\n    case 'f':\n      return 0x0c\n    case 'v':\n      return 0x0b\n    case '0':\n      return 0x00\n    default:\n      return null\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Parser\n// ---------------------------------------------------------------------------\n\n/**\n * Recursive-descent parser for the supported subset.\n *\n * The grammar has no production for lookaround or backreferences, so those\n * are rejected structurally rather than by pattern inspection.\n */\nclass Parser {\n  private pos = 0\n  /** Group 0 is the whole match, so user groups start at 1. */\n  groupCount = 0\n\n  /**\n   * `wordBoundaries` admits `\\b` and `\\B`. A zero-width test of the two\n   * characters around the position is as linear as `^`, so the engine can\n   * run one; redirect rules have always refused it, and still do.\n   */\n  constructor(\n    private readonly src: string,\n    private readonly wordBoundaries = false,\n  ) {}\n\n  parse(): Node {\n    const node = this.parseAlternation()\n    if (this.pos < this.src.length) {\n      // Only an unbalanced `)` can get here.\n      throw new PatternError(`unexpected \"${this.src[this.pos]}\"`)\n    }\n    return node\n  }\n\n  private peek(): string {\n    return this.src[this.pos]\n  }\n\n  private parseAlternation(): Node {\n    const options: Node[] = [this.parseConcat()]\n    while (this.peek() === '|') {\n      this.pos++\n      options.push(this.parseConcat())\n    }\n    return options.length === 1 ? options[0] : { t: 'alt', options }\n  }\n\n  private parseConcat(): Node {\n    const items: Node[] = []\n    while (this.pos < this.src.length) {\n      const ch = this.peek()\n      if (ch === '|' || ch === ')') break\n      items.push(this.parseRepeat())\n    }\n    if (items.length === 0) return { t: 'empty' }\n    return items.length === 1 ? items[0] : { t: 'cat', items }\n  }\n\n  private parseRepeat(): Node {\n    const atom = this.parseAtom()\n    let min: number\n    let max: number\n    const ch = this.peek()\n    if (ch === '*') {\n      this.pos++\n      min = 0\n      max = Infinity\n    } else if (ch === '+') {\n      this.pos++\n      min = 1\n      max = Infinity\n    } else if (ch === '?') {\n      this.pos++\n      min = 0\n      max = 1\n    } else if (ch === '{') {\n      const bounds = this.tryParseBounds()\n      if (bounds === null) return atom\n      min = bounds[0]\n      max = bounds[1]\n    } else {\n      return atom\n    }\n    let greedy = true\n    if (this.peek() === '?') {\n      this.pos++\n      greedy = false\n    }\n    if (this.peek() === '*' || this.peek() === '+') {\n      // `a**` is a syntax error in JS too; refuse rather than guess.\n      throw new PatternError('a quantifier cannot follow a quantifier')\n    }\n    if (\n      atom.t === 'assertStart' ||\n      atom.t === 'assertEnd' ||\n      atom.t === 'wordBoundary' ||\n      atom.t === 'empty'\n    ) {\n      throw new PatternError('nothing to repeat')\n    }\n    return { t: 'rep', node: atom, min, max, greedy }\n  }\n\n  /**\n   * `{2}`, `{2,}`, `{2,5}`. A `{` that is not a valid bound is a literal\n   * brace in JS (`/a{x/` is fine), so return null and let the caller keep\n   * the atom; `parseAtom` will have already consumed the `{` as a literal.\n   */\n  private tryParseBounds(): [number, number] | null {\n    const start = this.pos\n    this.pos++ // consume `{`\n    const digits = (): number | null => {\n      const from = this.pos\n      while (this.pos < this.src.length && /[0-9]/.test(this.src[this.pos])) {\n        this.pos++\n      }\n      if (this.pos === from) return null\n      return Number(this.src.slice(from, this.pos))\n    }\n    const min = digits()\n    if (min === null) {\n      this.pos = start\n      return null\n    }\n    let max = min\n    if (this.peek() === ',') {\n      this.pos++\n      if (this.peek() === '}') {\n        max = Infinity\n      } else {\n        const parsed = digits()\n        if (parsed === null) {\n          this.pos = start\n          return null\n        }\n        max = parsed\n      }\n    }\n    if (this.peek() !== '}') {\n      this.pos = start\n      return null\n    }\n    this.pos++\n    if (min > MAX_REPEAT_COUNT || (max !== Infinity && max > MAX_REPEAT_COUNT)) {\n      throw new PatternError(`repeat counts above ${MAX_REPEAT_COUNT}`)\n    }\n    if (max < min) throw new PatternError('repeat range is backwards')\n    return [min, max]\n  }\n\n  private parseAtom(): Node {\n    const ch = this.src[this.pos]\n    if (ch === '(') return this.parseGroup()\n    if (ch === '[') return this.parseClass()\n    if (ch === '\\\\') return this.parseEscape()\n    if (ch === '.') {\n      this.pos++\n      return { t: 'any' }\n    }\n    if (ch === '^') {\n      this.pos++\n      return { t: 'assertStart' }\n    }\n    if (ch === '$') {\n      this.pos++\n      return { t: 'assertEnd' }\n    }\n    if (ch === '*' || ch === '+' || ch === '?') {\n      throw new PatternError('nothing to repeat')\n    }\n    this.pos++\n    return { t: 'char', c: ch.charCodeAt(0) }\n  }\n\n  private parseGroup(): Node {\n    this.pos++ // consume `(`\n    let index = 0\n    if (this.peek() === '?') {\n      const kind = this.src[this.pos + 1]\n      if (kind === ':') {\n        this.pos += 2\n      } else if (kind === '=' || kind === '!') {\n        throw new PatternError('lookahead is not supported')\n      } else if (kind === '<') {\n        const after = this.src[this.pos + 2]\n        throw new PatternError(\n          after === '=' || after === '!'\n            ? 'lookbehind is not supported'\n            : 'named groups are not supported',\n        )\n      } else {\n        throw new PatternError('this group type is not supported')\n      }\n    } else {\n      this.groupCount++\n      if (this.groupCount > MAX_CAPTURE_GROUPS) {\n        throw new PatternError(`more than ${MAX_CAPTURE_GROUPS} capture groups`)\n      }\n      index = this.groupCount\n    }\n    const node = this.parseAlternation()\n    if (this.peek() !== ')') throw new PatternError('unbalanced \"(\"')\n    this.pos++\n    return index === 0 ? node : { t: 'group', index, node }\n  }\n\n  private parseEscape(): Node {\n    this.pos++ // consume `\\`\n    const ch = this.src[this.pos]\n    if (ch === undefined) throw new PatternError('trailing backslash')\n    this.pos++\n    if (ch >= '1' && ch <= '9') {\n      throw new PatternError('backreferences are not supported')\n    }\n    if (ch === 'k') throw new PatternError('backreferences are not supported')\n    if (ch === 'b' || ch === 'B') {\n      if (!this.wordBoundaries) {\n        throw new PatternError('word boundaries are not supported')\n      }\n      return { t: 'wordBoundary', negated: ch === 'B' }\n    }\n    if (ch === 'p' || ch === 'P') {\n      throw new PatternError('unicode property escapes are not supported')\n    }\n    if (ch === 'd') return { t: 'class', ranges: DIGIT_RANGES, negated: false }\n    if (ch === 'D') return { t: 'class', ranges: DIGIT_RANGES, negated: true }\n    if (ch === 'w') return { t: 'class', ranges: WORD_RANGES, negated: false }\n    if (ch === 'W') return { t: 'class', ranges: WORD_RANGES, negated: true }\n    if (ch === 's') return { t: 'class', ranges: SPACE_RANGES, negated: false }\n    if (ch === 'S') return { t: 'class', ranges: SPACE_RANGES, negated: true }\n    if (ch === 'u' || ch === 'x') {\n      const width = ch === 'u' ? 4 : 2\n      const hex = this.src.slice(this.pos, this.pos + width)\n      if (!new RegExp(`^[0-9a-fA-F]{${width}}$`).test(hex)) {\n        throw new PatternError(`malformed \\\\${ch} escape`)\n      }\n      this.pos += width\n      return { t: 'char', c: parseInt(hex, 16) }\n    }\n    const control = controlEscape(ch)\n    if (control !== null) return { t: 'char', c: control }\n    // `\\.` `\\/` `\\(` … — an escaped literal.\n    return { t: 'char', c: ch.charCodeAt(0) }\n  }\n\n  private parseClass(): Node {\n    this.pos++ // consume `[`\n    let negated = false\n    if (this.peek() === '^') {\n      this.pos++\n      negated = true\n    }\n    const ranges: number[] = []\n    let first = true\n    for (;;) {\n      const ch = this.src[this.pos]\n      if (ch === undefined) throw new PatternError('unterminated \"[\"')\n      if (ch === ']' && !first) {\n        this.pos++\n        break\n      }\n      first = false\n      const lo = this.parseClassMember(ranges)\n      if (lo === null) continue // a shorthand already pushed its own ranges\n      // A `-` before `]` is a literal dash.\n      if (this.peek() === '-' && this.src[this.pos + 1] !== ']') {\n        this.pos++\n        const hi = this.parseClassMember(ranges)\n        if (hi === null) {\n          throw new PatternError('a shorthand cannot be a range endpoint')\n        }\n        if (hi < lo) throw new PatternError('character range is backwards')\n        ranges.push(lo, hi)\n      } else {\n        ranges.push(lo, lo)\n      }\n    }\n    if (ranges.length === 0 && !negated) {\n      // `[]` never matches in JS. Represent it as a negated match-everything.\n      return { t: 'class', ranges: [0, 0x10ffff], negated: true }\n    }\n    return { t: 'class', ranges, negated }\n  }\n\n  /**\n   * One member of a class. Returns its code point, or null when it was a\n   * shorthand (`\\d`, `\\w`, `\\s`) whose ranges were appended directly.\n   */\n  private parseClassMember(ranges: number[]): number | null {\n    const ch = this.src[this.pos]\n    if (ch !== '\\\\') {\n      this.pos++\n      return ch.charCodeAt(0)\n    }\n    this.pos++\n    const esc = this.src[this.pos]\n    if (esc === undefined) throw new PatternError('trailing backslash')\n    this.pos++\n    if (esc >= '1' && esc <= '9') {\n      throw new PatternError('backreferences are not supported')\n    }\n    if (esc === 'D' || esc === 'W' || esc === 'S') {\n      // The union of a negated shorthand with other members is not a simple\n      // range list. Refuse rather than get it subtly wrong.\n      throw new PatternError(\n        `\\\\${esc} inside a character class is not supported`,\n      )\n    }\n    if (esc === 'p' || esc === 'P') {\n      throw new PatternError('unicode property escapes are not supported')\n    }\n    if (esc === 'd') {\n      ranges.push(...DIGIT_RANGES)\n      return null\n    }\n    if (esc === 'w') {\n      ranges.push(...WORD_RANGES)\n      return null\n    }\n    if (esc === 's') {\n      ranges.push(...SPACE_RANGES)\n      return null\n    }\n    if (esc === 'b') return 0x08 // `\\b` is a backspace inside a class, as in JS\n    if (esc === 'u' || esc === 'x') {\n      const width = esc === 'u' ? 4 : 2\n      const hex = this.src.slice(this.pos, this.pos + width)\n      if (!new RegExp(`^[0-9a-fA-F]{${width}}$`).test(hex)) {\n        throw new PatternError(`malformed \\\\${esc} escape`)\n      }\n      this.pos += width\n      return parseInt(hex, 16)\n    }\n    const control = controlEscape(esc)\n    if (control !== null) return control\n    return esc.charCodeAt(0)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Bytecode\n// ---------------------------------------------------------------------------\n\ntype Inst =\n  /** Under `i`, `c` is already case-folded, and so is the input it meets. */\n  | { op: 'char'; c: number }\n  | { op: 'class'; ranges: number[]; negated: boolean }\n  /** `dotAll` (the `s` flag) lets it take a line terminator too. */\n  | { op: 'any'; dotAll: boolean }\n  | { op: 'split'; x: number; y: number }\n  | { op: 'jmp'; x: number }\n  | { op: 'save'; slot: number }\n  /** Records the input offset an optional iteration started at. */\n  | { op: 'mark'; slot: number }\n  /** Fails the thread unless the iteration since `mark` consumed input. */\n  | { op: 'progress'; slot: number }\n  /** Resets the captures inside a repeated body at each iteration. */\n  | { op: 'clear'; slots: number[] }\n  /** `multiline` (the `m` flag) lets each hold beside a line terminator. */\n  | { op: 'assertStart'; multiline: boolean }\n  | { op: 'assertEnd'; multiline: boolean }\n  /** Holds where a word character meets a non-word one (`\\B`: where not). */\n  | { op: 'assertWordBoundary'; negated: boolean }\n  | { op: 'match' }\n\n/** Capture-group indices appearing anywhere inside a subtree. */\nfunction collectGroups(node: Node, into: number[]): number[] {\n  switch (node.t) {\n    case 'group':\n      into.push(node.index)\n      collectGroups(node.node, into)\n      break\n    case 'alt':\n      for (const option of node.options) collectGroups(option, into)\n      break\n    case 'cat':\n      for (const item of node.items) collectGroups(item, into)\n      break\n    case 'rep':\n      collectGroups(node.node, into)\n      break\n    default:\n      break\n  }\n  return into\n}\n\nclass Compiler {\n  readonly prog: Inst[] = []\n  /**\n   * Scratch slots (allocated above the capture slots) holding the offset an\n   * optional iteration began at, for the empty-iteration rule below.\n   */\n  markSlots = 0\n\n  constructor(private readonly flags: Flags = NO_FLAGS) {}\n\n  /** Group 0 (the whole match) opens the program and closes it. */\n  compileProgram(node: Node): void {\n    this.emit({ op: 'save', slot: 0 })\n    this.compile(node)\n    this.emit({ op: 'save', slot: 1 })\n    this.emit({ op: 'match' })\n  }\n\n  private emit(inst: Inst): number {\n    if (this.prog.length >= MAX_PROGRAM_LENGTH) {\n      throw new PatternError(\n        `pattern compiles to more than ${MAX_PROGRAM_LENGTH} instructions`,\n      )\n    }\n    this.prog.push(inst)\n    return this.prog.length - 1\n  }\n\n  compile(node: Node): void {\n    switch (node.t) {\n      case 'empty':\n        return\n      case 'char':\n        this.emit({\n          op: 'char',\n          c: this.flags.ignoreCase ? canonicalize(node.c) : node.c,\n        })\n        return\n      case 'class':\n        this.emit({\n          op: 'class',\n          ranges: this.flags.ignoreCase ? foldRanges(node.ranges) : node.ranges,\n          negated: node.negated,\n        })\n        return\n      case 'any':\n        this.emit({ op: 'any', dotAll: this.flags.dotAll })\n        return\n      case 'assertStart':\n        this.emit({ op: 'assertStart', multiline: this.flags.multiline })\n        return\n      case 'assertEnd':\n        this.emit({ op: 'assertEnd', multiline: this.flags.multiline })\n        return\n      case 'wordBoundary':\n        this.emit({ op: 'assertWordBoundary', negated: node.negated })\n        return\n      case 'cat':\n        for (const item of node.items) this.compile(item)\n        return\n      case 'group':\n        this.emit({ op: 'save', slot: node.index * 2 })\n        this.compile(node.node)\n        this.emit({ op: 'save', slot: node.index * 2 + 1 })\n        return\n      case 'alt':\n        this.compileAlt(node.options)\n        return\n      case 'rep':\n        this.compileRep(node)\n        return\n    }\n  }\n\n  private compileAlt(options: Node[]): void {\n    // Chain of splits; every branch jumps to a shared end.\n    const jumpsToEnd: number[] = []\n    for (let i = 0; i < options.length; i++) {\n      const last = i === options.length - 1\n      let split = -1\n      if (!last) split = this.emit({ op: 'split', x: 0, y: 0 })\n      if (split >= 0) {\n        ;(this.prog[split] as { x: number }).x = this.prog.length\n      }\n      this.compile(options[i])\n      if (!last) jumpsToEnd.push(this.emit({ op: 'jmp', x: 0 }))\n      if (split >= 0) {\n        ;(this.prog[split] as { y: number }).y = this.prog.length\n      }\n    }\n    const end = this.prog.length\n    for (const jump of jumpsToEnd) (this.prog[jump] as { x: number }).x = end\n  }\n\n  /**\n   * Emits one *optional* iteration of a repeated body, applying the two\n   * ECMAScript RepeatMatcher rules that a naive NFA gets wrong:\n   *\n   *  - captures inside the body are reset at the start of every iteration,\n   *    so `/^(?:(a)|b)*$/.exec('ab')` leaves group 1 `undefined`;\n   *  - an iteration that consumes nothing is discarded once `min` is\n   *    satisfied, so `/^(-|\\d*)?/.exec('')` also leaves group 1 `undefined`\n   *    rather than capturing an empty string.\n   *\n   * Both are capture-visible only — they never change whether a pattern\n   * matches — but getting them right keeps this engine a drop-in for the\n   * patterns customers already have.\n   */\n  private compileOptionalBody(body: Node, captures: number[]): number {\n    if (captures.length > 0) {\n      this.emit({\n        op: 'clear',\n        slots: captures.flatMap((index) => [index * 2, index * 2 + 1]),\n      })\n    }\n    const slot = this.markSlots++\n    this.emit({ op: 'mark', slot })\n    this.compile(body)\n    this.emit({ op: 'progress', slot })\n    return slot\n  }\n\n  private compileRep(node: {\n    node: Node\n    min: number\n    max: number\n    greedy: boolean\n  }): void {\n    const { min, max, greedy } = node\n    const captures = collectGroups(node.node, [])\n    // The mandatory copies: `min` is not yet satisfied, so the\n    // empty-iteration rule does not apply to them.\n    for (let i = 0; i < min; i++) this.compile(node.node)\n    if (max === Infinity) {\n      // L: split(body, end); body; jmp L; end:\n      const split = this.emit({ op: 'split', x: 0, y: 0 })\n      const bodyStart = this.prog.length\n      this.compileOptionalBody(node.node, captures)\n      this.emit({ op: 'jmp', x: split })\n      const end = this.prog.length\n      this.setSplit(split, bodyStart, end, greedy)\n      return\n    }\n    // Bounded: `max - min` optional copies, each able to skip to the end.\n    const splits: number[] = []\n    for (let i = min; i < max; i++) {\n      const split = this.emit({ op: 'split', x: 0, y: 0 })\n      splits.push(split)\n      const bodyStart = this.prog.length\n      this.compileOptionalBody(node.node, captures)\n      // Patch `x` now; `y` (the skip target) is patched to the shared end.\n      if (greedy) (this.prog[split] as { x: number }).x = bodyStart\n      else (this.prog[split] as { y: number }).y = bodyStart\n    }\n    const end = this.prog.length\n    for (const split of splits) {\n      if (greedy) (this.prog[split] as { y: number }).y = end\n      else (this.prog[split] as { x: number }).x = end\n    }\n  }\n\n  /** `x` is tried before `y`, so greedy puts the body first. */\n  private setSplit(\n    at: number,\n    body: number,\n    end: number,\n    greedy: boolean,\n  ): void {\n    const inst = this.prog[at] as { x: number; y: number }\n    inst.x = greedy ? body : end\n    inst.y = greedy ? end : body\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Pike VM\n// ---------------------------------------------------------------------------\n\ninterface Thread {\n  pc: number\n  caps: number[]\n}\n\n/**\n * When a scan with no live thread and no match yet gives up.\n *\n * - `stopWhenIdle` gives up there. That is `exec`'s answer for every pattern\n *   a later start could not rescue, and it is what redirect rules have always\n *   matched with, so it stays theirs. It is NOT `RegExp`'s answer for a\n *   pattern whose only way to match from a later start is a bare `$`: a\n *   rule written `/old|` matches every path in JavaScript and only `/old`\n *   here, and moving a live redirect rule to the other answer would turn a\n *   typo into a catch-all.\n * - `searchToEnd` keeps seeding a start at every offset, as `RegExp` does, so\n *   `(^a)?$`, a bare `$`, and a multiline `^` after a line terminator all\n *   answer what JavaScript answers. Still one pass: each offset seeds once.\n */\ntype ScanMode = 'stopWhenIdle' | 'searchToEnd'\n\n/**\n * Simulates every live NFA state in lockstep across the input.\n *\n * The `visited` generation array is what makes this linear: within a single\n * input position each program counter is added at most once, so the whole\n * run costs at most `inputLength × programLength` steps regardless of what\n * the pattern looks like.\n */\nfunction run(\n  prog: Inst[],\n  slotCount: number,\n  markBase: number,\n  input: string,\n  flags: Flags,\n  mode: ScanMode,\n): number[] | null {\n  const visited = new Int32Array(prog.length).fill(-1)\n  let generation = 0\n  const length = input.length\n  // Under `i` every input unit is compared by its folded form, which the\n  // program's characters and classes were compiled against.\n  let folded: Uint16Array | undefined\n  if (flags.ignoreCase) {\n    folded = new Uint16Array(length)\n    for (let at = 0; at < length; at++) {\n      folded[at] = canonicalize(input.charCodeAt(at))\n    }\n  }\n\n  const addThread = (\n    list: Thread[],\n    pc: number,\n    caps: number[],\n    sp: number,\n    mark: number,\n  ): void => {\n    // Iterative epsilon closure — a deep pattern must not blow the JS stack.\n    const stack: Array<{ pc: number; caps: number[] }> = [{ pc, caps }]\n    while (stack.length > 0) {\n      const entry = stack.pop()\n      if (visited[entry.pc] === mark) continue\n      visited[entry.pc] = mark\n      const inst = prog[entry.pc]\n      if (inst.op === 'jmp') {\n        stack.push({ pc: inst.x, caps: entry.caps })\n      } else if (inst.op === 'split') {\n        // Push `y` first so `x` (the higher priority branch) pops first.\n        stack.push({ pc: inst.y, caps: entry.caps })\n        stack.push({ pc: inst.x, caps: entry.caps })\n      } else if (inst.op === 'save') {\n        const next = entry.caps.slice()\n        next[inst.slot] = sp\n        stack.push({ pc: entry.pc + 1, caps: next })\n      } else if (inst.op === 'mark') {\n        const next = entry.caps.slice()\n        next[markBase + inst.slot] = sp\n        stack.push({ pc: entry.pc + 1, caps: next })\n      } else if (inst.op === 'progress') {\n        // Discard an iteration that consumed nothing (ECMAScript\n        // RepeatMatcher step 2.b). This also guarantees the epsilon closure\n        // cannot cycle forever through an empty-matching body.\n        if (entry.caps[markBase + inst.slot] < sp) {\n          stack.push({ pc: entry.pc + 1, caps: entry.caps })\n        }\n      } else if (inst.op === 'clear') {\n        const next = entry.caps.slice()\n        for (const slot of inst.slots) next[slot] = -1\n        stack.push({ pc: entry.pc + 1, caps: next })\n      } else if (inst.op === 'assertStart') {\n        if (\n          sp === 0 ||\n          (inst.multiline && isLineTerminator(input.charCodeAt(sp - 1)))\n        ) {\n          stack.push({ pc: entry.pc + 1, caps: entry.caps })\n        }\n      } else if (inst.op === 'assertEnd') {\n        if (\n          sp === length ||\n          (inst.multiline && isLineTerminator(input.charCodeAt(sp)))\n        ) {\n          stack.push({ pc: entry.pc + 1, caps: entry.caps })\n        }\n      } else if (inst.op === 'assertWordBoundary') {\n        // Read from the input as written: without the `u` flag a word\n        // character is `[A-Za-z0-9_]`, and case folding does not move it.\n        const before =\n          sp > 0 && rangesContain(WORD_RANGES, input.charCodeAt(sp - 1))\n        const after =\n          sp < length && rangesContain(WORD_RANGES, input.charCodeAt(sp))\n        const boundary = before !== after\n        if (boundary !== inst.negated) {\n          stack.push({ pc: entry.pc + 1, caps: entry.caps })\n        }\n      } else {\n        list.push({ pc: entry.pc, caps: entry.caps })\n      }\n    }\n  }\n\n  // NOTE: the iterative closure above uses a LIFO stack, which reverses the\n  // order sibling epsilon branches are appended in. Priority is restored by\n  // pushing the lower-priority branch first (see the `split` case), so `x`\n  // is always explored before `y`.\n\n  const initial = new Array<number>(slotCount).fill(-1)\n  let current: Thread[] = []\n  addThread(current, 0, initial, 0, generation++)\n  let matched: number[] | null = null\n\n  for (let sp = 0; sp <= length; sp++) {\n    // With nothing live, a match found is final and a sticky pattern has\n    // nowhere else to start. Otherwise only `stopWhenIdle` ends the scan\n    // here; see `ScanMode` for what that costs.\n    if (\n      current.length === 0 &&\n      (matched !== null || flags.sticky || mode === 'stopWhenIdle')\n    ) {\n      break\n    }\n    const code =\n      sp < length ? (folded ? folded[sp] : input.charCodeAt(sp)) : -1\n    const next: Thread[] = []\n    const mark = generation++\n    for (let i = 0; i < current.length; i++) {\n      const thread = current[i]\n      const inst = prog[thread.pc]\n      if (inst.op === 'match') {\n        // Leftmost-first: this thread outranks every thread after it, so its\n        // result is the one a backtracking engine would return. Threads\n        // *ahead* of it are still live and may overwrite this on a later\n        // step — which is exactly the greedy preference JS applies.\n        matched = thread.caps\n        break\n      }\n      if (code < 0) continue\n      let consumes = false\n      if (inst.op === 'char') {\n        consumes = code === inst.c\n      } else if (inst.op === 'any') {\n        // A line terminator folds to itself, so the folded unit reads true.\n        consumes = inst.dotAll || !isLineTerminator(code)\n      } else if (inst.op === 'class') {\n        const inRanges = rangesContain(inst.ranges, code)\n        consumes = inst.negated ? !inRanges : inRanges\n      }\n      if (consumes) addThread(next, thread.pc + 1, thread.caps, sp + 1, mark)\n    }\n    // `exec` searches: JS retries the whole pattern at each later offset.\n    // That matters whenever `^` binds to only part of the pattern, e.g.\n    // `^/a|/b$`. Seeding a fresh start thread *after* the continuing ones\n    // keeps it lower priority, so an earlier start always wins (leftmost).\n    // Once a match exists no later start could be more leftmost, so seeding\n    // stops — which is also what bounds this to one pass. A sticky pattern\n    // (`y`) is only ever tried where the input starts.\n    if (matched === null && sp + 1 <= length && !flags.sticky) {\n      addThread(next, 0, initial, sp + 1, mark)\n    }\n    current = next\n  }\n  return matched\n}\n\n// ---------------------------------------------------------------------------\n// Public surface\n// ---------------------------------------------------------------------------\n\n/**\n * A compiled pattern. `exec` mirrors the slice of `RegExp.prototype.exec`\n * the redirect matcher uses: index 0 is the whole match, index n is capture\n * group n, and a group that did not participate is `undefined`.\n */\nexport interface LinearPattern {\n  readonly source: string\n  /** Instruction count — worst-case cost is `input.length × programLength`. */\n  readonly programLength: number\n  exec(input: string): Array<string | undefined> | null\n}\n\n/** A pattern compiled to the program `run` executes. */\ninterface Compiled {\n  prog: Inst[]\n  flags: Flags\n  groupCount: number\n  markBase: number\n  slotCount: number\n}\n\n/** Which of the two dialects a pattern is compiled in. */\ntype Dialect = 'pattern' | 'test'\n\n/**\n * Compiles a pattern and its flags. Throws `PatternError` for either.\n *\n * The `test` dialect ({@link compileLinearTest}) also reads `\\b` and `\\B`;\n * the `pattern` dialect is the one redirect rules have always been held to.\n */\nfunction compileSource(\n  pattern: string,\n  flags: string,\n  dialect: Dialect,\n): Compiled {\n  const mode = parseFlags(flags)\n  const parser = new Parser(pattern, dialect === 'test')\n  const ast = parser.parse()\n  const compiler = new Compiler(mode)\n  compiler.compileProgram(ast)\n  // Capture slots first, then one scratch slot per optional iteration.\n  const markBase = (parser.groupCount + 1) * 2\n  return {\n    prog: compiler.prog,\n    flags: mode,\n    groupCount: parser.groupCount,\n    markBase,\n    slotCount: markBase + compiler.markSlots,\n  }\n}\n\n/** Why `compileSource` refused, or null when it did not. */\nfunction explain(pattern: string, flags: string, dialect: Dialect): string | null {\n  try {\n    compileSource(pattern, flags, dialect)\n    return null\n  } catch (error) {\n    if (error instanceof PatternError) return error.message\n    return 'the pattern could not be understood'\n  }\n}\n\n/**\n * Compiles a pattern for linear-time matching, or returns null when it is\n * malformed or uses syntax outside the supported subset.\n *\n * Takes no flags, and scans as redirect rules always have (see `ScanMode`).\n * Never throws, and never hands the pattern to `new RegExp`.\n */\nexport function compileLinearPattern(pattern: string): LinearPattern | null {\n  try {\n    const { prog, flags, groupCount, markBase, slotCount } = compileSource(\n      pattern,\n      '',\n      'pattern',\n    )\n    return {\n      source: pattern,\n      programLength: prog.length,\n      exec(input: string) {\n        const caps = run(\n          prog,\n          slotCount,\n          markBase,\n          String(input ?? ''),\n          flags,\n          'stopWhenIdle',\n        )\n        if (caps === null) return null\n        const result: Array<string | undefined> = []\n        for (let group = 0; group <= groupCount; group++) {\n          const start = caps[group * 2]\n          const end = caps[group * 2 + 1]\n          result.push(\n            start < 0 || end < 0 || end < start\n              ? undefined\n              : input.slice(start, end),\n          )\n        }\n        return result\n      },\n    }\n  } catch (error) {\n    if (error instanceof PatternError) return null\n    // A genuinely unexpected fault must still fail closed rather than let an\n    // unvalidated pattern through.\n    return null\n  }\n}\n\n/**\n * Explains why {@link compileLinearPattern} refuses a pattern, for\n * console-side validation. Returns null when the pattern is fine.\n */\nexport function explainLinearPattern(pattern: string): string | null {\n  return explain(pattern, '', 'pattern')\n}\n\n/** A compiled pattern that answers one question: does the input match. */\nexport interface LinearTest {\n  readonly source: string\n  readonly flags: string\n  /** Instruction count — worst-case cost is `input.length × programLength`. */\n  readonly programLength: number\n  /**\n   * What `new RegExp(source, flags).test(input)` answers for a fresh\n   * `RegExp`, in time linear in the input.\n   */\n  test(input: string): boolean\n}\n\n/**\n * Compiles a pattern and its flags into a {@link LinearTest}, or returns null\n * when either is malformed or outside the supported subset: the syntax in\n * `UNSUPPORTED_SYNTAX` except word boundaries, which this reads, and any flag\n * outside {@link FLAG_CHARS}.\n *\n * Unlike {@link compileLinearPattern} it scans to the end of the input (see\n * `ScanMode`), so every pattern it accepts answers what `RegExp` answers.\n * Never throws, and never hands the pattern to `new RegExp`.\n */\nexport function compileLinearTest(\n  pattern: string,\n  flags = '',\n): LinearTest | null {\n  try {\n    const compiled = compileSource(pattern, flags, 'test')\n    return {\n      source: pattern,\n      flags,\n      programLength: compiled.prog.length,\n      test(input: string) {\n        return (\n          run(\n            compiled.prog,\n            compiled.slotCount,\n            compiled.markBase,\n            String(input ?? ''),\n            compiled.flags,\n            'searchToEnd',\n          ) !== null\n        )\n      },\n    }\n  } catch {\n    // A PatternError is a refusal, and a genuinely unexpected fault must\n    // still fail closed rather than let an unvalidated pattern through.\n    return null\n  }\n}\n\n/**\n * Explains why {@link compileLinearTest} refuses a pattern or its flags.\n * Returns null when both are fine.\n */\nexport function explainLinearTest(pattern: string, flags = ''): string | null {\n  return explain(pattern, flags, 'test')\n}\n"],"names":["UNSUPPORTED_SYNTAX","MAX_PROGRAM_LENGTH","MAX_REPEAT_COUNT","MAX_CAPTURE_GROUPS","PatternError","Error","FLAG_CHARS","NO_FLAGS","ignoreCase","multiline","dotAll","sticky","parseFlags","flags","seen","Set","flag","includes","has","add","canonicalize","code","upper","String","fromCharCode","toUpperCase","length","folded","charCodeAt","foldedUnits","unitsThatFold","unit","push","foldRanges","ranges","units","added","i","lo","hi","Math","min","j","rangesContain","size","merged","sort","a","b","DIGIT_RANGES","WORD_RANGES","SPACE_RANGES","isLineTerminator","controlEscape","ch","Parser","parse","node","parseAlternation","pos","src","peek","options","parseConcat","t","items","parseRepeat","atom","parseAtom","max","Infinity","bounds","tryParseBounds","greedy","start","digits","from","test","Number","slice","parsed","parseGroup","parseClass","parseEscape","c","index","kind","after","groupCount","undefined","wordBoundaries","negated","width","hex","RegExp","parseInt","control","first","parseClassMember","esc","collectGroups","into","option","item","Compiler","compileProgram","emit","op","slot","compile","inst","prog","compileAlt","compileRep","jumpsToEnd","last","split","x","y","end","jump","compileOptionalBody","body","captures","slots","flatMap","markSlots","bodyStart","setSplit","splits","at","run","slotCount","markBase","input","mode","visited","Int32Array","fill","generation","Uint16Array","addThread","list","pc","caps","sp","mark","stack","entry","pop","next","before","boundary","initial","Array","current","matched","thread","consumes","inRanges","compileSource","pattern","dialect","parser","ast","compiler","explain","error","message","compileLinearPattern","source","programLength","exec","result","group","explainLinearPattern","compileLinearTest","compiled","explainLinearTest"],"mappings":"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"}

package/src/lib/no-side-effects.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2022 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Convince closure compiler that the wrapped function has no side-effects.
+ *
+ * Closure compiler always assumes that `toString` has no side-effects. We use
+ * this quirk to allow us to execute a function but have closure compiler mark
+ * the call as no-side-effects. It is important that the return value for the
+ * `noSideEffects` function be assigned to something which is retained otherwise
+ * the call to `noSideEffects` will be removed by closure compiler.
+ *
+ * @see https://github.com/angular/angular/blob/master/packages/core/src/util/closure.ts
+ */
+export declare function noSideEffects<T>(fn: () => T): T;
+export default noSideEffects;

package/src/lib/no-side-effects.js

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2022 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * Convince closure compiler that the wrapped function has no side-effects.
+ *
+ * Closure compiler always assumes that `toString` has no side-effects. We use
+ * this quirk to allow us to execute a function but have closure compiler mark
+ * the call as no-side-effects. It is important that the return value for the
+ * `noSideEffects` function be assigned to something which is retained otherwise
+ * the call to `noSideEffects` will be removed by closure compiler.
+ *
+ * @see https://github.com/angular/angular/blob/master/packages/core/src/util/closure.ts
+ */ export function noSideEffects(fn) {
+    return ({
+        toString: fn
+    }).toString();
+}
+export default noSideEffects;
+
+//# sourceMappingURL=no-side-effects.js.map

package/src/lib/no-side-effects.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/shared/util/tools/src/lib/no-side-effects.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2022 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Convince closure compiler that the wrapped function has no side-effects.\n *\n * Closure compiler always assumes that `toString` has no side-effects. We use\n * this quirk to allow us to execute a function but have closure compiler mark\n * the call as no-side-effects. It is important that the return value for the\n * `noSideEffects` function be assigned to something which is retained otherwise\n * the call to `noSideEffects` will be removed by closure compiler.\n *\n * @see https://github.com/angular/angular/blob/master/packages/core/src/util/closure.ts\n */\nexport function noSideEffects<T>(fn: () => T): T {\n  return {toString: fn}.toString()\n}\n\nexport default noSideEffects\n"],"names":["noSideEffects","fn","toString"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;CAUC,GACD,OAAO,SAASA,cAAiBC,EAAW;IAC1C,OAAO,CAAA;QAACC,UAAUD;IAAE,CAAA,EAAEC,QAAQ;AAChC;AAEA,eAAeF,cAAa"}

package/src/lib/noop.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2023 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Create a no operation function with no return
+ */
+export declare function noop(..._: any[]): any;
+export default noop;

package/src/lib/noop.js

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2023 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * Create a no operation function with no return
+ */ export function noop(..._) {
+/*Do nothing.*/ }
+export default noop;
+
+//# sourceMappingURL=noop.js.map

package/src/lib/noop.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/shared/util/tools/src/lib/noop.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2023 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Create a no operation function with no return\n */\nexport function noop(..._: any[]): any {\n  /*Do nothing.*/\n}\n\nexport default noop\n"],"names":["noop","_"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;CAEC,GACD,OAAO,SAASA,KAAK,GAAGC,CAAQ;AAC9B,aAAa,GACf;AAEA,eAAeD,KAAI"}

package/src/lib/normalized.d.ts

@@ -0,0 +1,164 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NormalizedData, NormalizedModel } from '@aglyn/shared-data-types';
+type ID = string;
+/**
+ * Normalized data for 3NF
+ *
+ * @export
+ * @abstract
+ * @class Normalized
+ * @extends {NormalizedData<T, K>}
+ * @template T
+ * @template K
+ * @see https://en.wikipedia.org/wiki/Third_normal_form
+ */
+export declare class Normalized<T = any, K extends ID = ID> implements NormalizedModel<T, K> {
+    readonly props?: NormalizedData<T, K>;
+    static build<T, K extends ID>(): NormalizedData<T, K>;
+    ids: K[];
+    byId: {
+        [P in K]?: T;
+    };
+    get length(): number;
+    constructor(props?: NormalizedData<T, K>);
+    /**
+     * Maps the ids/keys to their respective values in byId
+     *
+     * @static
+     * @template T
+     * @template V
+     * @param {T} v
+     * @returns {V[]}
+     * @memberof Normalized
+     */
+    static toArray<T extends NormalizedData<V>, V>(v: T): V[];
+    /**
+     * Resets the keys/ids and values/byId back to empty
+     *
+     * @static
+     * @param {NormalizedData} v
+     * @returns {NormalizedData}
+     * @memberof Normalized
+     */
+    static clear<T extends NormalizedData<any>>(v: T): T;
+    /**
+     * Clears all values
+     * @returns {this}
+     * @memberof Normalized
+     */
+    clear(): this;
+    /**
+     * Create a new class instance from the provided params
+     *
+     * @static
+     * @template T
+     * @template K
+     * @param {(...T[] | [id: K, value: any][])} items
+     * @returns {NormalizedModel<T>}
+     * @memberof Normalized
+     */
+    static from<T extends {
+        id: ID;
+    }, K extends ID>(...items: T[] | [id: K, value: any][]): NormalizedModel<T>;
+    /**
+     * Removes an item from an existing key value data structure object
+     *
+     * @static
+     * @template T
+     * @param {ID} id
+     * @param {NormalizedData<T>} model
+     * @returns {NormalizedData<T>}
+     * @memberof Normalized
+     */
+    static remove<T extends NormalizedData<TT, any>, K extends ID, TT = any>(id: K, model: T): NormalizedData<TT, ID>;
+    /**
+     * Sets an item in an existing denormalized key value object.
+     *
+     * @static
+     * @template T
+     * @template V
+     * @template K
+     * @param {[id: K, value: V]} item
+     * @param {T} model
+     * @param {number} [index]
+     * @returns {T}
+     * @memberof Normalized
+     */
+    static set<T extends NormalizedData<V, K>, V, K extends ID>(item: [id: K, value: V], model: T, index?: number): T;
+    /**
+     * Get a property from the key value. shortens call such as model.byId[foo]
+     *
+     * @static
+     * @template T
+     * @param {ID} id
+     * @param {NormalizedData<T>} model
+     * @returns {(undefined | T)}
+     * @memberof Normalized
+     */
+    static get<T extends NormalizedData<V, K>, K extends ID, V>(id: K, model: T): V | null;
+    /**
+     * The properties to keep when object is passed to JSON.stringify(...)
+     * @returns {NormalizedData<T, K>}
+     * @memberof Normalized
+     */
+    toJSON(): NormalizedData<T, K>;
+    /**
+     * Converts the current values into an array ordered by the
+     * appearance of the key in ids array
+     * @returns {Array<T>}
+     * @memberof Normalized
+     */
+    toArray(): Array<T>;
+    /**
+     * Aliases the static method to shortcut delete operations on this instance
+     *
+     * @param {K} id
+     * @returns {this}
+     * @memberof Normalized
+     */
+    remove(id: K): this;
+    /**
+     * Returns whether or not the model byId has property key/id
+     *
+     * @param {ID} id
+     * @returns {boolean}
+     * @memberof Normalized
+     */
+    has(id: ID): boolean;
+    /**
+     * Aliases the static method to shortcut set operations on this instance
+     *
+     * @param {ID} id
+     * @param {*} [value]
+     * @param {number} [index]
+     * @returns {this}
+     * @memberof Normalized
+     */
+    set(id: ID, value?: T, index?: number): this;
+    /**
+     * Shortcuts getting the value of properties of the current instance
+     *
+     * @param {ID} id
+     * @returns {(undefined | T)}
+     * @memberof Normalized
+     */
+    get(id: ID): undefined | T;
+    /** @ignore */
+    private get hasOwnProperty();
+}
+export {};