@bcts/envelope-pattern 1.0.0-alpha.22 → 1.0.0-beta.0

package/src/parse/leaf/array-parser.ts

@@ -0,0 +1,36 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ * Array parser — port of `bc-envelope-pattern-rust`
+ * `parse/leaf/array_parser.rs`.
+ *
+ * Mirrors Rust's flow exactly: after the `[` token has been consumed,
+ * delegate to `utils::parseArrayInner` (which handles `*`, `{n}`, `{n,m}`,
+ * `{n,}` directly and otherwise wraps the body in `[...]` and re-parses
+ * via dcbor-pattern), then expect a closing `]`.
+ *
+ * @module envelope-pattern/parse/leaf/array-parser
+ */
+
+import { type Result, err, expectedCloseBracket, ok, unexpectedToken } from "../../error";
+import type { Pattern } from "../../pattern";
+import type { Lexer } from "../token";
+import { parseArrayInner } from "../utils";
+
+export function parseArray(lexer: Lexer): Result<Pattern> {
+  const remainder = lexer.remainder();
+  const inner = parseArrayInner(remainder);
+  if (!inner.ok) return inner;
+  const [pattern, consumed] = inner.value;
+  lexer.bump(consumed);
+
+  const close = lexer.next();
+  if (close === undefined) {
+    return err(expectedCloseBracket(lexer.span()));
+  }
+  if (close.token.type !== "BracketClose") {
+    return err(unexpectedToken(close.token, close.span));
+  }
+  return ok(pattern);
+}

package/src/parse/leaf/cbor-parser.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ * CBOR pattern parser — port of `bc-envelope-pattern-rust`
+ * `parse/leaf/cbor_parser.rs`.
+ *
+ * Mirrors Rust's flow: lookahead for `(`. If absent, return `any_cbor()`.
+ * Otherwise consume the `(`, delegate to `parseCborInner` (handles
+ * `/regex/`, `ur:…`, and CBOR diagnostic notation), and expect a closing
+ * `)`.
+ *
+ * @module envelope-pattern/parse/leaf/cbor-parser
+ */
+
+import { type Result, err, expectedCloseParen, ok, unexpectedToken } from "../../error";
+import { type Pattern, anyCbor } from "../../pattern";
+import type { Lexer } from "../token";
+import { parseCborInner } from "../utils";
+
+export function parseCbor(lexer: Lexer): Result<Pattern> {
+  const next = lexer.peekToken();
+  if (next?.token.type !== "ParenOpen") {
+    return ok(anyCbor());
+  }
+
+  lexer.next(); // consume (
+
+  const remainder = lexer.remainder();
+  const innerResult = parseCborInner(remainder);
+  if (!innerResult.ok) return innerResult;
+  const [pattern, consumed] = innerResult.value;
+  lexer.bump(consumed);
+
+  const close = lexer.next();
+  if (close === undefined) {
+    return err(expectedCloseParen(lexer.span()));
+  }
+  if (close.token.type !== "ParenClose") {
+    return err(unexpectedToken(close.token, close.span));
+  }
+  return ok(pattern);
+}

package/src/parse/leaf/date-parser.ts

