@bcts/dcbor-pattern 1.0.0-alpha.11

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["#min","#max","#interval","#reluctance","DEFAULT_FORMAT_OPTS: FormatPathsOpts","#opts","diagnostic: string","cbor","lines: string[]","result: string[]","paths","matchFn: ((pattern: Pattern, haystack: Cbor) => boolean) | undefined","pathsFn: ((pattern: Pattern, haystack: Cbor) => Path[]) | undefined","pathsWithCapturesFn:\n  | ((pattern: Pattern, haystack: Cbor) => MatchResultInternal)\n  | undefined","pathsWithCapturesDirectFn:\n  | ((pattern: Pattern, haystack: Cbor) => MatchResultInternal)\n  | undefined","nullPattern","date","knownValue","matchFn","repeatPattern","arrayPath: Cbor[]","arrayContextPaths: Cbor[][]","#patterns","#arr","#matchFn","matchFn","repeatPattern","#patterns","#arr","#matchFn","matchFn","assignments: [number, number][]","elements: Cbor[]","repeatPattern","capturePattern","paths: Path[]","paths","patternDisplay","patternDisplay","taggedPaths: Path[]","path: Cbor[]","updated: Path[]","patternDisplay","patternDisplay","patternDisplay","patternDisplay","patternDisplay","patternDisplay","patternDisplay","results: Path[]","patternDisplay","patternDisplay","patternDisplay","cbor","children: Cbor[]","values: Cbor[]","states: { cbor: Cbor; path: Path }[][]","next: { cbor: Cbor; path: Path }[]","counts: number[]","out: { cbor: Cbor; path: Path }[]","stack: Thread[]","newThread: Thread","th2: Thread","createSearchPattern","stack","initialCaptures: Path[][]","start: Thread","results: { path: Path; captures: Path[][] }[]","paths: Path[]","capturedPaths: Path[]","deduplicated: Path[]","code: Instr[]","literals: Pattern[]","captureNames: string[]","jumpAddrs: number[]","captureMap: [string, number][]","innerNames: string[]","paths","captures","capturePattern","anyPatternCreate","nullPatternCreate","andPatternCreate","orPatternCreate","notPatternCreate","capturePatternCreate","searchPatternCreate","sequencePatternCreate","repeatPatternCreate","KEYWORDS: Record<string, Token>","#input","#position","tokens: SpannedToken[]","max: number | undefined","parseOrFn: ((lexer: Lexer) => Result<Pattern>) | undefined","pattern","closeResult","patterns: Pattern[]","constraints: [Pattern, Pattern][]","tagSelector: TagSelector","patterns: Pattern[]","patterns: Pattern[]"],"sources":["../src/error.ts","../src/reluctance.ts","../src/interval.ts","../src/quantifier.ts","../src/format.ts","../src/pattern/match-registry.ts","../src/pattern/value/bool-pattern.ts","../src/pattern/value/null-pattern.ts","../src/pattern/value/number-pattern.ts","../src/pattern/value/text-pattern.ts","../src/pattern/value/bytes-utils.ts","../src/pattern/value/bytestring-pattern.ts","../src/pattern/value/date-pattern.ts","../src/pattern/value/digest-pattern.ts","../src/pattern/value/known-value-pattern.ts","../src/pattern/value/index.ts","../src/pattern/structure/array-pattern/helpers.ts","../src/pattern/structure/array-pattern/backtrack.ts","../src/pattern/structure/array-pattern/assigner.ts","../src/pattern/structure/array-pattern/index.ts","../src/pattern/structure/map-pattern.ts","../src/pattern/structure/tagged-pattern.ts","../src/pattern/structure/index.ts","../src/pattern/meta/any-pattern.ts","../src/pattern/meta/and-pattern.ts","../src/pattern/meta/or-pattern.ts","../src/pattern/meta/not-pattern.ts","../src/pattern/meta/repeat-pattern.ts","../src/pattern/meta/capture-pattern.ts","../src/pattern/meta/search-pattern.ts","../src/pattern/meta/sequence-pattern.ts","../src/pattern/meta/index.ts","../src/pattern/vm.ts","../src/pattern/matcher.ts","../src/pattern/index.ts","../src/parse/token.ts","../src/parse/value/bool-parser.ts","../src/parse/value/null-parser.ts","../src/parse/value/number-parser.ts","../src/parse/value/text-parser.ts","../src/parse/value/bytestring-parser.ts","../src/parse/value/date-parser.ts","../src/parse/value/digest-parser.ts","../src/parse/value/known-value-parser.ts","../src/parse/parse-registry.ts","../src/parse/structure/array-parser.ts","../src/parse/structure/map-parser.ts","../src/parse/structure/tagged-parser.ts","../src/parse/meta/capture-parser.ts","../src/parse/meta/search-parser.ts","../src/parse/meta/repeat-parser.ts","../src/parse/meta/primary-parser.ts","../src/parse/meta/not-parser.ts","../src/parse/meta/and-parser.ts","../src/parse/meta/or-parser.ts","../src/parse/index.ts"],"sourcesContent":["/**\n * Error types for dCBOR pattern parsing.\n *\n * This module provides error handling utilities for the dCBOR pattern\n * matching system, including a discriminated union Error type and\n * a Result type for type-safe error handling.\n *\n * @module error\n */\n\nimport type { Token } from \"./parse/token\";\n\n/**\n * Represents a span in the input string, indicating position for error reporting.\n */\nexport interface Span {\n  readonly start: number;\n  readonly end: number;\n}\n\n/**\n * Creates a new Span.\n */\nexport const span = (start: number, end: number): Span => ({ start, end });\n\n/**\n * Errors that can occur during parsing of dCBOR patterns.\n *\n * This is a discriminated union type matching the Rust Error enum.\n */\nexport type Error =\n  | { readonly type: \"EmptyInput\" }\n  | { readonly type: \"UnexpectedEndOfInput\" }\n  | { readonly type: \"ExtraData\"; readonly span: Span }\n  | { readonly type: \"UnexpectedToken\"; readonly token: Token; readonly span: Span }\n  | { readonly type: \"UnrecognizedToken\"; readonly span: Span }\n  | { readonly type: \"InvalidRegex\"; readonly span: Span }\n  | { readonly type: \"UnterminatedRegex\"; readonly span: Span }\n  | { readonly type: \"UnterminatedString\"; readonly span: Span }\n  | { readonly type: \"InvalidRange\"; readonly span: Span }\n  | { readonly type: \"InvalidHexString\"; readonly span: Span }\n  | { readonly type: \"UnterminatedHexString\"; readonly span: Span }\n  | { readonly type: \"InvalidDateFormat\"; readonly span: Span }\n  | { readonly type: \"InvalidNumberFormat\"; readonly span: Span }\n  | { readonly type: \"InvalidUr\"; readonly message: string; readonly span: Span }\n  | { readonly type: \"ExpectedOpenParen\"; readonly span: Span }\n  | { readonly type: \"ExpectedCloseParen\"; readonly span: Span }\n  | { readonly type: \"ExpectedCloseBracket\"; readonly span: Span }\n  | { readonly type: \"ExpectedCloseBrace\"; readonly span: Span }\n  | { readonly type: \"ExpectedColon\"; readonly span: Span }\n  | { readonly type: \"ExpectedPattern\"; readonly span: Span }\n  | { readonly type: \"UnmatchedParentheses\"; readonly span: Span }\n  | { readonly type: \"UnmatchedBraces\"; readonly span: Span }\n  | { readonly type: \"InvalidCaptureGroupName\"; readonly name: string; readonly span: Span }\n  | { readonly type: \"InvalidDigestPattern\"; readonly message: string; readonly span: Span }\n  | { readonly type: \"UnterminatedDigestQuoted\"; readonly span: Span }\n  | { readonly type: \"UnterminatedDateQuoted\"; readonly span: Span }\n  | { readonly type: \"InvalidDigest\"; readonly span: Span }\n  | { readonly type: \"InvalidDate\"; readonly span: Span }\n  | { readonly type: \"Unknown\" };\n\n/**\n * A Result type specialized for dCBOR pattern parsing.\n * Matches Rust's Result<T, Error> pattern.\n */\nexport type Result<T> =\n  | { readonly ok: true; readonly value: T }\n  | { readonly ok: false; readonly error: Error };\n\n/**\n * Creates a successful Result.\n */\nexport const Ok = <T>(value: T): Result<T> => ({ ok: true, value });\n\n/**\n * Creates a failed Result.\n */\nexport const Err = <T>(error: Error): Result<T> => ({ ok: false, error });\n\n/**\n * Unwraps a Result, throwing an error if it's not Ok.\n */\nexport const unwrap = <T>(result: Result<T>): T => {\n  if (result.ok) {\n    return result.value;\n  }\n  throw new PatternError(result.error);\n};\n\n/**\n * Unwraps a Result, returning the default value if it's an error.\n */\nexport const unwrapOr = <T>(result: Result<T>, defaultValue: T): T => {\n  if (result.ok) {\n    return result.value;\n  }\n  return defaultValue;\n};\n\n/**\n * Maps a Result's value if it's Ok.\n */\nexport const map = <T, U>(result: Result<T>, fn: (value: T) => U): Result<U> => {\n  if (result.ok) {\n    return Ok(fn(result.value));\n  }\n  return result as Result<U>;\n};\n\n/**\n * Converts an Error to a human-readable string.\n */\nexport const errorToString = (error: Error): string => {\n  switch (error.type) {\n    case \"EmptyInput\":\n      return \"Empty input\";\n    case \"UnexpectedEndOfInput\":\n      return \"Unexpected end of input\";\n    case \"ExtraData\":\n      return `Extra data at end of input at ${error.span.start}..${error.span.end}`;\n    case \"UnexpectedToken\":\n      return `Unexpected token at ${error.span.start}..${error.span.end}`;\n    case \"UnrecognizedToken\":\n      return `Unrecognized token at position ${error.span.start}..${error.span.end}`;\n    case \"InvalidRegex\":\n      return `Invalid regex pattern at ${error.span.start}..${error.span.end}`;\n    case \"UnterminatedRegex\":\n      return `Unterminated regex pattern at ${error.span.start}..${error.span.end}`;\n    case \"UnterminatedString\":\n      return `Unterminated string literal at ${error.span.start}..${error.span.end}`;\n    case \"InvalidRange\":\n      return `Invalid range at ${error.span.start}..${error.span.end}`;\n    case \"InvalidHexString\":\n      return `Invalid hex string at ${error.span.start}..${error.span.end}`;\n    case \"UnterminatedHexString\":\n      return `Unterminated hex string at ${error.span.start}..${error.span.end}`;\n    case \"InvalidDateFormat\":\n      return `Invalid date format at ${error.span.start}..${error.span.end}`;\n    case \"InvalidNumberFormat\":\n      return `Invalid number format at ${error.span.start}..${error.span.end}`;\n    case \"InvalidUr\":\n      return `Invalid UR: ${error.message} at ${error.span.start}..${error.span.end}`;\n    case \"ExpectedOpenParen\":\n      return `Expected opening parenthesis at ${error.span.start}..${error.span.end}`;\n    case \"ExpectedCloseParen\":\n      return `Expected closing parenthesis at ${error.span.start}..${error.span.end}`;\n    case \"ExpectedCloseBracket\":\n      return `Expected closing bracket at ${error.span.start}..${error.span.end}`;\n    case \"ExpectedCloseBrace\":\n      return `Expected closing brace at ${error.span.start}..${error.span.end}`;\n    case \"ExpectedColon\":\n      return `Expected colon at ${error.span.start}..${error.span.end}`;\n    case \"ExpectedPattern\":\n      return `Expected pattern after operator at ${error.span.start}..${error.span.end}`;\n    case \"UnmatchedParentheses\":\n      return `Unmatched parentheses at ${error.span.start}..${error.span.end}`;\n    case \"UnmatchedBraces\":\n      return `Unmatched braces at ${error.span.start}..${error.span.end}`;\n    case \"InvalidCaptureGroupName\":\n      return `Invalid capture group name '${error.name}' at ${error.span.start}..${error.span.end}`;\n    case \"InvalidDigestPattern\":\n      return `Invalid digest pattern: ${error.message} at ${error.span.start}..${error.span.end}`;\n    case \"UnterminatedDigestQuoted\":\n      return `Unterminated digest quoted pattern at ${error.span.start}..${error.span.end}`;\n    case \"UnterminatedDateQuoted\":\n      return `Unterminated date quoted pattern at ${error.span.start}..${error.span.end}`;\n    case \"InvalidDigest\":\n      return `Invalid digest at ${error.span.start}..${error.span.end}`;\n    case \"InvalidDate\":\n      return `Invalid date at ${error.span.start}..${error.span.end}`;\n    case \"Unknown\":\n      return \"Unknown error\";\n  }\n};\n\n/**\n * Adjusts the span of an error by adding the given offset to both start and end positions.\n * Returns a new error with adjusted span, or the original error if it has no span.\n */\nexport const adjustSpan = (error: Error, offset: number): Error => {\n  switch (error.type) {\n    case \"ExtraData\":\n      return { type: \"ExtraData\", span: span(offset + error.span.start, offset + error.span.end) };\n    case \"UnexpectedToken\":\n      return {\n        type: \"UnexpectedToken\",\n        token: error.token,\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"UnrecognizedToken\":\n      return {\n        type: \"UnrecognizedToken\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"InvalidRegex\":\n      return {\n        type: \"InvalidRegex\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"UnterminatedRegex\":\n      return {\n        type: \"UnterminatedRegex\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"UnterminatedString\":\n      return {\n        type: \"UnterminatedString\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"InvalidRange\":\n      return {\n        type: \"InvalidRange\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"InvalidHexString\":\n      return {\n        type: \"InvalidHexString\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"UnterminatedHexString\":\n      return {\n        type: \"UnterminatedHexString\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"InvalidDateFormat\":\n      return {\n        type: \"InvalidDateFormat\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"InvalidNumberFormat\":\n      return {\n        type: \"InvalidNumberFormat\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"InvalidUr\":\n      return {\n        type: \"InvalidUr\",\n        message: error.message,\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"ExpectedOpenParen\":\n      return {\n        type: \"ExpectedOpenParen\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"ExpectedCloseParen\":\n      return {\n        type: \"ExpectedCloseParen\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"ExpectedCloseBracket\":\n      return {\n        type: \"ExpectedCloseBracket\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"ExpectedCloseBrace\":\n      return {\n        type: \"ExpectedCloseBrace\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"ExpectedColon\":\n      return {\n        type: \"ExpectedColon\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"ExpectedPattern\":\n      return {\n        type: \"ExpectedPattern\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"UnmatchedParentheses\":\n      return {\n        type: \"UnmatchedParentheses\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"UnmatchedBraces\":\n      return {\n        type: \"UnmatchedBraces\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"InvalidCaptureGroupName\":\n      return {\n        type: \"InvalidCaptureGroupName\",\n        name: error.name,\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"InvalidDigestPattern\":\n      return {\n        type: \"InvalidDigestPattern\",\n        message: error.message,\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"UnterminatedDigestQuoted\":\n      return {\n        type: \"UnterminatedDigestQuoted\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"UnterminatedDateQuoted\":\n      return {\n        type: \"UnterminatedDateQuoted\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"InvalidDigest\":\n      return {\n        type: \"InvalidDigest\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    case \"InvalidDate\":\n      return {\n        type: \"InvalidDate\",\n        span: span(offset + error.span.start, offset + error.span.end),\n      };\n    // For errors without spans, return them as-is\n    case \"EmptyInput\":\n    case \"UnexpectedEndOfInput\":\n    case \"Unknown\":\n      return error;\n  }\n};\n\n/**\n * JavaScript Error class wrapper for PatternError.\n * Provides stack traces and works with try/catch blocks.\n */\nexport class PatternError extends globalThis.Error {\n  public readonly errorType: Error;\n\n  constructor(errorType: Error, message?: string) {\n    super(message ?? errorToString(errorType));\n    this.name = \"PatternError\";\n    this.errorType = errorType;\n  }\n}\n","/**\n * Reluctance for quantifiers.\n *\n * This module defines the matching behavior for quantified patterns,\n * controlling how greedily the pattern matcher consumes input.\n *\n * @module reluctance\n */\n\n/**\n * Reluctance for quantifiers.\n *\n * Controls how a quantified pattern matches:\n * - `Greedy`: Match as many as possible, backtrack if needed\n * - `Lazy`: Match as few as possible, add more if needed\n * - `Possessive`: Match as many as possible, never backtrack\n */\nexport enum Reluctance {\n  /**\n   * Grabs as many repetitions as possible, then backtracks if the rest of\n   * the pattern cannot match.\n   */\n  Greedy = \"greedy\",\n\n  /**\n   * Starts with as few repetitions as possible, adding more only if the rest\n   * of the pattern cannot match.\n   */\n  Lazy = \"lazy\",\n\n  /**\n   * Grabs as many repetitions as possible and never backtracks; if the rest\n   * of the pattern cannot match, the whole match fails.\n   */\n  Possessive = \"possessive\",\n}\n\n/**\n * Default reluctance is Greedy.\n */\nexport const DEFAULT_RELUCTANCE = Reluctance.Greedy;\n\n/**\n * Returns the suffix character for a reluctance type.\n *\n * @param reluctance - The reluctance type\n * @returns The suffix string (\"\" for Greedy, \"?\" for Lazy, \"+\" for Possessive)\n *\n * @example\n * ```typescript\n * reluctanceSuffix(Reluctance.Greedy)     // \"\"\n * reluctanceSuffix(Reluctance.Lazy)       // \"?\"\n * reluctanceSuffix(Reluctance.Possessive) // \"+\"\n * ```\n */\nexport const reluctanceSuffix = (reluctance: Reluctance): string => {\n  switch (reluctance) {\n    case Reluctance.Greedy:\n      return \"\";\n    case Reluctance.Lazy:\n      return \"?\";\n    case Reluctance.Possessive:\n      return \"+\";\n  }\n};\n","/**\n * Provides an `Interval` type representing a range of values with a\n * minimum and optional maximum.\n *\n * This module is used in the context of pattern matching for dCBOR items\n * to represent cardinality specifications like `{n}`, `{n,m}`, or `{n,}`\n * in pattern expressions.\n *\n * @module interval\n */\n\n/**\n * Represents an inclusive interval with a minimum value and an optional\n * maximum value.\n *\n * When the maximum is `undefined`, the interval is considered unbounded above.\n *\n * @example\n * ```typescript\n * // Single value interval\n * const exact = new Interval(3, 3);  // Matches exactly 3\n *\n * // Bounded range\n * const range = new Interval(1, 5);  // Matches 1 to 5 inclusive\n *\n * // Unbounded range\n * const unbounded = new Interval(2); // Matches 2 or more\n * ```\n */\nexport class Interval {\n  readonly #min: number;\n  readonly #max: number | undefined;\n\n  /**\n   * Creates a new Interval.\n   *\n   * @param min - The minimum value (inclusive)\n   * @param max - The maximum value (inclusive), or undefined for unbounded\n   */\n  constructor(min: number, max?: number) {\n    this.#min = min;\n    this.#max = max;\n  }\n\n  /**\n   * Creates an interval from a range specification.\n   *\n   * @param start - The start of the range (inclusive)\n   * @param end - The end of the range (inclusive), or undefined for unbounded\n   * @returns A new Interval\n   */\n  static from(start: number, end?: number): Interval {\n    return new Interval(start, end);\n  }\n\n  /**\n   * Creates an interval for exactly n occurrences.\n   *\n   * @param n - The exact count\n   * @returns A new Interval with min = max = n\n   */\n  static exactly(n: number): Interval {\n    return new Interval(n, n);\n  }\n\n  /**\n   * Creates an interval for at least n occurrences.\n   *\n   * @param n - The minimum count\n   * @returns A new Interval with min = n and no maximum\n   */\n  static atLeast(n: number): Interval {\n    return new Interval(n, undefined);\n  }\n\n  /**\n   * Creates an interval for at most n occurrences.\n   *\n   * @param n - The maximum count\n   * @returns A new Interval with min = 0 and max = n\n   */\n  static atMost(n: number): Interval {\n    return new Interval(0, n);\n  }\n\n  /**\n   * Creates an interval for zero or more occurrences (0..).\n   *\n   * @returns A new Interval representing *\n   */\n  static zeroOrMore(): Interval {\n    return new Interval(0, undefined);\n  }\n\n  /**\n   * Creates an interval for one or more occurrences (1..).\n   *\n   * @returns A new Interval representing +\n   */\n  static oneOrMore(): Interval {\n    return new Interval(1, undefined);\n  }\n\n  /**\n   * Creates an interval for zero or one occurrence (0..=1).\n   *\n   * @returns A new Interval representing ?\n   */\n  static zeroOrOne(): Interval {\n    return new Interval(0, 1);\n  }\n\n  /**\n   * Returns the minimum value of the interval.\n   */\n  min(): number {\n    return this.#min;\n  }\n\n  /**\n   * Returns the maximum value of the interval, or `undefined` if unbounded.\n   */\n  max(): number | undefined {\n    return this.#max;\n  }\n\n  /**\n   * Checks if the given count falls within this interval.\n   *\n   * @param count - The count to check\n   * @returns true if count is within the interval\n   */\n  contains(count: number): boolean {\n    return count >= this.#min && (this.#max === undefined || count <= this.#max);\n  }\n\n  /**\n   * Checks if the interval represents a single value (i.e., min equals max).\n   */\n  isSingle(): boolean {\n    return this.#max !== undefined && this.#min === this.#max;\n  }\n\n  /**\n   * Checks if the interval is unbounded (i.e., has no maximum value).\n   */\n  isUnbounded(): boolean {\n    return this.#max === undefined;\n  }\n\n  /**\n   * Returns a string representation of the interval using standard range notation.\n   *\n   * @returns The range notation string\n   *\n   * @example\n   * ```typescript\n   * new Interval(3, 3).rangeNotation()  // \"{3}\"\n   * new Interval(1, 5).rangeNotation()  // \"{1,5}\"\n   * new Interval(2).rangeNotation()     // \"{2,}\"\n   * ```\n   */\n  rangeNotation(): string {\n    if (this.#max !== undefined && this.#min === this.#max) {\n      return `{${this.#min}}`;\n    }\n    if (this.#max !== undefined) {\n      return `{${this.#min},${this.#max}}`;\n    }\n    return `{${this.#min},}`;\n  }\n\n  /**\n   * Returns a string representation of the interval using shorthand notation\n   * where applicable.\n   *\n   * @returns The shorthand notation string\n   *\n   * @example\n   * ```typescript\n   * new Interval(0, 1).shorthandNotation()  // \"?\"\n   * new Interval(0).shorthandNotation()     // \"*\"\n   * new Interval(1).shorthandNotation()     // \"+\"\n   * new Interval(1, 5).shorthandNotation()  // \"{1,5}\"\n   * ```\n   */\n  shorthandNotation(): string {\n    // Check for optional (?)\n    if (this.#min === 0 && this.#max === 1) {\n      return \"?\";\n    }\n    // Check for single value\n    if (this.#max !== undefined && this.#min === this.#max) {\n      return `{${this.#min}}`;\n    }\n    // Check for bounded range\n    if (this.#max !== undefined) {\n      return `{${this.#min},${this.#max}}`;\n    }\n    // Check for zero or more (*)\n    if (this.#min === 0) {\n      return \"*\";\n    }\n    // Check for one or more (+)\n    if (this.#min === 1) {\n      return \"+\";\n    }\n    // General unbounded case\n    return `{${this.#min},}`;\n  }\n\n  /**\n   * Returns a string representation using range notation.\n   */\n  toString(): string {\n    return this.rangeNotation();\n  }\n\n  /**\n   * Checks equality with another Interval.\n   */\n  equals(other: Interval): boolean {\n    return this.#min === other.#min && this.#max === other.#max;\n  }\n}\n\n/**\n * Default interval is exactly 1 occurrence.\n */\nexport const DEFAULT_INTERVAL = Interval.exactly(1);\n","/**\n * Quantifier for pattern repetition.\n *\n * This module provides the Quantifier class which combines an interval\n * (how many times to match) with a reluctance (matching strategy).\n *\n * @module quantifier\n */\n\nimport { Interval } from \"./interval\";\nimport { type Reluctance, DEFAULT_RELUCTANCE, reluctanceSuffix } from \"./reluctance\";\n\n/**\n * Defines how many times a pattern may or must match, with an interval and a\n * reluctance.\n *\n * @example\n * ```typescript\n * // Zero or more, greedy\n * const star = Quantifier.zeroOrMore();\n *\n * // One or more, lazy\n * const plusLazy = Quantifier.oneOrMore(Reluctance.Lazy);\n *\n * // Exactly 3 times\n * const exact = Quantifier.exactly(3);\n *\n * // Between 2 and 5, possessive\n * const range = Quantifier.between(2, 5, Reluctance.Possessive);\n * ```\n */\nexport class Quantifier {\n  readonly #interval: Interval;\n  readonly #reluctance: Reluctance;\n\n  /**\n   * Creates a new Quantifier.\n   *\n   * @param interval - The interval defining how many times to match\n   * @param reluctance - The matching strategy (default: Greedy)\n   */\n  constructor(interval: Interval, reluctance: Reluctance = DEFAULT_RELUCTANCE) {\n    this.#interval = interval;\n    this.#reluctance = reluctance;\n  }\n\n  /**\n   * Creates a quantifier from min/max values.\n   *\n   * @param min - Minimum occurrences\n   * @param max - Maximum occurrences (undefined for unbounded)\n   * @param reluctance - The matching strategy\n   */\n  static from(min: number, max?: number, reluctance: Reluctance = DEFAULT_RELUCTANCE): Quantifier {\n    return new Quantifier(new Interval(min, max), reluctance);\n  }\n\n  /**\n   * Creates a quantifier for exactly n occurrences.\n   */\n  static exactly(n: number, reluctance: Reluctance = DEFAULT_RELUCTANCE): Quantifier {\n    return new Quantifier(Interval.exactly(n), reluctance);\n  }\n\n  /**\n   * Creates a quantifier for at least n occurrences.\n   */\n  static atLeast(n: number, reluctance: Reluctance = DEFAULT_RELUCTANCE): Quantifier {\n    return new Quantifier(Interval.atLeast(n), reluctance);\n  }\n\n  /**\n   * Creates a quantifier for at most n occurrences.\n   */\n  static atMost(n: number, reluctance: Reluctance = DEFAULT_RELUCTANCE): Quantifier {\n    return new Quantifier(Interval.atMost(n), reluctance);\n  }\n\n  /**\n   * Creates a quantifier for between min and max occurrences.\n   */\n  static between(\n    min: number,\n    max: number,\n    reluctance: Reluctance = DEFAULT_RELUCTANCE,\n  ): Quantifier {\n    return new Quantifier(new Interval(min, max), reluctance);\n  }\n\n  /**\n   * Creates a quantifier for zero or more occurrences (*).\n   */\n  static zeroOrMore(reluctance: Reluctance = DEFAULT_RELUCTANCE): Quantifier {\n    return new Quantifier(Interval.zeroOrMore(), reluctance);\n  }\n\n  /**\n   * Creates a quantifier for one or more occurrences (+).\n   */\n  static oneOrMore(reluctance: Reluctance = DEFAULT_RELUCTANCE): Quantifier {\n    return new Quantifier(Interval.oneOrMore(), reluctance);\n  }\n\n  /**\n   * Creates a quantifier for zero or one occurrence (?).\n   */\n  static zeroOrOne(reluctance: Reluctance = DEFAULT_RELUCTANCE): Quantifier {\n    return new Quantifier(Interval.zeroOrOne(), reluctance);\n  }\n\n  /**\n   * Returns the minimum number of occurrences.\n   */\n  min(): number {\n    return this.#interval.min();\n  }\n\n  /**\n   * Returns the maximum number of occurrences, or undefined if unbounded.\n   */\n  max(): number | undefined {\n    return this.#interval.max();\n  }\n\n  /**\n   * Returns the interval.\n   */\n  interval(): Interval {\n    return this.#interval;\n  }\n\n  /**\n   * Returns the reluctance (matching strategy).\n   */\n  reluctance(): Reluctance {\n    return this.#reluctance;\n  }\n\n  /**\n   * Checks if the given count is within the quantifier's range.\n   */\n  contains(count: number): boolean {\n    return this.#interval.contains(count);\n  }\n\n  /**\n   * Checks if the quantifier is unbounded (no maximum).\n   */\n  isUnbounded(): boolean {\n    return this.#interval.isUnbounded();\n  }\n\n  /**\n   * Returns a string representation of the quantifier.\n   *\n   * @example\n   * ```typescript\n   * Quantifier.zeroOrMore().toString()              // \"*\"\n   * Quantifier.zeroOrMore(Reluctance.Lazy).toString() // \"*?\"\n   * Quantifier.between(1, 5).toString()             // \"{1,5}\"\n   * ```\n   */\n  toString(): string {\n    return `${this.#interval.shorthandNotation()}${reluctanceSuffix(this.#reluctance)}`;\n  }\n\n  /**\n   * Checks equality with another Quantifier.\n   */\n  equals(other: Quantifier): boolean {\n    return this.#interval.equals(other.#interval) && this.#reluctance === other.#reluctance;\n  }\n\n  /**\n   * Converts to an Interval (discarding reluctance).\n   */\n  toInterval(): Interval {\n    return this.#interval;\n  }\n}\n\n/**\n * Default quantifier is exactly 1 occurrence, greedy.\n */\nexport const DEFAULT_QUANTIFIER = Quantifier.exactly(1);\n","/**\n * Format Module for dcbor-pattern\n *\n * This module provides formatting utilities for displaying paths returned by\n * pattern matching. Unlike `bc-envelope-pattern` which supports digest URs and\n * envelope URs, this module focuses on CBOR diagnostic notation formatting.\n *\n * ## Features\n *\n * - **Diagnostic formatting**: Format CBOR elements using either standard or\n *   flat diagnostic notation\n * - **Path indentation**: Automatically indent nested path elements\n * - **Truncation support**: Optionally truncate long representations with\n *   ellipsis\n * - **Flexible options**: Choose whether to show all elements or just the\n *   final destination\n *\n * @module format\n */\n\nimport { type Cbor, summary, diagnosticOpt } from \"@bcts/dcbor\";\n\n/**\n * A Path is a sequence of CBOR values representing the traversal from root\n * to a matched element.\n */\nexport type Path = Cbor[];\n\n/**\n * A builder that provides formatting options for each path element.\n */\nexport enum PathElementFormat {\n  /**\n   * Diagnostic summary format, with optional maximum length for truncation.\n   */\n  DiagnosticSummary = \"diagnostic_summary\",\n\n  /**\n   * Flat diagnostic format (single line), with optional maximum length for\n   * truncation.\n   */\n  DiagnosticFlat = \"diagnostic_flat\",\n}\n\n/**\n * Options for formatting paths.\n */\nexport interface FormatPathsOpts {\n  /**\n   * Whether to indent each path element.\n   * If true, each element will be indented by 4 spaces per level.\n   * @default true\n   */\n  readonly indent: boolean;\n\n  /**\n   * Format for each path element.\n   * @default PathElementFormat.DiagnosticSummary\n   */\n  readonly elementFormat: PathElementFormat;\n\n  /**\n   * Maximum length for element representation before truncation.\n   * If undefined, no truncation is applied.\n   */\n  readonly maxLength: number | undefined;\n\n  /**\n   * If true, only the last element of each path will be formatted.\n   * This is useful for displaying only the final destination of a path.\n   * If false, all elements will be formatted.\n   * @default false\n   */\n  readonly lastElementOnly: boolean;\n}\n\n/**\n * Default formatting options.\n */\nexport const DEFAULT_FORMAT_OPTS: FormatPathsOpts = {\n  indent: true,\n  elementFormat: PathElementFormat.DiagnosticSummary,\n  maxLength: undefined,\n  lastElementOnly: false,\n} as const;\n\n/**\n * Creates formatting options with builder pattern.\n */\nexport class FormatPathsOptsBuilder {\n  #opts: FormatPathsOpts;\n\n  constructor() {\n    this.#opts = { ...DEFAULT_FORMAT_OPTS };\n  }\n\n  /**\n   * Creates a new builder with default options.\n   */\n  static new(): FormatPathsOptsBuilder {\n    return new FormatPathsOptsBuilder();\n  }\n\n  /**\n   * Sets whether to indent each path element.\n   */\n  indent(indent: boolean): FormatPathsOptsBuilder {\n    this.#opts = { ...this.#opts, indent };\n    return this;\n  }\n\n  /**\n   * Sets the format for each path element.\n   */\n  elementFormat(format: PathElementFormat): FormatPathsOptsBuilder {\n    this.#opts = { ...this.#opts, elementFormat: format };\n    return this;\n  }\n\n  /**\n   * Sets the maximum length for element representation.\n   */\n  maxLength(length: number | undefined): FormatPathsOptsBuilder {\n    this.#opts = { ...this.#opts, maxLength: length };\n    return this;\n  }\n\n  /**\n   * Sets whether to format only the last element of each path.\n   */\n  lastElementOnly(lastOnly: boolean): FormatPathsOptsBuilder {\n    this.#opts = { ...this.#opts, lastElementOnly: lastOnly };\n    return this;\n  }\n\n  /**\n   * Builds the options object.\n   */\n  build(): FormatPathsOpts {\n    return this.#opts;\n  }\n}\n\n/**\n * Truncates a string to the specified maximum length, appending an ellipsis if\n * truncated.\n *\n * @internal\n * @param s - The string to truncate\n * @param maxLength - Maximum length, or undefined for no truncation\n * @returns The possibly truncated string\n */\nconst truncateWithEllipsis = (s: string, maxLength?: number): string => {\n  if (maxLength === undefined || s.length <= maxLength) {\n    return s;\n  }\n  if (maxLength > 1) {\n    return `${s.slice(0, maxLength - 1)}…`;\n  }\n  return \"…\";\n};\n\n/**\n * Format a single CBOR element according to the specified format.\n *\n * @internal\n * @param cbor - The CBOR value to format\n * @param format - The format to use\n * @param maxLength - Maximum length before truncation\n * @returns The formatted string\n */\nconst formatCborElement = (cbor: Cbor, format: PathElementFormat, maxLength?: number): string => {\n  let diagnostic: string;\n\n  // Use the diagnostic functions from @bcts/dcbor\n  if (format === PathElementFormat.DiagnosticSummary) {\n    // summary() provides a compact representation with summarizers\n    diagnostic = summary(cbor);\n  } else {\n    // diagnosticOpt with flat: true provides a single-line representation\n    diagnostic = diagnosticOpt(cbor, { flat: true });\n  }\n\n  return truncateWithEllipsis(diagnostic, maxLength);\n};\n\n/**\n * Format each path element on its own line, each line successively indented by\n * 4 spaces. Options can be provided to customize the formatting.\n *\n * @param path - The path to format\n * @param opts - Formatting options\n * @returns The formatted path string\n */\nexport const formatPathOpt = (path: Path, opts: FormatPathsOpts = DEFAULT_FORMAT_OPTS): string => {\n  if (opts.lastElementOnly) {\n    // Only format the last element, no indentation.\n    const lastElement = path[path.length - 1];\n    if (lastElement !== undefined) {\n      return formatCborElement(lastElement, opts.elementFormat, opts.maxLength);\n    }\n    return \"\";\n  }\n\n  // Multi-line output with indentation for diagnostic formats.\n  const lines: string[] = [];\n  for (let index = 0; index < path.length; index++) {\n    const element = path[index];\n    const indent = opts.indent ? \" \".repeat(index * 4) : \"\";\n    const content = formatCborElement(element, opts.elementFormat, opts.maxLength);\n    lines.push(`${indent}${content}`);\n  }\n  return lines.join(\"\\n\");\n};\n\n/**\n * Format each path element on its own line, each line successively indented by\n * 4 spaces.\n *\n * @param path - The path to format\n * @returns The formatted path string\n */\nexport const formatPath = (path: Path): string => {\n  return formatPathOpt(path, DEFAULT_FORMAT_OPTS);\n};\n\n/**\n * Format multiple paths with captures in a structured way.\n * Captures come first, sorted lexicographically by name, with their name\n * prefixed by '@'. Regular paths follow after all captures.\n *\n * @param paths - The paths to format\n * @param captures - Named capture groups and their paths\n * @param opts - Formatting options\n * @returns The formatted string\n */\nexport const formatPathsWithCaptures = (\n  paths: Path[],\n  captures: Map<string, Path[]>,\n  opts: FormatPathsOpts = DEFAULT_FORMAT_OPTS,\n): string => {\n  const result: string[] = [];\n\n  // First, format all captures, sorted lexicographically by name\n  const captureNames = Array.from(captures.keys()).sort();\n\n  for (const captureName of captureNames) {\n    const capturePaths = captures.get(captureName);\n    if (capturePaths !== undefined) {\n      result.push(`@${captureName}`);\n      for (const path of capturePaths) {\n        const formattedPath = formatPathOpt(path, opts);\n        // Add indentation to each line of the formatted path\n        for (const line of formattedPath.split(\"\\n\")) {\n          if (line.length > 0) {\n            result.push(`    ${line}`);\n          }\n        }\n      }\n    }\n  }\n\n  // Then, format all regular paths\n  for (const path of paths) {\n    const formattedPath = formatPathOpt(path, opts);\n    for (const line of formattedPath.split(\"\\n\")) {\n      if (line.length > 0) {\n        result.push(line);\n      }\n    }\n  }\n\n  return result.join(\"\\n\");\n};\n\n/**\n * Format multiple paths with custom formatting options.\n *\n * @param paths - The paths to format\n * @param opts - Formatting options\n * @returns The formatted string\n */\nexport const formatPathsOpt = (\n  paths: Path[],\n  opts: FormatPathsOpts = DEFAULT_FORMAT_OPTS,\n): string => {\n  // Call formatPathsWithCaptures with empty captures\n  return formatPathsWithCaptures(paths, new Map(), opts);\n};\n\n/**\n * Format multiple paths with default options.\n *\n * @param paths - The paths to format\n * @returns The formatted string\n */\nexport const formatPaths = (paths: Path[]): string => {\n  return formatPathsOpt(paths, DEFAULT_FORMAT_OPTS);\n};\n","/**\n * Late-binding registry for pattern matching functions.\n * This avoids circular dependencies between pattern modules.\n *\n * @module pattern/match-registry\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../format\";\n\n// Forward declare Pattern type to avoid circular import\n// The actual Pattern type is defined in ./index.ts\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Pattern = any;\n\n/**\n * Match result with paths and captures.\n */\nexport interface MatchResultInternal {\n  readonly paths: Path[];\n  readonly captures: Map<string, Path[]>;\n}\n\n/**\n * Registry for the pattern matching function.\n * This gets set by pattern/index.ts after all modules are loaded.\n */\nexport let matchFn: ((pattern: Pattern, haystack: Cbor) => boolean) | undefined;\n\n/**\n * Registry for the pattern paths function.\n * This gets set by pattern/index.ts after all modules are loaded.\n */\nexport let pathsFn: ((pattern: Pattern, haystack: Cbor) => Path[]) | undefined;\n\n/**\n * Registry for the pattern paths with captures function (VM-based).\n * This gets set by pattern/index.ts after all modules are loaded.\n */\nexport let pathsWithCapturesFn:\n  | ((pattern: Pattern, haystack: Cbor) => MatchResultInternal)\n  | undefined;\n\n/**\n * Registry for the direct pattern paths with captures function (non-VM).\n * This is used by the VM to avoid infinite recursion.\n */\nexport let pathsWithCapturesDirectFn:\n  | ((pattern: Pattern, haystack: Cbor) => MatchResultInternal)\n  | undefined;\n\n/**\n * Sets the pattern matching function.\n * Called by pattern/index.ts during module initialization.\n */\nexport const setMatchFn = (fn: (pattern: Pattern, haystack: Cbor) => boolean): void => {\n  matchFn = fn;\n};\n\n/**\n * Sets the pattern paths function.\n * Called by pattern/index.ts during module initialization.\n */\nexport const setPathsFn = (fn: (pattern: Pattern, haystack: Cbor) => Path[]): void => {\n  pathsFn = fn;\n};\n\n/**\n * Sets the pattern paths with captures function.\n * Called by pattern/index.ts during module initialization.\n */\nexport const setPathsWithCapturesFn = (\n  fn: (pattern: Pattern, haystack: Cbor) => MatchResultInternal,\n): void => {\n  pathsWithCapturesFn = fn;\n};\n\n/**\n * Sets the direct pattern paths with captures function (non-VM).\n * Called by pattern/index.ts during module initialization.\n */\nexport const setPathsWithCapturesDirectFn = (\n  fn: (pattern: Pattern, haystack: Cbor) => MatchResultInternal,\n): void => {\n  pathsWithCapturesDirectFn = fn;\n};\n\n/**\n * Matches a pattern against a CBOR value using the registered function.\n * @throws Error if the match function hasn't been registered yet.\n */\nexport const matchPattern = (pattern: Pattern, haystack: Cbor): boolean => {\n  if (matchFn === undefined) {\n    throw new Error(\"Pattern match function not initialized\");\n  }\n  return matchFn(pattern, haystack);\n};\n\n/**\n * Gets paths for a pattern against a CBOR value using the registered function.\n * @throws Error if the paths function hasn't been registered yet.\n */\nexport const getPatternPaths = (pattern: Pattern, haystack: Cbor): Path[] => {\n  if (pathsFn === undefined) {\n    throw new Error(\"Pattern paths function not initialized\");\n  }\n  return pathsFn(pattern, haystack);\n};\n\n/**\n * Gets paths with captures for a pattern against a CBOR value (VM-based).\n * @throws Error if the function hasn't been registered yet.\n */\nexport const getPatternPathsWithCaptures = (\n  pattern: Pattern,\n  haystack: Cbor,\n): MatchResultInternal => {\n  if (pathsWithCapturesFn === undefined) {\n    throw new Error(\"Pattern paths with captures function not initialized\");\n  }\n  return pathsWithCapturesFn(pattern, haystack);\n};\n\n/**\n * Gets paths with captures directly without the VM (non-recursive).\n * This is used by the VM to avoid infinite recursion.\n * @throws Error if the function hasn't been registered yet.\n */\nexport const getPatternPathsWithCapturesDirect = (\n  pattern: Pattern,\n  haystack: Cbor,\n): MatchResultInternal => {\n  if (pathsWithCapturesDirectFn === undefined) {\n    throw new Error(\"Direct pattern paths with captures function not initialized\");\n  }\n  return pathsWithCapturesDirectFn(pattern, haystack);\n};\n","/**\n * Boolean pattern for dCBOR pattern matching.\n *\n * @module pattern/value/bool-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport { asBoolean } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\n\n/**\n * Pattern for matching boolean values in dCBOR.\n */\nexport type BoolPattern =\n  | { readonly variant: \"Any\" }\n  | { readonly variant: \"Value\"; readonly value: boolean };\n\n/**\n * Creates a BoolPattern that matches any boolean value.\n */\nexport const boolPatternAny = (): BoolPattern => ({ variant: \"Any\" });\n\n/**\n * Creates a BoolPattern that matches a specific boolean value.\n */\nexport const boolPatternValue = (value: boolean): BoolPattern => ({\n  variant: \"Value\",\n  value,\n});\n\n/**\n * Tests if a CBOR value matches this boolean pattern.\n */\nexport const boolPatternMatches = (pattern: BoolPattern, haystack: Cbor): boolean => {\n  const value = asBoolean(haystack);\n  if (value === undefined) {\n    return false;\n  }\n  switch (pattern.variant) {\n    case \"Any\":\n      return true;\n    case \"Value\":\n      return value === pattern.value;\n  }\n};\n\n/**\n * Returns paths to matching boolean values.\n */\nexport const boolPatternPaths = (pattern: BoolPattern, haystack: Cbor): Path[] => {\n  if (boolPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats a BoolPattern as a string.\n */\nexport const boolPatternDisplay = (pattern: BoolPattern): string => {\n  switch (pattern.variant) {\n    case \"Any\":\n      return \"bool\";\n    case \"Value\":\n      return pattern.value ? \"true\" : \"false\";\n  }\n};\n","/**\n * Null pattern for dCBOR pattern matching.\n *\n * @module pattern/value/null-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport { isNull } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\n\n/**\n * Pattern for matching null values in dCBOR.\n * This is a unit type - there's only one way to match null.\n */\nexport interface NullPattern {\n  readonly variant: \"Null\";\n}\n\n/**\n * Creates a NullPattern.\n */\nexport const nullPattern = (): NullPattern => ({ variant: \"Null\" });\n\n/**\n * Tests if a CBOR value matches the null pattern.\n */\nexport const nullPatternMatches = (_pattern: NullPattern, haystack: Cbor): boolean => {\n  return isNull(haystack);\n};\n\n/**\n * Returns paths to matching null values.\n */\nexport const nullPatternPaths = (pattern: NullPattern, haystack: Cbor): Path[] => {\n  if (nullPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats a NullPattern as a string.\n */\nexport const nullPatternDisplay = (_pattern: NullPattern): string => {\n  return \"null\";\n};\n","/**\n * Number pattern for dCBOR pattern matching.\n *\n * @module pattern/value/number-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport { asNumber, isNumber } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\n\n/**\n * Pattern for matching number values in dCBOR.\n */\nexport type NumberPattern =\n  | { readonly variant: \"Any\" }\n  | { readonly variant: \"Value\"; readonly value: number }\n  | { readonly variant: \"Range\"; readonly min: number; readonly max: number }\n  | { readonly variant: \"GreaterThan\"; readonly value: number }\n  | { readonly variant: \"GreaterThanOrEqual\"; readonly value: number }\n  | { readonly variant: \"LessThan\"; readonly value: number }\n  | { readonly variant: \"LessThanOrEqual\"; readonly value: number }\n  | { readonly variant: \"NaN\" }\n  | { readonly variant: \"Infinity\" }\n  | { readonly variant: \"NegInfinity\" };\n\n/**\n * Creates a NumberPattern that matches any number.\n */\nexport const numberPatternAny = (): NumberPattern => ({ variant: \"Any\" });\n\n/**\n * Creates a NumberPattern that matches a specific number.\n */\nexport const numberPatternValue = (value: number): NumberPattern => ({\n  variant: \"Value\",\n  value,\n});\n\n/**\n * Creates a NumberPattern that matches numbers within a range (inclusive).\n */\nexport const numberPatternRange = (min: number, max: number): NumberPattern => ({\n  variant: \"Range\",\n  min,\n  max,\n});\n\n/**\n * Creates a NumberPattern that matches numbers greater than a value.\n */\nexport const numberPatternGreaterThan = (value: number): NumberPattern => ({\n  variant: \"GreaterThan\",\n  value,\n});\n\n/**\n * Creates a NumberPattern that matches numbers greater than or equal to a value.\n */\nexport const numberPatternGreaterThanOrEqual = (value: number): NumberPattern => ({\n  variant: \"GreaterThanOrEqual\",\n  value,\n});\n\n/**\n * Creates a NumberPattern that matches numbers less than a value.\n */\nexport const numberPatternLessThan = (value: number): NumberPattern => ({\n  variant: \"LessThan\",\n  value,\n});\n\n/**\n * Creates a NumberPattern that matches numbers less than or equal to a value.\n */\nexport const numberPatternLessThanOrEqual = (value: number): NumberPattern => ({\n  variant: \"LessThanOrEqual\",\n  value,\n});\n\n/**\n * Creates a NumberPattern that matches NaN.\n */\nexport const numberPatternNaN = (): NumberPattern => ({ variant: \"NaN\" });\n\n/**\n * Creates a NumberPattern that matches positive infinity.\n */\nexport const numberPatternInfinity = (): NumberPattern => ({\n  variant: \"Infinity\",\n});\n\n/**\n * Creates a NumberPattern that matches negative infinity.\n */\nexport const numberPatternNegInfinity = (): NumberPattern => ({\n  variant: \"NegInfinity\",\n});\n\n/**\n * Tests if a CBOR value matches this number pattern.\n */\nexport const numberPatternMatches = (pattern: NumberPattern, haystack: Cbor): boolean => {\n  switch (pattern.variant) {\n    case \"Any\":\n      return isNumber(haystack);\n    case \"Value\": {\n      const value = asNumber(haystack);\n      return value !== undefined && value === pattern.value;\n    }\n    case \"Range\": {\n      const value = asNumber(haystack);\n      return value !== undefined && value >= pattern.min && value <= pattern.max;\n    }\n    case \"GreaterThan\": {\n      const value = asNumber(haystack);\n      return value !== undefined && value > pattern.value;\n    }\n    case \"GreaterThanOrEqual\": {\n      const value = asNumber(haystack);\n      return value !== undefined && value >= pattern.value;\n    }\n    case \"LessThan\": {\n      const value = asNumber(haystack);\n      return value !== undefined && value < pattern.value;\n    }\n    case \"LessThanOrEqual\": {\n      const value = asNumber(haystack);\n      return value !== undefined && value <= pattern.value;\n    }\n    case \"NaN\": {\n      const value = asNumber(haystack);\n      return value !== undefined && Number.isNaN(value);\n    }\n    case \"Infinity\": {\n      const value = asNumber(haystack);\n      return value !== undefined && value === Number.POSITIVE_INFINITY;\n    }\n    case \"NegInfinity\": {\n      const value = asNumber(haystack);\n      return value !== undefined && value === Number.NEGATIVE_INFINITY;\n    }\n  }\n};\n\n/**\n * Returns paths to matching number values.\n */\nexport const numberPatternPaths = (pattern: NumberPattern, haystack: Cbor): Path[] => {\n  if (numberPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats a NumberPattern as a string.\n */\nexport const numberPatternDisplay = (pattern: NumberPattern): string => {\n  switch (pattern.variant) {\n    case \"Any\":\n      return \"number\";\n    case \"Value\":\n      return String(pattern.value);\n    case \"Range\":\n      return `${pattern.min}..${pattern.max}`;\n    case \"GreaterThan\":\n      return `>${pattern.value}`;\n    case \"GreaterThanOrEqual\":\n      return `>=${pattern.value}`;\n    case \"LessThan\":\n      return `<${pattern.value}`;\n    case \"LessThanOrEqual\":\n      return `<=${pattern.value}`;\n    case \"NaN\":\n      return \"NaN\";\n    case \"Infinity\":\n      return \"Infinity\";\n    case \"NegInfinity\":\n      return \"-Infinity\";\n  }\n};\n","/**\n * Text pattern for dCBOR pattern matching.\n *\n * @module pattern/value/text-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport { asText } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\n\n/**\n * Pattern for matching text values in dCBOR.\n */\nexport type TextPattern =\n  | { readonly variant: \"Any\" }\n  | { readonly variant: \"Value\"; readonly value: string }\n  | { readonly variant: \"Regex\"; readonly pattern: RegExp };\n\n/**\n * Creates a TextPattern that matches any text.\n */\nexport const textPatternAny = (): TextPattern => ({ variant: \"Any\" });\n\n/**\n * Creates a TextPattern that matches a specific text value.\n */\nexport const textPatternValue = (value: string): TextPattern => ({\n  variant: \"Value\",\n  value,\n});\n\n/**\n * Creates a TextPattern that matches text by regex.\n */\nexport const textPatternRegex = (pattern: RegExp): TextPattern => ({\n  variant: \"Regex\",\n  pattern,\n});\n\n/**\n * Tests if a CBOR value matches this text pattern.\n */\nexport const textPatternMatches = (pattern: TextPattern, haystack: Cbor): boolean => {\n  const value = asText(haystack);\n  if (value === undefined) {\n    return false;\n  }\n  switch (pattern.variant) {\n    case \"Any\":\n      return true;\n    case \"Value\":\n      return value === pattern.value;\n    case \"Regex\":\n      return pattern.pattern.test(value);\n  }\n};\n\n/**\n * Returns paths to matching text values.\n */\nexport const textPatternPaths = (pattern: TextPattern, haystack: Cbor): Path[] => {\n  if (textPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats a TextPattern as a string.\n */\nexport const textPatternDisplay = (pattern: TextPattern): string => {\n  switch (pattern.variant) {\n    case \"Any\":\n      return \"text\";\n    case \"Value\": {\n      const escaped = pattern.value.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"');\n      return `\"${escaped}\"`;\n    }\n    case \"Regex\":\n      return `/${pattern.pattern.source}/`;\n  }\n};\n","/**\n * Byte array utility functions.\n *\n * @module pattern/value/bytes-utils\n */\n\n/**\n * Compares two Uint8Arrays for equality.\n */\nexport const bytesEqual = (a: Uint8Array, b: Uint8Array): boolean => {\n  if (a.length !== b.length) {\n    return false;\n  }\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * Tests if bytes start with a prefix.\n */\nexport const bytesStartsWith = (bytes: Uint8Array, prefix: Uint8Array): boolean => {\n  if (bytes.length < prefix.length) {\n    return false;\n  }\n  for (let i = 0; i < prefix.length; i++) {\n    if (bytes[i] !== prefix[i]) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * Converts a Uint8Array to a Latin-1 string for regex matching.\n * Each byte value (0-255) maps directly to a character code.\n * This mimics Rust's regex::bytes::Regex behavior.\n */\nexport const bytesToLatin1 = (bytes: Uint8Array): string => {\n  let result = \"\";\n  for (const byte of bytes) {\n    result += String.fromCharCode(byte);\n  }\n  return result;\n};\n","/**\n * ByteString pattern for dCBOR pattern matching.\n *\n * @module pattern/value/bytestring-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport { asBytes, bytesToHex } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport { bytesEqual, bytesToLatin1 } from \"./bytes-utils\";\n\n/**\n * Pattern for matching byte string values in dCBOR.\n *\n * The BinaryRegex variant matches against raw bytes by converting them to\n * a Latin-1 string (where each byte 0-255 maps to exactly one character).\n * This mimics Rust's regex::bytes::Regex behavior.\n *\n * For example:\n * - To match bytes starting with 0x00: `/^\\x00/`\n * - To match ASCII digits: `/^\\d+$/`\n * - To match specific hex pattern: `/\\x48\\x65\\x6c\\x6c\\x6f/` (matches \"Hello\")\n */\nexport type ByteStringPattern =\n  | { readonly variant: \"Any\" }\n  | { readonly variant: \"Value\"; readonly value: Uint8Array }\n  | { readonly variant: \"BinaryRegex\"; readonly pattern: RegExp };\n\n/**\n * Creates a ByteStringPattern that matches any byte string.\n */\nexport const byteStringPatternAny = (): ByteStringPattern => ({\n  variant: \"Any\",\n});\n\n/**\n * Creates a ByteStringPattern that matches a specific byte string value.\n */\nexport const byteStringPatternValue = (value: Uint8Array): ByteStringPattern => ({\n  variant: \"Value\",\n  value,\n});\n\n/**\n * Creates a ByteStringPattern that matches byte strings by binary regex.\n *\n * The regex matches against raw bytes converted to a Latin-1 string.\n * Use escape sequences like `\\x00` to match specific byte values.\n *\n * @example\n * ```typescript\n * // Match bytes starting with 0x00\n * byteStringPatternBinaryRegex(/^\\x00/)\n *\n * // Match ASCII \"Hello\"\n * byteStringPatternBinaryRegex(/Hello/)\n *\n * // Match any digits\n * byteStringPatternBinaryRegex(/^\\d+$/)\n * ```\n */\nexport const byteStringPatternBinaryRegex = (pattern: RegExp): ByteStringPattern => ({\n  variant: \"BinaryRegex\",\n  pattern,\n});\n\n/**\n * Tests if a CBOR value matches this byte string pattern.\n */\nexport const byteStringPatternMatches = (pattern: ByteStringPattern, haystack: Cbor): boolean => {\n  const value = asBytes(haystack);\n  if (value === undefined) {\n    return false;\n  }\n  switch (pattern.variant) {\n    case \"Any\":\n      return true;\n    case \"Value\":\n      return bytesEqual(value, pattern.value);\n    case \"BinaryRegex\": {\n      // Convert bytes to Latin-1 string for regex matching\n      // This mimics Rust's regex::bytes::Regex behavior\n      const latin1String = bytesToLatin1(value);\n      return pattern.pattern.test(latin1String);\n    }\n  }\n};\n\n/**\n * Returns paths to matching byte string values.\n */\nexport const byteStringPatternPaths = (pattern: ByteStringPattern, haystack: Cbor): Path[] => {\n  if (byteStringPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats a ByteStringPattern as a string.\n */\nexport const byteStringPatternDisplay = (pattern: ByteStringPattern): string => {\n  switch (pattern.variant) {\n    case \"Any\":\n      return \"bstr\";\n    case \"Value\":\n      return `h'${bytesToHex(pattern.value)}'`;\n    case \"BinaryRegex\":\n      return `h'/${pattern.pattern.source}/'`;\n  }\n};\n","/**\n * Date pattern for dCBOR pattern matching.\n *\n * @module pattern/value/date-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport { CborDate, tagValue, isTagged } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\n\n/**\n * Pattern for matching date values in dCBOR.\n * Dates in CBOR are represented as tagged values with tag 1.\n */\nexport type DatePattern =\n  | { readonly variant: \"Any\" }\n  | { readonly variant: \"Value\"; readonly value: CborDate }\n  | {\n      readonly variant: \"Range\";\n      readonly min: CborDate;\n      readonly max: CborDate;\n    }\n  | { readonly variant: \"Earliest\"; readonly value: CborDate }\n  | { readonly variant: \"Latest\"; readonly value: CborDate }\n  | { readonly variant: \"StringValue\"; readonly value: string }\n  | { readonly variant: \"Regex\"; readonly pattern: RegExp };\n\n/** CBOR tag for date (RFC 8943) */\nconst DATE_TAG = 1n;\n\n/**\n * Creates a DatePattern that matches any date.\n */\nexport const datePatternAny = (): DatePattern => ({ variant: \"Any\" });\n\n/**\n * Creates a DatePattern that matches a specific date.\n */\nexport const datePatternValue = (value: CborDate): DatePattern => ({\n  variant: \"Value\",\n  value,\n});\n\n/**\n * Creates a DatePattern that matches dates within a range (inclusive).\n */\nexport const datePatternRange = (min: CborDate, max: CborDate): DatePattern => ({\n  variant: \"Range\",\n  min,\n  max,\n});\n\n/**\n * Creates a DatePattern that matches dates on or after the specified date.\n */\nexport const datePatternEarliest = (value: CborDate): DatePattern => ({\n  variant: \"Earliest\",\n  value,\n});\n\n/**\n * Creates a DatePattern that matches dates on or before the specified date.\n */\nexport const datePatternLatest = (value: CborDate): DatePattern => ({\n  variant: \"Latest\",\n  value,\n});\n\n/**\n * Creates a DatePattern that matches dates by their ISO-8601 string representation.\n */\nexport const datePatternStringValue = (value: string): DatePattern => ({\n  variant: \"StringValue\",\n  value,\n});\n\n/**\n * Creates a DatePattern that matches dates by regex on their ISO-8601 string.\n */\nexport const datePatternRegex = (pattern: RegExp): DatePattern => ({\n  variant: \"Regex\",\n  pattern,\n});\n\n/**\n * Extracts a CborDate from a tagged CBOR value if it's a date (tag 1).\n */\nconst extractDate = (haystack: Cbor): CborDate | undefined => {\n  if (!isTagged(haystack)) {\n    return undefined;\n  }\n  const tag = tagValue(haystack);\n  if (tag !== DATE_TAG) {\n    return undefined;\n  }\n  try {\n    return CborDate.fromTaggedCbor(haystack);\n  } catch {\n    return undefined;\n  }\n};\n\n/**\n * Tests if a CBOR value matches this date pattern.\n */\nexport const datePatternMatches = (pattern: DatePattern, haystack: Cbor): boolean => {\n  const date = extractDate(haystack);\n  if (date === undefined) {\n    return false;\n  }\n\n  switch (pattern.variant) {\n    case \"Any\":\n      return true;\n    case \"Value\":\n      return date.timestamp() === pattern.value.timestamp();\n    case \"Range\":\n      return (\n        date.timestamp() >= pattern.min.timestamp() && date.timestamp() <= pattern.max.timestamp()\n      );\n    case \"Earliest\":\n      return date.timestamp() >= pattern.value.timestamp();\n    case \"Latest\":\n      return date.timestamp() <= pattern.value.timestamp();\n    case \"StringValue\":\n      return date.toString() === pattern.value;\n    case \"Regex\":\n      return pattern.pattern.test(date.toString());\n  }\n};\n\n/**\n * Returns paths to matching date values.\n */\nexport const datePatternPaths = (pattern: DatePattern, haystack: Cbor): Path[] => {\n  if (datePatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats a DatePattern as a string.\n */\nexport const datePatternDisplay = (pattern: DatePattern): string => {\n  switch (pattern.variant) {\n    case \"Any\":\n      return \"date\";\n    case \"Value\":\n      return `date'${pattern.value.toString()}'`;\n    case \"Range\":\n      return `date'${pattern.min.toString()}...${pattern.max.toString()}'`;\n    case \"Earliest\":\n      return `date'${pattern.value.toString()}...'`;\n    case \"Latest\":\n      return `date'...${pattern.value.toString()}'`;\n    case \"StringValue\":\n      return `date'${pattern.value}'`;\n    case \"Regex\":\n      return `date'/${pattern.pattern.source}/'`;\n  }\n};\n","/**\n * Digest pattern for dCBOR pattern matching.\n *\n * @module pattern/value/digest-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport { tagValue, isTagged, tagContent, asBytes, bytesToHex } from \"@bcts/dcbor\";\nimport type { Digest } from \"@bcts/components\";\nimport type { Path } from \"../../format\";\nimport { bytesEqual, bytesStartsWith } from \"./bytes-utils\";\n\n/**\n * Pattern for matching digest values in dCBOR.\n * Digests are represented as tagged values with tag 40001.\n *\n * Note: The BinaryRegex variant uses a RegExp that matches against the\n * hex-encoded string representation of the digest bytes. This is a known\n * difference from the Rust implementation which uses regex::bytes::Regex.\n */\nexport type DigestPattern =\n  | { readonly variant: \"Any\" }\n  | { readonly variant: \"Value\"; readonly value: Digest }\n  | { readonly variant: \"Prefix\"; readonly prefix: Uint8Array }\n  | { readonly variant: \"BinaryRegex\"; readonly pattern: RegExp };\n\n/** CBOR tag for digest (BCR-2021-002) */\nconst DIGEST_TAG = 40001n;\n\n/** Expected size of a SHA-256 digest */\nconst DIGEST_SIZE = 32;\n\n/**\n * Creates a DigestPattern that matches any digest.\n */\nexport const digestPatternAny = (): DigestPattern => ({ variant: \"Any\" });\n\n/**\n * Creates a DigestPattern that matches a specific digest.\n */\nexport const digestPatternValue = (value: Digest): DigestPattern => ({\n  variant: \"Value\",\n  value,\n});\n\n/**\n * Creates a DigestPattern that matches digests with a prefix.\n */\nexport const digestPatternPrefix = (prefix: Uint8Array): DigestPattern => ({\n  variant: \"Prefix\",\n  prefix,\n});\n\n/**\n * Creates a DigestPattern that matches digests by binary regex.\n *\n * Note: In TypeScript, this matches against the hex-encoded representation\n * of the digest bytes.\n */\nexport const digestPatternBinaryRegex = (pattern: RegExp): DigestPattern => ({\n  variant: \"BinaryRegex\",\n  pattern,\n});\n\n/**\n * Extracts digest bytes from a tagged CBOR value if it's a digest (tag 40001).\n */\nconst extractDigestBytes = (haystack: Cbor): Uint8Array | undefined => {\n  if (!isTagged(haystack)) {\n    return undefined;\n  }\n  const tag = tagValue(haystack);\n  if (tag !== DIGEST_TAG) {\n    return undefined;\n  }\n  const content = tagContent(haystack);\n  if (content === undefined) {\n    return undefined;\n  }\n  const bytes = asBytes(content);\n  if (bytes?.length !== DIGEST_SIZE) {\n    return undefined;\n  }\n  return bytes;\n};\n\n/**\n * Tests if a CBOR value matches this digest pattern.\n */\nexport const digestPatternMatches = (pattern: DigestPattern, haystack: Cbor): boolean => {\n  const digestBytes = extractDigestBytes(haystack);\n  if (digestBytes === undefined) {\n    return false;\n  }\n\n  switch (pattern.variant) {\n    case \"Any\":\n      return true;\n    case \"Value\":\n      return bytesEqual(digestBytes, pattern.value.data());\n    case \"Prefix\":\n      return bytesStartsWith(digestBytes, pattern.prefix);\n    case \"BinaryRegex\": {\n      // Convert bytes to hex string for regex matching\n      const hexString = bytesToHex(digestBytes);\n      return pattern.pattern.test(hexString);\n    }\n  }\n};\n\n/**\n * Returns paths to matching digest values.\n */\nexport const digestPatternPaths = (pattern: DigestPattern, haystack: Cbor): Path[] => {\n  if (digestPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats a DigestPattern as a string.\n */\nexport const digestPatternDisplay = (pattern: DigestPattern): string => {\n  switch (pattern.variant) {\n    case \"Any\":\n      return \"digest\";\n    case \"Value\":\n      // Use UR string if available, otherwise hex\n      return `digest'${bytesToHex(pattern.value.data())}'`;\n    case \"Prefix\":\n      return `digest'${bytesToHex(pattern.prefix)}'`;\n    case \"BinaryRegex\":\n      return `digest'/${pattern.pattern.source}/'`;\n  }\n};\n","/**\n * KnownValue pattern for dCBOR pattern matching.\n *\n * @module pattern/value/known-value-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport { tagValue, isTagged, tagContent, asUnsigned } from \"@bcts/dcbor\";\nimport { KnownValue, KNOWN_VALUE_TAG } from \"@bcts/known-values\";\nimport type { Path } from \"../../format\";\n\n/**\n * Pattern for matching known values in dCBOR.\n * Known values are represented as tagged values with tag 40000.\n */\nexport type KnownValuePattern =\n  | { readonly variant: \"Any\" }\n  | { readonly variant: \"Value\"; readonly value: KnownValue }\n  | { readonly variant: \"Named\"; readonly name: string }\n  | { readonly variant: \"Regex\"; readonly pattern: RegExp };\n\n/**\n * Creates a KnownValuePattern that matches any known value.\n */\nexport const knownValuePatternAny = (): KnownValuePattern => ({\n  variant: \"Any\",\n});\n\n/**\n * Creates a KnownValuePattern that matches a specific known value.\n */\nexport const knownValuePatternValue = (value: KnownValue): KnownValuePattern => ({\n  variant: \"Value\",\n  value,\n});\n\n/**\n * Creates a KnownValuePattern that matches a known value by name.\n */\nexport const knownValuePatternNamed = (name: string): KnownValuePattern => ({\n  variant: \"Named\",\n  name,\n});\n\n/**\n * Creates a KnownValuePattern that matches known values by regex on name.\n */\nexport const knownValuePatternRegex = (pattern: RegExp): KnownValuePattern => ({\n  variant: \"Regex\",\n  pattern,\n});\n\n/**\n * Extracts a KnownValue from a tagged CBOR value if it's a known value (tag 40000).\n */\nconst extractKnownValue = (haystack: Cbor): KnownValue | undefined => {\n  if (!isTagged(haystack)) {\n    return undefined;\n  }\n  const tag = tagValue(haystack);\n  if (tag !== KNOWN_VALUE_TAG.value) {\n    return undefined;\n  }\n  const content = tagContent(haystack);\n  if (content === undefined) {\n    return undefined;\n  }\n  const value = asUnsigned(content);\n  if (value === undefined) {\n    return undefined;\n  }\n  return new KnownValue(value);\n};\n\n/**\n * Tests if a CBOR value matches this known value pattern.\n */\nexport const knownValuePatternMatches = (pattern: KnownValuePattern, haystack: Cbor): boolean => {\n  const knownValue = extractKnownValue(haystack);\n  if (knownValue === undefined) {\n    return false;\n  }\n\n  switch (pattern.variant) {\n    case \"Any\":\n      return true;\n    case \"Value\":\n      return knownValue.valueBigInt() === pattern.value.valueBigInt();\n    case \"Named\": {\n      // Look up the known value by name and compare\n      // KnownValue has a name method that we can compare\n      return knownValue.name() === pattern.name;\n    }\n    case \"Regex\":\n      return pattern.pattern.test(knownValue.name());\n  }\n};\n\n/**\n * Returns paths to matching known values.\n */\nexport const knownValuePatternPaths = (pattern: KnownValuePattern, haystack: Cbor): Path[] => {\n  if (knownValuePatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats a KnownValuePattern as a string.\n */\nexport const knownValuePatternDisplay = (pattern: KnownValuePattern): string => {\n  switch (pattern.variant) {\n    case \"Any\":\n      return \"known\";\n    case \"Value\":\n      return `'${pattern.value.name()}'`;\n    case \"Named\":\n      return `'${pattern.name}'`;\n    case \"Regex\":\n      return `'/${pattern.pattern.source}/'`;\n  }\n};\n","/**\n * Value patterns for dCBOR pattern matching.\n *\n * @module pattern/value\n */\n\nexport * from \"./bool-pattern\";\nexport * from \"./null-pattern\";\nexport * from \"./number-pattern\";\nexport * from \"./text-pattern\";\nexport * from \"./bytestring-pattern\";\nexport * from \"./date-pattern\";\nexport * from \"./digest-pattern\";\nexport * from \"./known-value-pattern\";\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\n\nimport { type BoolPattern, boolPatternPaths, boolPatternDisplay } from \"./bool-pattern\";\nimport { type NullPattern, nullPatternPaths, nullPatternDisplay } from \"./null-pattern\";\nimport { type NumberPattern, numberPatternPaths, numberPatternDisplay } from \"./number-pattern\";\nimport { type TextPattern, textPatternPaths, textPatternDisplay } from \"./text-pattern\";\nimport {\n  type ByteStringPattern,\n  byteStringPatternPaths,\n  byteStringPatternDisplay,\n} from \"./bytestring-pattern\";\nimport { type DatePattern, datePatternPaths, datePatternDisplay } from \"./date-pattern\";\nimport { type DigestPattern, digestPatternPaths, digestPatternDisplay } from \"./digest-pattern\";\nimport {\n  type KnownValuePattern,\n  knownValuePatternPaths,\n  knownValuePatternDisplay,\n} from \"./known-value-pattern\";\n\n/**\n * Union of all value pattern types.\n */\nexport type ValuePattern =\n  | { readonly type: \"Bool\"; readonly pattern: BoolPattern }\n  | { readonly type: \"Null\"; readonly pattern: NullPattern }\n  | { readonly type: \"Number\"; readonly pattern: NumberPattern }\n  | { readonly type: \"Text\"; readonly pattern: TextPattern }\n  | { readonly type: \"ByteString\"; readonly pattern: ByteStringPattern }\n  | { readonly type: \"Date\"; readonly pattern: DatePattern }\n  | { readonly type: \"Digest\"; readonly pattern: DigestPattern }\n  | { readonly type: \"KnownValue\"; readonly pattern: KnownValuePattern };\n\n/**\n * Returns paths to matching values for a ValuePattern.\n */\nexport const valuePatternPaths = (pattern: ValuePattern, haystack: Cbor): Path[] => {\n  switch (pattern.type) {\n    case \"Bool\":\n      return boolPatternPaths(pattern.pattern, haystack);\n    case \"Null\":\n      return nullPatternPaths(pattern.pattern, haystack);\n    case \"Number\":\n      return numberPatternPaths(pattern.pattern, haystack);\n    case \"Text\":\n      return textPatternPaths(pattern.pattern, haystack);\n    case \"ByteString\":\n      return byteStringPatternPaths(pattern.pattern, haystack);\n    case \"Date\":\n      return datePatternPaths(pattern.pattern, haystack);\n    case \"Digest\":\n      return digestPatternPaths(pattern.pattern, haystack);\n    case \"KnownValue\":\n      return knownValuePatternPaths(pattern.pattern, haystack);\n  }\n};\n\n/**\n * Tests if a CBOR value matches a ValuePattern.\n */\nexport const valuePatternMatches = (pattern: ValuePattern, haystack: Cbor): boolean => {\n  return valuePatternPaths(pattern, haystack).length > 0;\n};\n\n/**\n * Formats a ValuePattern as a string.\n */\nexport const valuePatternDisplay = (pattern: ValuePattern): string => {\n  switch (pattern.type) {\n    case \"Bool\":\n      return boolPatternDisplay(pattern.pattern);\n    case \"Null\":\n      return nullPatternDisplay(pattern.pattern);\n    case \"Number\":\n      return numberPatternDisplay(pattern.pattern);\n    case \"Text\":\n      return textPatternDisplay(pattern.pattern);\n    case \"ByteString\":\n      return byteStringPatternDisplay(pattern.pattern);\n    case \"Date\":\n      return datePatternDisplay(pattern.pattern);\n    case \"Digest\":\n      return digestPatternDisplay(pattern.pattern);\n    case \"KnownValue\":\n      return knownValuePatternDisplay(pattern.pattern);\n  }\n};\n\n// Convenience constructors for ValuePattern\n\n/**\n * Creates a Bool ValuePattern.\n */\nexport const valueBool = (pattern: BoolPattern): ValuePattern => ({\n  type: \"Bool\",\n  pattern,\n});\n\n/**\n * Creates a Null ValuePattern.\n */\nexport const valueNull = (pattern: NullPattern): ValuePattern => ({\n  type: \"Null\",\n  pattern,\n});\n\n/**\n * Creates a Number ValuePattern.\n */\nexport const valueNumber = (pattern: NumberPattern): ValuePattern => ({\n  type: \"Number\",\n  pattern,\n});\n\n/**\n * Creates a Text ValuePattern.\n */\nexport const valueText = (pattern: TextPattern): ValuePattern => ({\n  type: \"Text\",\n  pattern,\n});\n\n/**\n * Creates a ByteString ValuePattern.\n */\nexport const valueByteString = (pattern: ByteStringPattern): ValuePattern => ({\n  type: \"ByteString\",\n  pattern,\n});\n\n/**\n * Creates a Date ValuePattern.\n */\nexport const valueDate = (pattern: DatePattern): ValuePattern => ({\n  type: \"Date\",\n  pattern,\n});\n\n/**\n * Creates a Digest ValuePattern.\n */\nexport const valueDigest = (pattern: DigestPattern): ValuePattern => ({\n  type: \"Digest\",\n  pattern,\n});\n\n/**\n * Creates a KnownValue ValuePattern.\n */\nexport const valueKnownValue = (pattern: KnownValuePattern): ValuePattern => ({\n  type: \"KnownValue\",\n  pattern,\n});\n","/**\n * Helper functions for array pattern matching.\n *\n * @module pattern/structure/array-pattern/helpers\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Pattern } from \"../../index\";\nimport type { RepeatPattern } from \"../../meta/repeat-pattern\";\nimport type { Quantifier } from \"../../../quantifier\";\n\n/**\n * Check if a pattern is a repeat pattern.\n */\nexport const isRepeatPattern = (pattern: Pattern): boolean => {\n  return pattern.kind === \"Meta\" && pattern.pattern.type === \"Repeat\";\n};\n\n/**\n * Check if a pattern is a capture pattern containing a repeat pattern.\n * Returns the inner repeat pattern if found.\n */\nexport const extractCaptureWithRepeat = (pattern: Pattern): RepeatPattern | undefined => {\n  if (pattern.kind === \"Meta\" && pattern.pattern.type === \"Capture\") {\n    const capturePattern = pattern.pattern.pattern;\n    const innerPattern = capturePattern.pattern;\n    if (innerPattern.kind === \"Meta\" && innerPattern.pattern.type === \"Repeat\") {\n      return innerPattern.pattern.pattern;\n    }\n  }\n  return undefined;\n};\n\n/**\n * Extract any repeat pattern from a pattern, whether direct or within a capture.\n */\nexport const extractRepeatPattern = (pattern: Pattern): RepeatPattern | undefined => {\n  if (pattern.kind === \"Meta\") {\n    if (pattern.pattern.type === \"Repeat\") {\n      return pattern.pattern.pattern;\n    }\n    if (pattern.pattern.type === \"Capture\") {\n      const capturePattern = pattern.pattern.pattern;\n      const innerPattern = capturePattern.pattern;\n      if (innerPattern.kind === \"Meta\" && innerPattern.pattern.type === \"Repeat\") {\n        return innerPattern.pattern.pattern;\n      }\n    }\n  }\n  return undefined;\n};\n\n/**\n * Check if a slice of patterns contains any repeat patterns (direct or in captures).\n */\nexport const hasRepeatPatternsInSlice = (patterns: Pattern[]): boolean => {\n  return patterns.some((p) => extractRepeatPattern(p) !== undefined);\n};\n\n/**\n * Calculate the bounds for repeat pattern matching based on quantifier and\n * available elements.\n */\nexport const calculateRepeatBounds = (\n  quantifier: Quantifier,\n  elementIdx: number,\n  arrLen: number,\n): [number, number] => {\n  const minCount = quantifier.min();\n  const remainingElements = Math.max(0, arrLen - elementIdx);\n  const maxCount = Math.min(quantifier.max() ?? remainingElements, remainingElements);\n  return [minCount, maxCount];\n};\n\n/**\n * Check if a repeat pattern can match a specific number of elements starting\n * at elementIdx.\n */\nexport const canRepeatMatch = (\n  repeatPattern: RepeatPattern,\n  arr: Cbor[],\n  elementIdx: number,\n  repCount: number,\n  matchFn: (pattern: Pattern, value: Cbor) => boolean,\n): boolean => {\n  if (repCount === 0) {\n    return true; // Zero repetitions always match\n  }\n  for (let i = 0; i < repCount; i++) {\n    const element = arr[elementIdx + i];\n    if (!matchFn(repeatPattern.pattern, element)) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * Build a simple array context path: [arrayCbor, element]\n */\nexport const buildSimpleArrayContextPath = (arrayCbor: Cbor, element: Cbor): Cbor[] => {\n  return [arrayCbor, element];\n};\n\n/**\n * Build an extended array context path: [arrayCbor, element] + capturedPath\n * (skip first element)\n */\nexport const buildExtendedArrayContextPath = (\n  arrayCbor: Cbor,\n  element: Cbor,\n  capturedPath: Cbor[],\n): Cbor[] => {\n  const arrayPath: Cbor[] = [arrayCbor, element];\n  if (capturedPath.length > 1) {\n    arrayPath.push(...capturedPath.slice(1));\n  }\n  return arrayPath;\n};\n\n/**\n * Transform nested captures to include array context, extending allCaptures.\n */\nexport const transformCapturesWithArrayContext = (\n  arrayCbor: Cbor,\n  element: Cbor,\n  nestedCaptures: Map<string, Cbor[][]>,\n  allCaptures: Map<string, Cbor[][]>,\n): void => {\n  for (const [captureName, capturedPaths] of nestedCaptures) {\n    const arrayContextPaths: Cbor[][] = [];\n    for (const capturedPath of capturedPaths) {\n      const arrayPath = buildExtendedArrayContextPath(arrayCbor, element, capturedPath);\n      arrayContextPaths.push(arrayPath);\n    }\n    const existing = allCaptures.get(captureName) ?? [];\n    existing.push(...arrayContextPaths);\n    allCaptures.set(captureName, existing);\n  }\n};\n","/**\n * Generic backtracking framework for array pattern matching.\n *\n * This module provides a generic backtracking algorithm that can work with\n * different types of state management (boolean matching vs assignment tracking).\n *\n * @module pattern/structure/array-pattern/backtrack\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Pattern } from \"../../index\";\nimport type { RepeatPattern } from \"../../meta/repeat-pattern\";\nimport { extractCaptureWithRepeat, calculateRepeatBounds, canRepeatMatch } from \"./helpers\";\n\n/**\n * Generic backtracking state interface.\n * Abstracts the differences between boolean matching and assignment tracking.\n */\nexport interface BacktrackState<T> {\n  /**\n   * Try to advance the state with a new assignment and return true if successful.\n   */\n  tryAdvance(patternIdx: number, elementIdx: number): boolean;\n\n  /**\n   * Backtrack by removing the last state change.\n   */\n  backtrack(): void;\n\n  /**\n   * Check if we've reached a successful final state.\n   */\n  isSuccess(\n    patternIdx: number,\n    elementIdx: number,\n    patternsLen: number,\n    elementsLen: number,\n  ): boolean;\n\n  /**\n   * Get the final result.\n   */\n  getResult(): T;\n}\n\n/**\n * Boolean backtracking state - just tracks success/failure.\n */\nexport class BooleanBacktrackState implements BacktrackState<boolean> {\n  tryAdvance(_patternIdx: number, _elementIdx: number): boolean {\n    return true; // Always allow advancement for boolean matching\n  }\n\n  backtrack(): void {\n    // Nothing to backtrack for boolean state\n  }\n\n  isSuccess(\n    patternIdx: number,\n    elementIdx: number,\n    patternsLen: number,\n    elementsLen: number,\n  ): boolean {\n    return patternIdx >= patternsLen && elementIdx >= elementsLen;\n  }\n\n  getResult(): boolean {\n    return true; // If we get here, we succeeded\n  }\n}\n\n/**\n * Assignment tracking backtracking state - collects pattern-element pairs.\n */\nexport class AssignmentBacktrackState implements BacktrackState<[number, number][]> {\n  readonly assignments: [number, number][] = [];\n\n  tryAdvance(patternIdx: number, elementIdx: number): boolean {\n    this.assignments.push([patternIdx, elementIdx]);\n    return true;\n  }\n\n  backtrack(): void {\n    this.assignments.pop();\n  }\n\n  isSuccess(\n    patternIdx: number,\n    elementIdx: number,\n    patternsLen: number,\n    elementsLen: number,\n  ): boolean {\n    return patternIdx >= patternsLen && elementIdx >= elementsLen;\n  }\n\n  getResult(): [number, number][] {\n    return this.assignments;\n  }\n\n  len(): number {\n    return this.assignments.length;\n  }\n\n  truncate(len: number): void {\n    this.assignments.length = len;\n  }\n}\n\n/**\n * Generic backtracking algorithm that works with any BacktrackState.\n */\nexport class GenericBacktracker {\n  readonly #patterns: Pattern[];\n  readonly #arr: Cbor[];\n  readonly #matchFn: (pattern: Pattern, value: Cbor) => boolean;\n\n  constructor(\n    patterns: Pattern[],\n    arr: Cbor[],\n    matchFn: (pattern: Pattern, value: Cbor) => boolean,\n  ) {\n    this.#patterns = patterns;\n    this.#arr = arr;\n    this.#matchFn = matchFn;\n  }\n\n  /**\n   * Generic backtracking algorithm that works with any state type.\n   */\n  backtrack<T>(state: BacktrackState<T>, patternIdx: number, elementIdx: number): boolean {\n    // Base case: if we've matched all patterns\n    if (state.isSuccess(patternIdx, elementIdx, this.#patterns.length, this.#arr.length)) {\n      return true;\n    }\n\n    if (patternIdx >= this.#patterns.length) {\n      return false; // No more patterns but still have elements\n    }\n\n    const currentPattern = this.#patterns[patternIdx];\n\n    // Check if this is a repeat pattern\n    if (currentPattern.kind === \"Meta\" && currentPattern.pattern.type === \"Repeat\") {\n      const repeatPattern = currentPattern.pattern.pattern;\n      return this.tryRepeatBacktrack(repeatPattern, state, patternIdx, elementIdx);\n    }\n\n    // Check if this is a capture pattern\n    if (currentPattern.kind === \"Meta\" && currentPattern.pattern.type === \"Capture\") {\n      // Check if the capture pattern contains a repeat pattern\n      const repeatPattern = extractCaptureWithRepeat(currentPattern);\n      if (repeatPattern !== undefined) {\n        // Handle this like a repeat pattern\n        return this.tryRepeatBacktrack(repeatPattern, state, patternIdx, elementIdx);\n      }\n\n      // Handle as a normal single-element capture\n      if (elementIdx < this.#arr.length) {\n        const element = this.#arr[elementIdx];\n        const matches = this.#matchFn(currentPattern, element);\n\n        if (matches && state.tryAdvance(patternIdx, elementIdx)) {\n          if (this.backtrack(state, patternIdx + 1, elementIdx + 1)) {\n            return true;\n          }\n          // Backtracking is handled by the recursive call failing\n          state.backtrack();\n        }\n      }\n      return false;\n    }\n\n    // Non-repeat pattern: must match exactly one element\n    if (elementIdx < this.#arr.length) {\n      const element = this.#arr[elementIdx];\n      const matches = this.#matchFn(currentPattern, element);\n\n      if (matches && state.tryAdvance(patternIdx, elementIdx)) {\n        if (this.backtrack(state, patternIdx + 1, elementIdx + 1)) {\n          return true;\n        }\n        // Backtracking is handled by the recursive call failing\n        state.backtrack();\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Helper for repeat pattern backtracking with generic state.\n   */\n  private tryRepeatBacktrack<T>(\n    repeatPattern: RepeatPattern,\n    state: BacktrackState<T>,\n    patternIdx: number,\n    elementIdx: number,\n  ): boolean {\n    const quantifier = repeatPattern.quantifier;\n    const [minCount, maxCount] = calculateRepeatBounds(quantifier, elementIdx, this.#arr.length);\n\n    // Try different numbers of repetitions (greedy: start with max)\n    for (let repCount = maxCount; repCount >= minCount; repCount--) {\n      if (\n        elementIdx + repCount <= this.#arr.length &&\n        canRepeatMatch(repeatPattern, this.#arr, elementIdx, repCount, this.#matchFn)\n      ) {\n        // Record state for all consumed elements\n        let advancedCount = 0;\n        let canAdvance = true;\n        for (let i = 0; i < repCount; i++) {\n          if (!state.tryAdvance(patternIdx, elementIdx + i)) {\n            // If we can't advance, backtrack what we've added\n            // and try next repCount\n            for (let j = 0; j < advancedCount; j++) {\n              state.backtrack();\n            }\n            canAdvance = false;\n            break;\n          }\n          advancedCount++;\n        }\n\n        if (!canAdvance) {\n          continue;\n        }\n\n        // Try to match the rest of the sequence recursively\n        if (this.backtrack(state, patternIdx + 1, elementIdx + repCount)) {\n          return true;\n        }\n\n        // Backtrack: undo all the advances we made for this repCount\n        for (let i = 0; i < repCount; i++) {\n          state.backtrack();\n        }\n      }\n    }\n    return false;\n  }\n}\n","/**\n * Sequence assigner for array pattern matching.\n *\n * Handles element-to-pattern assignment logic, encapsulating the complex logic\n * for mapping array elements to sequence patterns.\n *\n * @module pattern/structure/array-pattern/assigner\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Pattern } from \"../../index\";\nimport { hasRepeatPatternsInSlice } from \"./helpers\";\nimport { GenericBacktracker, BooleanBacktrackState, AssignmentBacktrackState } from \"./backtrack\";\n\n/**\n * Helper class for handling element-to-pattern assignment logic.\n * Encapsulates the complex logic for mapping array elements to sequence\n * patterns that was previously duplicated between matching and capture\n * collection.\n */\nexport class SequenceAssigner {\n  readonly #patterns: Pattern[];\n  readonly #arr: Cbor[];\n  readonly #matchFn: (pattern: Pattern, value: Cbor) => boolean;\n\n  constructor(\n    patterns: Pattern[],\n    arr: Cbor[],\n    matchFn: (pattern: Pattern, value: Cbor) => boolean,\n  ) {\n    this.#patterns = patterns;\n    this.#arr = arr;\n    this.#matchFn = matchFn;\n  }\n\n  /**\n   * Check if the sequence can match against the array elements (boolean result).\n   */\n  canMatch(): boolean {\n    // Simple case: if no patterns, then empty array should match\n    if (this.#patterns.length === 0) {\n      return this.#arr.length === 0;\n    }\n\n    // Check if we have any repeat patterns that require backtracking\n    const hasRepeatPatterns = hasRepeatPatternsInSlice(this.#patterns);\n\n    // Simple case: if pattern count equals element count AND no repeat patterns\n    if (this.#patterns.length === this.#arr.length && !hasRepeatPatterns) {\n      // Try one-to-one matching\n      return this.#patterns.every((pattern, i) => this.#matchFn(pattern, this.#arr[i]));\n    }\n\n    // Complex case: use generic backtracking framework\n    const backtracker = new GenericBacktracker(this.#patterns, this.#arr, this.#matchFn);\n    const state = new BooleanBacktrackState();\n    return backtracker.backtrack(state, 0, 0);\n  }\n\n  /**\n   * Find the element-to-pattern assignments (returns assignment pairs).\n   */\n  findAssignments(): [number, number][] | undefined {\n    // Simple case: if no patterns, then empty array should match\n    if (this.#patterns.length === 0) {\n      return this.#arr.length === 0 ? [] : undefined;\n    }\n\n    // Check if we have any repeat patterns that require backtracking\n    const hasRepeatPatterns = hasRepeatPatternsInSlice(this.#patterns);\n\n    // Simple case: if pattern count equals element count AND no repeat patterns\n    if (this.#patterns.length === this.#arr.length && !hasRepeatPatterns) {\n      const assignments: [number, number][] = [];\n      for (let patternIdx = 0; patternIdx < this.#patterns.length; patternIdx++) {\n        const pattern = this.#patterns[patternIdx];\n        const element = this.#arr[patternIdx];\n        if (this.#matchFn(pattern, element)) {\n          assignments.push([patternIdx, patternIdx]);\n        } else {\n          return undefined; // Pattern doesn't match its corresponding element\n        }\n      }\n      return assignments;\n    }\n\n    // Complex case: use generic backtracking framework\n    const backtracker = new GenericBacktracker(this.#patterns, this.#arr, this.#matchFn);\n    const state = new AssignmentBacktrackState();\n    if (backtracker.backtrack(state, 0, 0)) {\n      return state.assignments;\n    }\n    return undefined;\n  }\n}\n","/**\n * Array pattern for dCBOR pattern matching.\n *\n * @module pattern/structure/array-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport { isArray, arrayLength, arrayItem, cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../../format\";\nimport type { Pattern } from \"../../index\";\nimport type { SequencePattern } from \"../../meta/sequence-pattern\";\nimport type { RepeatPattern } from \"../../meta/repeat-pattern\";\nimport { Interval } from \"../../../interval\";\nimport { matchPattern } from \"../../match-registry\";\nimport {\n  hasRepeatPatternsInSlice,\n  extractCaptureWithRepeat,\n  isRepeatPattern,\n  buildSimpleArrayContextPath,\n} from \"./helpers\";\nimport { SequenceAssigner } from \"./assigner\";\n\n// Re-export helper modules\nexport * from \"./helpers\";\nexport * from \"./backtrack\";\nexport * from \"./assigner\";\n\n/**\n * Pattern for matching CBOR array structures.\n */\nexport type ArrayPattern =\n  | { readonly variant: \"Any\" }\n  | { readonly variant: \"Elements\"; readonly pattern: Pattern }\n  | { readonly variant: \"Length\"; readonly length: Interval };\n\n/**\n * Creates an ArrayPattern that matches any array.\n */\nexport const arrayPatternAny = (): ArrayPattern => ({ variant: \"Any\" });\n\n/**\n * Creates an ArrayPattern that matches arrays with elements matching the pattern.\n */\nexport const arrayPatternWithElements = (pattern: Pattern): ArrayPattern => ({\n  variant: \"Elements\",\n  pattern,\n});\n\n/**\n * Creates an ArrayPattern that matches arrays with a specific length.\n */\nexport const arrayPatternWithLength = (length: number): ArrayPattern => ({\n  variant: \"Length\",\n  length: Interval.exactly(length),\n});\n\n/**\n * Creates an ArrayPattern that matches arrays with length in a range.\n */\nexport const arrayPatternWithLengthRange = (min: number, max?: number): ArrayPattern => ({\n  variant: \"Length\",\n  length: max !== undefined ? Interval.from(min, max) : Interval.atLeast(min),\n});\n\n/**\n * Creates an ArrayPattern that matches arrays with length in an interval.\n */\nexport const arrayPatternWithLengthInterval = (interval: Interval): ArrayPattern => ({\n  variant: \"Length\",\n  length: interval,\n});\n\n/**\n * Gets array elements as Cbor array.\n */\nconst getArrayElements = (haystack: Cbor): Cbor[] | undefined => {\n  if (!isArray(haystack)) {\n    return undefined;\n  }\n  const len = arrayLength(haystack);\n  if (len === undefined) {\n    return undefined;\n  }\n  const elements: Cbor[] = [];\n  for (let i = 0; i < len; i++) {\n    const item = arrayItem(haystack, i);\n    if (item === undefined) {\n      return undefined;\n    }\n    elements.push(item);\n  }\n  return elements;\n};\n\n/**\n * Match a single repeat pattern against array elements.\n */\nconst matchRepeatPatternAgainstArray = (repeatPattern: RepeatPattern, arr: Cbor[]): boolean => {\n  const quantifier = repeatPattern.quantifier;\n  const minCount = quantifier.min();\n  const maxCount = quantifier.max() ?? arr.length;\n\n  // Check if the array length is within the valid range for this repeat\n  if (arr.length < minCount || arr.length > maxCount) {\n    return false;\n  }\n\n  // Check if all elements match the repeated pattern\n  return arr.every((element) => matchPattern(repeatPattern.pattern, element));\n};\n\n/**\n * Match a sequence of patterns against array elements using backtracking.\n */\nconst matchSequencePatternsAgainstArray = (seqPattern: SequencePattern, arr: Cbor[]): boolean => {\n  const patterns = seqPattern.patterns;\n  const assigner = new SequenceAssigner(patterns, arr, matchPattern);\n  return assigner.canMatch();\n};\n\n/**\n * Check if a sequence pattern can match against array elements.\n */\nconst canMatchSequenceAgainstArray = (pattern: Pattern, arr: Cbor[]): boolean => {\n  if (pattern.kind === \"Meta\") {\n    if (pattern.pattern.type === \"Sequence\") {\n      return matchSequencePatternsAgainstArray(pattern.pattern.pattern, arr);\n    }\n    if (pattern.pattern.type === \"Repeat\") {\n      return matchRepeatPatternAgainstArray(pattern.pattern.pattern, arr);\n    }\n  }\n  // For non-sequence patterns, fall back to simple matching\n  const arrayCbor = cbor(arr);\n  return matchPattern(pattern, arrayCbor);\n};\n\n/**\n * Match a complex sequence against array elements.\n */\nconst matchComplexSequence = (haystack: Cbor, pattern: Pattern): Path[] => {\n  const arr = getArrayElements(haystack);\n  if (arr === undefined) {\n    return [];\n  }\n\n  const canMatch = canMatchSequenceAgainstArray(pattern, arr);\n  if (canMatch) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Find which array elements are assigned to which sequence patterns.\n */\nconst findSequenceElementAssignments = (\n  seqPattern: SequencePattern,\n  arr: Cbor[],\n): [number, number][] | undefined => {\n  const patterns = seqPattern.patterns;\n  const assigner = new SequenceAssigner(patterns, arr, matchPattern);\n  return assigner.findAssignments();\n};\n\n/**\n * Handle sequence patterns with captures by manually matching elements\n * and collecting captures with proper array context.\n */\nconst handleSequenceCaptures = (\n  seqPattern: SequencePattern,\n  arrayCbor: Cbor,\n  arr: Cbor[],\n): [Path[], Map<string, Path[]>] => {\n  const assignments = findSequenceElementAssignments(seqPattern, arr);\n  if (assignments === undefined) {\n    return [[], new Map<string, Path[]>()];\n  }\n\n  const allCaptures = new Map<string, Path[]>();\n\n  // Process each pattern and its assigned elements\n  for (let patternIdx = 0; patternIdx < seqPattern.patterns.length; patternIdx++) {\n    const pattern = seqPattern.patterns[patternIdx];\n\n    // Check if this is a capture pattern containing a repeat pattern\n    if (pattern.kind === \"Meta\" && pattern.pattern.type === \"Capture\") {\n      const capturePattern = pattern.pattern.pattern;\n\n      // Check if the capture contains a repeat pattern\n      if (extractCaptureWithRepeat(pattern) !== undefined) {\n        // This is a capture pattern with a repeat (like @rest((*)*)\n        // We need to capture the sub-array of matched elements\n        const capturedElements: Cbor[] = assignments\n          .filter(([pIdx, _]) => pIdx === patternIdx)\n          .map(([_, eIdx]) => arr[eIdx]);\n\n        // Create a sub-array from the captured elements\n        const subArray = cbor(capturedElements);\n\n        // For capture patterns, we directly capture the sub-array with the capture name\n        const captureName = capturePattern.name;\n        const arrayContextPath = buildSimpleArrayContextPath(arrayCbor, subArray);\n\n        const existing = allCaptures.get(captureName) ?? [];\n        existing.push(arrayContextPath);\n        allCaptures.set(captureName, existing);\n        continue;\n      }\n    }\n\n    // Check if this is a direct repeat pattern that might capture multiple elements\n    if (isRepeatPattern(pattern) && pattern.kind === \"Meta\" && pattern.pattern.type === \"Repeat\") {\n      const repeatPattern = pattern.pattern.pattern;\n\n      // For repeat patterns, check if they have captures\n      // by looking at the inner pattern\n      const innerPattern = repeatPattern.pattern;\n      if (innerPattern.kind === \"Meta\" && innerPattern.pattern.type === \"Capture\") {\n        // This is a repeat pattern with captures\n        const capturedElements: Cbor[] = assignments\n          .filter(([pIdx, _]) => pIdx === patternIdx)\n          .map(([_, eIdx]) => arr[eIdx]);\n\n        // Create a sub-array from the captured elements\n        const subArray = cbor(capturedElements);\n\n        // Get the capture name from the inner capture pattern\n        const captureName = innerPattern.pattern.pattern.name;\n        const arrayContextPath = buildSimpleArrayContextPath(arrayCbor, subArray);\n\n        const existing = allCaptures.get(captureName) ?? [];\n        existing.push(arrayContextPath);\n        allCaptures.set(captureName, existing);\n        continue;\n      }\n    }\n\n    // For non-repeat patterns or repeat patterns without captures,\n    // process each assigned element individually\n    const elementIndices = assignments\n      .filter(([pIdx, _]) => pIdx === patternIdx)\n      .map(([_, eIdx]) => eIdx);\n\n    for (const elementIdx of elementIndices) {\n      const element = arr[elementIdx];\n\n      // Check if this pattern has any captures\n      if (pattern.kind === \"Meta\" && pattern.pattern.type === \"Capture\") {\n        const captureName = pattern.pattern.pattern.name;\n        const arrayContextPath = buildSimpleArrayContextPath(arrayCbor, element);\n\n        const existing = allCaptures.get(captureName) ?? [];\n        existing.push(arrayContextPath);\n        allCaptures.set(captureName, existing);\n      }\n    }\n  }\n\n  // Return the array path and all captures\n  return [[[arrayCbor]], allCaptures];\n};\n\n/**\n * Tests if a CBOR value matches this array pattern.\n */\nexport const arrayPatternMatches = (pattern: ArrayPattern, haystack: Cbor): boolean => {\n  if (!isArray(haystack)) {\n    return false;\n  }\n\n  switch (pattern.variant) {\n    case \"Any\":\n      return true;\n    case \"Elements\": {\n      const arr = getArrayElements(haystack);\n      if (arr === undefined) {\n        return false;\n      }\n\n      const elemPattern = pattern.pattern;\n\n      // Check pattern type for appropriate matching\n      if (elemPattern.kind === \"Meta\") {\n        if (elemPattern.pattern.type === \"Sequence\") {\n          // Use sequence matching with backtracking\n          return matchSequencePatternsAgainstArray(elemPattern.pattern.pattern, arr);\n        }\n        if (elemPattern.pattern.type === \"Repeat\") {\n          // Use repeat matching\n          return matchRepeatPatternAgainstArray(elemPattern.pattern.pattern, arr);\n        }\n        if (elemPattern.pattern.type === \"Capture\") {\n          // For capture patterns, check if any element matches\n          return arr.some((element) => matchPattern(elemPattern, element));\n        }\n      }\n\n      // For value/structure patterns, require exactly one element that matches\n      if (\n        elemPattern.kind === \"Value\" ||\n        elemPattern.kind === \"Structure\" ||\n        (elemPattern.kind === \"Meta\" && elemPattern.pattern.type === \"Any\")\n      ) {\n        if (arr.length !== 1) {\n          return false;\n        }\n        return matchPattern(elemPattern, arr[0]);\n      }\n\n      // For other meta patterns (or, and, etc.), check if any element matches\n      return arr.some((element) => matchPattern(elemPattern, element));\n    }\n    case \"Length\": {\n      const len = arrayLength(haystack);\n      return len !== undefined && pattern.length.contains(len);\n    }\n  }\n};\n\n/**\n * Returns paths to matching array values.\n */\nexport const arrayPatternPaths = (pattern: ArrayPattern, haystack: Cbor): Path[] => {\n  if (!isArray(haystack)) {\n    return [];\n  }\n\n  const arr = getArrayElements(haystack);\n  if (arr === undefined) {\n    return [];\n  }\n\n  switch (pattern.variant) {\n    case \"Any\":\n      return [[haystack]];\n\n    case \"Elements\": {\n      const elemPattern = pattern.pattern;\n\n      // Check pattern type for appropriate matching\n      if (elemPattern.kind === \"Meta\") {\n        if (elemPattern.pattern.type === \"Sequence\") {\n          const seqPattern = elemPattern.pattern.pattern;\n          const hasRepeats = hasRepeatPatternsInSlice(seqPattern.patterns);\n\n          if (hasRepeats) {\n            // Use complex sequence matching\n            return matchComplexSequence(haystack, elemPattern);\n          }\n\n          // Simple sequence: match each pattern against consecutive elements\n          if (seqPattern.patterns.length === arr.length) {\n            for (let i = 0; i < seqPattern.patterns.length; i++) {\n              if (!matchPattern(seqPattern.patterns[i], arr[i])) {\n                return [];\n              }\n            }\n            return [[haystack]];\n          }\n          return [];\n        }\n\n        if (elemPattern.pattern.type === \"Repeat\") {\n          return matchComplexSequence(haystack, elemPattern);\n        }\n\n        if (elemPattern.pattern.type === \"Capture\") {\n          // For capture patterns, check if any element matches\n          const hasMatch = arr.some((element) => matchPattern(elemPattern, element));\n          return hasMatch ? [[haystack]] : [];\n        }\n      }\n\n      // For value/structure patterns, require exactly one element that matches\n      if (\n        elemPattern.kind === \"Value\" ||\n        elemPattern.kind === \"Structure\" ||\n        (elemPattern.kind === \"Meta\" && elemPattern.pattern.type === \"Any\")\n      ) {\n        if (arr.length !== 1) {\n          return [];\n        }\n        return matchPattern(elemPattern, arr[0]) ? [[haystack]] : [];\n      }\n\n      // For other meta patterns, check if any element matches\n      const hasMatch = arr.some((element) => matchPattern(elemPattern, element));\n      return hasMatch ? [[haystack]] : [];\n    }\n\n    case \"Length\":\n      return pattern.length.contains(arr.length) ? [[haystack]] : [];\n  }\n};\n\n/**\n * Returns paths with captures for array patterns.\n */\nexport const arrayPatternPathsWithCaptures = (\n  pattern: ArrayPattern,\n  haystack: Cbor,\n): [Path[], Map<string, Path[]>] => {\n  if (!isArray(haystack)) {\n    return [[], new Map<string, Path[]>()];\n  }\n\n  const arr = getArrayElements(haystack);\n  if (arr === undefined) {\n    return [[], new Map<string, Path[]>()];\n  }\n\n  switch (pattern.variant) {\n    case \"Any\":\n    case \"Length\":\n      return [arrayPatternPaths(pattern, haystack), new Map<string, Path[]>()];\n\n    case \"Elements\": {\n      const elemPattern = pattern.pattern;\n\n      // Check for sequence patterns with captures\n      if (elemPattern.kind === \"Meta\" && elemPattern.pattern.type === \"Sequence\") {\n        const seqPattern = elemPattern.pattern.pattern;\n\n        // First check if this pattern matches\n        if (!arrayPatternMatches(pattern, haystack)) {\n          return [[], new Map<string, Path[]>()];\n        }\n\n        return handleSequenceCaptures(seqPattern, haystack, arr);\n      }\n\n      // For capture patterns\n      if (elemPattern.kind === \"Meta\" && elemPattern.pattern.type === \"Capture\") {\n        const capturePattern = elemPattern.pattern.pattern;\n        const matchingElements = arr.filter((element) => matchPattern(elemPattern, element));\n\n        if (matchingElements.length === 0) {\n          return [[], new Map<string, Path[]>()];\n        }\n\n        const captures = new Map<string, Path[]>();\n        const paths: Path[] = [];\n\n        for (const element of matchingElements) {\n          paths.push(buildSimpleArrayContextPath(haystack, element));\n        }\n\n        captures.set(capturePattern.name, paths);\n        return [[[haystack]], captures];\n      }\n\n      // Default: no captures\n      return [arrayPatternPaths(pattern, haystack), new Map<string, Path[]>()];\n    }\n  }\n};\n\n/**\n * Formats an ArrayPattern as a string.\n */\nexport const arrayPatternDisplay = (\n  pattern: ArrayPattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  switch (pattern.variant) {\n    case \"Any\":\n      return \"array\";\n    case \"Elements\": {\n      const elemPattern = pattern.pattern;\n      // For sequence patterns within arrays, format elements with commas\n      if (elemPattern.kind === \"Meta\" && elemPattern.pattern.type === \"Sequence\") {\n        const parts = elemPattern.pattern.pattern.patterns.map(patternDisplay);\n        return `[${parts.join(\", \")}]`;\n      }\n      return `[${patternDisplay(pattern.pattern)}]`;\n    }\n    case \"Length\":\n      return `[${pattern.length.toString()}]`;\n  }\n};\n\n/**\n * Compares two ArrayPatterns for equality.\n */\nexport const arrayPatternEquals = (\n  a: ArrayPattern,\n  b: ArrayPattern,\n  patternEquals: (p1: Pattern, p2: Pattern) => boolean,\n): boolean => {\n  if (a.variant !== b.variant) {\n    return false;\n  }\n  switch (a.variant) {\n    case \"Any\":\n      return true;\n    case \"Elements\":\n      return patternEquals(a.pattern, (b as typeof a).pattern);\n    case \"Length\":\n      return a.length.equals((b as typeof a).length);\n  }\n};\n","/**\n * Map pattern for dCBOR pattern matching.\n *\n * @module pattern/structure/map-pattern\n */\n\nimport type { Cbor, CborInput } from \"@bcts/dcbor\";\nimport { isMap, mapSize, mapKeys, mapValue, cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport type { Pattern } from \"../index\";\nimport { Interval } from \"../../interval\";\nimport { matchPattern } from \"../match-registry\";\n\n/**\n * Pattern for matching CBOR map structures.\n */\nexport type MapPattern =\n  | { readonly variant: \"Any\" }\n  | {\n      readonly variant: \"Constraints\";\n      readonly constraints: [Pattern, Pattern][];\n    }\n  | { readonly variant: \"Length\"; readonly length: Interval };\n\n/**\n * Creates a MapPattern that matches any map.\n */\nexport const mapPatternAny = (): MapPattern => ({ variant: \"Any\" });\n\n/**\n * Creates a MapPattern that matches maps with key-value constraints.\n */\nexport const mapPatternWithConstraints = (constraints: [Pattern, Pattern][]): MapPattern => ({\n  variant: \"Constraints\",\n  constraints,\n});\n\n/**\n * Creates a MapPattern that matches maps with a specific number of entries.\n */\nexport const mapPatternWithLength = (length: number): MapPattern => ({\n  variant: \"Length\",\n  length: Interval.exactly(length),\n});\n\n/**\n * Creates a MapPattern that matches maps with length in a range.\n */\nexport const mapPatternWithLengthRange = (min: number, max?: number): MapPattern => ({\n  variant: \"Length\",\n  length: max !== undefined ? Interval.from(min, max) : Interval.atLeast(min),\n});\n\n/**\n * Creates a MapPattern that matches maps with length in an interval.\n */\nexport const mapPatternWithLengthInterval = (interval: Interval): MapPattern => ({\n  variant: \"Length\",\n  length: interval,\n});\n\n/**\n * Tests if a CBOR value matches this map pattern.\n */\nexport const mapPatternMatches = (pattern: MapPattern, haystack: Cbor): boolean => {\n  if (!isMap(haystack)) {\n    return false;\n  }\n\n  switch (pattern.variant) {\n    case \"Any\":\n      return true;\n    case \"Constraints\": {\n      const keys = mapKeys(haystack);\n      if (keys === undefined) {\n        return false;\n      }\n      // All constraints must be satisfied\n      for (const [keyPattern, valuePattern] of pattern.constraints) {\n        let foundMatch = false;\n        for (const key of keys) {\n          if (matchPattern(keyPattern, key)) {\n            const rawValue = mapValue(haystack, key);\n            if (rawValue !== undefined && rawValue !== null) {\n              // Wrap raw JavaScript value in CBOR if needed\n              const value = (rawValue as Cbor)?.isCbor\n                ? (rawValue as Cbor)\n                : cbor(rawValue as CborInput);\n              if (matchPattern(valuePattern, value)) {\n                foundMatch = true;\n                break;\n              }\n            }\n          }\n        }\n        if (!foundMatch) {\n          return false;\n        }\n      }\n      return true;\n    }\n    case \"Length\": {\n      const size = mapSize(haystack);\n      return size !== undefined && pattern.length.contains(size);\n    }\n  }\n};\n\n/**\n * Returns paths to matching map values.\n */\nexport const mapPatternPaths = (pattern: MapPattern, haystack: Cbor): Path[] => {\n  if (mapPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Helper to build a map context path (map -> element).\n */\nconst buildMapContextPath = (mapCbor: Cbor, element: Cbor): Path => {\n  return [mapCbor, element];\n};\n\n/**\n * Collects captures from a pattern by checking if it's a capture pattern.\n */\nconst collectCapturesFromPattern = (\n  pattern: Pattern,\n  matchedValue: Cbor,\n  mapContext: Cbor,\n  captures: Map<string, Path[]>,\n): void => {\n  if (pattern.kind === \"Meta\" && pattern.pattern.type === \"Capture\") {\n    const captureName = pattern.pattern.pattern.name;\n    const contextPath = buildMapContextPath(mapContext, matchedValue);\n    const existing = captures.get(captureName) ?? [];\n    existing.push(contextPath);\n    captures.set(captureName, existing);\n\n    // Also collect from inner pattern\n    collectCapturesFromPattern(pattern.pattern.pattern.pattern, matchedValue, mapContext, captures);\n  }\n};\n\n/**\n * Returns paths with captures for map patterns.\n */\nexport const mapPatternPathsWithCaptures = (\n  pattern: MapPattern,\n  haystack: Cbor,\n): [Path[], Map<string, Path[]>] => {\n  if (!isMap(haystack)) {\n    return [[], new Map<string, Path[]>()];\n  }\n\n  switch (pattern.variant) {\n    case \"Any\":\n    case \"Length\":\n      return [mapPatternPaths(pattern, haystack), new Map<string, Path[]>()];\n\n    case \"Constraints\": {\n      const keys = mapKeys(haystack);\n      if (keys === undefined) {\n        return [[], new Map<string, Path[]>()];\n      }\n\n      const captures = new Map<string, Path[]>();\n\n      // For each constraint, find the matching key-value pair and collect captures\n      for (const [keyPattern, valuePattern] of pattern.constraints) {\n        for (const key of keys) {\n          if (matchPattern(keyPattern, key)) {\n            const rawValue = mapValue(haystack, key);\n            if (rawValue !== undefined && rawValue !== null) {\n              // Wrap raw JavaScript value in CBOR if needed\n              const value = (rawValue as Cbor)?.isCbor\n                ? (rawValue as Cbor)\n                : cbor(rawValue as CborInput);\n              if (matchPattern(valuePattern, value)) {\n                // Collect captures from key pattern\n                collectCapturesFromPattern(keyPattern, key, haystack, captures);\n                // Collect captures from value pattern\n                collectCapturesFromPattern(valuePattern, value, haystack, captures);\n                break;\n              }\n            }\n          }\n        }\n      }\n\n      // If pattern matches, return the map path with captures\n      if (mapPatternMatches(pattern, haystack)) {\n        return [[[haystack]], captures];\n      }\n      return [[], new Map<string, Path[]>()];\n    }\n  }\n};\n\n/**\n * Formats a MapPattern as a string.\n */\nexport const mapPatternDisplay = (\n  pattern: MapPattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  switch (pattern.variant) {\n    case \"Any\":\n      return \"map\";\n    case \"Constraints\": {\n      const parts = pattern.constraints.map(\n        ([k, v]) => `${patternDisplay(k)}: ${patternDisplay(v)}`,\n      );\n      return `{${parts.join(\", \")}}`;\n    }\n    case \"Length\":\n      return `{${pattern.length.toString()}}`;\n  }\n};\n\n/**\n * Compares two MapPatterns for equality.\n */\nexport const mapPatternEquals = (\n  a: MapPattern,\n  b: MapPattern,\n  patternEquals: (p1: Pattern, p2: Pattern) => boolean,\n): boolean => {\n  if (a.variant !== b.variant) {\n    return false;\n  }\n  switch (a.variant) {\n    case \"Any\":\n      return true;\n    case \"Constraints\": {\n      const bConstraints = (b as typeof a).constraints;\n      if (a.constraints.length !== bConstraints.length) {\n        return false;\n      }\n      for (let i = 0; i < a.constraints.length; i++) {\n        if (\n          !patternEquals(a.constraints[i][0], bConstraints[i][0]) ||\n          !patternEquals(a.constraints[i][1], bConstraints[i][1])\n        ) {\n          return false;\n        }\n      }\n      return true;\n    }\n    case \"Length\":\n      return a.length.equals((b as typeof a).length);\n  }\n};\n","/**\n * Tagged pattern for dCBOR pattern matching.\n *\n * @module pattern/structure/tagged-pattern\n */\n\nimport type { Cbor, Tag } from \"@bcts/dcbor\";\nimport { isTagged, tagValue, tagContent } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport type { Pattern } from \"../index\";\nimport { matchPattern, getPatternPathsWithCapturesDirect } from \"../match-registry\";\n\n/**\n * Pattern for matching CBOR tagged value structures.\n */\nexport type TaggedPattern =\n  | { readonly variant: \"Any\" }\n  | {\n      readonly variant: \"Tag\";\n      readonly tag: Tag;\n      readonly pattern: Pattern;\n    }\n  | {\n      readonly variant: \"Name\";\n      readonly name: string;\n      readonly pattern: Pattern;\n    }\n  | {\n      readonly variant: \"Regex\";\n      readonly regex: RegExp;\n      readonly pattern: Pattern;\n    };\n\n/**\n * Creates a TaggedPattern that matches any tagged value.\n */\nexport const taggedPatternAny = (): TaggedPattern => ({ variant: \"Any\" });\n\n/**\n * Creates a TaggedPattern that matches tagged values with specific tag and content.\n */\nexport const taggedPatternWithTag = (tag: Tag, pattern: Pattern): TaggedPattern => ({\n  variant: \"Tag\",\n  tag,\n  pattern,\n});\n\n/**\n * Creates a TaggedPattern that matches tagged values with a tag having the given name.\n */\nexport const taggedPatternWithName = (name: string, pattern: Pattern): TaggedPattern => ({\n  variant: \"Name\",\n  name,\n  pattern,\n});\n\n/**\n * Creates a TaggedPattern that matches tagged values with a tag name matching the regex.\n */\nexport const taggedPatternWithRegex = (regex: RegExp, pattern: Pattern): TaggedPattern => ({\n  variant: \"Regex\",\n  regex,\n  pattern,\n});\n\n/**\n * Tests if a CBOR value matches this tagged pattern.\n */\nexport const taggedPatternMatches = (pattern: TaggedPattern, haystack: Cbor): boolean => {\n  if (!isTagged(haystack)) {\n    return false;\n  }\n\n  const tag = tagValue(haystack);\n  const content = tagContent(haystack);\n\n  if (content === undefined) {\n    return false;\n  }\n\n  switch (pattern.variant) {\n    case \"Any\":\n      return true;\n    case \"Tag\":\n      return tag === pattern.tag.value && matchPattern(pattern.pattern, content);\n    case \"Name\": {\n      // Get tag name from global tags store\n      // For now, compare the tag value as string\n      const tagName = String(tag);\n      return tagName === pattern.name && matchPattern(pattern.pattern, content);\n    }\n    case \"Regex\": {\n      const tagName = String(tag);\n      return pattern.regex.test(tagName) && matchPattern(pattern.pattern, content);\n    }\n  }\n};\n\n/**\n * Returns paths to matching tagged values.\n */\nexport const taggedPatternPaths = (pattern: TaggedPattern, haystack: Cbor): Path[] => {\n  if (taggedPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Returns paths with captures for a tagged pattern.\n * Collects captures from inner patterns for Tag variant.\n */\nexport const taggedPatternPathsWithCaptures = (\n  pattern: TaggedPattern,\n  haystack: Cbor,\n): [Path[], Map<string, Path[]>] => {\n  if (!isTagged(haystack)) {\n    return [[], new Map<string, Path[]>()];\n  }\n\n  const tag = tagValue(haystack);\n  const content = tagContent(haystack);\n\n  if (content === undefined) {\n    return [[], new Map<string, Path[]>()];\n  }\n\n  switch (pattern.variant) {\n    case \"Any\":\n      // Matches any tagged value, no captures\n      return [[[haystack]], new Map<string, Path[]>()];\n\n    case \"Tag\": {\n      if (tag !== pattern.tag.value) {\n        return [[], new Map<string, Path[]>()];\n      }\n      // Get paths and captures from inner pattern\n      const innerResult = getPatternPathsWithCapturesDirect(pattern.pattern, content);\n      if (innerResult.paths.length === 0) {\n        return [[], innerResult.captures];\n      }\n\n      // Build paths that include the tagged value as root\n      const taggedPaths: Path[] = innerResult.paths.map((contentPath: Path) => {\n        const path: Cbor[] = [haystack];\n        // Skip the content's root in the path\n        if (contentPath.length > 1) {\n          path.push(...contentPath.slice(1));\n        }\n        return path;\n      });\n\n      // Update captures to include tagged value as root\n      const updatedCaptures = new Map<string, Path[]>();\n      for (const [name, capturePaths] of innerResult.captures) {\n        const updated: Path[] = capturePaths.map((_capturePath: Path) => {\n          // For tagged patterns, capture path is [tagged_value, content]\n          return [haystack, content];\n        });\n        updatedCaptures.set(name, updated);\n      }\n\n      return [taggedPaths, updatedCaptures];\n    }\n\n    case \"Name\":\n    case \"Regex\":\n      // For other variants, fall back to basic paths without captures\n      return [taggedPatternPaths(pattern, haystack), new Map<string, Path[]>()];\n  }\n};\n\n/**\n * Formats a TaggedPattern as a string.\n */\nexport const taggedPatternDisplay = (\n  pattern: TaggedPattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  switch (pattern.variant) {\n    case \"Any\":\n      return \"tagged\";\n    case \"Tag\":\n      return `tagged(${pattern.tag.value}, ${patternDisplay(pattern.pattern)})`;\n    case \"Name\":\n      return `tagged(${pattern.name}, ${patternDisplay(pattern.pattern)})`;\n    case \"Regex\":\n      return `tagged(/${pattern.regex.source}/, ${patternDisplay(pattern.pattern)})`;\n  }\n};\n","/**\n * Structure patterns for dCBOR pattern matching.\n *\n * @module pattern/structure\n */\n\nexport * from \"./array-pattern\";\nexport * from \"./map-pattern\";\nexport * from \"./tagged-pattern\";\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport type { Pattern } from \"../index\";\n\nimport {\n  type ArrayPattern,\n  arrayPatternPaths,\n  arrayPatternDisplay,\n  arrayPatternPathsWithCaptures,\n} from \"./array-pattern\";\nimport {\n  type MapPattern,\n  mapPatternPaths,\n  mapPatternDisplay,\n  mapPatternPathsWithCaptures,\n} from \"./map-pattern\";\nimport {\n  type TaggedPattern,\n  taggedPatternPaths,\n  taggedPatternDisplay,\n  taggedPatternPathsWithCaptures,\n} from \"./tagged-pattern\";\n\n/**\n * Union of all structure pattern types.\n */\nexport type StructurePattern =\n  | { readonly type: \"Array\"; readonly pattern: ArrayPattern }\n  | { readonly type: \"Map\"; readonly pattern: MapPattern }\n  | { readonly type: \"Tagged\"; readonly pattern: TaggedPattern };\n\n/**\n * Returns paths to matching structures for a StructurePattern.\n */\nexport const structurePatternPaths = (pattern: StructurePattern, haystack: Cbor): Path[] => {\n  switch (pattern.type) {\n    case \"Array\":\n      return arrayPatternPaths(pattern.pattern, haystack);\n    case \"Map\":\n      return mapPatternPaths(pattern.pattern, haystack);\n    case \"Tagged\":\n      return taggedPatternPaths(pattern.pattern, haystack);\n  }\n};\n\n/**\n * Tests if a CBOR value matches a StructurePattern.\n */\nexport const structurePatternMatches = (pattern: StructurePattern, haystack: Cbor): boolean => {\n  return structurePatternPaths(pattern, haystack).length > 0;\n};\n\n/**\n * Returns paths with captures for a StructurePattern.\n * Used internally by the VM to avoid infinite recursion.\n */\nexport const structurePatternPathsWithCaptures = (\n  pattern: StructurePattern,\n  haystack: Cbor,\n): [Path[], Map<string, Path[]>] => {\n  switch (pattern.type) {\n    case \"Array\":\n      return arrayPatternPathsWithCaptures(pattern.pattern, haystack);\n    case \"Map\":\n      return mapPatternPathsWithCaptures(pattern.pattern, haystack);\n    case \"Tagged\":\n      return taggedPatternPathsWithCaptures(pattern.pattern, haystack);\n  }\n};\n\n/**\n * Formats a StructurePattern as a string.\n */\nexport const structurePatternDisplay = (\n  pattern: StructurePattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  switch (pattern.type) {\n    case \"Array\":\n      return arrayPatternDisplay(pattern.pattern, patternDisplay);\n    case \"Map\":\n      return mapPatternDisplay(pattern.pattern, patternDisplay);\n    case \"Tagged\":\n      return taggedPatternDisplay(pattern.pattern, patternDisplay);\n  }\n};\n\n// Convenience constructors for StructurePattern\n\n/**\n * Creates an Array StructurePattern.\n */\nexport const structureArray = (pattern: ArrayPattern): StructurePattern => ({\n  type: \"Array\",\n  pattern,\n});\n\n/**\n * Creates a Map StructurePattern.\n */\nexport const structureMap = (pattern: MapPattern): StructurePattern => ({\n  type: \"Map\",\n  pattern,\n});\n\n/**\n * Creates a Tagged StructurePattern.\n */\nexport const structureTagged = (pattern: TaggedPattern): StructurePattern => ({\n  type: \"Tagged\",\n  pattern,\n});\n","/**\n * Any pattern for dCBOR pattern matching.\n * Always matches any CBOR value.\n *\n * @module pattern/meta/any-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\n\n/**\n * A pattern that always matches any CBOR value.\n */\nexport interface AnyPattern {\n  readonly variant: \"Any\";\n}\n\n/**\n * Creates an AnyPattern.\n */\nexport const anyPattern = (): AnyPattern => ({ variant: \"Any\" });\n\n/**\n * Tests if a CBOR value matches this any pattern.\n * Always returns true.\n */\nexport const anyPatternMatches = (_pattern: AnyPattern, _haystack: Cbor): boolean => {\n  return true;\n};\n\n/**\n * Returns paths to matching values.\n */\nexport const anyPatternPaths = (_pattern: AnyPattern, haystack: Cbor): Path[] => {\n  return [[haystack]];\n};\n\n/**\n * Formats an AnyPattern as a string.\n */\nexport const anyPatternDisplay = (_pattern: AnyPattern): string => {\n  return \"*\";\n};\n","/**\n * And pattern for dCBOR pattern matching.\n * Matches if all contained patterns match.\n *\n * @module pattern/meta/and-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport type { Pattern } from \"../index\";\nimport { matchPattern } from \"../match-registry\";\n\n/**\n * A pattern that matches if all contained patterns match.\n */\nexport interface AndPattern {\n  readonly variant: \"And\";\n  readonly patterns: Pattern[];\n}\n\n/**\n * Creates an AndPattern with the given patterns.\n */\nexport const andPattern = (patterns: Pattern[]): AndPattern => ({\n  variant: \"And\",\n  patterns,\n});\n\n/**\n * Tests if a CBOR value matches this and pattern.\n * All patterns must match.\n */\nexport const andPatternMatches = (pattern: AndPattern, haystack: Cbor): boolean => {\n  return pattern.patterns.every((p: Pattern) => matchPattern(p, haystack));\n};\n\n/**\n * Returns paths to matching values.\n */\nexport const andPatternPaths = (pattern: AndPattern, haystack: Cbor): Path[] => {\n  if (andPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats an AndPattern as a string.\n */\nexport const andPatternDisplay = (\n  pattern: AndPattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  const parts = pattern.patterns.map(patternDisplay);\n  return parts.join(\" & \");\n};\n","/**\n * Or pattern for dCBOR pattern matching.\n * Matches if any contained pattern matches.\n *\n * @module pattern/meta/or-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport type { Pattern } from \"../index\";\nimport { matchPattern } from \"../match-registry\";\n\n/**\n * A pattern that matches if any contained pattern matches.\n */\nexport interface OrPattern {\n  readonly variant: \"Or\";\n  readonly patterns: Pattern[];\n}\n\n/**\n * Creates an OrPattern with the given patterns.\n */\nexport const orPattern = (patterns: Pattern[]): OrPattern => ({\n  variant: \"Or\",\n  patterns,\n});\n\n/**\n * Tests if a CBOR value matches this or pattern.\n * At least one pattern must match.\n */\nexport const orPatternMatches = (pattern: OrPattern, haystack: Cbor): boolean => {\n  return pattern.patterns.some((p: Pattern) => matchPattern(p, haystack));\n};\n\n/**\n * Returns paths to matching values.\n */\nexport const orPatternPaths = (pattern: OrPattern, haystack: Cbor): Path[] => {\n  if (orPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats an OrPattern as a string.\n */\nexport const orPatternDisplay = (\n  pattern: OrPattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  const parts = pattern.patterns.map(patternDisplay);\n  return parts.join(\" | \");\n};\n","/**\n * Not pattern for dCBOR pattern matching.\n * Matches if the inner pattern does NOT match.\n *\n * @module pattern/meta/not-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport type { Pattern } from \"../index\";\nimport { matchPattern } from \"../match-registry\";\n\n/**\n * A pattern that matches if the inner pattern does NOT match.\n */\nexport interface NotPattern {\n  readonly variant: \"Not\";\n  readonly pattern: Pattern;\n}\n\n/**\n * Creates a NotPattern with the given inner pattern.\n */\nexport const notPattern = (pattern: Pattern): NotPattern => ({\n  variant: \"Not\",\n  pattern,\n});\n\n/**\n * Tests if a CBOR value matches this not pattern.\n * Returns true if the inner pattern does NOT match.\n */\nexport const notPatternMatches = (pattern: NotPattern, haystack: Cbor): boolean => {\n  return !matchPattern(pattern.pattern, haystack);\n};\n\n/**\n * Returns paths to matching values.\n */\nexport const notPatternPaths = (pattern: NotPattern, haystack: Cbor): Path[] => {\n  if (notPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Check if a pattern is complex for display purposes.\n * Complex patterns need parentheses when inside a NOT pattern.\n */\nconst isComplex = (pattern: Pattern): boolean => {\n  if (pattern.kind === \"Meta\") {\n    // AND, OR, NOT, Sequence are complex\n    return [\"And\", \"Or\", \"Not\", \"Sequence\"].includes(pattern.pattern.type);\n  }\n  return false;\n};\n\n/**\n * Formats a NotPattern as a string.\n */\nexport const notPatternDisplay = (\n  pattern: NotPattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  if (isComplex(pattern.pattern)) {\n    return `!(${patternDisplay(pattern.pattern)})`;\n  }\n  return `!${patternDisplay(pattern.pattern)}`;\n};\n","/**\n * Repeat pattern for dCBOR pattern matching.\n * Matches with repetition based on a quantifier.\n *\n * @module pattern/meta/repeat-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport type { Pattern } from \"../index\";\nimport { Quantifier } from \"../../quantifier\";\n\n/**\n * A pattern that matches with repetition.\n */\nexport interface RepeatPattern {\n  readonly variant: \"Repeat\";\n  readonly pattern: Pattern;\n  readonly quantifier: Quantifier;\n}\n\n/**\n * Creates a RepeatPattern with the given pattern and quantifier.\n */\nexport const repeatPattern = (pattern: Pattern, quantifier: Quantifier): RepeatPattern => ({\n  variant: \"Repeat\",\n  pattern,\n  quantifier,\n});\n\n/**\n * Creates a RepeatPattern that matches zero or more times (greedy).\n */\nexport const repeatZeroOrMore = (pattern: Pattern): RepeatPattern => ({\n  variant: \"Repeat\",\n  pattern,\n  quantifier: Quantifier.zeroOrMore(),\n});\n\n/**\n * Creates a RepeatPattern that matches one or more times (greedy).\n */\nexport const repeatOneOrMore = (pattern: Pattern): RepeatPattern => ({\n  variant: \"Repeat\",\n  pattern,\n  quantifier: Quantifier.oneOrMore(),\n});\n\n/**\n * Creates a RepeatPattern that matches zero or one time (greedy).\n */\nexport const repeatOptional = (pattern: Pattern): RepeatPattern => ({\n  variant: \"Repeat\",\n  pattern,\n  quantifier: Quantifier.zeroOrOne(),\n});\n\n/**\n * Creates a RepeatPattern that matches exactly n times.\n */\nexport const repeatExact = (pattern: Pattern, n: number): RepeatPattern => ({\n  variant: \"Repeat\",\n  pattern,\n  quantifier: Quantifier.exactly(n),\n});\n\n/**\n * Creates a RepeatPattern that matches between min and max times.\n */\nexport const repeatRange = (pattern: Pattern, min: number, max?: number): RepeatPattern => ({\n  variant: \"Repeat\",\n  pattern,\n  quantifier: max !== undefined ? Quantifier.between(min, max) : Quantifier.atLeast(min),\n});\n\nimport { matchPattern } from \"../match-registry\";\n\n/**\n * Tests if a CBOR value matches this repeat pattern.\n * Note: This is a simplified implementation. Complex matching\n * will be implemented with the VM.\n */\nexport const repeatPatternMatches = (pattern: RepeatPattern, haystack: Cbor): boolean => {\n  // Simple case: check if the inner pattern matches at least once\n  // and the quantifier allows it\n  const innerMatches = matchPattern(pattern.pattern, haystack);\n  const min = pattern.quantifier.min();\n  const max = pattern.quantifier.max();\n\n  if (innerMatches) {\n    // If pattern matches once, check if 1 is in valid range\n    return min <= 1 && (max === undefined || max >= 1);\n  }\n  // If pattern doesn't match, only valid if min is 0\n  return min === 0;\n};\n\n/**\n * Returns paths to matching values.\n */\nexport const repeatPatternPaths = (pattern: RepeatPattern, haystack: Cbor): Path[] => {\n  if (repeatPatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats a RepeatPattern as a string.\n * Always wraps the inner pattern in parentheses to match Rust behavior.\n */\nexport const repeatPatternDisplay = (\n  pattern: RepeatPattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  return `(${patternDisplay(pattern.pattern)})${pattern.quantifier.toString()}`;\n};\n","/**\n * Capture pattern for dCBOR pattern matching.\n * Captures matched values with a name.\n *\n * @module pattern/meta/capture-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport type { Pattern } from \"../index\";\nimport { matchPattern } from \"../match-registry\";\n\n/**\n * A pattern that captures matched values with a name.\n */\nexport interface CapturePattern {\n  readonly variant: \"Capture\";\n  readonly name: string;\n  readonly pattern: Pattern;\n}\n\n/**\n * Creates a CapturePattern with the given name and inner pattern.\n */\nexport const capturePattern = (name: string, pattern: Pattern): CapturePattern => ({\n  variant: \"Capture\",\n  name,\n  pattern,\n});\n\n/**\n * Tests if a CBOR value matches this capture pattern.\n * Capture itself doesn't affect matching - it delegates to inner pattern.\n */\nexport const capturePatternMatches = (pattern: CapturePattern, haystack: Cbor): boolean => {\n  return matchPattern(pattern.pattern, haystack);\n};\n\n/**\n * Returns paths to matching values.\n */\nexport const capturePatternPaths = (pattern: CapturePattern, haystack: Cbor): Path[] => {\n  if (capturePatternMatches(pattern, haystack)) {\n    return [[haystack]];\n  }\n  return [];\n};\n\n/**\n * Formats a CapturePattern as a string.\n */\nexport const capturePatternDisplay = (\n  pattern: CapturePattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  return `@${pattern.name}(${patternDisplay(pattern.pattern)})`;\n};\n","/**\n * Search pattern for dCBOR pattern matching.\n * Searches the entire CBOR tree for matches.\n *\n * @module pattern/meta/search-pattern\n */\n\nimport type { Cbor, CborInput } from \"@bcts/dcbor\";\nimport {\n  isArray,\n  isMap,\n  isTagged,\n  arrayLength,\n  arrayItem,\n  mapKeys,\n  mapValue,\n  tagContent,\n  cbor,\n} from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport type { Pattern } from \"../index\";\nimport { matchPattern } from \"../match-registry\";\n\n/**\n * A pattern that searches the entire CBOR tree for matches.\n */\nexport interface SearchPattern {\n  readonly variant: \"Search\";\n  readonly pattern: Pattern;\n}\n\n/**\n * Creates a SearchPattern with the given inner pattern.\n */\nexport const searchPattern = (pattern: Pattern): SearchPattern => ({\n  variant: \"Search\",\n  pattern,\n});\n\n/**\n * Recursively searches the CBOR tree and collects all matching paths.\n */\nconst searchRecursive = (\n  pattern: Pattern,\n  haystack: Cbor,\n  currentPath: Cbor[],\n  results: Path[],\n): void => {\n  // Check if current node matches\n  if (matchPattern(pattern, haystack)) {\n    results.push([...currentPath, haystack]);\n  }\n\n  // Recursively search children\n  if (isArray(haystack)) {\n    const len = arrayLength(haystack);\n    if (len !== undefined) {\n      for (let i = 0; i < len; i++) {\n        const item = arrayItem(haystack, i);\n        if (item !== undefined) {\n          searchRecursive(pattern, item, [...currentPath, haystack], results);\n        }\n      }\n    }\n  } else if (isMap(haystack)) {\n    const keys = mapKeys(haystack);\n    if (keys !== undefined) {\n      for (const key of keys) {\n        // Search in keys\n        searchRecursive(pattern, key, [...currentPath, haystack], results);\n        // Search in values\n        const rawValue = mapValue(haystack, key);\n        if (rawValue !== undefined && rawValue !== null) {\n          // Wrap raw JavaScript value in CBOR if needed\n          const value = (rawValue as Cbor)?.isCbor\n            ? (rawValue as Cbor)\n            : cbor(rawValue as CborInput);\n          searchRecursive(pattern, value, [...currentPath, haystack], results);\n        }\n      }\n    }\n  } else if (isTagged(haystack)) {\n    const content = tagContent(haystack);\n    if (content !== undefined) {\n      searchRecursive(pattern, content, [...currentPath, haystack], results);\n    }\n  }\n};\n\n/**\n * Tests if a CBOR value matches this search pattern.\n * Returns true if any node in the tree matches.\n */\nexport const searchPatternMatches = (pattern: SearchPattern, haystack: Cbor): boolean => {\n  const paths = searchPatternPaths(pattern, haystack);\n  return paths.length > 0;\n};\n\n/**\n * Returns paths to all matching values in the tree.\n */\nexport const searchPatternPaths = (pattern: SearchPattern, haystack: Cbor): Path[] => {\n  const results: Path[] = [];\n  searchRecursive(pattern.pattern, haystack, [], results);\n  return results;\n};\n\n/**\n * Result type for paths with captures from search operations.\n */\nexport interface SearchWithCaptures {\n  readonly paths: Path[];\n  readonly captures: Map<string, Path[]>;\n}\n\n/**\n * Recursively searches the CBOR tree, collecting paths and captures.\n */\nconst searchRecursiveWithCaptures = (\n  pattern: Pattern,\n  haystack: Cbor,\n  currentPath: Cbor[],\n  results: Path[],\n  captures: Map<string, Path[]>,\n  collectCapture: (p: Pattern, h: Cbor, path: Cbor[]) => void,\n): void => {\n  // Check if current node matches\n  if (matchPattern(pattern, haystack)) {\n    const matchPath = [...currentPath, haystack];\n    results.push(matchPath);\n    // Collect captures for this match\n    collectCapture(pattern, haystack, matchPath);\n  }\n\n  // Recursively search children\n  if (isArray(haystack)) {\n    const len = arrayLength(haystack);\n    if (len !== undefined) {\n      for (let i = 0; i < len; i++) {\n        const item = arrayItem(haystack, i);\n        if (item !== undefined) {\n          searchRecursiveWithCaptures(\n            pattern,\n            item,\n            [...currentPath, haystack],\n            results,\n            captures,\n            collectCapture,\n          );\n        }\n      }\n    }\n  } else if (isMap(haystack)) {\n    const keys = mapKeys(haystack);\n    if (keys !== undefined) {\n      for (const key of keys) {\n        // Search in keys\n        searchRecursiveWithCaptures(\n          pattern,\n          key,\n          [...currentPath, haystack],\n          results,\n          captures,\n          collectCapture,\n        );\n        // Search in values\n        const rawValue = mapValue(haystack, key);\n        if (rawValue !== undefined && rawValue !== null) {\n          // Wrap raw JavaScript value in CBOR if needed\n          const value = (rawValue as Cbor)?.isCbor\n            ? (rawValue as Cbor)\n            : cbor(rawValue as CborInput);\n          searchRecursiveWithCaptures(\n            pattern,\n            value,\n            [...currentPath, haystack],\n            results,\n            captures,\n            collectCapture,\n          );\n        }\n      }\n    }\n  } else if (isTagged(haystack)) {\n    const content = tagContent(haystack);\n    if (content !== undefined) {\n      searchRecursiveWithCaptures(\n        pattern,\n        content,\n        [...currentPath, haystack],\n        results,\n        captures,\n        collectCapture,\n      );\n    }\n  }\n};\n\n/**\n * Extract capture from a pattern at a given match location.\n * Recursively searches for all capture patterns.\n */\nconst extractCaptures = (\n  pattern: Pattern,\n  matchPath: Cbor[],\n  captures: Map<string, Path[]>,\n): void => {\n  if (pattern.kind === \"Meta\") {\n    switch (pattern.pattern.type) {\n      case \"Capture\": {\n        const captureName = pattern.pattern.pattern.name;\n        const existing = captures.get(captureName) ?? [];\n        existing.push(matchPath);\n        captures.set(captureName, existing);\n        // Also extract from inner pattern\n        extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);\n        break;\n      }\n      case \"And\":\n        for (const p of pattern.pattern.pattern.patterns) {\n          extractCaptures(p, matchPath, captures);\n        }\n        break;\n      case \"Or\":\n        for (const p of pattern.pattern.pattern.patterns) {\n          extractCaptures(p, matchPath, captures);\n        }\n        break;\n      case \"Sequence\":\n        for (const p of pattern.pattern.pattern.patterns) {\n          extractCaptures(p, matchPath, captures);\n        }\n        break;\n      case \"Not\":\n        extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);\n        break;\n      case \"Repeat\":\n        extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);\n        break;\n      case \"Search\":\n        extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);\n        break;\n      case \"Any\":\n        // No captures\n        break;\n    }\n  } else if (pattern.kind === \"Structure\") {\n    switch (pattern.pattern.type) {\n      case \"Array\":\n        if (pattern.pattern.pattern.variant === \"Elements\") {\n          extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);\n        }\n        break;\n      case \"Map\":\n        if (pattern.pattern.pattern.variant === \"Constraints\") {\n          for (const [keyPattern, valuePattern] of pattern.pattern.pattern.constraints) {\n            extractCaptures(keyPattern, matchPath, captures);\n            extractCaptures(valuePattern, matchPath, captures);\n          }\n        }\n        break;\n      case \"Tagged\":\n        if (pattern.pattern.pattern.variant !== \"Any\") {\n          extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);\n        }\n        break;\n    }\n  }\n};\n\n/**\n * Returns paths with captures for all matching values in the tree.\n */\nexport const searchPatternPathsWithCaptures = (\n  pattern: SearchPattern,\n  haystack: Cbor,\n): SearchWithCaptures => {\n  const results: Path[] = [];\n  const captures = new Map<string, Path[]>();\n\n  const collectCapture = (p: Pattern, _h: Cbor, path: Cbor[]): void => {\n    extractCaptures(p, path, captures);\n  };\n\n  searchRecursiveWithCaptures(pattern.pattern, haystack, [], results, captures, collectCapture);\n\n  return { paths: results, captures };\n};\n\n/**\n * Formats a SearchPattern as a string.\n */\nexport const searchPatternDisplay = (\n  pattern: SearchPattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  return `search(${patternDisplay(pattern.pattern)})`;\n};\n","/**\n * Sequence pattern for dCBOR pattern matching.\n * Matches a sequence of patterns in order.\n *\n * @module pattern/meta/sequence-pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport type { Pattern } from \"../index\";\n\n/**\n * A pattern that matches a sequence of patterns in order.\n * Used primarily for matching array elements.\n */\nexport interface SequencePattern {\n  readonly variant: \"Sequence\";\n  readonly patterns: Pattern[];\n}\n\n/**\n * Creates a SequencePattern with the given patterns.\n */\nexport const sequencePattern = (patterns: Pattern[]): SequencePattern => ({\n  variant: \"Sequence\",\n  patterns,\n});\n\n/**\n * Tests if a CBOR value matches this sequence pattern.\n *\n * Note: Sequence patterns are used within array patterns for matching\n * consecutive elements. When used standalone (not within an array),\n * they return false/empty as the actual sequence matching logic is\n * handled by the VM and array pattern matching.\n */\nexport const sequencePatternMatches = (_pattern: SequencePattern, _haystack: Cbor): boolean => {\n  // Sequence patterns are meant for array element matching.\n  // When used standalone, they don't match any single CBOR value.\n  // The VM handles actual sequence matching within arrays.\n  return false;\n};\n\n/**\n * Returns paths to matching values.\n *\n * Note: Sequence patterns return empty paths when used directly.\n * The actual sequence matching is handled by the VM within array contexts.\n */\nexport const sequencePatternPaths = (_pattern: SequencePattern, _haystack: Cbor): Path[] => {\n  // Sequence patterns return empty paths when used directly.\n  // This matches Rust behavior where sequence matching is VM-based.\n  return [];\n};\n\n/**\n * Formats a SequencePattern as a string.\n */\nexport const sequencePatternDisplay = (\n  pattern: SequencePattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  const parts = pattern.patterns.map(patternDisplay);\n  return parts.join(\", \");\n};\n\n/**\n * Gets the patterns in this sequence.\n */\nexport const sequencePatternPatterns = (pattern: SequencePattern): Pattern[] => {\n  return pattern.patterns;\n};\n","/**\n * Meta patterns for dCBOR pattern matching.\n *\n * @module pattern/meta\n */\n\nexport * from \"./any-pattern\";\nexport * from \"./and-pattern\";\nexport * from \"./or-pattern\";\nexport * from \"./not-pattern\";\nexport * from \"./repeat-pattern\";\nexport * from \"./capture-pattern\";\nexport * from \"./search-pattern\";\nexport * from \"./sequence-pattern\";\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../../format\";\nimport type { Pattern } from \"../index\";\n\nimport { type AnyPattern, anyPatternPaths, anyPatternDisplay } from \"./any-pattern\";\nimport { type AndPattern, andPatternPaths, andPatternDisplay } from \"./and-pattern\";\nimport { type OrPattern, orPatternPaths, orPatternDisplay } from \"./or-pattern\";\nimport { type NotPattern, notPatternPaths, notPatternDisplay } from \"./not-pattern\";\nimport { type RepeatPattern, repeatPatternPaths, repeatPatternDisplay } from \"./repeat-pattern\";\nimport { type CapturePattern, capturePatternPaths, capturePatternDisplay } from \"./capture-pattern\";\nimport { type SearchPattern, searchPatternPaths, searchPatternDisplay } from \"./search-pattern\";\nimport {\n  type SequencePattern,\n  sequencePatternPaths,\n  sequencePatternDisplay,\n} from \"./sequence-pattern\";\n\n/**\n * Union of all meta pattern types.\n */\nexport type MetaPattern =\n  | { readonly type: \"Any\"; readonly pattern: AnyPattern }\n  | { readonly type: \"And\"; readonly pattern: AndPattern }\n  | { readonly type: \"Or\"; readonly pattern: OrPattern }\n  | { readonly type: \"Not\"; readonly pattern: NotPattern }\n  | { readonly type: \"Repeat\"; readonly pattern: RepeatPattern }\n  | { readonly type: \"Capture\"; readonly pattern: CapturePattern }\n  | { readonly type: \"Search\"; readonly pattern: SearchPattern }\n  | { readonly type: \"Sequence\"; readonly pattern: SequencePattern };\n\n/**\n * Returns paths to matching values for a MetaPattern.\n */\nexport const metaPatternPaths = (pattern: MetaPattern, haystack: Cbor): Path[] => {\n  switch (pattern.type) {\n    case \"Any\":\n      return anyPatternPaths(pattern.pattern, haystack);\n    case \"And\":\n      return andPatternPaths(pattern.pattern, haystack);\n    case \"Or\":\n      return orPatternPaths(pattern.pattern, haystack);\n    case \"Not\":\n      return notPatternPaths(pattern.pattern, haystack);\n    case \"Repeat\":\n      return repeatPatternPaths(pattern.pattern, haystack);\n    case \"Capture\":\n      return capturePatternPaths(pattern.pattern, haystack);\n    case \"Search\":\n      return searchPatternPaths(pattern.pattern, haystack);\n    case \"Sequence\":\n      return sequencePatternPaths(pattern.pattern, haystack);\n  }\n};\n\n/**\n * Tests if a CBOR value matches a MetaPattern.\n */\nexport const metaPatternMatches = (pattern: MetaPattern, haystack: Cbor): boolean => {\n  return metaPatternPaths(pattern, haystack).length > 0;\n};\n\n/**\n * Formats a MetaPattern as a string.\n */\nexport const metaPatternDisplay = (\n  pattern: MetaPattern,\n  patternDisplay: (p: Pattern) => string,\n): string => {\n  switch (pattern.type) {\n    case \"Any\":\n      return anyPatternDisplay(pattern.pattern);\n    case \"And\":\n      return andPatternDisplay(pattern.pattern, patternDisplay);\n    case \"Or\":\n      return orPatternDisplay(pattern.pattern, patternDisplay);\n    case \"Not\":\n      return notPatternDisplay(pattern.pattern, patternDisplay);\n    case \"Repeat\":\n      return repeatPatternDisplay(pattern.pattern, patternDisplay);\n    case \"Capture\":\n      return capturePatternDisplay(pattern.pattern, patternDisplay);\n    case \"Search\":\n      return searchPatternDisplay(pattern.pattern, patternDisplay);\n    case \"Sequence\":\n      return sequencePatternDisplay(pattern.pattern, patternDisplay);\n  }\n};\n\n// Convenience constructors for MetaPattern\n\n/**\n * Creates an Any MetaPattern.\n */\nexport const metaAny = (pattern: AnyPattern): MetaPattern => ({\n  type: \"Any\",\n  pattern,\n});\n\n/**\n * Creates an And MetaPattern.\n */\nexport const metaAnd = (pattern: AndPattern): MetaPattern => ({\n  type: \"And\",\n  pattern,\n});\n\n/**\n * Creates an Or MetaPattern.\n */\nexport const metaOr = (pattern: OrPattern): MetaPattern => ({\n  type: \"Or\",\n  pattern,\n});\n\n/**\n * Creates a Not MetaPattern.\n */\nexport const metaNot = (pattern: NotPattern): MetaPattern => ({\n  type: \"Not\",\n  pattern,\n});\n\n/**\n * Creates a Repeat MetaPattern.\n */\nexport const metaRepeat = (pattern: RepeatPattern): MetaPattern => ({\n  type: \"Repeat\",\n  pattern,\n});\n\n/**\n * Creates a Capture MetaPattern.\n */\nexport const metaCapture = (pattern: CapturePattern): MetaPattern => ({\n  type: \"Capture\",\n  pattern,\n});\n\n/**\n * Creates a Search MetaPattern.\n */\nexport const metaSearch = (pattern: SearchPattern): MetaPattern => ({\n  type: \"Search\",\n  pattern,\n});\n\n/**\n * Creates a Sequence MetaPattern.\n */\nexport const metaSequence = (pattern: SequencePattern): MetaPattern => ({\n  type: \"Sequence\",\n  pattern,\n});\n","/**\n * Tiny Thompson-style VM for walking dCBOR trees.\n *\n * The VM runs byte-code produced by Pattern compile methods.\n *\n * @module pattern/vm\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport {\n  isArray,\n  isMap,\n  isTagged,\n  arrayLength,\n  arrayItem,\n  mapKeys,\n  mapValue,\n  tagContent,\n} from \"@bcts/dcbor\";\nimport type { Path } from \"../format\";\nimport type { Pattern } from \"./index\";\nimport type { Quantifier } from \"../quantifier\";\nimport { Reluctance } from \"../reluctance\";\nimport { getPatternPaths, getPatternPathsWithCapturesDirect } from \"./match-registry\";\nimport {\n  searchPatternPathsWithCaptures,\n  searchPattern as createSearchPattern,\n} from \"./meta/search-pattern\";\n\n/**\n * Navigation axis for traversing dCBOR tree structures.\n */\nexport type Axis = \"ArrayElement\" | \"MapKey\" | \"MapValue\" | \"TaggedContent\";\n\n/**\n * Return child CBOR values reachable from `cbor` via the given axis.\n */\nexport const axisChildren = (axis: Axis, cbor: Cbor): Cbor[] => {\n  switch (axis) {\n    case \"ArrayElement\": {\n      if (!isArray(cbor)) return [];\n      const len = arrayLength(cbor);\n      if (len === undefined) return [];\n      const children: Cbor[] = [];\n      for (let i = 0; i < len; i++) {\n        const item = arrayItem(cbor, i);\n        if (item !== undefined) {\n          children.push(item);\n        }\n      }\n      return children;\n    }\n    case \"MapKey\": {\n      if (!isMap(cbor)) return [];\n      const keys = mapKeys(cbor);\n      if (keys === undefined || keys === null) return [];\n      return keys;\n    }\n    case \"MapValue\": {\n      if (!isMap(cbor)) return [];\n      const keys = mapKeys(cbor);\n      if (keys === undefined || keys === null) return [];\n      const values: Cbor[] = [];\n      for (const key of keys) {\n        const value = mapValue(cbor, key);\n        if (value !== undefined && value !== null) {\n          values.push(value as Cbor);\n        }\n      }\n      return values;\n    }\n    case \"TaggedContent\": {\n      if (!isTagged(cbor)) return [];\n      const content = tagContent(cbor);\n      if (content === undefined) return [];\n      return [content];\n    }\n  }\n};\n\n/**\n * Bytecode instructions for the pattern VM.\n */\nexport type Instr =\n  | { type: \"MatchPredicate\"; literalIndex: number }\n  | { type: \"MatchStructure\"; literalIndex: number }\n  | { type: \"Split\"; a: number; b: number }\n  | { type: \"Jump\"; address: number }\n  | { type: \"PushAxis\"; axis: Axis }\n  | { type: \"Pop\" }\n  | { type: \"Save\" }\n  | { type: \"Accept\" }\n  | {\n      type: \"Search\";\n      patternIndex: number;\n      captureMap: [string, number][];\n    }\n  | { type: \"ExtendSequence\" }\n  | { type: \"CombineSequence\" }\n  | { type: \"NotMatch\"; patternIndex: number }\n  | { type: \"Repeat\"; patternIndex: number; quantifier: Quantifier }\n  | { type: \"CaptureStart\"; captureIndex: number }\n  | { type: \"CaptureEnd\"; captureIndex: number };\n\n/**\n * A compiled pattern program.\n */\nexport interface Program {\n  code: Instr[];\n  literals: Pattern[];\n  captureNames: string[];\n}\n\n/**\n * Internal back-tracking state.\n */\ninterface Thread {\n  pc: number;\n  cbor: Cbor;\n  path: Path;\n  savedPaths: Path[];\n  captures: Path[][];\n  captureStack: number[][];\n}\n\n/**\n * Compares two CBOR values for equality by their serialized form.\n */\nconst cborEquals = (a: Cbor, b: Cbor): boolean => {\n  // Simple reference equality check first\n  if (a === b) return true;\n\n  // Compare by JSON representation (simplified)\n  try {\n    return JSON.stringify(a) === JSON.stringify(b);\n  } catch {\n    return false;\n  }\n};\n\n/**\n * Hash a path for deduplication.\n * Uses CBOR diagnostic notation for proper serialization.\n */\nconst pathHash = (path: Path): string => {\n  // Use toDiagnostic for proper CBOR serialization\n  return path\n    .map((item) => (typeof item.toDiagnostic === \"function\" ? item.toDiagnostic() : String(item)))\n    .join(\"|\");\n};\n\n/**\n * Match atomic patterns without recursion into the VM.\n *\n * This function handles only the patterns that are safe to use in\n * MatchPredicate instructions.\n */\nexport const atomicPaths = (pattern: Pattern, cbor: Cbor): Path[] => {\n  switch (pattern.kind) {\n    case \"Value\":\n    case \"Structure\":\n      return getPatternPaths(pattern, cbor);\n    case \"Meta\":\n      if (pattern.pattern.type === \"Any\") {\n        return [[cbor]];\n      }\n      throw new Error(`Non-atomic meta pattern used in MatchPredicate: ${pattern.pattern.type}`);\n  }\n};\n\n/**\n * Compute repeat paths based on pattern, quantifier, and starting state.\n */\nconst repeatPaths = (\n  pattern: Pattern,\n  cbor: Cbor,\n  path: Path,\n  quantifier: Quantifier,\n): { cbor: Cbor; path: Path }[] => {\n  // Build states for all possible repetition counts\n  const states: { cbor: Cbor; path: Path }[][] = [[{ cbor, path: [...path] }]];\n  const bound = quantifier.max() ?? Number.MAX_SAFE_INTEGER;\n\n  // Try matching the pattern repeatedly\n  for (let rep = 0; rep < bound; rep++) {\n    const next: { cbor: Cbor; path: Path }[] = [];\n    const lastState = states[states.length - 1];\n\n    for (const state of lastState) {\n      const subPaths = getPatternPaths(pattern, state.cbor);\n\n      for (const subPath of subPaths) {\n        const last = subPath[subPath.length - 1];\n        if (last === undefined) continue;\n\n        // Avoid infinite loops\n        if (cborEquals(last, state.cbor)) continue;\n\n        const combined = [...state.path];\n        // Skip first element if it's the same as current cbor\n        const firstElement = subPath[0];\n        const startIdx = firstElement !== undefined && cborEquals(firstElement, state.cbor) ? 1 : 0;\n        for (let i = startIdx; i < subPath.length; i++) {\n          combined.push(subPath[i]);\n        }\n        next.push({ cbor: last, path: combined });\n      }\n    }\n\n    if (next.length === 0) break;\n    states.push(next);\n  }\n\n  // Zero repetition case\n  const hasZeroRep = quantifier.min() === 0;\n  const zeroRepResult = hasZeroRep ? [{ cbor, path: [...path] }] : [];\n\n  // Calculate maximum allowed repetitions\n  const maxPossible = states.length - 1;\n  const maxAllowed = Math.min(bound, maxPossible);\n\n  // Check if we can satisfy the minimum repetition requirement\n  if (maxAllowed < quantifier.min() && quantifier.min() > 0) {\n    return [];\n  }\n\n  // Calculate the range of repetition counts\n  const minCount = quantifier.min() === 0 ? 1 : quantifier.min();\n  const maxCount = maxAllowed < minCount ? -1 : maxAllowed;\n\n  if (maxCount < minCount) {\n    return zeroRepResult;\n  }\n\n  // Generate list of counts based on reluctance\n  let counts: number[];\n  const reluctance = quantifier.reluctance();\n\n  if (reluctance === Reluctance.Greedy) {\n    counts = [];\n    for (let i = maxCount; i >= minCount; i--) {\n      counts.push(i);\n    }\n  } else if (reluctance === Reluctance.Lazy) {\n    counts = [];\n    for (let i = minCount; i <= maxCount; i++) {\n      counts.push(i);\n    }\n  } else {\n    // Possessive\n    counts = maxCount >= minCount ? [maxCount] : [];\n  }\n\n  // Collect results\n  const out: { cbor: Cbor; path: Path }[] = [];\n\n  if (reluctance === Reluctance.Greedy) {\n    for (const c of counts) {\n      const list = states[c];\n      if (list !== undefined) {\n        out.push(...list);\n      }\n    }\n    if (hasZeroRep && out.length === 0) {\n      out.push({ cbor, path: [...path] });\n    }\n  } else {\n    if (hasZeroRep) {\n      out.push({ cbor, path: [...path] });\n    }\n    for (const c of counts) {\n      const list = states[c];\n      if (list !== undefined) {\n        out.push(...list);\n      }\n    }\n  }\n\n  return out;\n};\n\n/**\n * Execute a single thread until it halts.\n */\nconst runThread = (\n  prog: Program,\n  start: Thread,\n  out: { path: Path; captures: Path[][] }[],\n): boolean => {\n  let produced = false;\n  const stack: Thread[] = [start];\n\n  while (stack.length > 0) {\n    const th = stack.pop();\n    if (th === undefined) break;\n\n    threadLoop: while (true) {\n      const instr = prog.code[th.pc];\n\n      switch (instr.type) {\n        case \"MatchPredicate\": {\n          const paths = atomicPaths(prog.literals[instr.literalIndex], th.cbor);\n          if (paths.length === 0) {\n            break threadLoop;\n          }\n          th.pc += 1;\n          break;\n        }\n\n        case \"MatchStructure\": {\n          const pattern = prog.literals[instr.literalIndex];\n          if (pattern.kind !== \"Structure\") {\n            throw new Error(\"MatchStructure used with non-structure pattern\");\n          }\n\n          const result = getPatternPathsWithCapturesDirect(pattern, th.cbor);\n          if (result.paths.length === 0) {\n            break threadLoop;\n          }\n\n          // Merge structure captures into thread captures\n          for (let i = 0; i < prog.captureNames.length; i++) {\n            const name = prog.captureNames[i];\n            const capturedPaths = result.captures.get(name);\n            if (capturedPaths !== undefined) {\n              while (th.captures.length <= i) {\n                th.captures.push([]);\n              }\n              th.captures[i].push(...capturedPaths);\n            }\n          }\n\n          // Handle structure paths\n          if (result.paths.length === 1 && result.paths[0].length === 1) {\n            th.pc += 1;\n          } else {\n            for (const structurePath of result.paths) {\n              const target = structurePath[structurePath.length - 1];\n              if (target !== undefined) {\n                const newThread: Thread = {\n                  pc: th.pc + 1,\n                  cbor: target,\n                  path: [...th.path, ...structurePath.slice(1)],\n                  savedPaths: [...th.savedPaths],\n                  captures: th.captures.map((c) => [...c]),\n                  captureStack: th.captureStack.map((s) => [...s]),\n                };\n                stack.push(newThread);\n              }\n            }\n            break threadLoop;\n          }\n          break;\n        }\n\n        case \"Split\": {\n          const th2: Thread = {\n            pc: instr.b,\n            cbor: th.cbor,\n            path: [...th.path],\n            savedPaths: [...th.savedPaths],\n            captures: th.captures.map((c) => [...c]),\n            captureStack: th.captureStack.map((s) => [...s]),\n          };\n          stack.push(th2);\n          th.pc = instr.a;\n          break;\n        }\n\n        case \"Jump\": {\n          th.pc = instr.address;\n          break;\n        }\n\n        case \"PushAxis\": {\n          const children = axisChildren(instr.axis, th.cbor);\n          for (const child of children) {\n            const newThread: Thread = {\n              pc: th.pc + 1,\n              cbor: child,\n              path: [...th.path, child],\n              savedPaths: [...th.savedPaths],\n              captures: th.captures.map((c) => [...c]),\n              captureStack: th.captureStack.map((s) => [...s]),\n            };\n            stack.push(newThread);\n          }\n          break threadLoop;\n        }\n\n        case \"Pop\": {\n          if (th.path.length === 0) {\n            break threadLoop;\n          }\n          th.path.pop();\n          const parent = th.path[th.path.length - 1];\n          if (parent !== undefined) {\n            th.cbor = parent;\n          }\n          th.pc += 1;\n          break;\n        }\n\n        case \"Save\": {\n          out.push({ path: [...th.path], captures: th.captures.map((c) => [...c]) });\n          produced = true;\n          th.pc += 1;\n          break;\n        }\n\n        case \"Accept\": {\n          out.push({ path: [...th.path], captures: th.captures.map((c) => [...c]) });\n          produced = true;\n          break threadLoop;\n        }\n\n        case \"Search\": {\n          // Create a SearchPattern wrapper for the inner pattern\n          const innerPattern = prog.literals[instr.patternIndex];\n          const searchPat = createSearchPattern(innerPattern);\n\n          // Use recursive search with captures\n          const result = searchPatternPathsWithCaptures(searchPat, th.cbor);\n\n          for (const searchPath of result.paths) {\n            const newThread: Thread = {\n              pc: th.pc + 1,\n              cbor: th.cbor,\n              path: searchPath,\n              savedPaths: [...th.savedPaths],\n              captures: th.captures.map((c) => [...c]),\n              captureStack: th.captureStack.map((s) => [...s]),\n            };\n\n            // Apply capture mappings\n            for (const [name, captureIdx] of instr.captureMap) {\n              if (captureIdx < newThread.captures.length) {\n                const capturePaths = result.captures.get(name);\n                if (capturePaths !== undefined) {\n                  for (const capturePath of capturePaths) {\n                    newThread.captures[captureIdx].push(capturePath);\n                  }\n                }\n              }\n            }\n\n            stack.push(newThread);\n          }\n          break threadLoop;\n        }\n\n        case \"ExtendSequence\": {\n          th.savedPaths.push([...th.path]);\n          const last = th.path[th.path.length - 1];\n          if (last !== undefined) {\n            th.path = [last];\n            th.cbor = last;\n          }\n          th.pc += 1;\n          break;\n        }\n\n        case \"CombineSequence\": {\n          const saved = th.savedPaths.pop();\n          if (saved !== undefined) {\n            const combined = [...saved];\n            if (th.path.length > 1) {\n              combined.push(...th.path.slice(1));\n            }\n            th.path = combined;\n          }\n          th.pc += 1;\n          break;\n        }\n\n        case \"NotMatch\": {\n          const paths = getPatternPaths(prog.literals[instr.patternIndex], th.cbor);\n          if (paths.length > 0) {\n            break threadLoop; // Pattern matched, so NOT fails\n          }\n          th.pc += 1;\n          break;\n        }\n\n        case \"Repeat\": {\n          const results = repeatPaths(\n            prog.literals[instr.patternIndex],\n            th.cbor,\n            th.path,\n            instr.quantifier,\n          );\n\n          for (const result of results) {\n            const newThread: Thread = {\n              pc: th.pc + 1,\n              cbor: result.cbor,\n              path: result.path,\n              savedPaths: [...th.savedPaths],\n              captures: th.captures.map((c) => [...c]),\n              captureStack: th.captureStack.map((s) => [...s]),\n            };\n            stack.push(newThread);\n          }\n          break threadLoop;\n        }\n\n        case \"CaptureStart\": {\n          const idx = instr.captureIndex;\n          while (th.captures.length <= idx) {\n            th.captures.push([]);\n          }\n          while (th.captureStack.length <= idx) {\n            th.captureStack.push([]);\n          }\n          th.captureStack[idx].push(th.path.length);\n          th.pc += 1;\n          break;\n        }\n\n        case \"CaptureEnd\": {\n          const idx = instr.captureIndex;\n          const stack = th.captureStack[idx];\n          if (stack !== undefined && stack.length > 0) {\n            stack.pop();\n            const capturedPath = [...th.path];\n            const captureArray = th.captures[idx];\n            if (captureArray !== undefined) {\n              captureArray.push(capturedPath);\n            }\n          }\n          th.pc += 1;\n          break;\n        }\n      }\n    }\n  }\n\n  return produced;\n};\n\n/**\n * Execute a program against a dCBOR value, returning all matching paths and captures.\n */\nexport const run = (\n  prog: Program,\n  root: Cbor,\n): { paths: Path[]; captures: Map<string, Path[]> } => {\n  // Initialize captures array with one empty array per capture name\n  const initialCaptures: Path[][] = prog.captureNames.map(() => []);\n\n  const start: Thread = {\n    pc: 0,\n    cbor: root,\n    path: [root],\n    savedPaths: [],\n    captures: initialCaptures,\n    captureStack: [],\n  };\n\n  const results: { path: Path; captures: Path[][] }[] = [];\n  runThread(prog, start, results);\n\n  // Deduplicate paths while preserving original order\n  const seenPaths = new Set<string>();\n  const paths: Path[] = [];\n\n  for (const result of results) {\n    const hash = pathHash(result.path);\n    if (!seenPaths.has(hash)) {\n      seenPaths.add(hash);\n      paths.push(result.path);\n    }\n  }\n\n  // Build capture map from capture names and results\n  const captures = new Map<string, Path[]>();\n\n  for (let i = 0; i < prog.captureNames.length; i++) {\n    const name = prog.captureNames[i];\n    const capturedPaths: Path[] = [];\n\n    for (const result of results) {\n      const captureGroup = result.captures[i];\n      if (captureGroup !== undefined) {\n        capturedPaths.push(...captureGroup);\n      }\n    }\n\n    // Deduplicate captured paths\n    if (capturedPaths.length > 0) {\n      const seenCapturePaths = new Set<string>();\n      const deduplicated: Path[] = [];\n\n      for (const path of capturedPaths) {\n        const hash = pathHash(path);\n        if (!seenCapturePaths.has(hash)) {\n          seenCapturePaths.add(hash);\n          deduplicated.push(path);\n        }\n      }\n\n      captures.set(name, deduplicated);\n    }\n  }\n\n  return { paths, captures };\n};\n\n/**\n * VM for executing pattern programs against dCBOR values.\n */\nexport class Vm {\n  /**\n   * Execute a program against a dCBOR value.\n   */\n  static run(prog: Program, root: Cbor): { paths: Path[]; captures: Map<string, Path[]> } {\n    return run(prog, root);\n  }\n}\n","/**\n * Matcher interface for dCBOR pattern matching.\n *\n * @module pattern/matcher\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../format\";\nimport type { Instr, Program } from \"./vm\";\nimport type { Pattern } from \"./index\";\nimport type { StructurePattern } from \"./structure\";\nimport type { MetaPattern } from \"./meta\";\n\n/**\n * Result of pattern matching with captures.\n */\nexport interface MatchWithCaptures {\n  readonly paths: Path[];\n  readonly captures: Map<string, Path[]>;\n}\n\n/**\n * Interface for objects that can match against CBOR values.\n *\n * This interface defines the contract for all pattern types in the system.\n * Implementations handle matching, path collection, and VM bytecode compilation.\n */\nexport interface Matcher {\n  /**\n   * Return all matching paths along with any named captures.\n   *\n   * @param haystack - The CBOR value to match against\n   * @returns A tuple of paths and captures map\n   */\n  pathsWithCaptures(haystack: Cbor): MatchWithCaptures;\n\n  /**\n   * Return only the matching paths, discarding any captures.\n   *\n   * @param haystack - The CBOR value to match against\n   * @returns Array of paths to matching elements\n   */\n  paths(haystack: Cbor): Path[];\n\n  /**\n   * Check if the pattern matches the given CBOR value.\n   *\n   * @param haystack - The CBOR value to test\n   * @returns true if the pattern matches\n   */\n  matches(haystack: Cbor): boolean;\n\n  /**\n   * Compile this pattern into VM bytecode.\n   *\n   * @param code - The instruction array to append to\n   * @param literals - The literals array to append to\n   * @param captures - The capture names array\n   */\n  compile(code: Instr[], literals: Pattern[], captures: string[]): void;\n\n  /**\n   * Recursively collect all capture names from this pattern.\n   *\n   * @param names - The array to collect names into\n   */\n  collectCaptureNames(names: string[]): void;\n\n  /**\n   * Check if the pattern display is \"complex\" (requires parentheses).\n   *\n   * @returns true if the pattern requires grouping\n   */\n  isComplex(): boolean;\n\n  /**\n   * Format the pattern as a string.\n   */\n  toString(): string;\n}\n\n/**\n * Default implementation helpers for Matcher.\n */\nexport const MatcherDefaults = {\n  /**\n   * Default paths implementation using pathsWithCaptures.\n   */\n  paths(matcher: Pick<Matcher, \"pathsWithCaptures\">, haystack: Cbor): Path[] {\n    return matcher.pathsWithCaptures(haystack).paths;\n  },\n\n  /**\n   * Default matches implementation using paths.\n   */\n  matches(matcher: Pick<Matcher, \"paths\">, haystack: Cbor): boolean {\n    return matcher.paths(haystack).length > 0;\n  },\n\n  /**\n   * Default pathsWithCaptures throws not implemented.\n   */\n  pathsWithCaptures(_haystack: Cbor): MatchWithCaptures {\n    throw new Error(\"pathsWithCaptures not implemented\");\n  },\n\n  /**\n   * Default compile throws not implemented.\n   */\n  compile(_code: Instr[], _literals: Pattern[], _captures: string[]): void {\n    throw new Error(\"compile not implemented\");\n  },\n\n  /**\n   * Default collectCaptureNames does nothing.\n   */\n  collectCaptureNames(_names: string[]): void {\n    // Default implementation does nothing\n  },\n\n  /**\n   * Default isComplex returns false.\n   */\n  isComplex(): boolean {\n    return false;\n  },\n};\n\n/**\n * Compiles a pattern into a VM program.\n *\n * @param pattern - The pattern to compile\n * @returns A compiled program ready for execution\n */\nexport const compilePattern = (pattern: Pattern): Program => {\n  const code: Instr[] = [];\n  const literals: Pattern[] = [];\n  const captureNames: string[] = [];\n\n  // Collect all capture names first\n  collectPatternCaptureNames(pattern, captureNames);\n\n  // Compile the pattern\n  compilePatternToCode(pattern, code, literals, captureNames);\n\n  // Add final Accept instruction\n  code.push({ type: \"Accept\" });\n\n  return {\n    code,\n    literals,\n    captureNames,\n  };\n};\n\n/**\n * Recursively collects capture names from a pattern.\n */\nconst collectPatternCaptureNames = (pattern: Pattern, names: string[]): void => {\n  switch (pattern.kind) {\n    case \"Value\":\n      // Value patterns don't have captures\n      break;\n    case \"Structure\":\n      // Structure patterns may have element patterns with captures\n      collectStructurePatternCaptureNames(pattern.pattern, names);\n      break;\n    case \"Meta\":\n      collectMetaPatternCaptureNames(pattern.pattern, names);\n      break;\n  }\n};\n\n/**\n * Collects capture names from structure patterns.\n */\nconst collectStructurePatternCaptureNames = (pattern: StructurePattern, names: string[]): void => {\n  switch (pattern.type) {\n    case \"Array\":\n      if (pattern.pattern.variant === \"Elements\") {\n        collectPatternCaptureNames(pattern.pattern.pattern, names);\n      }\n      break;\n    case \"Map\":\n      if (pattern.pattern.variant === \"Constraints\") {\n        for (const constraint of pattern.pattern.constraints) {\n          // Constraints are tuples: [keyPattern, valuePattern]\n          collectPatternCaptureNames(constraint[0], names);\n          collectPatternCaptureNames(constraint[1], names);\n        }\n      }\n      break;\n    case \"Tagged\":\n      // Tagged patterns (Tag, Name, Regex variants) have a `pattern` property\n      if (pattern.pattern.variant !== \"Any\") {\n        collectPatternCaptureNames(pattern.pattern.pattern, names);\n      }\n      break;\n  }\n};\n\n/**\n * Collects capture names from meta patterns.\n */\nconst collectMetaPatternCaptureNames = (pattern: MetaPattern, names: string[]): void => {\n  switch (pattern.type) {\n    case \"Capture\":\n      if (!names.includes(pattern.pattern.name)) {\n        names.push(pattern.pattern.name);\n      }\n      collectPatternCaptureNames(pattern.pattern.pattern, names);\n      break;\n    case \"And\":\n      for (const p of pattern.pattern.patterns) {\n        collectPatternCaptureNames(p, names);\n      }\n      break;\n    case \"Or\":\n      for (const p of pattern.pattern.patterns) {\n        collectPatternCaptureNames(p, names);\n      }\n      break;\n    case \"Not\":\n      collectPatternCaptureNames(pattern.pattern.pattern, names);\n      break;\n    case \"Repeat\":\n      collectPatternCaptureNames(pattern.pattern.pattern, names);\n      break;\n    case \"Search\":\n      collectPatternCaptureNames(pattern.pattern.pattern, names);\n      break;\n    case \"Sequence\":\n      for (const p of pattern.pattern.patterns) {\n        collectPatternCaptureNames(p, names);\n      }\n      break;\n    case \"Any\":\n      // Any patterns don't have captures\n      break;\n  }\n};\n\n/**\n * Compiles a pattern to VM bytecode.\n */\nconst compilePatternToCode = (\n  pattern: Pattern,\n  code: Instr[],\n  literals: Pattern[],\n  captureNames: string[],\n): void => {\n  switch (pattern.kind) {\n    case \"Value\":\n      // Value patterns use MatchPredicate\n      literals.push(pattern);\n      code.push({ type: \"MatchPredicate\", literalIndex: literals.length - 1 });\n      break;\n    case \"Structure\":\n      // Structure patterns use MatchStructure\n      literals.push(pattern);\n      code.push({ type: \"MatchStructure\", literalIndex: literals.length - 1 });\n      break;\n    case \"Meta\":\n      compileMetaPattern(pattern.pattern, code, literals, captureNames);\n      break;\n  }\n};\n\n/**\n * Compiles meta patterns to VM bytecode.\n */\nconst compileMetaPattern = (\n  pattern: MetaPattern,\n  code: Instr[],\n  literals: Pattern[],\n  captureNames: string[],\n): void => {\n  switch (pattern.type) {\n    case \"Any\":\n      // Any matches everything - compile as predicate\n      literals.push({ kind: \"Meta\", pattern });\n      code.push({ type: \"MatchPredicate\", literalIndex: literals.length - 1 });\n      break;\n\n    case \"And\": {\n      // All patterns must match\n      for (const p of pattern.pattern.patterns) {\n        compilePatternToCode(p, code, literals, captureNames);\n      }\n      break;\n    }\n\n    case \"Or\": {\n      // Use splits to try each alternative\n      const patterns = pattern.pattern.patterns;\n      if (patterns.length === 0) break;\n      if (patterns.length === 1) {\n        compilePatternToCode(patterns[0], code, literals, captureNames);\n        break;\n      }\n\n      // Create split chain for alternatives\n      const jumpAddrs: number[] = [];\n      for (let i = 0; i < patterns.length - 1; i++) {\n        const splitAddr = code.length;\n        code.push({ type: \"Split\", a: 0, b: 0 }); // Placeholder\n\n        // First alternative starts right after split\n        (code[splitAddr] as { type: \"Split\"; a: number; b: number }).a = code.length;\n        compilePatternToCode(patterns[i], code, literals, captureNames);\n        jumpAddrs.push(code.length);\n        code.push({ type: \"Jump\", address: 0 }); // Jump to end, placeholder\n\n        // Second alternative address\n        (code[splitAddr] as { type: \"Split\"; a: number; b: number }).b = code.length;\n      }\n      // Last pattern\n      compilePatternToCode(patterns[patterns.length - 1], code, literals, captureNames);\n\n      // Fix up jump addresses\n      const endAddr = code.length;\n      for (const addr of jumpAddrs) {\n        (code[addr] as { type: \"Jump\"; address: number }).address = endAddr;\n      }\n      break;\n    }\n\n    case \"Not\": {\n      // Store the inner pattern and use NotMatch instruction\n      literals.push(pattern.pattern.pattern);\n      code.push({ type: \"NotMatch\", patternIndex: literals.length - 1 });\n      break;\n    }\n\n    case \"Repeat\": {\n      literals.push(pattern.pattern.pattern);\n      code.push({\n        type: \"Repeat\",\n        patternIndex: literals.length - 1,\n        quantifier: pattern.pattern.quantifier,\n      });\n      break;\n    }\n\n    case \"Capture\": {\n      const captureIndex = captureNames.indexOf(pattern.pattern.name);\n      code.push({ type: \"CaptureStart\", captureIndex });\n      compilePatternToCode(pattern.pattern.pattern, code, literals, captureNames);\n      code.push({ type: \"CaptureEnd\", captureIndex });\n      break;\n    }\n\n    case \"Search\": {\n      // Build capture map for the search pattern\n      const captureMap: [string, number][] = [];\n      const innerNames: string[] = [];\n      collectPatternCaptureNames(pattern.pattern.pattern, innerNames);\n      for (const name of innerNames) {\n        const idx = captureNames.indexOf(name);\n        if (idx >= 0) {\n          captureMap.push([name, idx]);\n        }\n      }\n\n      literals.push(pattern.pattern.pattern);\n      code.push({\n        type: \"Search\",\n        patternIndex: literals.length - 1,\n        captureMap,\n      });\n      break;\n    }\n\n    case \"Sequence\": {\n      const patterns = pattern.pattern.patterns;\n      if (patterns.length === 0) break;\n\n      compilePatternToCode(patterns[0], code, literals, captureNames);\n\n      for (let i = 1; i < patterns.length; i++) {\n        code.push({ type: \"ExtendSequence\" });\n        compilePatternToCode(patterns[i], code, literals, captureNames);\n        code.push({ type: \"CombineSequence\" });\n      }\n      break;\n    }\n  }\n};\n","/**\n * Pattern types for dCBOR pattern matching.\n *\n * This module provides the core Pattern type and its variants for\n * matching dCBOR values.\n *\n * @module pattern\n */\n\nimport type { Cbor } from \"@bcts/dcbor\";\nimport type { Path } from \"../format\";\nimport {\n  setMatchFn,\n  setPathsFn,\n  setPathsWithCapturesFn,\n  setPathsWithCapturesDirectFn,\n} from \"./match-registry\";\n\n// Re-export sub-modules\nexport * from \"./value\";\nexport * from \"./structure\";\nexport * from \"./meta\";\nexport * from \"./vm\";\nexport * from \"./matcher\";\nexport * from \"./match-registry\";\n\nimport { type ValuePattern, valuePatternPaths, valuePatternDisplay } from \"./value\";\nimport {\n  type StructurePattern,\n  structurePatternPaths,\n  structurePatternDisplay,\n  structurePatternPathsWithCaptures,\n} from \"./structure\";\nimport { type MetaPattern, metaPatternPaths, metaPatternDisplay } from \"./meta\";\nimport { compilePattern } from \"./matcher\";\nimport { Vm } from \"./vm\";\n\n/**\n * The main Pattern type - a discriminated union of all pattern variants.\n */\nexport type Pattern =\n  | { readonly kind: \"Value\"; readonly pattern: ValuePattern }\n  | { readonly kind: \"Structure\"; readonly pattern: StructurePattern }\n  | { readonly kind: \"Meta\"; readonly pattern: MetaPattern };\n\n/**\n * Result of pattern matching with captures.\n */\nexport interface MatchResult {\n  readonly paths: Path[];\n  readonly captures: Map<string, Path[]>;\n}\n\n// ============================================================================\n// Pattern Matching Functions\n// ============================================================================\n\n/**\n * Returns paths to matching elements in a CBOR value.\n *\n * @param pattern - The pattern to match\n * @param haystack - The CBOR value to search\n * @returns Array of paths to matching elements\n */\nexport const patternPaths = (pattern: Pattern, haystack: Cbor): Path[] => {\n  switch (pattern.kind) {\n    case \"Value\":\n      return valuePatternPaths(pattern.pattern, haystack);\n    case \"Structure\":\n      return structurePatternPaths(pattern.pattern, haystack);\n    case \"Meta\":\n      return metaPatternPaths(pattern.pattern, haystack);\n  }\n};\n\n/**\n * Tests if a pattern matches a CBOR value.\n *\n * @param pattern - The pattern to match\n * @param haystack - The CBOR value to test\n * @returns true if the pattern matches\n */\nexport const patternMatches = (pattern: Pattern, haystack: Cbor): boolean => {\n  return patternPaths(pattern, haystack).length > 0;\n};\n\n/**\n * Formats a pattern as a string.\n *\n * @param pattern - The pattern to format\n * @returns String representation of the pattern\n */\nexport const patternDisplay = (pattern: Pattern): string => {\n  const displayFn = (p: Pattern): string => patternDisplay(p);\n  switch (pattern.kind) {\n    case \"Value\":\n      return valuePatternDisplay(pattern.pattern);\n    case \"Structure\":\n      return structurePatternDisplay(pattern.pattern, displayFn);\n    case \"Meta\":\n      return metaPatternDisplay(pattern.pattern, displayFn);\n  }\n};\n\n// ============================================================================\n// Convenience Functions (aliases for backwards compatibility)\n// ============================================================================\n\n/**\n * Matches a pattern against a CBOR value and returns all matching paths.\n *\n * @param pattern - The pattern to match\n * @param haystack - The CBOR value to search\n * @returns Array of paths to matching elements\n */\nexport const paths = patternPaths;\n\n/**\n * Checks if a pattern matches a CBOR value.\n *\n * @param pattern - The pattern to match\n * @param haystack - The CBOR value to test\n * @returns true if the pattern matches\n */\nexport const matches = patternMatches;\n\n/**\n * Computes paths with captures directly without using the VM.\n * This is used internally by the VM to avoid infinite recursion.\n *\n * Note: This function delegates capture collection to the pattern's\n * own matching mechanism. The VM has its own capture tracking, so\n * this just returns paths with any captures found during matching.\n *\n * @param pattern - The pattern to match\n * @param haystack - The CBOR value to search\n * @returns Match result with paths and captures\n */\nexport const pathsWithCapturesDirect = (pattern: Pattern, haystack: Cbor): MatchResult => {\n  // For structure patterns, use the specialized function that properly handles captures\n  if (pattern.kind === \"Structure\") {\n    const [paths, captures] = structurePatternPathsWithCaptures(pattern.pattern, haystack);\n    return { paths, captures };\n  }\n\n  // For value patterns, no captures possible\n  if (pattern.kind === \"Value\") {\n    const paths = patternPaths(pattern, haystack);\n    return { paths, captures: new Map() };\n  }\n\n  // For meta patterns, collect captures recursively\n  const paths = patternPaths(pattern, haystack);\n  const captures = new Map<string, Path[]>();\n\n  const collectCaptures = (p: Pattern, h: Cbor): void => {\n    if (p.kind === \"Meta\") {\n      switch (p.pattern.type) {\n        case \"Capture\": {\n          const capturePattern = p.pattern.pattern;\n          const capturedPaths = patternPaths(capturePattern.pattern, h);\n          if (capturedPaths.length > 0) {\n            const existing = captures.get(capturePattern.name) ?? [];\n            captures.set(capturePattern.name, [...existing, ...capturedPaths]);\n          }\n          collectCaptures(capturePattern.pattern, h);\n          break;\n        }\n        case \"And\":\n          for (const inner of p.pattern.pattern.patterns) {\n            collectCaptures(inner, h);\n          }\n          break;\n        case \"Or\":\n          for (const inner of p.pattern.pattern.patterns) {\n            if (patternMatches(inner, h)) {\n              collectCaptures(inner, h);\n              break;\n            }\n          }\n          break;\n        case \"Not\":\n          break;\n        case \"Repeat\":\n          collectCaptures(p.pattern.pattern.pattern, h);\n          break;\n        case \"Sequence\":\n          for (const inner of p.pattern.pattern.patterns) {\n            collectCaptures(inner, h);\n          }\n          break;\n        case \"Search\":\n          collectCaptures(p.pattern.pattern.pattern, h);\n          break;\n        case \"Any\":\n          break;\n      }\n    } else if (p.kind === \"Structure\") {\n      // Delegate to structure-specific function\n      const [_, structureCaptures] = structurePatternPathsWithCaptures(p.pattern, h);\n      for (const [name, capturePaths] of structureCaptures) {\n        const existing = captures.get(name) ?? [];\n        captures.set(name, [...existing, ...capturePaths]);\n      }\n    }\n  };\n\n  if (paths.length > 0) {\n    collectCaptures(pattern, haystack);\n  }\n\n  return { paths, captures };\n};\n\n/**\n * Matches a pattern against a CBOR value and returns paths with captures.\n *\n * @param pattern - The pattern to match\n * @param haystack - The CBOR value to search\n * @returns Match result with paths and captures\n */\nexport const pathsWithCaptures = (pattern: Pattern, haystack: Cbor): MatchResult => {\n  const program = compilePattern(pattern);\n  const result = Vm.run(program, haystack);\n  return result;\n};\n\n/**\n * Alias for pathsWithCaptures for internal VM use.\n */\nexport const patternPathsWithCaptures = pathsWithCaptures;\n\n// ============================================================================\n// Pattern Constructors\n// ============================================================================\n\nimport { boolPatternAny, boolPatternValue } from \"./value/bool-pattern\";\nimport { nullPattern as nullPatternCreate } from \"./value/null-pattern\";\nimport {\n  numberPatternAny,\n  numberPatternValue,\n  numberPatternRange,\n  numberPatternGreaterThan,\n  numberPatternGreaterThanOrEqual,\n  numberPatternLessThan,\n  numberPatternLessThanOrEqual,\n  numberPatternNaN,\n  numberPatternInfinity,\n  numberPatternNegInfinity,\n} from \"./value/number-pattern\";\nimport { textPatternAny, textPatternValue, textPatternRegex } from \"./value/text-pattern\";\nimport {\n  byteStringPatternAny,\n  byteStringPatternValue,\n  byteStringPatternBinaryRegex,\n} from \"./value/bytestring-pattern\";\nimport {\n  datePatternAny,\n  datePatternValue,\n  datePatternRange,\n  datePatternEarliest,\n  datePatternLatest,\n  datePatternStringValue,\n  datePatternRegex,\n} from \"./value/date-pattern\";\nimport {\n  digestPatternAny,\n  digestPatternValue,\n  digestPatternPrefix,\n  digestPatternBinaryRegex,\n} from \"./value/digest-pattern\";\nimport {\n  knownValuePatternAny,\n  knownValuePatternValue,\n  knownValuePatternNamed,\n  knownValuePatternRegex,\n} from \"./value/known-value-pattern\";\n\nimport { arrayPatternAny } from \"./structure/array-pattern\";\nimport { mapPatternAny } from \"./structure/map-pattern\";\nimport {\n  taggedPatternAny,\n  taggedPatternWithTag,\n  taggedPatternWithName,\n  taggedPatternWithRegex,\n} from \"./structure/tagged-pattern\";\n\nimport { anyPattern as anyPatternCreate } from \"./meta/any-pattern\";\nimport { andPattern as andPatternCreate } from \"./meta/and-pattern\";\nimport { orPattern as orPatternCreate } from \"./meta/or-pattern\";\nimport { notPattern as notPatternCreate } from \"./meta/not-pattern\";\nimport { capturePattern as capturePatternCreate } from \"./meta/capture-pattern\";\nimport { searchPattern as searchPatternCreate } from \"./meta/search-pattern\";\nimport { sequencePattern as sequencePatternCreate } from \"./meta/sequence-pattern\";\nimport { repeatPattern as repeatPatternCreate } from \"./meta/repeat-pattern\";\nimport { Quantifier } from \"../quantifier\";\nimport type { Tag } from \"@bcts/dcbor\";\nimport type { CborDate } from \"@bcts/dcbor\";\nimport type { Digest } from \"@bcts/components\";\nimport type { KnownValue } from \"@bcts/known-values\";\n\n/**\n * Creates a pattern that matches any value.\n */\nexport const any = (): Pattern => ({\n  kind: \"Meta\",\n  pattern: { type: \"Any\", pattern: anyPatternCreate() },\n});\n\n/**\n * Creates a pattern that matches any boolean.\n */\nexport const anyBool = (): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Bool\", pattern: boolPatternAny() },\n});\n\n/**\n * Creates a pattern that matches a specific boolean value.\n */\nexport const bool = (value: boolean): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Bool\", pattern: boolPatternValue(value) },\n});\n\n/**\n * Creates a pattern that matches null.\n */\nexport const nullPattern = (): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Null\", pattern: nullPatternCreate() },\n});\n\n/**\n * Creates a pattern that matches any number.\n */\nexport const anyNumber = (): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Number\", pattern: numberPatternAny() },\n});\n\n/**\n * Creates a pattern that matches a specific number.\n */\nexport const number = (value: number): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Number\", pattern: numberPatternValue(value) },\n});\n\n/**\n * Creates a pattern that matches numbers in a range.\n */\nexport const numberRange = (min: number, max: number): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Number\", pattern: numberPatternRange(min, max) },\n});\n\n/**\n * Creates a pattern that matches any text.\n */\nexport const anyText = (): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Text\", pattern: textPatternAny() },\n});\n\n/**\n * Creates a pattern that matches specific text.\n */\nexport const text = (value: string): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Text\", pattern: textPatternValue(value) },\n});\n\n/**\n * Creates a pattern that matches text using a regex.\n */\nexport const textRegex = (pattern: RegExp): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Text\", pattern: textPatternRegex(pattern) },\n});\n\n/**\n * Creates a pattern that matches any byte string.\n */\nexport const anyByteString = (): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"ByteString\", pattern: byteStringPatternAny() },\n});\n\n/**\n * Creates a pattern that matches a specific byte string.\n */\nexport const byteString = (value: Uint8Array): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"ByteString\", pattern: byteStringPatternValue(value) },\n});\n\n/**\n * Creates a pattern that matches byte strings using a binary regex.\n *\n * The regex matches against raw bytes converted to a Latin-1 string.\n * Use escape sequences like `\\x00` to match specific byte values.\n *\n * @example\n * ```typescript\n * // Match bytes starting with 0x00\n * byteStringRegex(/^\\x00/)\n *\n * // Match ASCII \"Hello\"\n * byteStringRegex(/Hello/)\n * ```\n */\nexport const byteStringRegex = (pattern: RegExp): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"ByteString\", pattern: byteStringPatternBinaryRegex(pattern) },\n});\n\n/**\n * Creates a pattern that matches any array.\n */\nexport const anyArray = (): Pattern => ({\n  kind: \"Structure\",\n  pattern: { type: \"Array\", pattern: arrayPatternAny() },\n});\n\n/**\n * Creates a pattern that matches any map.\n */\nexport const anyMap = (): Pattern => ({\n  kind: \"Structure\",\n  pattern: { type: \"Map\", pattern: mapPatternAny() },\n});\n\n/**\n * Creates a pattern that matches any tagged value.\n */\nexport const anyTagged = (): Pattern => ({\n  kind: \"Structure\",\n  pattern: { type: \"Tagged\", pattern: taggedPatternAny() },\n});\n\n/**\n * Creates an AND pattern that matches if all patterns match.\n */\nexport const and = (...patterns: Pattern[]): Pattern => ({\n  kind: \"Meta\",\n  pattern: { type: \"And\", pattern: andPatternCreate(patterns) },\n});\n\n/**\n * Creates an OR pattern that matches if any pattern matches.\n */\nexport const or = (...patterns: Pattern[]): Pattern => ({\n  kind: \"Meta\",\n  pattern: { type: \"Or\", pattern: orPatternCreate(patterns) },\n});\n\n/**\n * Creates a NOT pattern that matches if the pattern does not match.\n */\nexport const not = (pattern: Pattern): Pattern => ({\n  kind: \"Meta\",\n  pattern: { type: \"Not\", pattern: notPatternCreate(pattern) },\n});\n\n/**\n * Creates a capture pattern with a name.\n */\nexport const capture = (name: string, pattern: Pattern): Pattern => ({\n  kind: \"Meta\",\n  pattern: { type: \"Capture\", pattern: capturePatternCreate(name, pattern) },\n});\n\n/**\n * Creates a search pattern for recursive matching.\n */\nexport const search = (pattern: Pattern): Pattern => ({\n  kind: \"Meta\",\n  pattern: { type: \"Search\", pattern: searchPatternCreate(pattern) },\n});\n\n/**\n * Creates a sequence pattern for ordered matching.\n */\nexport const sequence = (...patterns: Pattern[]): Pattern => ({\n  kind: \"Meta\",\n  pattern: { type: \"Sequence\", pattern: sequencePatternCreate(patterns) },\n});\n\n// ============================================================================\n// Number Pattern Constructors (additional)\n// ============================================================================\n\n/**\n * Creates a pattern that matches numbers greater than a value.\n */\nexport const numberGreaterThan = (value: number): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Number\", pattern: numberPatternGreaterThan(value) },\n});\n\n/**\n * Creates a pattern that matches numbers greater than or equal to a value.\n */\nexport const numberGreaterThanOrEqual = (value: number): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Number\", pattern: numberPatternGreaterThanOrEqual(value) },\n});\n\n/**\n * Creates a pattern that matches numbers less than a value.\n */\nexport const numberLessThan = (value: number): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Number\", pattern: numberPatternLessThan(value) },\n});\n\n/**\n * Creates a pattern that matches numbers less than or equal to a value.\n */\nexport const numberLessThanOrEqual = (value: number): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Number\", pattern: numberPatternLessThanOrEqual(value) },\n});\n\n/**\n * Creates a pattern that matches NaN.\n */\nexport const numberNaN = (): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Number\", pattern: numberPatternNaN() },\n});\n\n/**\n * Creates a pattern that matches positive infinity.\n */\nexport const numberInfinity = (): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Number\", pattern: numberPatternInfinity() },\n});\n\n/**\n * Creates a pattern that matches negative infinity.\n */\nexport const numberNegInfinity = (): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Number\", pattern: numberPatternNegInfinity() },\n});\n\n// ============================================================================\n// Date Pattern Constructors\n// ============================================================================\n\n/**\n * Creates a pattern that matches any date.\n */\nexport const anyDate = (): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Date\", pattern: datePatternAny() },\n});\n\n/**\n * Creates a pattern that matches a specific date.\n */\nexport const date = (value: CborDate): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Date\", pattern: datePatternValue(value) },\n});\n\n/**\n * Creates a pattern that matches dates within a range (inclusive).\n */\nexport const dateRange = (min: CborDate, max: CborDate): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Date\", pattern: datePatternRange(min, max) },\n});\n\n/**\n * Creates a pattern that matches dates on or after the specified date.\n */\nexport const dateEarliest = (value: CborDate): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Date\", pattern: datePatternEarliest(value) },\n});\n\n/**\n * Creates a pattern that matches dates on or before the specified date.\n */\nexport const dateLatest = (value: CborDate): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Date\", pattern: datePatternLatest(value) },\n});\n\n/**\n * Creates a pattern that matches dates by their ISO-8601 string representation.\n */\nexport const dateIso8601 = (value: string): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Date\", pattern: datePatternStringValue(value) },\n});\n\n/**\n * Creates a pattern that matches dates by regex on their ISO-8601 string.\n */\nexport const dateRegex = (pattern: RegExp): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Date\", pattern: datePatternRegex(pattern) },\n});\n\n// ============================================================================\n// Digest Pattern Constructors\n// ============================================================================\n\n/**\n * Creates a pattern that matches any digest.\n */\nexport const anyDigest = (): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Digest\", pattern: digestPatternAny() },\n});\n\n/**\n * Creates a pattern that matches a specific digest.\n */\nexport const digest = (value: Digest): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Digest\", pattern: digestPatternValue(value) },\n});\n\n/**\n * Creates a pattern that matches digests with a prefix.\n */\nexport const digestPrefix = (prefix: Uint8Array): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Digest\", pattern: digestPatternPrefix(prefix) },\n});\n\n/**\n * Creates a pattern that matches digests by binary regex.\n */\nexport const digestBinaryRegex = (pattern: RegExp): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"Digest\", pattern: digestPatternBinaryRegex(pattern) },\n});\n\n// ============================================================================\n// KnownValue Pattern Constructors\n// ============================================================================\n\n/**\n * Creates a pattern that matches any known value.\n */\nexport const anyKnownValue = (): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"KnownValue\", pattern: knownValuePatternAny() },\n});\n\n/**\n * Creates a pattern that matches a specific known value.\n */\nexport const knownValue = (value: KnownValue): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"KnownValue\", pattern: knownValuePatternValue(value) },\n});\n\n/**\n * Creates a pattern that matches a known value by name.\n */\nexport const knownValueNamed = (name: string): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"KnownValue\", pattern: knownValuePatternNamed(name) },\n});\n\n/**\n * Creates a pattern that matches known values by regex on their name.\n */\nexport const knownValueRegex = (pattern: RegExp): Pattern => ({\n  kind: \"Value\",\n  pattern: { type: \"KnownValue\", pattern: knownValuePatternRegex(pattern) },\n});\n\n// ============================================================================\n// Tagged Pattern Constructors\n// ============================================================================\n\n/**\n * Creates a pattern that matches tagged values with a specific tag.\n */\nexport const tagged = (tag: Tag, pattern: Pattern): Pattern => ({\n  kind: \"Structure\",\n  pattern: { type: \"Tagged\", pattern: taggedPatternWithTag(tag, pattern) },\n});\n\n/**\n * Creates a pattern that matches tagged values by tag name.\n */\nexport const taggedName = (name: string, pattern: Pattern): Pattern => ({\n  kind: \"Structure\",\n  pattern: { type: \"Tagged\", pattern: taggedPatternWithName(name, pattern) },\n});\n\n/**\n * Creates a pattern that matches tagged values by tag name regex.\n */\nexport const taggedRegex = (regex: RegExp, pattern: Pattern): Pattern => ({\n  kind: \"Structure\",\n  pattern: { type: \"Tagged\", pattern: taggedPatternWithRegex(regex, pattern) },\n});\n\n// ============================================================================\n// Meta Pattern Constructors (additional)\n// ============================================================================\n\n/**\n * Creates a repeat pattern with the given pattern and quantifier.\n */\nexport const repeat = (pattern: Pattern, quantifier: Quantifier): Pattern => ({\n  kind: \"Meta\",\n  pattern: { type: \"Repeat\", pattern: repeatPatternCreate(pattern, quantifier) },\n});\n\n/**\n * Creates a grouped pattern (equivalent to repeat with exactly 1).\n * This is useful for precedence grouping in pattern expressions.\n */\nexport const group = (pattern: Pattern): Pattern => ({\n  kind: \"Meta\",\n  pattern: { type: \"Repeat\", pattern: repeatPatternCreate(pattern, Quantifier.exactly(1)) },\n});\n\n// ============================================================================\n// Initialize Match Registry\n// ============================================================================\n\n// Register all pattern functions with the match registry\n// This breaks the circular dependency between pattern files\nsetMatchFn(patternMatches);\nsetPathsFn(patternPaths);\nsetPathsWithCapturesFn(pathsWithCaptures);\nsetPathsWithCapturesDirectFn(pathsWithCapturesDirect);\n","/**\n * Token types and Lexer for the dCBOR pattern language.\n *\n * This module provides tokenization for dCBOR pattern expressions,\n * converting input strings into a sequence of tokens for parsing.\n *\n * @module parse/token\n */\n\nimport { type Span, span, type Result, Ok, Err } from \"../error\";\nimport { Quantifier } from \"../quantifier\";\nimport { Reluctance } from \"../reluctance\";\n\n/**\n * Token types for dCBOR pattern parsing.\n *\n * This is a discriminated union matching the Rust Token enum.\n */\nexport type Token =\n  // Operators\n  | { readonly type: \"And\" }\n  | { readonly type: \"Or\" }\n  | { readonly type: \"Not\" }\n\n  // Quantifiers\n  | { readonly type: \"RepeatZeroOrMore\" }\n  | { readonly type: \"RepeatZeroOrMoreLazy\" }\n  | { readonly type: \"RepeatZeroOrMorePossessive\" }\n  | { readonly type: \"RepeatOneOrMore\" }\n  | { readonly type: \"RepeatOneOrMoreLazy\" }\n  | { readonly type: \"RepeatOneOrMorePossessive\" }\n  | { readonly type: \"RepeatZeroOrOne\" }\n  | { readonly type: \"RepeatZeroOrOneLazy\" }\n  | { readonly type: \"RepeatZeroOrOnePossessive\" }\n\n  // Structure keywords\n  | { readonly type: \"Tagged\" }\n  | { readonly type: \"Array\" }\n  | { readonly type: \"Map\" }\n\n  // Value keywords\n  | { readonly type: \"Bool\" }\n  | { readonly type: \"ByteString\" }\n  | { readonly type: \"Date\" }\n  | { readonly type: \"Known\" }\n  | { readonly type: \"Null\" }\n  | { readonly type: \"Number\" }\n  | { readonly type: \"Text\" }\n  | { readonly type: \"Digest\" }\n  | { readonly type: \"Search\" }\n\n  // Literals\n  | { readonly type: \"BoolTrue\" }\n  | { readonly type: \"BoolFalse\" }\n  | { readonly type: \"NaN\" }\n  | { readonly type: \"Infinity\" }\n  | { readonly type: \"NegInfinity\" }\n\n  // Delimiters\n  | { readonly type: \"ParenOpen\" }\n  | { readonly type: \"ParenClose\" }\n  | { readonly type: \"BracketOpen\" }\n  | { readonly type: \"BracketClose\" }\n  | { readonly type: \"BraceOpen\" }\n  | { readonly type: \"BraceClose\" }\n  | { readonly type: \"Comma\" }\n  | { readonly type: \"Colon\" }\n  | { readonly type: \"Ellipsis\" }\n\n  // Comparisons\n  | { readonly type: \"GreaterThanOrEqual\" }\n  | { readonly type: \"LessThanOrEqual\" }\n  | { readonly type: \"GreaterThan\" }\n  | { readonly type: \"LessThan\" }\n\n  // Complex literals\n  | { readonly type: \"NumberLiteral\"; readonly value: number }\n  | { readonly type: \"GroupName\"; readonly name: string }\n  | { readonly type: \"StringLiteral\"; readonly value: string }\n  | { readonly type: \"SingleQuoted\"; readonly value: string }\n  | { readonly type: \"Regex\"; readonly pattern: string }\n  | { readonly type: \"HexString\"; readonly value: Uint8Array }\n  | { readonly type: \"HexRegex\"; readonly pattern: string }\n  | { readonly type: \"DateQuoted\"; readonly value: string }\n  | { readonly type: \"DigestQuoted\"; readonly value: string }\n  | { readonly type: \"Range\"; readonly quantifier: Quantifier };\n\n/**\n * A token with its position in the source.\n */\nexport interface SpannedToken {\n  readonly token: Token;\n  readonly span: Span;\n}\n\n/**\n * Simple keywords that map directly to tokens.\n */\nconst KEYWORDS: Record<string, Token> = {\n  // Structure keywords\n  tagged: { type: \"Tagged\" },\n  array: { type: \"Array\" },\n  map: { type: \"Map\" },\n\n  // Value keywords\n  bool: { type: \"Bool\" },\n  bstr: { type: \"ByteString\" },\n  date: { type: \"Date\" },\n  known: { type: \"Known\" },\n  null: { type: \"Null\" },\n  number: { type: \"Number\" },\n  text: { type: \"Text\" },\n  digest: { type: \"Digest\" },\n  search: { type: \"Search\" },\n\n  // Boolean literals\n  true: { type: \"BoolTrue\" },\n  false: { type: \"BoolFalse\" },\n\n  // Special values\n  NaN: { type: \"NaN\" },\n  Infinity: { type: \"Infinity\" },\n};\n\n/**\n * Check if a character is whitespace.\n */\nconst isWhitespace = (ch: string): boolean => {\n  return ch === \" \" || ch === \"\\t\" || ch === \"\\r\" || ch === \"\\n\" || ch === \"\\f\";\n};\n\n/**\n * Check if a character is a digit.\n */\nconst isDigit = (ch: string): boolean => {\n  return ch >= \"0\" && ch <= \"9\";\n};\n\n/**\n * Check if a character is a hex digit.\n */\nconst isHexDigit = (ch: string): boolean => {\n  return (ch >= \"0\" && ch <= \"9\") || (ch >= \"a\" && ch <= \"f\") || (ch >= \"A\" && ch <= \"F\");\n};\n\n/**\n * Check if a character is an identifier start character.\n */\nconst isIdentStart = (ch: string): boolean => {\n  return (ch >= \"a\" && ch <= \"z\") || (ch >= \"A\" && ch <= \"Z\") || ch === \"_\";\n};\n\n/**\n * Check if a character is an identifier continuation character.\n */\nconst isIdentCont = (ch: string): boolean => {\n  return isIdentStart(ch) || isDigit(ch);\n};\n\n/**\n * Parse a hex string to bytes.\n */\nconst hexToBytes = (hex: string): Uint8Array | undefined => {\n  if (hex.length % 2 !== 0) {\n    return undefined;\n  }\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < hex.length; i += 2) {\n    const byte = parseInt(hex.slice(i, i + 2), 16);\n    if (isNaN(byte)) {\n      return undefined;\n    }\n    bytes[i / 2] = byte;\n  }\n  return bytes;\n};\n\n/**\n * Lexer state for tokenizing dCBOR pattern expressions.\n */\nexport class Lexer {\n  readonly #input: string;\n  #position: number;\n\n  constructor(input: string) {\n    this.#input = input;\n    this.#position = 0;\n  }\n\n  /**\n   * Creates a new lexer for the given input.\n   */\n  static new(input: string): Lexer {\n    return new Lexer(input);\n  }\n\n  /**\n   * Returns the input string.\n   */\n  input(): string {\n    return this.#input;\n  }\n\n  /**\n   * Returns the current position in the input.\n   */\n  position(): number {\n    return this.#position;\n  }\n\n  /**\n   * Returns the remaining input.\n   */\n  remainder(): string {\n    return this.#input.slice(this.#position);\n  }\n\n  /**\n   * Peeks at the current character without consuming it.\n   */\n  peek(): string | undefined {\n    return this.#input[this.#position];\n  }\n\n  /**\n   * Peeks at the character at offset from current position.\n   */\n  peekAt(offset: number): string | undefined {\n    return this.#input[this.#position + offset];\n  }\n\n  /**\n   * Consumes and returns the current character.\n   */\n  advance(): string | undefined {\n    const ch = this.#input[this.#position];\n    if (ch !== undefined) {\n      this.#position++;\n    }\n    return ch;\n  }\n\n  /**\n   * Advances by n characters.\n   */\n  bump(n: number): void {\n    this.#position += n;\n  }\n\n  /**\n   * Creates a span from start to current position.\n   */\n  spanFrom(start: number): Span {\n    return span(start, this.#position);\n  }\n\n  /**\n   * Skips whitespace characters.\n   */\n  skipWhitespace(): void {\n    while (this.#position < this.#input.length && isWhitespace(this.#input[this.#position])) {\n      this.#position++;\n    }\n  }\n\n  /**\n   * Checks if the remainder starts with the given string.\n   */\n  startsWith(s: string): boolean {\n    return this.#input.slice(this.#position).startsWith(s);\n  }\n\n  /**\n   * Gets the next token.\n   */\n  next(): Result<SpannedToken> | undefined {\n    this.skipWhitespace();\n\n    if (this.#position >= this.#input.length) {\n      return undefined;\n    }\n\n    const start = this.#position;\n    const ch = this.peek() ?? \"\";\n\n    // Try multi-character operators first\n    if (this.startsWith(\"-Infinity\")) {\n      this.bump(9);\n      return Ok({ token: { type: \"NegInfinity\" }, span: this.spanFrom(start) });\n    }\n\n    if (this.startsWith(\"...\")) {\n      this.bump(3);\n      return Ok({ token: { type: \"Ellipsis\" }, span: this.spanFrom(start) });\n    }\n\n    // Two-dot ellipsis for ranges (check after three-dot)\n    if (this.startsWith(\"..\") && !this.startsWith(\"...\")) {\n      this.bump(2);\n      return Ok({ token: { type: \"Ellipsis\" }, span: this.spanFrom(start) });\n    }\n\n    if (this.startsWith(\">=\")) {\n      this.bump(2);\n      return Ok({ token: { type: \"GreaterThanOrEqual\" }, span: this.spanFrom(start) });\n    }\n\n    if (this.startsWith(\"<=\")) {\n      this.bump(2);\n      return Ok({ token: { type: \"LessThanOrEqual\" }, span: this.spanFrom(start) });\n    }\n\n    if (this.startsWith(\"*?\")) {\n      this.bump(2);\n      return Ok({ token: { type: \"RepeatZeroOrMoreLazy\" }, span: this.spanFrom(start) });\n    }\n\n    if (this.startsWith(\"*+\")) {\n      this.bump(2);\n      return Ok({ token: { type: \"RepeatZeroOrMorePossessive\" }, span: this.spanFrom(start) });\n    }\n\n    if (this.startsWith(\"+?\")) {\n      this.bump(2);\n      return Ok({ token: { type: \"RepeatOneOrMoreLazy\" }, span: this.spanFrom(start) });\n    }\n\n    if (this.startsWith(\"++\")) {\n      this.bump(2);\n      return Ok({ token: { type: \"RepeatOneOrMorePossessive\" }, span: this.spanFrom(start) });\n    }\n\n    if (this.startsWith(\"??\")) {\n      this.bump(2);\n      return Ok({ token: { type: \"RepeatZeroOrOneLazy\" }, span: this.spanFrom(start) });\n    }\n\n    if (this.startsWith(\"?+\")) {\n      this.bump(2);\n      return Ok({ token: { type: \"RepeatZeroOrOnePossessive\" }, span: this.spanFrom(start) });\n    }\n\n    // Single character operators\n    switch (ch) {\n      case \"&\":\n        this.advance();\n        return Ok({ token: { type: \"And\" }, span: this.spanFrom(start) });\n      case \"|\":\n        this.advance();\n        return Ok({ token: { type: \"Or\" }, span: this.spanFrom(start) });\n      case \"!\":\n        this.advance();\n        return Ok({ token: { type: \"Not\" }, span: this.spanFrom(start) });\n      case \"*\":\n        this.advance();\n        return Ok({ token: { type: \"RepeatZeroOrMore\" }, span: this.spanFrom(start) });\n      case \"+\":\n        this.advance();\n        return Ok({ token: { type: \"RepeatOneOrMore\" }, span: this.spanFrom(start) });\n      case \"?\":\n        this.advance();\n        return Ok({ token: { type: \"RepeatZeroOrOne\" }, span: this.spanFrom(start) });\n      case \"(\":\n        this.advance();\n        return Ok({ token: { type: \"ParenOpen\" }, span: this.spanFrom(start) });\n      case \")\":\n        this.advance();\n        return Ok({ token: { type: \"ParenClose\" }, span: this.spanFrom(start) });\n      case \"[\":\n        this.advance();\n        return Ok({ token: { type: \"BracketOpen\" }, span: this.spanFrom(start) });\n      case \"]\":\n        this.advance();\n        return Ok({ token: { type: \"BracketClose\" }, span: this.spanFrom(start) });\n      case \"}\":\n        this.advance();\n        return Ok({ token: { type: \"BraceClose\" }, span: this.spanFrom(start) });\n      case \",\":\n        this.advance();\n        return Ok({ token: { type: \"Comma\" }, span: this.spanFrom(start) });\n      case \":\":\n        this.advance();\n        return Ok({ token: { type: \"Colon\" }, span: this.spanFrom(start) });\n      case \">\":\n        this.advance();\n        return Ok({ token: { type: \"GreaterThan\" }, span: this.spanFrom(start) });\n      case \"<\":\n        this.advance();\n        return Ok({ token: { type: \"LessThan\" }, span: this.spanFrom(start) });\n    }\n\n    // Brace open - may be range or just brace\n    if (ch === \"{\") {\n      this.advance();\n      return this.parseBraceOpen(start);\n    }\n\n    // String literal\n    if (ch === '\"') {\n      this.advance();\n      return this.parseString(start);\n    }\n\n    // Single quoted string\n    if (ch === \"'\") {\n      this.advance();\n      return this.parseSingleQuoted(start);\n    }\n\n    // Regex\n    if (ch === \"/\") {\n      this.advance();\n      return this.parseRegex(start);\n    }\n\n    // Group name (@name)\n    if (ch === \"@\") {\n      this.advance();\n      return this.parseGroupName(start);\n    }\n\n    // Hex string or hex regex (h'...' or h'/.../')\n    if (ch === \"h\" && this.peekAt(1) === \"'\") {\n      this.bump(2);\n      // Check if it's a hex regex\n      if (this.peek() === \"/\") {\n        this.advance();\n        return this.parseHexRegex(start);\n      }\n      return this.parseHexString(start);\n    }\n\n    // Number literal (including negative)\n    if (isDigit(ch) || (ch === \"-\" && isDigit(this.peekAt(1) ?? \"\"))) {\n      return this.parseNumber(start);\n    }\n\n    // Identifier or keyword (including date' and digest')\n    if (isIdentStart(ch)) {\n      return this.parseIdentifierOrKeyword(start);\n    }\n\n    // Unrecognized token\n    this.advance();\n    return Err({ type: \"UnrecognizedToken\", span: this.spanFrom(start) });\n  }\n\n  /**\n   * Tokenizes the entire input and returns all tokens.\n   */\n  tokenize(): Result<SpannedToken[]> {\n    const tokens: SpannedToken[] = [];\n\n    while (true) {\n      const result = this.next();\n      if (result === undefined) {\n        break;\n      }\n      if (!result.ok) {\n        return result as Result<SpannedToken[]>;\n      }\n      tokens.push(result.value);\n    }\n\n    return Ok(tokens);\n  }\n\n  /**\n   * Parse { - could be BraceOpen or Range.\n   */\n  private parseBraceOpen(start: number): Result<SpannedToken> {\n    // Look ahead to see if this is a range pattern\n    const remainder = this.remainder();\n\n    // Skip whitespace and check for digit\n    let pos = 0;\n    while (pos < remainder.length && isWhitespace(remainder[pos])) {\n      pos++;\n    }\n\n    if (pos < remainder.length && isDigit(remainder[pos])) {\n      // Check if it looks like a range pattern\n      if (this.looksLikeRangePattern(remainder.slice(pos))) {\n        return this.parseRange(start);\n      }\n    }\n\n    return Ok({ token: { type: \"BraceOpen\" }, span: this.spanFrom(start) });\n  }\n\n  /**\n   * Check if content looks like a range pattern.\n   */\n  private looksLikeRangePattern(content: string): boolean {\n    let i = 0;\n\n    // Skip whitespace\n    while (i < content.length && isWhitespace(content[i])) {\n      i++;\n    }\n\n    // Need at least one digit\n    if (i >= content.length || !isDigit(content[i])) {\n      return false;\n    }\n\n    // Skip digits\n    while (i < content.length && isDigit(content[i])) {\n      i++;\n    }\n\n    // Skip whitespace\n    while (i < content.length && isWhitespace(content[i])) {\n      i++;\n    }\n\n    // After digits, should see comma or closing brace\n    // If we see a colon, it's a map constraint, not a range\n    if (i < content.length) {\n      const ch = content[i];\n      if (ch === \":\") {\n        return false;\n      }\n      return ch === \",\" || ch === \"}\";\n    }\n\n    return false;\n  }\n\n  /**\n   * Parse a range pattern like {1,5} or {3,} or {5}.\n   */\n  private parseRange(start: number): Result<SpannedToken> {\n    // Skip whitespace\n    this.skipWhitespace();\n\n    // Parse first number\n    const minStart = this.#position;\n    let peeked = this.peek();\n    while (peeked !== undefined && isDigit(peeked)) {\n      this.advance();\n      peeked = this.peek();\n    }\n\n    if (this.#position === minStart) {\n      return Err({ type: \"InvalidRange\", span: this.spanFrom(start) });\n    }\n\n    const min = parseInt(this.#input.slice(minStart, this.#position), 10);\n\n    this.skipWhitespace();\n\n    let max: number | undefined;\n\n    const nextCh = this.peek();\n    if (nextCh === \",\") {\n      this.advance();\n      this.skipWhitespace();\n\n      const afterComma = this.peek();\n      if (afterComma === \"}\") {\n        // Unbounded: {n,}\n        this.advance();\n        max = undefined;\n      } else if (afterComma !== undefined && isDigit(afterComma)) {\n        // Bounded: {n,m}\n        const maxStart = this.#position;\n        let maxPeeked = this.peek();\n        while (maxPeeked !== undefined && isDigit(maxPeeked)) {\n          this.advance();\n          maxPeeked = this.peek();\n        }\n        max = parseInt(this.#input.slice(maxStart, this.#position), 10);\n\n        this.skipWhitespace();\n        if (this.peek() !== \"}\") {\n          return Err({ type: \"InvalidRange\", span: this.spanFrom(start) });\n        }\n        this.advance();\n      } else {\n        return Err({ type: \"InvalidRange\", span: this.spanFrom(start) });\n      }\n    } else if (nextCh === \"}\") {\n      // Exact: {n}\n      this.advance();\n      max = min;\n    } else {\n      return Err({ type: \"InvalidRange\", span: this.spanFrom(start) });\n    }\n\n    // Check for reluctance modifier\n    let reluctance = Reluctance.Greedy;\n    const modCh = this.peek();\n    if (modCh === \"?\") {\n      this.advance();\n      reluctance = Reluctance.Lazy;\n    } else if (modCh === \"+\") {\n      this.advance();\n      reluctance = Reluctance.Possessive;\n    }\n\n    // Validate range\n    if (max !== undefined && min > max) {\n      return Err({ type: \"InvalidRange\", span: this.spanFrom(start) });\n    }\n\n    const quantifier =\n      max !== undefined\n        ? Quantifier.between(min, max, reluctance)\n        : Quantifier.atLeast(min, reluctance);\n\n    return Ok({ token: { type: \"Range\", quantifier }, span: this.spanFrom(start) });\n  }\n\n  /**\n   * Parse a string literal.\n   */\n  private parseString(start: number): Result<SpannedToken> {\n    let result = \"\";\n    let escape = false;\n\n    while (this.#position < this.#input.length) {\n      const ch = this.advance() ?? \"\";\n\n      if (escape) {\n        switch (ch) {\n          case '\"':\n            result += '\"';\n            break;\n          case \"\\\\\":\n            result += \"\\\\\";\n            break;\n          case \"n\":\n            result += \"\\n\";\n            break;\n          case \"r\":\n            result += \"\\r\";\n            break;\n          case \"t\":\n            result += \"\\t\";\n            break;\n          default:\n            result += \"\\\\\";\n            result += ch;\n            break;\n        }\n        escape = false;\n      } else if (ch === \"\\\\\") {\n        escape = true;\n      } else if (ch === '\"') {\n        return Ok({ token: { type: \"StringLiteral\", value: result }, span: this.spanFrom(start) });\n      } else {\n        result += ch;\n      }\n    }\n\n    return Err({ type: \"UnterminatedString\", span: this.spanFrom(start) });\n  }\n\n  /**\n   * Parse a single-quoted string.\n   */\n  private parseSingleQuoted(start: number): Result<SpannedToken> {\n    let result = \"\";\n    let escape = false;\n\n    while (this.#position < this.#input.length) {\n      const ch = this.advance() ?? \"\";\n\n      if (escape) {\n        switch (ch) {\n          case \"'\":\n            result += \"'\";\n            break;\n          case \"\\\\\":\n            result += \"\\\\\";\n            break;\n          case \"n\":\n            result += \"\\n\";\n            break;\n          case \"r\":\n            result += \"\\r\";\n            break;\n          case \"t\":\n            result += \"\\t\";\n            break;\n          default:\n            result += \"\\\\\";\n            result += ch;\n            break;\n        }\n        escape = false;\n      } else if (ch === \"\\\\\") {\n        escape = true;\n      } else if (ch === \"'\") {\n        return Ok({ token: { type: \"SingleQuoted\", value: result }, span: this.spanFrom(start) });\n      } else {\n        result += ch;\n      }\n    }\n\n    return Err({ type: \"UnterminatedString\", span: this.spanFrom(start) });\n  }\n\n  /**\n   * Parse a regex pattern.\n   */\n  private parseRegex(start: number): Result<SpannedToken> {\n    let pattern = \"\";\n    let escape = false;\n\n    while (this.#position < this.#input.length) {\n      const ch = this.advance() ?? \"\";\n\n      if (escape) {\n        pattern += ch;\n        escape = false;\n      } else if (ch === \"\\\\\") {\n        pattern += ch;\n        escape = true;\n      } else if (ch === \"/\") {\n        // Validate regex\n        try {\n          new RegExp(pattern);\n        } catch {\n          return Err({ type: \"InvalidRegex\", span: this.spanFrom(start) });\n        }\n        return Ok({ token: { type: \"Regex\", pattern }, span: this.spanFrom(start) });\n      } else {\n        pattern += ch;\n      }\n    }\n\n    return Err({ type: \"UnterminatedRegex\", span: this.spanFrom(start) });\n  }\n\n  /**\n   * Parse a group name.\n   */\n  private parseGroupName(start: number): Result<SpannedToken> {\n    const nameStart = this.#position;\n\n    // First char must be identifier start\n    if (!isIdentStart(this.peek() ?? \"\")) {\n      return Err({ type: \"InvalidCaptureGroupName\", name: \"\", span: this.spanFrom(start) });\n    }\n\n    let identCh = this.peek();\n    while (identCh !== undefined && isIdentCont(identCh)) {\n      this.advance();\n      identCh = this.peek();\n    }\n\n    const name = this.#input.slice(nameStart, this.#position);\n    return Ok({ token: { type: \"GroupName\", name }, span: this.spanFrom(start) });\n  }\n\n  /**\n   * Parse a hex string.\n   */\n  private parseHexString(start: number): Result<SpannedToken> {\n    let hex = \"\";\n\n    while (this.#position < this.#input.length) {\n      const ch = this.peek() ?? \"\";\n\n      if (ch === \"'\") {\n        this.advance();\n        const bytes = hexToBytes(hex);\n        if (bytes === undefined) {\n          return Err({ type: \"InvalidHexString\", span: this.spanFrom(start) });\n        }\n        return Ok({ token: { type: \"HexString\", value: bytes }, span: this.spanFrom(start) });\n      } else if (isHexDigit(ch)) {\n        hex += ch;\n        this.advance();\n      } else {\n        return Err({ type: \"InvalidHexString\", span: this.spanFrom(start) });\n      }\n    }\n\n    return Err({ type: \"UnterminatedHexString\", span: this.spanFrom(start) });\n  }\n\n  /**\n   * Parse a hex regex pattern.\n   */\n  private parseHexRegex(start: number): Result<SpannedToken> {\n    let pattern = \"\";\n    let escape = false;\n\n    while (this.#position < this.#input.length) {\n      const ch = this.advance() ?? \"\";\n\n      if (escape) {\n        pattern += ch;\n        escape = false;\n      } else if (ch === \"\\\\\") {\n        pattern += ch;\n        escape = true;\n      } else if (ch === \"/\") {\n        // Check for closing '\n        if (this.peek() === \"'\") {\n          this.advance();\n          // Validate regex\n          try {\n            new RegExp(pattern);\n          } catch {\n            return Err({ type: \"InvalidRegex\", span: this.spanFrom(start) });\n          }\n          return Ok({ token: { type: \"HexRegex\", pattern }, span: this.spanFrom(start) });\n        }\n        pattern += ch;\n      } else {\n        pattern += ch;\n      }\n    }\n\n    return Err({ type: \"UnterminatedRegex\", span: this.spanFrom(start) });\n  }\n\n  /**\n   * Parse a number literal.\n   */\n  private parseNumber(start: number): Result<SpannedToken> {\n    const numStart = this.#position;\n\n    // Optional negative sign\n    if (this.peek() === \"-\") {\n      this.advance();\n    }\n\n    // Integer part\n    if (this.peek() === \"0\") {\n      this.advance();\n    } else if (isDigit(this.peek() ?? \"\")) {\n      while (isDigit(this.peek() ?? \"\")) {\n        this.advance();\n      }\n    } else {\n      return Err({ type: \"InvalidNumberFormat\", span: this.spanFrom(start) });\n    }\n\n    // Fractional part (but not if it's the start of a range like 1..10)\n    if (this.peek() === \".\" && this.peekAt(1) !== \".\") {\n      this.advance();\n      if (!isDigit(this.peek() ?? \"\")) {\n        return Err({ type: \"InvalidNumberFormat\", span: this.spanFrom(start) });\n      }\n      while (isDigit(this.peek() ?? \"\")) {\n        this.advance();\n      }\n    }\n\n    // Exponent part\n    if (this.peek() === \"e\" || this.peek() === \"E\") {\n      this.advance();\n      if (this.peek() === \"+\" || this.peek() === \"-\") {\n        this.advance();\n      }\n      if (!isDigit(this.peek() ?? \"\")) {\n        return Err({ type: \"InvalidNumberFormat\", span: this.spanFrom(start) });\n      }\n      while (isDigit(this.peek() ?? \"\")) {\n        this.advance();\n      }\n    }\n\n    const numStr = this.#input.slice(numStart, this.#position);\n    const value = parseFloat(numStr);\n\n    if (!isFinite(value)) {\n      return Err({ type: \"InvalidNumberFormat\", span: this.spanFrom(start) });\n    }\n\n    return Ok({ token: { type: \"NumberLiteral\", value }, span: this.spanFrom(start) });\n  }\n\n  /**\n   * Parse an identifier or keyword.\n   */\n  private parseIdentifierOrKeyword(start: number): Result<SpannedToken> {\n    const identStart = this.#position;\n\n    let identCh = this.peek();\n    while (identCh !== undefined && isIdentCont(identCh)) {\n      this.advance();\n      identCh = this.peek();\n    }\n\n    const ident = this.#input.slice(identStart, this.#position);\n\n    // Check for special quoted patterns\n    if (ident === \"date\" && this.peek() === \"'\") {\n      this.advance();\n      return this.parseDateQuoted(start);\n    }\n\n    if (ident === \"digest\" && this.peek() === \"'\") {\n      this.advance();\n      return this.parseDigestQuoted(start);\n    }\n\n    // Check for keyword\n    const keyword = KEYWORDS[ident];\n    if (keyword !== undefined) {\n      return Ok({ token: keyword, span: this.spanFrom(start) });\n    }\n\n    // Unknown identifier - treat as unrecognized\n    return Err({ type: \"UnrecognizedToken\", span: this.spanFrom(start) });\n  }\n\n  /**\n   * Parse a date quoted pattern.\n   */\n  private parseDateQuoted(start: number): Result<SpannedToken> {\n    let content = \"\";\n\n    while (this.#position < this.#input.length) {\n      const ch = this.advance() ?? \"\";\n\n      if (ch === \"'\") {\n        if (content.length === 0) {\n          return Err({ type: \"InvalidDateFormat\", span: this.spanFrom(start) });\n        }\n        return Ok({ token: { type: \"DateQuoted\", value: content }, span: this.spanFrom(start) });\n      }\n      content += ch;\n    }\n\n    return Err({ type: \"UnterminatedDateQuoted\", span: this.spanFrom(start) });\n  }\n\n  /**\n   * Parse a digest quoted pattern.\n   */\n  private parseDigestQuoted(start: number): Result<SpannedToken> {\n    let content = \"\";\n\n    while (this.#position < this.#input.length) {\n      const ch = this.advance() ?? \"\";\n\n      if (ch === \"'\") {\n        if (content.length === 0) {\n          return Err({\n            type: \"InvalidDigestPattern\",\n            message: \"empty content\",\n            span: this.spanFrom(start),\n          });\n        }\n        return Ok({ token: { type: \"DigestQuoted\", value: content }, span: this.spanFrom(start) });\n      }\n      content += ch;\n    }\n\n    return Err({ type: \"UnterminatedDigestQuoted\", span: this.spanFrom(start) });\n  }\n\n  /**\n   * Peeks at the next token without consuming it.\n   * Returns a Result with the token or undefined if at end of input.\n   */\n  peekToken(): Result<Token> | undefined {\n    const savedPosition = this.#position;\n    const result = this.next();\n    this.#position = savedPosition;\n\n    if (result === undefined) {\n      return undefined;\n    }\n\n    if (!result.ok) {\n      return result;\n    }\n\n    return Ok(result.value.token);\n  }\n\n  /**\n   * Returns the current span (position to position).\n   */\n  span(): Span {\n    return span(this.#position, this.#position);\n  }\n\n  /**\n   * Returns the last token's span.\n   */\n  lastSpan(): Span {\n    // This is a simplification - in reality we'd track the last span\n    return span(this.#position, this.#position);\n  }\n}\n\n// Re-export Span\nexport type { Span };\n","/**\n * Bool pattern parser.\n *\n * @module parse/value/bool-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok } from \"../../error\";\nimport { anyBool, bool } from \"../../pattern\";\n\n/**\n * Parse a boolean pattern from the `bool` keyword.\n */\nexport const parseBool = (_lexer: Lexer): Result<Pattern> => {\n  // `bool` keyword was already consumed, just return the pattern\n  return Ok(anyBool());\n};\n\n/**\n * Parse a `true` literal.\n */\nexport const parseBoolTrue = (_lexer: Lexer): Result<Pattern> => {\n  return Ok(bool(true));\n};\n\n/**\n * Parse a `false` literal.\n */\nexport const parseBoolFalse = (_lexer: Lexer): Result<Pattern> => {\n  return Ok(bool(false));\n};\n","/**\n * Null pattern parser.\n *\n * @module parse/value/null-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok } from \"../../error\";\nimport { nullPattern } from \"../../pattern\";\n\n/**\n * Parse a null pattern from the `null` keyword.\n */\nexport const parseNull = (_lexer: Lexer): Result<Pattern> => {\n  // `null` keyword was already consumed\n  return Ok(nullPattern());\n};\n","/**\n * Number pattern parser.\n *\n * @module parse/value/number-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok } from \"../../error\";\nimport { anyNumber } from \"../../pattern\";\n\n/**\n * Parse a number pattern from the `number` keyword.\n */\nexport const parseNumber = (_lexer: Lexer): Result<Pattern> => {\n  // `number` keyword was already consumed\n  return Ok(anyNumber());\n};\n","/**\n * Text pattern parser.\n *\n * @module parse/value/text-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok, Err } from \"../../error\";\nimport { anyText, text, textRegex } from \"../../pattern\";\n\n/**\n * Parse a text pattern from the `text` keyword.\n */\nexport const parseText = (lexer: Lexer): Result<Pattern> => {\n  // `text` keyword was already consumed\n  // Check if followed by a quoted value\n  const peeked = lexer.peekToken();\n  if (peeked?.ok === true) {\n    const token = peeked.value;\n    if (token.type === \"SingleQuoted\") {\n      lexer.next(); // consume the token\n      // Check if it's a regex (starts and ends with /)\n      if (token.value.startsWith(\"/\") && token.value.endsWith(\"/\") && token.value.length > 2) {\n        const regexBody = token.value.slice(1, -1);\n        try {\n          const regex = new RegExp(regexBody);\n          return Ok(textRegex(regex));\n        } catch {\n          return Err({ type: \"InvalidRegex\", span: lexer.span() });\n        }\n      }\n      // Otherwise it's a literal string match\n      return Ok(text(token.value));\n    }\n    if (token.type === \"StringLiteral\") {\n      lexer.next(); // consume the token\n      return Ok(text(token.value));\n    }\n  }\n  return Ok(anyText());\n};\n","/**\n * ByteString pattern parser.\n *\n * @module parse/value/bytestring-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok } from \"../../error\";\nimport { anyByteString, byteString, byteStringRegex } from \"../../pattern\";\n\n/**\n * Parse a bytestring pattern from the `bytes` keyword.\n */\nexport const parseByteString = (_lexer: Lexer): Result<Pattern> => {\n  // `bytes` keyword was already consumed\n  return Ok(anyByteString());\n};\n\n/**\n * Parse a hex string token result into a pattern.\n */\nexport const parseHexStringToken = (hexResult: Result<Uint8Array>): Result<Pattern> => {\n  if (!hexResult.ok) {\n    return hexResult;\n  }\n  return Ok(byteString(hexResult.value));\n};\n\n/**\n * Parse a hex regex token result into a pattern.\n *\n * In TypeScript, binary regex matching is implemented by converting bytes to Latin-1 strings.\n * This mimics Rust's regex::bytes::Regex behavior where each byte 0-255 maps to a character.\n */\nexport const parseHexRegexToken = (regexResult: Result<RegExp>): Result<Pattern> => {\n  if (!regexResult.ok) {\n    return regexResult;\n  }\n  return Ok(byteStringRegex(regexResult.value));\n};\n","/**\n * Date pattern parser.\n *\n * @module parse/value/date-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok } from \"../../error\";\n\n// Import date pattern constructor\nimport { datePatternAny } from \"../../pattern/value/date-pattern\";\n\n/**\n * Parse a date pattern from the `date` keyword.\n */\nexport const parseDate = (_lexer: Lexer): Result<Pattern> => {\n  // `date` keyword was already consumed\n  return Ok({\n    kind: \"Value\",\n    pattern: { type: \"Date\", pattern: datePatternAny() },\n  });\n};\n","/**\n * Digest pattern parser.\n *\n * @module parse/value/digest-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok } from \"../../error\";\n\n// Import digest pattern constructor\nimport { digestPatternAny } from \"../../pattern/value/digest-pattern\";\n\n/**\n * Parse a digest pattern from the `digest` keyword.\n */\nexport const parseDigest = (_lexer: Lexer): Result<Pattern> => {\n  // `digest` keyword was already consumed\n  return Ok({\n    kind: \"Value\",\n    pattern: { type: \"Digest\", pattern: digestPatternAny() },\n  });\n};\n","/**\n * KnownValue pattern parser.\n *\n * @module parse/value/known-value-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok } from \"../../error\";\n\n// Import known value pattern constructor\nimport { knownValuePatternAny } from \"../../pattern/value/known-value-pattern\";\n\n/**\n * Parse a known value pattern from the `known` keyword.\n */\nexport const parseKnownValue = (_lexer: Lexer): Result<Pattern> => {\n  // `known` keyword was already consumed\n  return Ok({\n    kind: \"Value\",\n    pattern: { type: \"KnownValue\", pattern: knownValuePatternAny() },\n  });\n};\n","/**\n * Parse registry for resolving circular dependencies between parsers.\n *\n * @module parse/parse-registry\n */\n\nimport type { Lexer } from \"./token\";\nimport type { Pattern } from \"../pattern\";\nimport type { Result } from \"../error\";\n\n/**\n * The registered parseOr function.\n */\nexport let parseOrFn: ((lexer: Lexer) => Result<Pattern>) | undefined;\n\n/**\n * Registers the parseOr function.\n */\nexport const setParseOrFn = (fn: (lexer: Lexer) => Result<Pattern>): void => {\n  parseOrFn = fn;\n};\n\n/**\n * Calls the registered parseOr function.\n */\nexport const parseOrFromRegistry = (lexer: Lexer): Result<Pattern> => {\n  if (parseOrFn === undefined) {\n    throw new Error(\"ParseOr function not initialized. Import parse/index to initialize.\");\n  }\n  return parseOrFn(lexer);\n};\n","/**\n * Array pattern parser.\n *\n * @module parse/structure/array-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok, Err } from \"../../error\";\nimport { sequence, or, and, not } from \"../../pattern\";\nimport {\n  arrayPatternWithLengthInterval,\n  arrayPatternWithElements,\n} from \"../../pattern/structure/array-pattern\";\nimport { Interval } from \"../../interval\";\nimport { parseOrFromRegistry } from \"../parse-registry\";\n\n/**\n * Parse a bracket array pattern: [pattern] or [{n}] etc.\n */\nexport const parseBracketArray = (lexer: Lexer): Result<Pattern> => {\n  // Opening bracket was already consumed\n  const peeked = lexer.peekToken();\n\n  if (peeked === undefined) {\n    return Err({ type: \"UnexpectedEndOfInput\" });\n  }\n\n  if (!peeked.ok) {\n    return peeked;\n  }\n\n  const token = peeked.value;\n\n  // Check for Range token (array length constraint like [{3}] or [{1,5}])\n  if (token.type === \"Range\") {\n    lexer.next(); // consume the Range token\n    const pattern = arrayPatternWithLengthInterval(token.quantifier.interval());\n\n    // Expect closing bracket\n    const closeResult = lexer.next();\n    if (closeResult === undefined) {\n      return Err({ type: \"ExpectedCloseBracket\", span: lexer.span() });\n    }\n    if (!closeResult.ok) {\n      return closeResult;\n    }\n    if (closeResult.value.token.type !== \"BracketClose\") {\n      return Err({\n        type: \"ExpectedCloseBracket\",\n        span: closeResult.value.span,\n      });\n    }\n\n    return Ok({\n      kind: \"Structure\",\n      pattern: { type: \"Array\", pattern },\n    });\n  }\n\n  // Check for closing bracket (empty array pattern [] - matches array with 0 elements)\n  if (token.type === \"BracketClose\") {\n    lexer.next(); // consume the closing bracket\n    return Ok({\n      kind: \"Structure\",\n      pattern: { type: \"Array\", pattern: arrayPatternWithLengthInterval(Interval.exactly(0)) },\n    });\n  }\n\n  // Parse as array with element pattern(s)\n  const elementPattern = parseArrayOr(lexer);\n  if (!elementPattern.ok) {\n    return elementPattern;\n  }\n\n  const pattern = arrayPatternWithElements(elementPattern.value);\n\n  // Expect closing bracket\n  const closeResult = lexer.next();\n  if (closeResult === undefined) {\n    return Err({ type: \"ExpectedCloseBracket\", span: lexer.span() });\n  }\n  if (!closeResult.ok) {\n    return closeResult;\n  }\n  if (closeResult.value.token.type !== \"BracketClose\") {\n    return Err({\n      type: \"ExpectedCloseBracket\",\n      span: closeResult.value.span,\n    });\n  }\n\n  return Ok({\n    kind: \"Structure\",\n    pattern: { type: \"Array\", pattern },\n  });\n};\n\n/**\n * Parse OR patterns within array context.\n */\nconst parseArrayOr = (lexer: Lexer): Result<Pattern> => {\n  const patterns: Pattern[] = [];\n  const first = parseArrayAnd(lexer);\n  if (!first.ok) {\n    return first;\n  }\n  patterns.push(first.value);\n\n  while (true) {\n    const peeked = lexer.peekToken();\n    if (peeked === undefined || !peeked.ok || peeked.value.type !== \"Or\") {\n      break;\n    }\n    lexer.next(); // consume the OR token\n\n    const next = parseArrayAnd(lexer);\n    if (!next.ok) {\n      return next;\n    }\n    patterns.push(next.value);\n  }\n\n  if (patterns.length === 1) {\n    return Ok(patterns[0]);\n  }\n\n  return Ok(or(...patterns));\n};\n\n/**\n * Parse AND patterns within array context.\n */\nconst parseArrayAnd = (lexer: Lexer): Result<Pattern> => {\n  const patterns: Pattern[] = [];\n  const first = parseArrayNot(lexer);\n  if (!first.ok) {\n    return first;\n  }\n  patterns.push(first.value);\n\n  while (true) {\n    const peeked = lexer.peekToken();\n    if (peeked === undefined || !peeked.ok || peeked.value.type !== \"And\") {\n      break;\n    }\n    lexer.next(); // consume the AND token\n\n    const next = parseArrayNot(lexer);\n    if (!next.ok) {\n      return next;\n    }\n    patterns.push(next.value);\n  }\n\n  if (patterns.length === 1) {\n    return Ok(patterns[0]);\n  }\n\n  return Ok(and(...patterns));\n};\n\n/**\n * Parse NOT patterns within array context.\n */\nconst parseArrayNot = (lexer: Lexer): Result<Pattern> => {\n  const peeked = lexer.peekToken();\n  if (peeked !== undefined && peeked.ok && peeked.value.type === \"Not\") {\n    lexer.next(); // consume the NOT token\n    const inner = parseArrayNot(lexer); // right associative\n    if (!inner.ok) {\n      return inner;\n    }\n    return Ok(not(inner.value));\n  }\n  return parseArraySequence(lexer);\n};\n\n/**\n * Parse sequence patterns within array context (comma-separated).\n */\nconst parseArraySequence = (lexer: Lexer): Result<Pattern> => {\n  const patterns: Pattern[] = [];\n  const first = parseOrFromRegistry(lexer);\n  if (!first.ok) {\n    return first;\n  }\n  patterns.push(first.value);\n\n  while (true) {\n    const peeked = lexer.peekToken();\n    if (peeked === undefined || !peeked.ok || peeked.value.type !== \"Comma\") {\n      break;\n    }\n    lexer.next(); // consume the comma\n\n    const next = parseOrFromRegistry(lexer);\n    if (!next.ok) {\n      return next;\n    }\n    patterns.push(next.value);\n  }\n\n  if (patterns.length === 1) {\n    return Ok(patterns[0]);\n  }\n\n  return Ok(sequence(...patterns));\n};\n","/**\n * Map pattern parser.\n *\n * @module parse/structure/map-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok, Err } from \"../../error\";\nimport { anyMap } from \"../../pattern\";\nimport {\n  mapPatternWithLengthInterval,\n  mapPatternWithConstraints,\n} from \"../../pattern/structure/map-pattern\";\nimport { parseOrFromRegistry } from \"../parse-registry\";\n\n/**\n * Parse a bracket map pattern: {pattern: pattern} or {{n}} etc.\n */\nexport const parseBracketMap = (lexer: Lexer): Result<Pattern> => {\n  // Opening brace was already consumed\n  const peeked = lexer.peekToken();\n\n  if (peeked === undefined) {\n    return Err({ type: \"UnexpectedEndOfInput\" });\n  }\n\n  if (!peeked.ok) {\n    return peeked;\n  }\n\n  const token = peeked.value;\n\n  // Check for closing brace (empty map - which means \"any map\")\n  if (token.type === \"BraceClose\") {\n    lexer.next(); // consume the closing brace\n    return Ok(anyMap());\n  }\n\n  // Check for Range token (map length constraint)\n  if (token.type === \"Range\") {\n    lexer.next(); // consume the Range token\n    const pattern = mapPatternWithLengthInterval(token.quantifier.interval());\n\n    // Expect closing brace\n    const closeResult = lexer.next();\n    if (closeResult === undefined) {\n      return Err({ type: \"ExpectedCloseBrace\", span: lexer.span() });\n    }\n    if (!closeResult.ok) {\n      return closeResult;\n    }\n    if (closeResult.value.token.type !== \"BraceClose\") {\n      return Err({\n        type: \"ExpectedCloseBrace\",\n        span: closeResult.value.span,\n      });\n    }\n\n    return Ok({\n      kind: \"Structure\",\n      pattern: { type: \"Map\", pattern },\n    });\n  }\n\n  // Parse as map with key-value constraints\n  const constraints: [Pattern, Pattern][] = [];\n\n  while (true) {\n    // Parse key pattern\n    const keyResult = parseOrFromRegistry(lexer);\n    if (!keyResult.ok) {\n      return keyResult;\n    }\n\n    // Expect colon\n    const colonResult = lexer.next();\n    if (colonResult === undefined) {\n      return Err({ type: \"ExpectedColon\", span: lexer.span() });\n    }\n    if (!colonResult.ok) {\n      return colonResult;\n    }\n    if (colonResult.value.token.type !== \"Colon\") {\n      return Err({\n        type: \"ExpectedColon\",\n        span: colonResult.value.span,\n      });\n    }\n\n    // Parse value pattern\n    const valueResult = parseOrFromRegistry(lexer);\n    if (!valueResult.ok) {\n      return valueResult;\n    }\n\n    constraints.push([keyResult.value, valueResult.value]);\n\n    // Check for comma or closing brace\n    const nextToken = lexer.peekToken();\n    if (nextToken?.ok !== true) {\n      return Err({ type: \"UnexpectedEndOfInput\" });\n    }\n\n    if (nextToken.value.type === \"BraceClose\") {\n      lexer.next(); // consume the closing brace\n      break;\n    }\n\n    if (nextToken.value.type === \"Comma\") {\n      lexer.next(); // consume the comma\n      continue;\n    }\n\n    return Err({\n      type: \"UnexpectedToken\",\n      token: nextToken.value,\n      span: lexer.span(),\n    });\n  }\n\n  // Create map pattern with constraints\n  return Ok({\n    kind: \"Structure\",\n    pattern: { type: \"Map\", pattern: mapPatternWithConstraints(constraints) },\n  });\n};\n","/**\n * Tagged pattern parser.\n *\n * Supports the following syntax:\n * - `tagged` - matches any tagged value\n * - `tagged(value, pattern)` - matches tagged value with specific u64 tag and content pattern\n * - `tagged(name, pattern)` - matches tagged value with named tag and content pattern\n * - `tagged(/regex/, pattern)` - matches tagged value with tag name matching regex and content pattern\n *\n * @module parse/structure/tagged-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok, Err } from \"../../error\";\nimport { anyTagged } from \"../../pattern\";\nimport { createTag } from \"@bcts/dcbor\";\nimport {\n  taggedPatternWithTag,\n  taggedPatternWithName,\n  taggedPatternWithRegex,\n} from \"../../pattern/structure/tagged-pattern\";\nimport { parse } from \"../index\";\n\n/**\n * Tag selector discriminated union.\n */\ntype TagSelector =\n  | { type: \"Value\"; value: number }\n  | { type: \"Name\"; name: string }\n  | { type: \"Regex\"; regex: RegExp };\n\n/**\n * Parse a tagged pattern from the `tagged` keyword.\n *\n * Supports:\n * - `tagged` - matches any tagged value\n * - `tagged(value, pattern)` - matches tagged value with specific tag number\n * - `tagged(name, pattern)` - matches tagged value with named tag\n * - `tagged(/regex/, pattern)` - matches tagged value with tag name matching regex\n */\nexport const parseTagged = (lexer: Lexer): Result<Pattern> => {\n  // Check if followed by opening parenthesis\n  const peeked = lexer.peekToken();\n\n  if (peeked === undefined || !peeked.ok || peeked.value.type !== \"ParenOpen\") {\n    // No parentheses, just \"tagged\" - matches any tagged value\n    return Ok(anyTagged());\n  }\n\n  // Consume the opening parenthesis\n  lexer.next();\n\n  // Get the remainder of the input for manual parsing\n  const remainder = lexer.remainder();\n  const remainderStart = lexer.position();\n\n  // Parse the tag selector and content pattern\n  const innerResult = parseTaggedInner(remainder, remainderStart);\n  if (!innerResult.ok) {\n    return innerResult;\n  }\n\n  const [tagSelector, contentPattern, consumed] = innerResult.value;\n\n  // Advance the lexer by the consumed amount\n  lexer.bump(consumed);\n\n  // Expect closing parenthesis\n  const closeResult = lexer.next();\n  if (closeResult === undefined) {\n    return Err({ type: \"ExpectedCloseParen\", span: lexer.span() });\n  }\n  if (!closeResult.ok) {\n    return closeResult;\n  }\n  if (closeResult.value.token.type !== \"ParenClose\") {\n    return Err({\n      type: \"ExpectedCloseParen\",\n      span: closeResult.value.span,\n    });\n  }\n\n  // Create the pattern based on tag selector type\n  let taggedPattern;\n  switch (tagSelector.type) {\n    case \"Value\": {\n      const tag = createTag(BigInt(tagSelector.value));\n      taggedPattern = taggedPatternWithTag(tag, contentPattern);\n      break;\n    }\n    case \"Name\":\n      taggedPattern = taggedPatternWithName(tagSelector.name, contentPattern);\n      break;\n    case \"Regex\":\n      taggedPattern = taggedPatternWithRegex(tagSelector.regex, contentPattern);\n      break;\n  }\n\n  return Ok({\n    kind: \"Structure\",\n    pattern: { type: \"Tagged\", pattern: taggedPattern },\n  });\n};\n\n/**\n * Parse the inner content of tagged(selector, pattern).\n * Returns [TagSelector, Pattern, consumed_bytes].\n */\nconst parseTaggedInner = (\n  src: string,\n  remainderStart: number,\n): Result<[TagSelector, Pattern, number]> => {\n  let pos = 0;\n  skipWhitespace(src, (p) => (pos = p), pos);\n\n  // Parse the tag selector (first parameter)\n  let tagSelector: TagSelector;\n\n  if (src[pos] === \"/\") {\n    // Regex pattern\n    const regexResult = parseTextRegex(src, pos);\n    if (!regexResult.ok) {\n      return regexResult;\n    }\n    const [regex, newPos] = regexResult.value;\n    pos = newPos;\n    tagSelector = { type: \"Regex\", regex };\n  } else {\n    // Could be a number or a name\n    const wordResult = parseBareWord(src, pos);\n    if (!wordResult.ok) {\n      return wordResult;\n    }\n    const [word, newPos] = wordResult.value;\n    pos = newPos;\n\n    const numValue = parseInt(word, 10);\n    if (!isNaN(numValue) && numValue.toString() === word) {\n      tagSelector = { type: \"Value\", value: numValue };\n    } else {\n      tagSelector = { type: \"Name\", name: word };\n    }\n  }\n\n  // Expect comma\n  skipWhitespace(src, (p) => (pos = p), pos);\n  if (pos >= src.length || src[pos] !== \",\") {\n    return Err({ type: \"UnexpectedEndOfInput\" });\n  }\n  pos += 1;\n  skipWhitespace(src, (p) => (pos = p), pos);\n\n  // Parse the content pattern (second parameter)\n  // Handle nested parentheses to find the end of the pattern\n  const patternStart = pos;\n  let parenDepth = 0;\n  while (pos < src.length) {\n    const ch = src[pos];\n    if (ch === \"(\") {\n      parenDepth += 1;\n    } else if (ch === \")\") {\n      if (parenDepth === 0) {\n        break; // This is the closing paren for our tagged()\n      }\n      parenDepth -= 1;\n    }\n    pos += 1;\n  }\n\n  const patternSrc = src.slice(patternStart, pos);\n  const trimmedPattern = patternSrc.trim();\n  const trimOffset = patternSrc.length - patternSrc.trimStart().length;\n\n  const contentResult = parse(trimmedPattern);\n  if (!contentResult.ok) {\n    // Adjust error spans to be relative to the original input\n    const error = contentResult.error;\n    if (\"span\" in error) {\n      const offset = remainderStart + patternStart + trimOffset;\n      const adjustedSpan = {\n        start: error.span.start + offset,\n        end: error.span.end + offset,\n      };\n      // Create a new error with the adjusted span\n      return Err({ ...error, span: adjustedSpan } as typeof error);\n    }\n    return contentResult;\n  }\n\n  return Ok([tagSelector, contentResult.value, pos]);\n};\n\n/**\n * Parse a regex from the input string starting with /\n */\nconst parseTextRegex = (src: string, startPos: number): Result<[RegExp, number]> => {\n  let pos = startPos;\n  skipWhitespace(src, (p) => (pos = p), pos);\n\n  if (pos >= src.length || src[pos] !== \"/\") {\n    return Err({ type: \"UnterminatedRegex\", span: { start: pos, end: pos } });\n  }\n  pos += 1;\n  const start = pos;\n  let escape = false;\n\n  while (pos < src.length) {\n    const ch = src[pos];\n    pos += 1;\n    if (escape) {\n      escape = false;\n      continue;\n    }\n    if (ch === \"\\\\\") {\n      escape = true;\n      continue;\n    }\n    if (ch === \"/\") {\n      const inner = src.slice(start, pos - 1);\n      try {\n        const regex = new RegExp(inner);\n        skipWhitespace(src, (p) => (pos = p), pos);\n        return Ok([regex, pos]);\n      } catch {\n        return Err({ type: \"InvalidRegex\", span: { start, end: pos } });\n      }\n    }\n  }\n\n  return Err({ type: \"UnterminatedRegex\", span: { start: pos, end: pos } });\n};\n\n/**\n * Parse a bare word (alphanumeric with hyphens and underscores).\n */\nconst parseBareWord = (src: string, startPos: number): Result<[string, number]> => {\n  let pos = startPos;\n  skipWhitespace(src, (p) => (pos = p), pos);\n\n  const start = pos;\n  while (pos < src.length) {\n    const ch = src[pos];\n    if (\" \\t\\n\\r\\f,)\".includes(ch)) {\n      break;\n    }\n    pos += 1;\n  }\n\n  if (start === pos) {\n    return Err({ type: \"UnexpectedEndOfInput\" });\n  }\n\n  const word = src.slice(start, pos);\n  skipWhitespace(src, (p) => (pos = p), pos);\n\n  return Ok([word, pos]);\n};\n\n/**\n * Skip whitespace characters.\n */\nconst skipWhitespace = (src: string, setPos: (p: number) => void, pos: number): void => {\n  while (pos < src.length && \" \\t\\n\\r\\f\".includes(src[pos])) {\n    pos += 1;\n  }\n  setPos(pos);\n};\n","/**\n * Capture pattern parser.\n *\n * @module parse/meta/capture-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok, Err } from \"../../error\";\nimport { capture } from \"../../pattern\";\nimport { parseOr } from \"./or-parser\";\n\n/**\n * Parse a capture pattern of the form `@name(pattern)`.\n */\nexport const parseCapture = (lexer: Lexer, name: string): Result<Pattern> => {\n  // Expect opening parenthesis\n  const openResult = lexer.next();\n  if (openResult === undefined) {\n    return Err({ type: \"UnexpectedEndOfInput\" });\n  }\n  if (!openResult.ok) {\n    return openResult;\n  }\n  if (openResult.value.token.type !== \"ParenOpen\") {\n    return Err({\n      type: \"UnexpectedToken\",\n      token: openResult.value.token,\n      span: openResult.value.span,\n    });\n  }\n\n  // Parse the inner pattern\n  const innerResult = parseOr(lexer);\n  if (!innerResult.ok) {\n    return innerResult;\n  }\n\n  // Expect closing parenthesis\n  const closeResult = lexer.next();\n  if (closeResult === undefined) {\n    return Err({ type: \"ExpectedCloseParen\", span: lexer.span() });\n  }\n  if (!closeResult.ok) {\n    return closeResult;\n  }\n  if (closeResult.value.token.type !== \"ParenClose\") {\n    return Err({\n      type: \"ExpectedCloseParen\",\n      span: closeResult.value.span,\n    });\n  }\n\n  return Ok(capture(name, innerResult.value));\n};\n","/**\n * Search pattern parser.\n *\n * @module parse/meta/search-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok, Err } from \"../../error\";\nimport { search } from \"../../pattern\";\nimport { parseOr } from \"./or-parser\";\n\n/**\n * Parse a search pattern `...(pattern)`.\n */\nexport const parseSearch = (lexer: Lexer): Result<Pattern> => {\n  // Expect opening parenthesis\n  const openResult = lexer.next();\n  if (openResult === undefined) {\n    return Err({ type: \"UnexpectedEndOfInput\" });\n  }\n  if (!openResult.ok) {\n    return openResult;\n  }\n  if (openResult.value.token.type !== \"ParenOpen\") {\n    return Err({\n      type: \"UnexpectedToken\",\n      token: openResult.value.token,\n      span: openResult.value.span,\n    });\n  }\n\n  // Parse the inner pattern\n  const innerResult = parseOr(lexer);\n  if (!innerResult.ok) {\n    return innerResult;\n  }\n\n  // Expect closing parenthesis\n  const closeResult = lexer.next();\n  if (closeResult === undefined) {\n    return Err({ type: \"ExpectedCloseParen\", span: lexer.span() });\n  }\n  if (!closeResult.ok) {\n    return closeResult;\n  }\n  if (closeResult.value.token.type !== \"ParenClose\") {\n    return Err({\n      type: \"ExpectedCloseParen\",\n      span: closeResult.value.span,\n    });\n  }\n\n  return Ok(search(innerResult.value));\n};\n","/**\n * Repeat pattern parser (quantifiers).\n *\n * @module parse/meta/repeat-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok } from \"../../error\";\nimport { Quantifier } from \"../../quantifier\";\nimport { Reluctance } from \"../../reluctance\";\nimport { repeatPattern } from \"../../pattern/meta/repeat-pattern\";\n\n/**\n * Parse quantifier tokens that follow a grouped pattern.\n */\nexport const parseQuantifier = (\n  pattern: Pattern,\n  lexer: Lexer,\n  forceRepeat: boolean,\n): Result<Pattern> => {\n  const peeked = lexer.peekToken();\n\n  if (peeked?.ok !== true) {\n    // No quantifier found\n    if (forceRepeat) {\n      return Ok(wrapInRepeat(pattern, Quantifier.exactly(1)));\n    }\n    return Ok(pattern);\n  }\n\n  const token = peeked.value;\n\n  switch (token.type) {\n    case \"RepeatZeroOrMore\":\n      lexer.next();\n      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrMore()));\n\n    case \"RepeatZeroOrMoreLazy\":\n      lexer.next();\n      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrMore(Reluctance.Lazy)));\n\n    case \"RepeatZeroOrMorePossessive\":\n      lexer.next();\n      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrMore(Reluctance.Possessive)));\n\n    case \"RepeatOneOrMore\":\n      lexer.next();\n      return Ok(wrapInRepeat(pattern, Quantifier.oneOrMore()));\n\n    case \"RepeatOneOrMoreLazy\":\n      lexer.next();\n      return Ok(wrapInRepeat(pattern, Quantifier.oneOrMore(Reluctance.Lazy)));\n\n    case \"RepeatOneOrMorePossessive\":\n      lexer.next();\n      return Ok(wrapInRepeat(pattern, Quantifier.oneOrMore(Reluctance.Possessive)));\n\n    case \"RepeatZeroOrOne\":\n      lexer.next();\n      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrOne()));\n\n    case \"RepeatZeroOrOneLazy\":\n      lexer.next();\n      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrOne(Reluctance.Lazy)));\n\n    case \"RepeatZeroOrOnePossessive\":\n      lexer.next();\n      return Ok(wrapInRepeat(pattern, Quantifier.zeroOrOne(Reluctance.Possessive)));\n\n    case \"Range\":\n      lexer.next();\n      return Ok(wrapInRepeat(pattern, token.quantifier));\n\n    // All other tokens - no quantifier found\n    case \"And\":\n    case \"Or\":\n    case \"Not\":\n    case \"Tagged\":\n    case \"Array\":\n    case \"Map\":\n    case \"Bool\":\n    case \"ByteString\":\n    case \"Date\":\n    case \"Known\":\n    case \"Null\":\n    case \"Number\":\n    case \"Text\":\n    case \"Digest\":\n    case \"Search\":\n    case \"BoolTrue\":\n    case \"BoolFalse\":\n    case \"NaN\":\n    case \"Infinity\":\n    case \"NegInfinity\":\n    case \"ParenOpen\":\n    case \"ParenClose\":\n    case \"BracketOpen\":\n    case \"BracketClose\":\n    case \"BraceOpen\":\n    case \"BraceClose\":\n    case \"Comma\":\n    case \"Colon\":\n    case \"Ellipsis\":\n    case \"GreaterThanOrEqual\":\n    case \"LessThanOrEqual\":\n    case \"GreaterThan\":\n    case \"LessThan\":\n    case \"NumberLiteral\":\n    case \"GroupName\":\n    case \"StringLiteral\":\n    case \"SingleQuoted\":\n    case \"Regex\":\n    case \"HexString\":\n    case \"HexRegex\":\n    case \"DateQuoted\":\n    case \"DigestQuoted\":\n      // No quantifier found\n      if (forceRepeat) {\n        return Ok(wrapInRepeat(pattern, Quantifier.exactly(1)));\n      }\n      return Ok(pattern);\n  }\n};\n\n/**\n * Wrap a pattern in a RepeatPattern with the given quantifier.\n */\nconst wrapInRepeat = (pattern: Pattern, quantifier: Quantifier): Pattern => ({\n  kind: \"Meta\",\n  pattern: { type: \"Repeat\", pattern: repeatPattern(pattern, quantifier) },\n});\n","/**\n * Primary pattern parser - handles atomic patterns.\n *\n * @module parse/meta/primary-parser\n */\n\nimport { CborDate } from \"@bcts/dcbor\";\nimport { Digest } from \"@bcts/components\";\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok, Err } from \"../../error\";\nimport { any, anyArray, anyMap, text, textRegex, number, numberRange } from \"../../pattern\";\nimport { parseBool, parseBoolTrue, parseBoolFalse } from \"../value/bool-parser\";\nimport { parseNull } from \"../value/null-parser\";\nimport { parseNumber } from \"../value/number-parser\";\nimport { parseText } from \"../value/text-parser\";\nimport {\n  parseByteString,\n  parseHexStringToken,\n  parseHexRegexToken,\n} from \"../value/bytestring-parser\";\nimport { parseDate } from \"../value/date-parser\";\nimport { parseDigest } from \"../value/digest-parser\";\nimport { parseKnownValue } from \"../value/known-value-parser\";\nimport { parseTagged } from \"../structure/tagged-parser\";\nimport { parseBracketArray } from \"../structure/array-parser\";\nimport { parseBracketMap } from \"../structure/map-parser\";\nimport { parseCapture } from \"./capture-parser\";\nimport { parseSearch } from \"./search-parser\";\nimport { parseQuantifier } from \"./repeat-parser\";\nimport { parseOr } from \"./or-parser\";\nimport { mapPatternWithLengthInterval } from \"../../pattern/structure/map-pattern\";\nimport {\n  numberPatternNaN,\n  numberPatternInfinity,\n  numberPatternNegInfinity,\n  numberPatternGreaterThanOrEqual,\n  numberPatternLessThanOrEqual,\n  numberPatternGreaterThan,\n  numberPatternLessThan,\n} from \"../../pattern/value/number-pattern\";\nimport { KnownValue } from \"@bcts/known-values\";\nimport {\n  knownValuePatternValue,\n  knownValuePatternNamed,\n  knownValuePatternRegex,\n} from \"../../pattern/value/known-value-pattern\";\n\n/**\n * Parse a primary pattern - the most basic unit of pattern matching.\n */\nexport const parsePrimary = (lexer: Lexer): Result<Pattern> => {\n  const tokenResult = lexer.next();\n\n  if (tokenResult === undefined) {\n    return Err({ type: \"UnexpectedEndOfInput\" });\n  }\n\n  if (!tokenResult.ok) {\n    return tokenResult;\n  }\n\n  const spanned = tokenResult.value;\n  const token = spanned.token;\n\n  switch (token.type) {\n    // Meta patterns\n    case \"RepeatZeroOrMore\":\n      // '*' as standalone pattern means \"any\"\n      return Ok(any());\n\n    case \"Search\":\n      return parseSearch(lexer);\n\n    // Parenthesized groups\n    case \"ParenOpen\": {\n      const patternResult = parseOr(lexer);\n      if (!patternResult.ok) {\n        return patternResult;\n      }\n\n      const closeResult = lexer.next();\n      if (closeResult === undefined) {\n        return Err({ type: \"ExpectedCloseParen\", span: lexer.span() });\n      }\n      if (!closeResult.ok) {\n        return closeResult;\n      }\n      if (closeResult.value.token.type !== \"ParenClose\") {\n        return Err({\n          type: \"ExpectedCloseParen\",\n          span: closeResult.value.span,\n        });\n      }\n\n      // After closing parenthesis, check for quantifiers\n      return parseQuantifier(patternResult.value, lexer, true);\n    }\n\n    // Capture patterns (@name(...))\n    case \"GroupName\":\n      return parseCapture(lexer, token.name);\n\n    // Value patterns\n    case \"Bool\":\n      return parseBool(lexer);\n    case \"BoolTrue\":\n      return parseBoolTrue(lexer);\n    case \"BoolFalse\":\n      return parseBoolFalse(lexer);\n    case \"ByteString\":\n      return parseByteString(lexer);\n    case \"Date\":\n      return parseDate(lexer);\n    case \"Digest\":\n      return parseDigest(lexer);\n    case \"DigestQuoted\":\n      try {\n        const digest = Digest.fromHex(token.value);\n        return Ok({\n          kind: \"Value\",\n          pattern: { type: \"Digest\", pattern: { variant: \"Value\", value: digest } },\n        });\n      } catch {\n        return Err({\n          type: \"InvalidDigest\",\n          span: spanned.span,\n        });\n      }\n    case \"DateQuoted\":\n      try {\n        const date = CborDate.fromString(token.value);\n        return Ok({\n          kind: \"Value\",\n          pattern: { type: \"Date\", pattern: { variant: \"Value\", value: date } },\n        });\n      } catch {\n        return Err({\n          type: \"InvalidDate\",\n          span: spanned.span,\n        });\n      }\n    case \"Known\":\n      return parseKnownValue(lexer);\n    case \"Null\":\n      return parseNull(lexer);\n    case \"Number\":\n      return parseNumber(lexer);\n    case \"Text\":\n      return parseText(lexer);\n\n    // Direct string literal\n    case \"StringLiteral\":\n      return Ok(text(token.value));\n\n    // Single-quoted pattern (non-prefixed known value)\n    case \"SingleQuoted\":\n      return parseSingleQuotedAsKnownValue(token.value);\n\n    // Direct regex literal\n    case \"Regex\":\n      try {\n        const regex = new RegExp(token.pattern);\n        return Ok(textRegex(regex));\n      } catch {\n        return Err({\n          type: \"InvalidRegex\",\n          span: spanned.span,\n        });\n      }\n\n    // Direct hex string literal\n    case \"HexString\":\n      return parseHexStringToken(Ok(token.value));\n\n    // Direct hex regex literal\n    case \"HexRegex\":\n      try {\n        const regex = new RegExp(token.pattern);\n        return parseHexRegexToken(Ok(regex));\n      } catch {\n        return Err({\n          type: \"InvalidRegex\",\n          span: spanned.span,\n        });\n      }\n\n    // Structure patterns\n    case \"Tagged\":\n      return parseTagged(lexer);\n\n    case \"Array\":\n      return Ok(anyArray());\n\n    case \"Map\":\n      return Ok(anyMap());\n\n    // Bracket syntax for arrays\n    case \"BracketOpen\":\n      return parseBracketArray(lexer);\n\n    // Brace syntax for maps\n    case \"BraceOpen\":\n      return parseBracketMap(lexer);\n\n    // Range tokens that represent map length constraints\n    case \"Range\":\n      return Ok({\n        kind: \"Structure\",\n        pattern: {\n          type: \"Map\",\n          pattern: mapPatternWithLengthInterval(token.quantifier.interval()),\n        },\n      });\n\n    // Number literal\n    case \"NumberLiteral\": {\n      // Look ahead for range operator\n      const peeked = lexer.peekToken();\n      if (peeked !== undefined && peeked.ok && peeked.value.type === \"Ellipsis\") {\n        lexer.next(); // consume the ellipsis\n        const endResult = lexer.next();\n        if (endResult === undefined) {\n          return Err({ type: \"UnexpectedEndOfInput\" });\n        }\n        if (!endResult.ok) {\n          return endResult;\n        }\n        if (endResult.value.token.type !== \"NumberLiteral\") {\n          return Err({\n            type: \"UnexpectedToken\",\n            token: endResult.value.token,\n            span: endResult.value.span,\n          });\n        }\n        return Ok(numberRange(token.value, endResult.value.token.value));\n      }\n      return Ok(number(token.value));\n    }\n\n    case \"NaN\":\n      return Ok({\n        kind: \"Value\",\n        pattern: { type: \"Number\", pattern: numberPatternNaN() },\n      });\n\n    case \"Infinity\":\n      return Ok({\n        kind: \"Value\",\n        pattern: { type: \"Number\", pattern: numberPatternInfinity() },\n      });\n\n    case \"NegInfinity\":\n      return Ok({\n        kind: \"Value\",\n        pattern: { type: \"Number\", pattern: numberPatternNegInfinity() },\n      });\n\n    case \"GreaterThanOrEqual\": {\n      const numResult = lexer.next();\n      if (numResult === undefined) {\n        return Err({ type: \"UnexpectedEndOfInput\" });\n      }\n      if (!numResult.ok) {\n        return numResult;\n      }\n      if (numResult.value.token.type !== \"NumberLiteral\") {\n        return Err({\n          type: \"UnexpectedToken\",\n          token: numResult.value.token,\n          span: numResult.value.span,\n        });\n      }\n      return Ok({\n        kind: \"Value\",\n        pattern: {\n          type: \"Number\",\n          pattern: numberPatternGreaterThanOrEqual(numResult.value.token.value),\n        },\n      });\n    }\n\n    case \"LessThanOrEqual\": {\n      const numResult = lexer.next();\n      if (numResult === undefined) {\n        return Err({ type: \"UnexpectedEndOfInput\" });\n      }\n      if (!numResult.ok) {\n        return numResult;\n      }\n      if (numResult.value.token.type !== \"NumberLiteral\") {\n        return Err({\n          type: \"UnexpectedToken\",\n          token: numResult.value.token,\n          span: numResult.value.span,\n        });\n      }\n      return Ok({\n        kind: \"Value\",\n        pattern: {\n          type: \"Number\",\n          pattern: numberPatternLessThanOrEqual(numResult.value.token.value),\n        },\n      });\n    }\n\n    case \"GreaterThan\": {\n      const numResult = lexer.next();\n      if (numResult === undefined) {\n        return Err({ type: \"UnexpectedEndOfInput\" });\n      }\n      if (!numResult.ok) {\n        return numResult;\n      }\n      if (numResult.value.token.type !== \"NumberLiteral\") {\n        return Err({\n          type: \"UnexpectedToken\",\n          token: numResult.value.token,\n          span: numResult.value.span,\n        });\n      }\n      return Ok({\n        kind: \"Value\",\n        pattern: {\n          type: \"Number\",\n          pattern: numberPatternGreaterThan(numResult.value.token.value),\n        },\n      });\n    }\n\n    case \"LessThan\": {\n      const numResult = lexer.next();\n      if (numResult === undefined) {\n        return Err({ type: \"UnexpectedEndOfInput\" });\n      }\n      if (!numResult.ok) {\n        return numResult;\n      }\n      if (numResult.value.token.type !== \"NumberLiteral\") {\n        return Err({\n          type: \"UnexpectedToken\",\n          token: numResult.value.token,\n          span: numResult.value.span,\n        });\n      }\n      return Ok({\n        kind: \"Value\",\n        pattern: {\n          type: \"Number\",\n          pattern: numberPatternLessThan(numResult.value.token.value),\n        },\n      });\n    }\n\n    // Unexpected tokens - these token types are not valid as primary patterns\n    case \"And\":\n    case \"Or\":\n    case \"Not\":\n    case \"RepeatZeroOrMoreLazy\":\n    case \"RepeatZeroOrMorePossessive\":\n    case \"RepeatOneOrMore\":\n    case \"RepeatOneOrMoreLazy\":\n    case \"RepeatOneOrMorePossessive\":\n    case \"RepeatZeroOrOne\":\n    case \"RepeatZeroOrOneLazy\":\n    case \"RepeatZeroOrOnePossessive\":\n    case \"ParenClose\":\n    case \"BracketClose\":\n    case \"BraceClose\":\n    case \"Comma\":\n    case \"Colon\":\n    case \"Ellipsis\":\n      return Err({\n        type: \"UnexpectedToken\",\n        token,\n        span: spanned.span,\n      });\n  }\n};\n\n/**\n * Parse a single-quoted pattern as a known value.\n *\n * This handles the non-prefixed single-quoted syntax:\n * - 'value' -> known value by numeric ID\n * - 'name' -> known value by name\n * - '/regex/' -> known value by regex\n */\nconst parseSingleQuotedAsKnownValue = (value: string): Result<Pattern> => {\n  // Check if it's a regex pattern (starts and ends with /)\n  if (value.startsWith(\"/\") && value.endsWith(\"/\") && value.length > 2) {\n    const regexStr = value.slice(1, -1);\n    try {\n      const regex = new RegExp(regexStr);\n      return Ok({\n        kind: \"Value\",\n        pattern: { type: \"KnownValue\", pattern: knownValuePatternRegex(regex) },\n      });\n    } catch {\n      return Err({ type: \"InvalidRegex\", span: { start: 0, end: value.length } });\n    }\n  }\n\n  // Try to parse as numeric ID\n  const numericValue = parseInt(value, 10);\n  if (!isNaN(numericValue) && numericValue.toString() === value && numericValue >= 0) {\n    const knownValue = new KnownValue(BigInt(numericValue));\n    return Ok({\n      kind: \"Value\",\n      pattern: { type: \"KnownValue\", pattern: knownValuePatternValue(knownValue) },\n    });\n  }\n\n  // Otherwise treat as name\n  return Ok({\n    kind: \"Value\",\n    pattern: { type: \"KnownValue\", pattern: knownValuePatternNamed(value) },\n  });\n};\n","/**\n * NOT pattern parser.\n *\n * @module parse/meta/not-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok } from \"../../error\";\nimport { not } from \"../../pattern\";\nimport { parsePrimary } from \"./primary-parser\";\n\n/**\n * Parse a NOT pattern or delegate to primary parser.\n */\nexport const parseNot = (lexer: Lexer): Result<Pattern> => {\n  const peeked = lexer.peekToken();\n  if (peeked !== undefined && peeked.ok && peeked.value.type === \"Not\") {\n    lexer.next(); // consume the NOT token\n    const inner = parseNot(lexer); // right associative recursion\n    if (!inner.ok) {\n      return inner;\n    }\n    return Ok(not(inner.value));\n  }\n  return parsePrimary(lexer);\n};\n","/**\n * AND pattern parser.\n *\n * @module parse/meta/and-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok } from \"../../error\";\nimport { and } from \"../../pattern\";\nimport { parseNot } from \"./not-parser\";\n\n/**\n * Parse an AND pattern.\n */\nexport const parseAnd = (lexer: Lexer): Result<Pattern> => {\n  const patterns: Pattern[] = [];\n  const first = parseNot(lexer);\n  if (!first.ok) {\n    return first;\n  }\n  patterns.push(first.value);\n\n  while (true) {\n    const peeked = lexer.peekToken();\n    if (peeked?.ok !== true) {\n      break;\n    }\n    if (peeked.value.type !== \"And\") {\n      break;\n    }\n    lexer.next(); // consume the AND token\n\n    const next = parseNot(lexer);\n    if (!next.ok) {\n      return next;\n    }\n    patterns.push(next.value);\n  }\n\n  if (patterns.length === 1) {\n    return Ok(patterns[0]);\n  }\n\n  return Ok(and(...patterns));\n};\n","/**\n * OR pattern parser - the top-level pattern parser.\n *\n * @module parse/meta/or-parser\n */\n\nimport type { Lexer } from \"../token\";\nimport type { Pattern } from \"../../pattern\";\nimport type { Result } from \"../../error\";\nimport { Ok } from \"../../error\";\nimport { or } from \"../../pattern\";\nimport { parseAnd } from \"./and-parser\";\n\n/**\n * Parse an OR pattern - the top-level pattern parser.\n */\nexport const parseOr = (lexer: Lexer): Result<Pattern> => {\n  const patterns: Pattern[] = [];\n  const first = parseAnd(lexer);\n  if (!first.ok) {\n    return first;\n  }\n  patterns.push(first.value);\n\n  while (true) {\n    const peeked = lexer.peekToken();\n    if (peeked?.ok !== true) {\n      break;\n    }\n    if (peeked.value.type !== \"Or\") {\n      break;\n    }\n    lexer.next(); // consume the OR token\n\n    const next = parseAnd(lexer);\n    if (!next.ok) {\n      return next;\n    }\n    patterns.push(next.value);\n  }\n\n  if (patterns.length === 1) {\n    return Ok(patterns[0]);\n  }\n\n  return Ok(or(...patterns));\n};\n","/**\n * Parsing module for dCBOR patterns.\n *\n * This module provides the parser for dCBOR pattern expressions,\n * converting string representations into Pattern AST nodes.\n *\n * @module parse\n */\n\nexport * from \"./token\";\nexport * from \"./value\";\nexport * from \"./structure\";\nexport * from \"./meta\";\nexport * from \"./parse-registry\";\n\nimport type { Pattern } from \"../pattern\";\nimport type { Result } from \"../error\";\nimport { Ok, Err } from \"../error\";\nimport { Lexer } from \"./token\";\nimport { parseOr } from \"./meta/or-parser\";\nimport { setParseOrFn } from \"./parse-registry\";\n\n// Register the parseOr function with the parse registry\n// This breaks the circular dependency between meta and structure parsers\nsetParseOrFn(parseOr);\n\n/**\n * Parses a complete dCBOR pattern expression.\n *\n * @param input - The pattern string to parse\n * @returns A Result containing the parsed Pattern or an error\n *\n * @example\n * ```typescript\n * const result = parse(\"number\");\n * if (result.ok) {\n *   console.log(result.value);\n * }\n * ```\n */\nexport const parse = (input: string): Result<Pattern> => {\n  const result = parsePartial(input);\n  if (!result.ok) {\n    return result;\n  }\n\n  const [pattern, consumed] = result.value;\n  if (consumed < input.length) {\n    // There's extra data after the pattern\n    return Err({\n      type: \"ExtraData\",\n      span: { start: consumed, end: input.length },\n    });\n  }\n\n  return Ok(pattern);\n};\n\n/**\n * Parses a partial dCBOR pattern expression, returning the parsed pattern\n * and the number of characters consumed.\n *\n * Unlike `parse()`, this function succeeds even if additional characters\n * follow the first pattern. The returned index points to the first unparsed\n * character after the pattern.\n *\n * @param input - The pattern string to parse\n * @returns A Result containing a tuple of [Pattern, consumedLength] or an error\n *\n * @example\n * ```typescript\n * const result = parsePartial(\"true rest\");\n * if (result.ok) {\n *   const [pattern, consumed] = result.value;\n *   console.log(consumed); // 4 or 5 (includes whitespace)\n * }\n * ```\n */\nexport const parsePartial = (input: string): Result<[Pattern, number]> => {\n  if (input.trim().length === 0) {\n    return Err({ type: \"EmptyInput\" });\n  }\n\n  const lexer = new Lexer(input);\n  const patternResult = parseOr(lexer);\n\n  if (!patternResult.ok) {\n    return patternResult;\n  }\n\n  // Calculate consumed bytes\n  const consumed = lexer.position();\n\n  return Ok([patternResult.value, consumed]);\n};\n"],"mappings":"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"}