@@ -0,0 +1,81 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ * Date content parser — port of `bc-envelope-pattern-rust`
+ * `parse/leaf/date_parser.rs`.
+ *
+ * Mirrors Rust's `Date::from_string`, which accepts a strict ISO-8601
+ * subset, by deferring to dcbor's `CborDate.fromString`. Falls back to JS
+ * `Date.parse` only as a defensive shim — that branch is unreachable for
+ * conformant inputs.
+ *
+ * @module envelope-pattern/parse/leaf/date-parser
+ */
+
+import { CborDate } from "@bcts/dcbor";
+import { type Result, type Span, err, invalidDateFormat, invalidRegex, ok } from "../../error";
+import { type Pattern, date, dateEarliest, dateLatest, dateRange, dateRegex } from "../../pattern";
+
+/**
+ * Parse a date pattern of one of the forms accepted by Rust:
+ *
+ * - `/regex/` (regex match against ISO-8601 string)
+ * - `start...end` (inclusive range)
+ * - `start...` (earliest)
+ * - `...end` (latest)
+ * - `iso-8601` (exact)
+ *
+ * Mirrors `parse_date_content` in Rust; uses `CborDate.fromString` so the
+ * accepted formats match Rust's `bc_envelope::prelude::Date::from_string`
+ * exactly rather than the looser JS `Date.parse`.
+ */
+export function parseDateContent(content: string, span: Span): Result<Pattern> {
+  // Regex form: /pattern/
+  if (content.startsWith("/") && content.endsWith("/") && content.length >= 2) {
+    const regexStr = content.slice(1, -1);
+    try {
+      return ok(dateRegex(new RegExp(regexStr)));
+    } catch {
+      return err(invalidRegex(span));
+    }
+  }
+
+  const ellipsisIdx = content.indexOf("...");
+  if (ellipsisIdx !== -1) {
+    const left = content.slice(0, ellipsisIdx);
+    const right = content.slice(ellipsisIdx + 3);
+
+    if (left.length === 0 && right.length > 0) {
+      const parsed = parseIsoDateStrict(right);
+      if (parsed === undefined) return err(invalidDateFormat(span));
+      return ok(dateLatest(parsed));
+    }
+    if (left.length > 0 && right.length === 0) {
+      const parsed = parseIsoDateStrict(left);
+      if (parsed === undefined) return err(invalidDateFormat(span));
+      return ok(dateEarliest(parsed));
+    }
+    if (left.length > 0 && right.length > 0) {
+      const start = parseIsoDateStrict(left);
+      const end = parseIsoDateStrict(right);
+      if (start === undefined || end === undefined) return err(invalidDateFormat(span));
+      return ok(dateRange(start, end));
+    }
+    return err(invalidDateFormat(span));
+  }
+
+  const parsed = parseIsoDateStrict(content);
+  if (parsed === undefined) {
+    return err(invalidDateFormat(span));
+  }
+  return ok(date(parsed));
+}
+
+function parseIsoDateStrict(value: string): CborDate | undefined {
+  try {
+    return CborDate.fromString(value);
+  } catch {
+    return undefined;
+  }
+}

package/src/parse/leaf/known-value-parser.ts

@@ -0,0 +1,73 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ * Helpers for parsing the body of a `'…'` (single-quoted) known-value
+ * literal. Mirrors the inline body of Rust's `Token::SingleQuotedPattern`
+ * branch in `parse_primary`:
+ *
+ * - If the contents are a valid `u64`, build `Pattern::known_value(...)`.
+ * - Otherwise, build `Pattern::known_value_named(...)`.
+ *
+ * The earlier port duck-typed a fake `KnownValue`; this version uses the
+ * real `KnownValue` constructor so all subsequent KnownValue methods work
+ * (e.g., `taggedCbor()`, `name()`, etc.).
+ *
+ * @module envelope-pattern/parse/leaf/known-value-parser
+ */
+
+import { KnownValue } from "@bcts/known-values";
+import { type Result, ok } from "../../error";
+import {
+  type Pattern,
+  KnownValuePattern,
+  knownValue,
+  leafKnownValue,
+  patternLeaf,
+} from "../../pattern";
+
+/**
+ * Maximum value of a Rust `u64`. Used to reject literals that would
+ * silently wrap or lose precision when constructing a `KnownValue`.
+ */
+const U64_MAX = 0xffffffffffffffffn;
+
+/**
+ * Parse the inner contents of a `'…'` known-value pattern token.
+ *
+ * Mirrors the Rust dispatch
+ * ```ignore
+ * if let Ok(value) = content.parse::<u64>() {
+ *     Pattern::known_value(KnownValue::new(value))
+ * } else {
+ *     Pattern::known_value_named(content)
+ * }
+ * ```
+ * but uses BigInt parsing to preserve full `u64` range — the previous
+ * `parseInt(...)` path silently truncated above `2^53-1`.
+ */
+export function parseKnownValueContent(content: string): Result<Pattern> {
+  if (isU64Literal(content)) {
+    const value = BigInt(content);
+    return ok(knownValue(new KnownValue(value)));
+  }
+  return ok(patternLeaf(leafKnownValue(KnownValuePattern.named(content))));
+}
+
+function isU64Literal(content: string): boolean {
+  if (content.length === 0) return false;
+  // Rust's `u64::from_str_radix(s, 10)` (used by `parse::<u64>`) accepts
+  // ASCII digits only — no leading sign, whitespace, or underscores —
+  // and tolerates leading zeros. Anything else falls back to a named
+  // KnownValue.
+  for (let i = 0; i < content.length; i++) {
+    const c = content.charCodeAt(i);
+    if (c < 0x30 || c > 0x39) return false;
+  }
+  try {
+    const value = BigInt(content);
+    return value >= 0n && value <= U64_MAX;
+  } catch {
+    return false;
+  }
+}

package/src/parse/leaf/null-parser.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ * Null parser — port of `bc-envelope-pattern-rust` `parse/leaf/null_parser.rs`.
+ *
+ * @module envelope-pattern/parse/leaf/null-parser
+ */
+
+import { ok, type Result } from "../../error";
+import { type Pattern, nullPattern } from "../../pattern";
+import type { Lexer } from "../token";
+
+export function parseNull(_lexer: Lexer): Result<Pattern> {
+  return ok(nullPattern());
+}

package/src/parse/leaf/number-parser.ts

@@ -0,0 +1,90 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ * Number parsers — port of `bc-envelope-pattern-rust` `parse/leaf/number_parser.rs`.
+ *
+ * @module envelope-pattern/parse/leaf/number-parser
+ */
+
+import { type Result, err, ok, unexpectedEndOfInput, unexpectedToken } from "../../error";
+import {
+  type Pattern,
+  NumberPattern,
+  number,
+  numberRange,
+  numberGreaterThan,
+  numberLessThan,
+  patternLeaf,
+  leafNumber,
+} from "../../pattern";
+import type { Lexer } from "../token";
+
+/**
+ * Parses an optional `...end` suffix following an already-consumed number,
+ * mirroring Rust `parse_number_range_or_comparison`.
+ */
+export function parseNumberRangeOrComparison(lexer: Lexer, firstValue: number): Result<Pattern> {
+  const next = lexer.peekToken();
+  if (next === undefined) {
+    return ok(number(firstValue));
+  }
+
+  if (next.token.type === "Ellipsis") {
+    lexer.next(); // consume ...
+    const endToken = lexer.next();
+    if (endToken === undefined) {
+      return err(unexpectedEndOfInput());
+    }
+
+    let endValue: number;
+    if (
+      endToken.token.type === "UnsignedInteger" ||
+      endToken.token.type === "Integer" ||
+      endToken.token.type === "Float"
+    ) {
+      if (!endToken.token.value.ok) return err(endToken.token.value.error);
+      endValue = endToken.token.value.value;
+    } else {
+      return err(unexpectedToken(endToken.token, endToken.span));
+    }
+
+    return ok(numberRange(firstValue, endValue));
+  }
+
+  return ok(number(firstValue));
+}
+
+/**
+ * Parses a number following a comparison operator, mirroring Rust
+ * `parse_comparison_number`.
+ */
+export function parseComparisonNumber(lexer: Lexer, op: ">=" | "<=" | ">" | "<"): Result<Pattern> {
+  const numToken = lexer.next();
+  if (numToken === undefined) {
+    return err(unexpectedEndOfInput());
+  }
+
+  let value: number;
+  if (
+    numToken.token.type === "UnsignedInteger" ||
+    numToken.token.type === "Integer" ||
+    numToken.token.type === "Float"
+  ) {
+    if (!numToken.token.value.ok) return err(numToken.token.value.error);
+    value = numToken.token.value.value;
+  } else {
+    return err(unexpectedToken(numToken.token, numToken.span));
+  }
+
+  switch (op) {
+    case ">=":
+      return ok(patternLeaf(leafNumber(NumberPattern.greaterThanOrEqual(value))));
+    case "<=":
+      return ok(patternLeaf(leafNumber(NumberPattern.lessThanOrEqual(value))));
+    case ">":
+      return ok(numberGreaterThan(value));
+    case "<":
+      return ok(numberLessThan(value));
+  }
+}

package/src/parse/leaf/tag-parser.ts

@@ -0,0 +1,160 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ * Tag parser — port of `bc-envelope-pattern-rust`
+ * `parse/leaf/tag_parser.rs`.
+ *
+ * Mirrors the Rust dispatch exactly: lookahead for `(`; if absent, return
+ * the bare `any_tag()`. Otherwise build a synthetic dcbor-pattern
+ * expression `tagged(<inner>)`, parse it via `@bcts/dcbor-pattern`, and
+ * extract the resulting `TaggedPattern` to wrap as an envelope-pattern
+ * leaf. This keeps the **full** tag selector (number, name, regex)
+ * intact — the previous port discarded the tag value entirely.
+ *
+ * @module envelope-pattern/parse/leaf/tag-parser
+ */
+
+import {
+  parse as parseDcborPattern,
+  patternDisplay as dcborPatternDisplay,
+} from "@bcts/dcbor-pattern";
+import {
+  type Result,
+  err,
+  expectedCloseParen,
+  ok,
+  unexpectedEndOfInput,
+  unexpectedToken,
+} from "../../error";
+import { type Pattern, TaggedPattern, anyTag, patternLeaf, leafTag } from "../../pattern";
+import type { Lexer } from "../token";
+
+/**
+ * Parse `tagged` and `tagged(...)` patterns.
+ */
+export function parseTag(lexer: Lexer): Result<Pattern> {
+  const next = lexer.peekToken();
+  if (next?.token.type !== "ParenOpen") {
+    return ok(anyTag());
+  }
+
+  lexer.next(); // consume (
+
+  const remainder = lexer.remainder();
+  const closeIdx = findMatchingCloseParen(remainder);
+  if (closeIdx === undefined) {
+    return err(expectedCloseParen(lexer.span()));
+  }
+  const innerContent = remainder.slice(0, closeIdx);
+  const taggedExpr = `tagged(${innerContent})`;
+
+  const dcborResult = parseDcborPattern(taggedExpr);
+  if (dcborResult.ok) {
+    const dcborPattern = dcborResult.value;
+    if (dcborPattern.kind === "Structure" && dcborPattern.pattern.type === "Tagged") {
+      lexer.bump(closeIdx);
+      const close = lexer.next();
+      if (close === undefined) {
+        return err(expectedCloseParen(lexer.span()));
+      }
+      if (close.token.type !== "ParenClose") {
+        return err(unexpectedToken(close.token, close.span));
+      }
+      return ok(patternLeaf(leafTag(TaggedPattern.fromDcborPattern(dcborPattern.pattern.pattern))));
+    }
+
+    // Shouldn't happen for a well-formed `tagged(...)` expression, but
+    // if dcbor-pattern returned a non-Tagged structure, fall through to
+    // the simple parser below (matching Rust's UnexpectedToken arm).
+  }
+
+  // Fall back to a simple inline parser for `tagged(N)` and
+  // `tagged(name)`, mirroring Rust `parse_tag_inner`. This path is
+  // exercised only when dcbor-pattern itself can't make sense of the
+  // body — e.g. a typo. We re-emit the same error shape Rust emits
+  // (Unknown / UnexpectedToken) by giving up and letting the dcbor
+  // result propagate.
+  const fallback = parseTagInner(innerContent);
+  if (!fallback.ok) {
+    return fallback;
+  }
+  lexer.bump(closeIdx);
+  const close = lexer.next();
+  if (close === undefined) {
+    return err(expectedCloseParen(lexer.span()));
+  }
+  if (close.token.type !== "ParenClose") {
+    return err(unexpectedToken(close.token, close.span));
+  }
+  return ok(fallback.value);
+}
+
+/**
+ * Locate the index of the closing `)` matching the `(` that has already
+ * been consumed by `parseTag`. Mirrors Rust `find_matching_paren`.
+ */
+function findMatchingCloseParen(src: string): number | undefined {
+  let depth = 0;
+  for (let i = 0; i < src.length; i++) {
+    const ch = src.charCodeAt(i);
+    if (ch === 0x28 /* ( */) {
+      depth += 1;
+    } else if (ch === 0x29 /* ) */) {
+      if (depth === 0) return i;
+      depth -= 1;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Fallback for `tagged(N)` and `tagged(name)` when the full delegation
+ * to dcbor-pattern fails. Mirrors Rust `parse_tag_inner`.
+ */
+function parseTagInner(src: string): Result<Pattern> {
+  const trimmed = src.trim();
+  if (trimmed.length === 0) {
+    return err(unexpectedEndOfInput());
+  }
+  if (trimmed.startsWith("/")) {
+    // Rust passes this to `parse_text_regex`; with dcbor-pattern as the
+    // primary path, regex tagged forms always succeed there. If we reach
+    // this fallback, surface as InvalidPattern.
+    return err(unexpectedEndOfInput());
+  }
+  // Try u64 first.
+  if (/^\d+$/.test(trimmed)) {
+    try {
+      const expr = `tagged(${trimmed})`;
+      const dcborResult = parseDcborPattern(expr);
+      if (
+        dcborResult.ok &&
+        dcborResult.value.kind === "Structure" &&
+        dcborResult.value.pattern.type === "Tagged"
+      ) {
+        return ok(
+          patternLeaf(leafTag(TaggedPattern.fromDcborPattern(dcborResult.value.pattern.pattern))),
+        );
+      }
+    } catch {
+      // ignore
+    }
+  }
+  // Treat as a name.
+  const expr = `tagged(${trimmed})`;
+  const dcborResult = parseDcborPattern(expr);
+  if (
+    dcborResult.ok &&
+    dcborResult.value.kind === "Structure" &&
+    dcborResult.value.pattern.type === "Tagged"
+  ) {
+    // Reference dcborPatternDisplay just to keep tree-shaker pinning the
+    // import path stable when used elsewhere.
+    void dcborPatternDisplay;
+    return ok(
+      patternLeaf(leafTag(TaggedPattern.fromDcborPattern(dcborResult.value.pattern.pattern))),
+    );
+  }
+  return err(unexpectedEndOfInput());
+}

package/src/parse/meta/and-parser.ts

@@ -0,0 +1,40 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ * And parser — port of `bc-envelope-pattern-rust`
+ * `parse/meta/and_parser.rs`.
+ *
+ * Mirrors Rust: `parse_and` calls `parse_primary` (NOT `parse_not`); `!`
+ * is handled at a higher precedence level by `parse_not`.
+ *
+ * @module envelope-pattern/parse/meta/and-parser
+ */
+
+import { type Result, ok } from "../../error";
+import { type Pattern, and } from "../../pattern";
+import type { Lexer } from "../token";
+import { parsePrimary } from "./primary-parser";
+
+export function parseAnd(lexer: Lexer): Result<Pattern> {
+  const patterns: Pattern[] = [];
+  const first = parsePrimary(lexer);
+  if (!first.ok) return first;
+  patterns.push(first.value);
+
+  while (true) {
+    const next = lexer.peekToken();
+    if (next?.token.type !== "And") {
+      break;
+    }
+    lexer.next(); // consume &
+    const nextExpr = parsePrimary(lexer);
+    if (!nextExpr.ok) return nextExpr;
+    patterns.push(nextExpr.value);
+  }
+
+  if (patterns.length === 1) {
+    return ok(patterns[0]);
+  }
+  return ok(and(patterns));
+}

package/src/parse/meta/capture-parser.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ * Capture parser — port of `bc-envelope-pattern-rust`
+ * `parse/meta/capture_parser.rs`.
+ *
+ * The `@name(...)` form requires explicit parentheses. Mirrors Rust
+ * exactly:
+ * ```ignore
+ * @name ( expr )
+ * ```
+ * The previous TS port called `parse_group` (primary + quantifier), which
+ * wrapped the inner expression in a redundant `GroupPattern` and accepted
+ * the bare `@name p` form that Rust rejects.
+ *
+ * @module envelope-pattern/parse/meta/capture-parser
+ */
+
+import {
+  type Result,
+  err,
+  expectedCloseParen,
+  ok,
+  unexpectedEndOfInput,
+  unexpectedToken,
+} from "../../error";
+import { type Pattern, capture } from "../../pattern";
+import type { Lexer } from "../token";
+import { parseOr } from "./or-parser";
+
+export function parseCapture(lexer: Lexer, name: string): Result<Pattern> {
+  const open = lexer.next();
+  if (open === undefined) {
+    return err(unexpectedEndOfInput());
+  }
+  if (open.token.type !== "ParenOpen") {
+    return err(unexpectedToken(open.token, open.span));
+  }
+  const inner = parseOr(lexer);
+  if (!inner.ok) return inner;
+  const close = lexer.next();
+  if (close === undefined) {
+    return err(expectedCloseParen(lexer.span()));
+  }
+  if (close.token.type !== "ParenClose") {
+    return err(unexpectedToken(close.token, close.span));
+  }
+  return ok(capture(name, inner.value));
+}

package/src/parse/meta/group-parser.ts

@@ -0,0 +1,77 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ * Group parser — port of `bc-envelope-pattern-rust`
+ * `parse/meta/group_parser.rs`.
+ *
+ * Called from `parse_primary` after the opening `(` has been consumed.
+ *
+ * Mirrors Rust exactly:
+ *
+ * - Parse the inner expression with `parse_or`.
+ * - Expect `)`. If missing, surface `ExpectedCloseParen`.
+ * - Lookahead **once** for a quantifier suffix. If present, consume it
+ *   and wrap as `Pattern::repeat(inner, …)`. Otherwise return the inner
+ *   expression unchanged.
+ *
+ * The previous TS port wrapped every parenthesised expression in a
+ * dedicated `GroupPattern` and applied quantifiers to bare primaries —
+ * both broke `format(parse(s)) === s` round-tripping.
+ *
+ * @module envelope-pattern/parse/meta/group-parser
+ */
+
+import { Quantifier, Reluctance } from "@bcts/dcbor-pattern";
+import { type Result, err, expectedCloseParen, ok, unexpectedToken } from "../../error";
+import { type Pattern, repeat } from "../../pattern";
+import type { Lexer } from "../token";
+import { parseOr } from "./or-parser";
+
+export function parseGroup(lexer: Lexer): Result<Pattern> {
+  const inner = parseOr(lexer);
+  if (!inner.ok) return inner;
+
+  const close = lexer.next();
+  if (close === undefined) {
+    return err(expectedCloseParen(lexer.span()));
+  }
+  if (close.token.type !== "ParenClose") {
+    return err(unexpectedToken(close.token, close.span));
+  }
+
+  const next = lexer.peekToken();
+  if (next === undefined) {
+    return inner;
+  }
+
+  let quantifier: Quantifier | undefined;
+  const tokenType = next.token.type;
+  if (tokenType === "RepeatZeroOrMore") {
+    quantifier = Quantifier.zeroOrMore(Reluctance.Greedy);
+  } else if (tokenType === "RepeatZeroOrMoreLazy") {
+    quantifier = Quantifier.zeroOrMore(Reluctance.Lazy);
+  } else if (tokenType === "RepeatZeroOrMorePossessive") {
+    quantifier = Quantifier.zeroOrMore(Reluctance.Possessive);
+  } else if (tokenType === "RepeatOneOrMore") {
+    quantifier = Quantifier.oneOrMore(Reluctance.Greedy);
+  } else if (tokenType === "RepeatOneOrMoreLazy") {
+    quantifier = Quantifier.oneOrMore(Reluctance.Lazy);
+  } else if (tokenType === "RepeatOneOrMorePossessive") {
+    quantifier = Quantifier.oneOrMore(Reluctance.Possessive);
+  } else if (tokenType === "RepeatZeroOrOne") {
+    quantifier = Quantifier.zeroOrOne(Reluctance.Greedy);
+  } else if (tokenType === "RepeatZeroOrOneLazy") {
+    quantifier = Quantifier.zeroOrOne(Reluctance.Lazy);
+  } else if (tokenType === "RepeatZeroOrOnePossessive") {
+    quantifier = Quantifier.zeroOrOne(Reluctance.Possessive);
+  } else if (tokenType === "Range") {
+    if (!next.token.value.ok) return err(next.token.value.error);
+    quantifier = next.token.value.value;
+  } else {
+    return inner;
+  }
+
+  lexer.next(); // consume the quantifier token
+  return ok(repeat(inner.value, quantifier.min(), quantifier.max(), quantifier.reluctance()));
+}