{"version":3,"file":"index.mjs","names":["PE","DCborDate","PE"],"sources":["../src/error.ts","../src/token.ts","../src/parse.ts","../src/compose.ts"],"sourcesContent":["/**\n * Copyright Β© 2023-2026 Blockchain Commons, LLC\n * Copyright Β© 2025-2026 Parity Technologies\n *\n *\n * @bcts/dcbor-parse - Error types\n *\n * This is a 1:1 TypeScript port of bc-dcbor-parse-rust error.rs\n *\n * @module dcbor-parse/error\n */\n\nimport type { Token } from \"./token\";\n\n/**\n * Represents a span (range) in the source string.\n *\n * Corresponds to the Rust `logos::Span` type.\n *\n * **Encoding caveat (TS↔Rust)**: Rust spans are *byte* offsets into the\n * UTF-8 source. JavaScript strings are UTF-16 code-unit indexed, and\n * the TS lexer reports spans in those native code-unit units. The two\n * representations agree for ASCII input. For non-BMP / multi-byte\n * input (e.g. `\"🌎\"`, emoji, CJK characters) the indices diverge. If\n * you need byte-exact spans across implementations, transcode the\n * source to UTF-8 first or apply the equivalent `String.length` ↔\n * UTF-8 byte length conversion at the boundary.\n */\nexport interface Span {\n readonly start: number;\n readonly end: number;\n}\n\n/**\n * Creates a span with the given start and end positions.\n */\nexport function span(start: number, end: number): Span {\n return { start, end };\n}\n\n/**\n * Creates a default (empty) span.\n */\nexport function defaultSpan(): Span {\n return { start: 0, end: 0 };\n}\n\n/**\n * Parse error types.\n *\n * Corresponds to the Rust `Error` enum in error.rs\n */\nexport type ParseError =\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: \"ExpectedComma\"; readonly span: Span }\n | { readonly type: \"ExpectedColon\"; readonly span: Span }\n | { readonly type: \"UnmatchedParentheses\"; readonly span: Span }\n | { readonly type: \"UnmatchedBraces\"; readonly span: Span }\n | { readonly type: \"ExpectedMapKey\"; readonly span: Span }\n | { readonly type: \"InvalidTagValue\"; readonly value: string; readonly span: Span }\n | { readonly type: \"UnknownTagName\"; readonly name: string; readonly span: Span }\n | { readonly type: \"InvalidHexString\"; readonly span: Span }\n | { readonly type: \"InvalidBase64String\"; readonly span: Span }\n | { readonly type: \"UnknownUrType\"; readonly urType: string; readonly span: Span }\n | { readonly type: \"InvalidUr\"; readonly message: string; readonly span: Span }\n | { readonly type: \"InvalidKnownValue\"; readonly value: string; readonly span: Span }\n | { readonly type: \"UnknownKnownValueName\"; readonly name: string; readonly span: Span }\n | { readonly type: \"InvalidDateString\"; readonly dateString: string; readonly span: Span }\n | { readonly type: \"DuplicateMapKey\"; readonly span: Span };\n\n// Error constructors (lowercase to differentiate from the type)\nexport const parseError = {\n emptyInput(): ParseError {\n return { type: \"EmptyInput\" };\n },\n\n unexpectedEndOfInput(): ParseError {\n return { type: \"UnexpectedEndOfInput\" };\n },\n\n extraData(span: Span): ParseError {\n return { type: \"ExtraData\", span };\n },\n\n unexpectedToken(token: Token, span: Span): ParseError {\n return { type: \"UnexpectedToken\", token, span };\n },\n\n unrecognizedToken(span: Span): ParseError {\n return { type: \"UnrecognizedToken\", span };\n },\n\n expectedComma(span: Span): ParseError {\n return { type: \"ExpectedComma\", span };\n },\n\n expectedColon(span: Span): ParseError {\n return { type: \"ExpectedColon\", span };\n },\n\n unmatchedParentheses(span: Span): ParseError {\n return { type: \"UnmatchedParentheses\", span };\n },\n\n unmatchedBraces(span: Span): ParseError {\n return { type: \"UnmatchedBraces\", span };\n },\n\n expectedMapKey(span: Span): ParseError {\n return { type: \"ExpectedMapKey\", span };\n },\n\n invalidTagValue(value: string, span: Span): ParseError {\n return { type: \"InvalidTagValue\", value, span };\n },\n\n unknownTagName(name: string, span: Span): ParseError {\n return { type: \"UnknownTagName\", name, span };\n },\n\n invalidHexString(span: Span): ParseError {\n return { type: \"InvalidHexString\", span };\n },\n\n invalidBase64String(span: Span): ParseError {\n return { type: \"InvalidBase64String\", span };\n },\n\n unknownUrType(urType: string, span: Span): ParseError {\n return { type: \"UnknownUrType\", urType, span };\n },\n\n invalidUr(message: string, span: Span): ParseError {\n return { type: \"InvalidUr\", message, span };\n },\n\n invalidKnownValue(value: string, span: Span): ParseError {\n return { type: \"InvalidKnownValue\", value, span };\n },\n\n unknownKnownValueName(name: string, span: Span): ParseError {\n return { type: \"UnknownKnownValueName\", name, span };\n },\n\n invalidDateString(dateString: string, span: Span): ParseError {\n return { type: \"InvalidDateString\", dateString, span };\n },\n\n duplicateMapKey(span: Span): ParseError {\n return { type: \"DuplicateMapKey\", span };\n },\n};\n\n/**\n * Checks if an error is the default unrecognized token error.\n *\n * Corresponds to Rust `Error::is_default()`\n */\nexport function isDefaultError(error: ParseError): boolean {\n return error.type === \"UnrecognizedToken\";\n}\n\n/**\n * Gets the error message for a parse error.\n *\n * Corresponds to Rust's `Display` implementation for `Error`\n */\nexport function errorMessage(error: ParseError): 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\";\n case \"UnexpectedToken\":\n return `Unexpected token ${tokenDebugString(error.token)}`;\n case \"UnrecognizedToken\":\n return \"Unrecognized token\";\n case \"ExpectedComma\":\n return \"Expected comma\";\n case \"ExpectedColon\":\n return \"Expected colon\";\n case \"UnmatchedParentheses\":\n return \"Unmatched parentheses\";\n case \"UnmatchedBraces\":\n return \"Unmatched braces\";\n case \"ExpectedMapKey\":\n return \"Expected map key\";\n case \"InvalidTagValue\":\n return `Invalid tag value '${error.value}'`;\n case \"UnknownTagName\":\n return `Unknown tag name '${error.name}'`;\n case \"InvalidHexString\":\n return \"Invalid hex string\";\n case \"InvalidBase64String\":\n return \"Invalid base64 string\";\n case \"UnknownUrType\":\n return `Unknown UR type '${error.urType}'`;\n case \"InvalidUr\":\n return `Invalid UR '${error.message}'`;\n case \"InvalidKnownValue\":\n return `Invalid known value '${error.value}'`;\n case \"UnknownKnownValueName\":\n return `Unknown known value name '${error.name}'`;\n case \"InvalidDateString\":\n return `Invalid date string '${error.dateString}'`;\n case \"DuplicateMapKey\":\n return \"Duplicate map key\";\n }\n}\n\n/**\n * Gets the span for a parse error, if applicable.\n */\nexport function errorSpan(error: ParseError): Span | undefined {\n switch (error.type) {\n case \"EmptyInput\":\n case \"UnexpectedEndOfInput\":\n return undefined;\n case \"ExtraData\":\n case \"UnexpectedToken\":\n case \"UnrecognizedToken\":\n case \"ExpectedComma\":\n case \"ExpectedColon\":\n case \"UnmatchedParentheses\":\n case \"UnmatchedBraces\":\n case \"ExpectedMapKey\":\n case \"InvalidTagValue\":\n case \"UnknownTagName\":\n case \"InvalidHexString\":\n case \"InvalidBase64String\":\n case \"UnknownUrType\":\n case \"InvalidUr\":\n case \"InvalidKnownValue\":\n case \"UnknownKnownValueName\":\n case \"InvalidDateString\":\n case \"DuplicateMapKey\":\n return error.span;\n }\n}\n\n/**\n * Formats an error message with source context, line number, and caret.\n *\n * Corresponds to Rust `Error::format_message()`\n */\nfunction formatMessage(message: string, source: string, range: Span): string {\n const start = range.start;\n const end = range.end;\n\n // Walk through the characters up to `start` to find line number and line start offset\n let lineNumber = 1;\n let lineStart = 0;\n\n for (let idx = 0; idx < source.length && idx < start; idx++) {\n if (source[idx] === \"\\n\") {\n lineNumber++;\n lineStart = idx + 1;\n }\n }\n\n // Grab the exact line text (or empty if out of bounds).\n //\n // Rust uses `source.lines()` here, which strips the trailing `\\r`\n // from `\\r\\n`-terminated lines (cf. `str::lines` docs). JS\n // `String#split(\"\\n\")` retains the `\\r`, so on Windows-style input we\n // would render an extra blank glyph at end-of-line and the caret\n // would shift. Strip a trailing `\\r` to match Rust's `lines()`.\n const lines = source.split(\"\\n\");\n let line = lines[lineNumber - 1] ?? \"\";\n if (line.endsWith(\"\\r\")) {\n line = line.slice(0, -1);\n }\n\n // Column is byte-offset into that line\n const column = Math.max(0, start - lineStart);\n\n // Underline at least one caret, even for zero-width spans\n const underlineLen = Math.max(1, end - start);\n const caret = \" \".repeat(column) + \"^\".repeat(underlineLen);\n\n return `line ${lineNumber}: ${message}\\n${line}\\n${caret}`;\n}\n\n/**\n * Gets the full error message with source context.\n *\n * Corresponds to Rust `Error::full_message()`\n */\nexport function fullErrorMessage(error: ParseError, source: string): string {\n const message = errorMessage(error);\n\n switch (error.type) {\n case \"EmptyInput\":\n return formatMessage(message, source, defaultSpan());\n case \"UnexpectedEndOfInput\":\n return formatMessage(message, source, span(source.length, source.length));\n case \"ExtraData\":\n case \"UnexpectedToken\":\n case \"UnrecognizedToken\":\n case \"ExpectedComma\":\n case \"ExpectedColon\":\n case \"UnmatchedParentheses\":\n case \"UnmatchedBraces\":\n case \"ExpectedMapKey\":\n case \"InvalidTagValue\":\n case \"UnknownTagName\":\n case \"InvalidHexString\":\n case \"InvalidBase64String\":\n case \"UnknownUrType\":\n case \"InvalidUr\":\n case \"InvalidKnownValue\":\n case \"UnknownKnownValueName\":\n case \"InvalidDateString\":\n case \"DuplicateMapKey\":\n return formatMessage(message, source, error.span);\n }\n}\n\n/**\n * Creates a default parse error (UnrecognizedToken with empty span).\n *\n * Corresponds to Rust `Error::default()`\n */\nexport function defaultParseError(): ParseError {\n return parseError.unrecognizedToken(defaultSpan());\n}\n\n/**\n * Result type for parse operations.\n *\n * Corresponds to Rust `Result`\n */\nexport type ParseResult =\n { readonly ok: true; readonly value: T } | { readonly ok: false; readonly error: ParseError };\n\n/**\n * Creates a successful result.\n */\nexport function ok(value: T): ParseResult {\n return { ok: true, value };\n}\n\n/**\n * Creates an error result.\n */\nexport function err(error: ParseError): ParseResult {\n return { ok: false, error };\n}\n\n/**\n * Checks if a result is successful.\n */\nexport function isOk(result: ParseResult): result is { ok: true; value: T } {\n return result.ok;\n}\n\n/**\n * Checks if a result is an error.\n */\nexport function isErr(result: ParseResult): result is { ok: false; error: ParseError } {\n return !result.ok;\n}\n\n/**\n * Unwraps a result, throwing if it's an error.\n */\nexport function unwrap(result: ParseResult): T {\n if (result.ok) {\n return result.value;\n }\n throw new Error(errorMessage(result.error));\n}\n\n/**\n * Unwraps a result error, throwing if it's successful.\n */\nexport function unwrapErr(result: ParseResult): ParseError {\n if (!result.ok) {\n return result.error;\n }\n throw new Error(\"Called unwrapErr on an Ok result\");\n}\n\n/**\n * Renders a {@link Token} the way Rust's\n * `#[derive(Debug)]` on the corresponding enum variant would:\n *\n * - Variant-only tokens (`BraceOpen`, `Comma`, `Null`, `Unit`, `NaN`,\n * …) print as the bare variant name.\n * - Variant-with-value tokens print as `Variant(value)` where `value`\n * uses Rust's `Debug` form for the payload type:\n * `Bool(true)`, `Number(3.14)`, `String(\"foo\")` (with the inner\n * double quotes preserved β€” TS keeps them on the slice anyway),\n * `TagValue(1234)`, `KnownValueNumber(42)`, `TagName(\"date\")`,\n * `KnownValueName(\"isA\")`, `DateLiteral(2023-02-08T15:30:45.000Z)`,\n * etc.\n *\n * Mirrors Rust's `Error::UnexpectedToken(Box, Span)` formatter\n * `#[error(\"Unexpected token {0:?}\")]` so error messages stay\n * byte-identical to Rust.\n */\nfunction tokenDebugString(token: Token): string {\n switch (token.type) {\n case \"Bool\":\n return `Bool(${token.value ? \"true\" : \"false\"})`;\n case \"BraceOpen\":\n return \"BraceOpen\";\n case \"BraceClose\":\n return \"BraceClose\";\n case \"BracketOpen\":\n return \"BracketOpen\";\n case \"BracketClose\":\n return \"BracketClose\";\n case \"ParenthesisOpen\":\n return \"ParenthesisOpen\";\n case \"ParenthesisClose\":\n return \"ParenthesisClose\";\n case \"Colon\":\n return \"Colon\";\n case \"Comma\":\n return \"Comma\";\n case \"Null\":\n return \"Null\";\n case \"NaN\":\n return \"NaN\";\n case \"Infinity\":\n return \"Infinity\";\n case \"NegInfinity\":\n return \"NegInfinity\";\n case \"Unit\":\n return \"Unit\";\n case \"ByteStringHex\":\n // Rust `Token::ByteStringHex(Result>)` debug-formats the\n // `Ok(Vec)` payload as `Ok([0x68, 0x65, ...])`. We render the\n // bytes in the same `[0xNN, ...]` form so the text matches.\n return `ByteStringHex(Ok(${formatBytesDebug(token.value)}))`;\n case \"ByteStringBase64\":\n return `ByteStringBase64(Ok(${formatBytesDebug(token.value)}))`;\n case \"DateLiteral\":\n // The Rust `Date` `Debug` impl is opaque; we delegate to the\n // CborDate's own string rendering, which is the closest TS gets.\n return `DateLiteral(Ok(${String(token.value)}))`;\n case \"Number\":\n return `Number(${formatNumberDebug(token.value)})`;\n case \"String\":\n // The lexer stores the slice including the outer quotes\n // (matching Rust `Token::String(String)` which holds the raw\n // `lex.slice()`). Rust's `Debug` impl on `String` re-quotes the\n // contents β€” so a token whose value is `\"hello\"` prints as\n // `String(\"\\\"hello\\\"\")`. Since the inner already contains the\n // quotes, we can mirror Rust by `JSON.stringify`-ing.\n return `String(${JSON.stringify(token.value)})`;\n case \"TagValue\":\n return `TagValue(Ok(${tagOrKnownValueDebug(token.value)}))`;\n case \"TagName\":\n return `TagName(${JSON.stringify(token.value)})`;\n case \"KnownValueNumber\":\n return `KnownValueNumber(Ok(${tagOrKnownValueDebug(token.value)}))`;\n case \"KnownValueName\":\n return `KnownValueName(${JSON.stringify(token.value)})`;\n case \"UR\":\n // Rust `Token::UR(Result)` β†’ `UR(Ok())`. We don't\n // have access to the Rust `UR::Debug` shape, so we emit the UR\n // string form, which is stable and unambiguous.\n return `UR(Ok(${token.value.string()}))`;\n }\n}\n\n/**\n * Renders a `Vec` the way Rust's `Debug` does:\n * `[0x68, 0x65, 0x6c, 0x6c, 0x6f]`.\n */\nfunction formatBytesDebug(bytes: Uint8Array): string {\n const parts: string[] = [];\n for (const b of bytes) {\n parts.push(`0x${b.toString(16).padStart(2, \"0\")}`);\n }\n return `[${parts.join(\", \")}]`;\n}\n\n/**\n * Renders a JS `number` the way Rust's `f64::Debug` typically prints\n * it β€” using a decimal point even for integral values (e.g. `42.0`),\n * and `inf` / `-inf` / `NaN` for non-finite numbers. The dCBOR-parse\n * Rust source rarely produces a `Number` token in error messages\n * (numbers normally land in tagged-content contexts), but we still\n * mirror the convention so any error text is consistent with Rust.\n */\nfunction formatNumberDebug(n: number): string {\n if (Number.isNaN(n)) return \"NaN\";\n if (!Number.isFinite(n)) return n > 0 ? \"inf\" : \"-inf\";\n if (Number.isInteger(n)) return `${n}.0`;\n return String(n);\n}\n\n/**\n * Renders a `u64` payload the way Rust's `Debug` does β€” a bare digit\n * sequence without trailing `n` for `bigint` values. Mirrors\n * `::fmt` and `::fmt` (TagValue is a\n * type alias for u64 in `bc-ur` / `dcbor`).\n */\nfunction tagOrKnownValueDebug(value: number | bigint): string {\n return typeof value === \"bigint\" ? value.toString() : String(value);\n}\n","/**\n * Copyright Β© 2023-2026 Blockchain Commons, LLC\n * Copyright Β© 2025-2026 Parity Technologies\n *\n *\n * @bcts/dcbor-parse - Token types and Lexer\n *\n * This is a 1:1 TypeScript port of bc-dcbor-parse-rust token.rs\n *\n * @module dcbor-parse/token\n */\n\nimport { type CborDate, CborDate as DCborDate } from \"@bcts/dcbor\";\nimport { UR } from \"@bcts/uniform-resources\";\nimport { type Span, span, parseError as PE, type ParseResult, ok, err } from \"./error\";\n\n/**\n * Token types produced by the lexer.\n *\n * Corresponds to the Rust `Token` enum in token.rs.\n *\n * **u64 parity**: `TagValue` and `KnownValueNumber` are widened to\n * `number | bigint` because Rust accepts the full `u64` range\n * (`0..=2^64-1`). Values that fit in\n * {@link Number.MAX_SAFE_INTEGER} (`2^53-1`) come through as plain\n * `number`s; anything larger arrives as a `bigint` so callers don't\n * silently lose precision. This matches the way `@bcts/dcbor` already\n * stores large unsigned integers (`number | bigint`) and lets the\n * downstream `cbor({ tag, value })` builder serialize correctly.\n *\n * **String value field**: the lexer keeps the outer double quotes on\n * the slice (e.g. `\"\\\"hello\\\"\"`); the parser strips them in\n * `parseString`. Mirrors Rust `Token::String(String)` which holds the\n * raw `lex.slice()` including quotes (`token.rs:115-119`).\n */\nexport type Token =\n | { readonly type: \"Bool\"; readonly value: boolean }\n | { readonly type: \"BraceOpen\" }\n | { readonly type: \"BraceClose\" }\n | { readonly type: \"BracketOpen\" }\n | { readonly type: \"BracketClose\" }\n | { readonly type: \"ParenthesisOpen\" }\n | { readonly type: \"ParenthesisClose\" }\n | { readonly type: \"Colon\" }\n | { readonly type: \"Comma\" }\n | { readonly type: \"Null\" }\n | { readonly type: \"NaN\" }\n | { readonly type: \"Infinity\" }\n | { readonly type: \"NegInfinity\" }\n | { readonly type: \"ByteStringHex\"; readonly value: Uint8Array }\n | { readonly type: \"ByteStringBase64\"; readonly value: Uint8Array }\n | { readonly type: \"DateLiteral\"; readonly value: CborDate }\n | { readonly type: \"Number\"; readonly value: number }\n | { readonly type: \"String\"; readonly value: string }\n | { readonly type: \"TagValue\"; readonly value: number | bigint }\n | { readonly type: \"TagName\"; readonly value: string }\n | { readonly type: \"KnownValueNumber\"; readonly value: number | bigint }\n | { readonly type: \"KnownValueName\"; readonly value: string }\n | { readonly type: \"Unit\" }\n | { readonly type: \"UR\"; readonly value: UR };\n\n// Token constructors (lowercase to differentiate from the type)\nexport const token = {\n bool(value: boolean): Token {\n return { type: \"Bool\", value };\n },\n braceOpen(): Token {\n return { type: \"BraceOpen\" };\n },\n braceClose(): Token {\n return { type: \"BraceClose\" };\n },\n bracketOpen(): Token {\n return { type: \"BracketOpen\" };\n },\n bracketClose(): Token {\n return { type: \"BracketClose\" };\n },\n parenthesisOpen(): Token {\n return { type: \"ParenthesisOpen\" };\n },\n parenthesisClose(): Token {\n return { type: \"ParenthesisClose\" };\n },\n colon(): Token {\n return { type: \"Colon\" };\n },\n comma(): Token {\n return { type: \"Comma\" };\n },\n null(): Token {\n return { type: \"Null\" };\n },\n nan(): Token {\n return { type: \"NaN\" };\n },\n infinity(): Token {\n return { type: \"Infinity\" };\n },\n negInfinity(): Token {\n return { type: \"NegInfinity\" };\n },\n byteStringHex(value: Uint8Array): Token {\n return { type: \"ByteStringHex\", value };\n },\n byteStringBase64(value: Uint8Array): Token {\n return { type: \"ByteStringBase64\", value };\n },\n dateLiteral(value: CborDate): Token {\n return { type: \"DateLiteral\", value };\n },\n number(value: number): Token {\n return { type: \"Number\", value };\n },\n string(value: string): Token {\n return { type: \"String\", value };\n },\n tagValue(value: number | bigint): Token {\n return { type: \"TagValue\", value };\n },\n tagName(value: string): Token {\n return { type: \"TagName\", value };\n },\n knownValueNumber(value: number | bigint): Token {\n return { type: \"KnownValueNumber\", value };\n },\n knownValueName(value: string): Token {\n return { type: \"KnownValueName\", value };\n },\n unit(): Token {\n return { type: \"Unit\" };\n },\n ur(value: UR): Token {\n return { type: \"UR\", value };\n },\n};\n\n/**\n * Lexer for dCBOR diagnostic notation.\n *\n * Corresponds to the Rust `logos::Lexer` used in parse.rs\n */\nexport class Lexer {\n private readonly _source: string;\n private _position: number;\n private _tokenStart: number;\n private _tokenEnd: number;\n\n constructor(source: string) {\n this._source = source;\n this._position = 0;\n this._tokenStart = 0;\n this._tokenEnd = 0;\n }\n\n /**\n * Gets the current span (position range of the last token).\n */\n span(): Span {\n return span(this._tokenStart, this._tokenEnd);\n }\n\n /**\n * Gets the slice of source corresponding to the last token.\n */\n slice(): string {\n return this._source.slice(this._tokenStart, this._tokenEnd);\n }\n\n /**\n * Gets the next token, or undefined if at end of input.\n * Returns a Result to handle lexing errors.\n */\n next(): ParseResult | undefined {\n this._skipWhitespaceAndComments();\n\n if (this._position >= this._source.length) {\n return undefined;\n }\n\n this._tokenStart = this._position;\n\n // Try to match tokens in order of specificity\n const result =\n this._tryMatchKeyword() ??\n this._tryMatchDateLiteral() ??\n this._tryMatchTagValueOrNumber() ??\n this._tryMatchTagName() ??\n this._tryMatchString() ??\n this._tryMatchByteStringHex() ??\n this._tryMatchByteStringBase64() ??\n this._tryMatchKnownValue() ??\n this._tryMatchUR() ??\n this._tryMatchPunctuation();\n\n if (result === undefined) {\n // Unrecognized token - consume one character\n this._position++;\n this._tokenEnd = this._position;\n return err(PE.unrecognizedToken(this.span()));\n }\n\n return result;\n }\n\n private _skipWhitespaceAndComments(): void {\n while (this._position < this._source.length) {\n const ch = this._source[this._position];\n\n // Skip whitespace\n if (ch === \" \" || ch === \"\\t\" || ch === \"\\r\" || ch === \"\\n\" || ch === \"\\f\") {\n this._position++;\n continue;\n }\n\n // Skip inline comments: `/[^/]*/` (matches the Rust skip regex\n // `/[^/]*/`). Note that the Rust regex *does* match `//` (zero\n // non-slash characters between the two slashes), so an empty\n // comment is a valid no-op for the lexer. We accept that case too;\n // earlier revisions of this port required at least one non-slash\n // body character, which broke parity with Rust on inputs like\n // `// trailing thought`.\n if (ch === \"/\") {\n // Confirm there is a closing slash somewhere ahead. If not, fall\n // through and let the punctuation matcher report an\n // unrecognized token (Rust would equally fail to match the skip\n // regex and emit an `UnrecognizedToken`).\n let scan = this._position + 1;\n while (scan < this._source.length && this._source[scan] !== \"/\") {\n scan++;\n }\n if (scan < this._source.length) {\n this._position = scan + 1; // jump past the closing /\n continue;\n }\n // No closing /: not a comment β€” leave _position alone and break\n // out so the punctuation matcher can flag the unrecognized `/`.\n break;\n }\n\n // Skip end-of-line comments: #...\n if (ch === \"#\") {\n while (this._position < this._source.length && this._source[this._position] !== \"\\n\") {\n this._position++;\n }\n continue;\n }\n\n break;\n }\n }\n\n /**\n * Matches reserved keywords: `true`, `false`, `null`, `NaN`,\n * `Infinity`, `-Infinity`, `Unit`.\n *\n * Mirrors Rust's `Logos` `#[token(...)]` matcher\n * (`bc-dcbor-parse-rust/src/token.rs:12-50, 164`), which is greedy\n * and emits the keyword token *as soon as the literal matches* β€”\n * subsequent characters become a separate (likely unrecognized) token\n * stream. So input like `truex` lexes as `Bool(true)` followed by an\n * unrecognized run on `x`. Earlier revisions of this port enforced an\n * identifier boundary check (`!_isIdentifierChar(nextChar)`) and\n * rejected the whole prefix as a single `UnrecognizedToken`, which\n * broke span/variant parity with Rust.\n */\n private _tryMatchKeyword(): ParseResult | undefined {\n const keywords: [string, Token][] = [\n // Order matters: `-Infinity` must come before any other `-` based\n // matcher (we lex this before numbers, so the `-` doesn't get\n // siphoned off as a sign).\n [\"-Infinity\", token.negInfinity()],\n [\"true\", token.bool(true)],\n [\"false\", token.bool(false)],\n [\"null\", token.null()],\n [\"NaN\", token.nan()],\n [\"Infinity\", token.infinity()],\n [\"Unit\", token.unit()],\n ];\n\n for (const [keyword, tok] of keywords) {\n if (this._matchLiteral(keyword)) {\n this._tokenEnd = this._position;\n return ok(tok);\n }\n }\n\n return undefined;\n }\n\n private _tryMatchDateLiteral(): ParseResult | undefined {\n // ISO-8601 date: YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS...\n const dateRegex = /^\\d{4}-\\d{2}-\\d{2}(?:T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})?)?/;\n const remaining = this._source.slice(this._position);\n const match = dateRegex.exec(remaining);\n\n if (match !== null) {\n const dateStr = match[0];\n this._position += dateStr.length;\n this._tokenEnd = this._position;\n\n // Validate date components before parsing to match Rust's strict behavior\n if (!isValidDateString(dateStr)) {\n return err(PE.invalidDateString(dateStr, this.span()));\n }\n\n try {\n const date = DCborDate.fromString(dateStr);\n return ok(token.dateLiteral(date));\n } catch {\n return err(PE.invalidDateString(dateStr, this.span()));\n }\n }\n\n return undefined;\n }\n\n private _tryMatchTagValueOrNumber(): ParseResult | undefined {\n // Check for tag value: integer followed by (\n // Or just a number\n const numberRegex = /^-?(?:0|[1-9]\\d*)(?:\\.\\d+)?(?:[eE][+-]?\\d+)?/;\n const remaining = this._source.slice(this._position);\n const match = numberRegex.exec(remaining);\n\n if (match !== null) {\n const numStr = match[0];\n const nextChar = this._source[this._position + numStr.length];\n\n // Check if this is a tag value (integer followed by parenthesis)\n if (\n nextChar === \"(\" &&\n !numStr.includes(\".\") &&\n !numStr.includes(\"e\") &&\n !numStr.includes(\"E\") &&\n !numStr.startsWith(\"-\")\n ) {\n // It's a tag value. Mirrors Rust `token.rs:128-136`:\n // `stripped.parse::()` accepts the full `u64` range\n // (`0..=2^64-1`). We use `BigInt` to get exact-integer parsing,\n // then narrow to `number` when the value fits in\n // `Number.MAX_SAFE_INTEGER` so callers don't pay the bigint\n // tax for tag numbers in the common range. Anything outside\n // `[0, 2^64-1]` is reported as `InvalidTagValue` matching Rust.\n this._position += numStr.length + 1; // Include the (\n this._tokenEnd = this._position;\n\n const parsed = parseUsize64(numStr);\n if (parsed === undefined) {\n return err(\n PE.invalidTagValue(numStr, span(this._tokenStart, this._tokenStart + numStr.length)),\n );\n }\n\n return ok(token.tagValue(parsed));\n }\n\n // It's a regular number\n this._position += numStr.length;\n this._tokenEnd = this._position;\n\n const num = parseFloat(numStr);\n return ok(token.number(num));\n }\n\n return undefined;\n }\n\n private _tryMatchTagName(): ParseResult | undefined {\n // Tag name: identifier followed by (\n const tagNameRegex = /^[a-zA-Z_][a-zA-Z0-9_-]*\\(/;\n const remaining = this._source.slice(this._position);\n const match = tagNameRegex.exec(remaining);\n\n if (match !== null) {\n const fullMatch = match[0];\n const name = fullMatch.slice(0, -1); // Remove trailing (\n this._position += fullMatch.length;\n this._tokenEnd = this._position;\n\n return ok(token.tagName(name));\n }\n\n return undefined;\n }\n\n private _tryMatchString(): ParseResult | undefined {\n if (this._source[this._position] !== '\"') {\n return undefined;\n }\n\n // JavaScript-style string with escape sequences\n // eslint-disable-next-line no-control-regex\n const stringRegex = /^\"([^\"\\\\\\x00-\\x1F]|\\\\([\"\\\\bnfrt/]|u[a-fA-F0-9]{4}))*\"/;\n const remaining = this._source.slice(this._position);\n const match = stringRegex.exec(remaining);\n\n if (match !== null) {\n const fullMatch = match[0];\n this._position += fullMatch.length;\n this._tokenEnd = this._position;\n\n // Return the full string including quotes\n return ok(token.string(fullMatch));\n }\n\n // Invalid string: emit an unrecognized token covering just the\n // opening `\"` and let the next call to `next()` re-lex. Mirrors\n // Rust's Logos behaviour when the `String` regex fails to match β€”\n // the lexer emits `Error::default()` (which `expect_token` upgrades\n // to `UnrecognizedToken(span)` for the single character) and\n // recovers at the very next byte. Earlier revisions of this port\n // consumed through the next `\"` or `\\n`, which inflated the error\n // span beyond what Rust reports.\n this._position++;\n this._tokenEnd = this._position;\n return err(PE.unrecognizedToken(this.span()));\n }\n\n private _tryMatchByteStringHex(): ParseResult | undefined {\n // h'...'\n if (!this._matchLiteral(\"h'\")) {\n return undefined;\n }\n\n const hexRegex = /^[0-9a-fA-F]*/;\n const remaining = this._source.slice(this._position);\n const match = hexRegex.exec(remaining);\n const hexPart = match !== null ? match[0] : \"\";\n\n this._position += hexPart.length;\n\n if (this._source[this._position] !== \"'\") {\n this._tokenEnd = this._position;\n return err(PE.invalidHexString(this.span()));\n }\n\n this._position++; // Skip closing '\n this._tokenEnd = this._position;\n\n // Check that hex string has even length\n if (hexPart.length % 2 !== 0) {\n return err(PE.invalidHexString(this.span()));\n }\n\n // Decode hex\n const bytes = hexToBytes(hexPart);\n return ok(token.byteStringHex(bytes));\n }\n\n private _tryMatchByteStringBase64(): ParseResult | undefined {\n // b64'...'\n if (!this._matchLiteral(\"b64'\")) {\n return undefined;\n }\n\n const base64Regex = /^[A-Za-z0-9+/=]*/;\n const remaining = this._source.slice(this._position);\n const match = base64Regex.exec(remaining);\n const base64Part = match !== null ? match[0] : \"\";\n\n this._position += base64Part.length;\n\n if (this._source[this._position] !== \"'\") {\n this._tokenEnd = this._position;\n return err(PE.invalidBase64String(this.span()));\n }\n\n this._position++; // Skip closing '\n this._tokenEnd = this._position;\n\n // Check minimum length requirement (2 characters)\n if (base64Part.length < 2) {\n return err(PE.invalidBase64String(this.span()));\n }\n\n // Decode base64\n try {\n const bytes = base64ToBytes(base64Part);\n return ok(token.byteStringBase64(bytes));\n } catch {\n return err(PE.invalidBase64String(this.span()));\n }\n }\n\n private _tryMatchKnownValue(): ParseResult | undefined {\n if (this._source[this._position] !== \"'\") {\n return undefined;\n }\n\n // Check for empty string '' (Unit)\n if (this._source[this._position + 1] === \"'\") {\n this._position += 2;\n this._tokenEnd = this._position;\n return ok(token.knownValueName(\"\"));\n }\n\n // Check for numeric known value: '0' or '[1-9][0-9]*'\n const numericRegex = /^'(0|[1-9][0-9]*)'/;\n const remaining = this._source.slice(this._position);\n let match = numericRegex.exec(remaining);\n\n if (match !== null) {\n const fullMatch = match[0];\n const numStr = match[1];\n this._position += fullMatch.length;\n this._tokenEnd = this._position;\n\n // Mirrors Rust `token.rs:146-153`: `stripped.parse::()`\n // accepts the full `u64` range. We share the helper used for\n // `TagValue` to get the same narrow-when-safe-else-bigint path.\n const value = parseUsize64(numStr);\n if (value === undefined) {\n return err(PE.invalidKnownValue(numStr, span(this._tokenStart + 1, this._tokenEnd - 1)));\n }\n\n return ok(token.knownValueNumber(value));\n }\n\n // Check for named known value: '[a-zA-Z_][a-zA-Z0-9_-]*'\n const nameRegex = /^'([a-zA-Z_][a-zA-Z0-9_-]*)'/;\n match = nameRegex.exec(remaining);\n\n if (match !== null) {\n const fullMatch = match[0];\n const name = match[1];\n this._position += fullMatch.length;\n this._tokenEnd = this._position;\n\n return ok(token.knownValueName(name));\n }\n\n // Invalid known value: emit an unrecognized token covering just the\n // opening `'` and let the next call to `next()` re-lex. Mirrors\n // Rust's Logos behaviour when neither `KnownValueNumber` nor\n // `KnownValueName` regex matches β€” the lexer emits `Error::default()`\n // (single character span) and recovers at the next byte. Earlier\n // revisions of this port consumed through the closing `'`, which\n // inflated the error span beyond what Rust reports.\n this._position++;\n this._tokenEnd = this._position;\n return err(PE.unrecognizedToken(this.span()));\n }\n\n private _tryMatchUR(): ParseResult | undefined {\n // ur:type/data\n const urRegex = /^ur:([a-zA-Z0-9][a-zA-Z0-9-]*)\\/([a-zA-Z]{8,})/;\n const remaining = this._source.slice(this._position);\n const match = urRegex.exec(remaining);\n\n if (match !== null) {\n const fullMatch = match[0];\n this._position += fullMatch.length;\n this._tokenEnd = this._position;\n\n try {\n const ur = UR.fromURString(fullMatch);\n return ok(token.ur(ur));\n } catch (e) {\n const errorMsg = e instanceof Error ? e.message : String(e);\n return err(PE.invalidUr(errorMsg, this.span()));\n }\n }\n\n return undefined;\n }\n\n private _tryMatchPunctuation(): ParseResult | undefined {\n const ch = this._source[this._position];\n\n const punctuation: Record = {\n \"{\": token.braceOpen(),\n \"}\": token.braceClose(),\n \"[\": token.bracketOpen(),\n \"]\": token.bracketClose(),\n \"(\": token.parenthesisOpen(),\n \")\": token.parenthesisClose(),\n \":\": token.colon(),\n \",\": token.comma(),\n };\n\n const matched = punctuation[ch];\n if (matched !== undefined) {\n this._position++;\n this._tokenEnd = this._position;\n return ok(matched);\n }\n\n return undefined;\n }\n\n private _matchLiteral(literal: string): boolean {\n if (this._source.slice(this._position, this._position + literal.length) === literal) {\n this._position += literal.length;\n return true;\n }\n return false;\n }\n}\n\n/**\n * Strictly parses a non-negative integer string in the range\n * `[0, 2^64 - 1]`, mirroring Rust `::from_str`.\n *\n * - Empty input or non-digit characters β†’ `undefined`.\n * - Values that fit in `Number.MAX_SAFE_INTEGER` are returned as plain\n * `number`s, so callers in the common case (tag values like `40000`,\n * known values like `1`) never see a `bigint`.\n * - Values in `(2^53-1, 2^64-1]` are returned as `bigint`. dCBOR's\n * `cbor({ tag, value })` and `KnownValue` constructors both accept\n * `bigint` natively, so the bigint flows through to wire encoding\n * without precision loss.\n * - Values strictly greater than `2^64 - 1` (or negative) are rejected\n * so this parser never produces a tag/known-value outside the\n * `u64` domain β€” matches Rust which fails `parse::()` in that\n * case.\n */\nconst MAX_U64: bigint = (1n << 64n) - 1n;\nfunction parseUsize64(s: string): number | bigint | undefined {\n if (s.length === 0) return undefined;\n // The regex feeding this helper already rejects sign / leading\n // zeros / non-digits; this guard is defensive in case the helper is\n // reused elsewhere.\n if (!/^\\d+$/.test(s)) return undefined;\n let value: bigint;\n try {\n value = BigInt(s);\n } catch {\n return undefined;\n }\n if (value < 0n || value > MAX_U64) return undefined;\n // Narrow to plain `number` when safe so common-case callers never\n // see a `bigint`.\n if (value <= BigInt(Number.MAX_SAFE_INTEGER)) {\n return Number(value);\n }\n return value;\n}\n\n/**\n * Converts a hex string to bytes.\n */\nfunction hexToBytes(hex: string): Uint8Array {\n const bytes = new Uint8Array(hex.length / 2);\n for (let i = 0; i < bytes.length; i++) {\n bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);\n }\n return bytes;\n}\n\n/**\n * Converts a base64 string to bytes with strict validation.\n * Rejects base64 strings with invalid padding (matches Rust's base64 crate behavior).\n */\nfunction base64ToBytes(base64: string): Uint8Array {\n // Validate base64 padding strictly (Rust's base64 crate requires proper padding)\n const expectedPadding = (4 - (base64.replace(/=/g, \"\").length % 4)) % 4;\n const paddingMatch = /=+$/.exec(base64);\n const actualPadding = paddingMatch !== null ? paddingMatch[0].length : 0;\n\n // If there should be padding but there isn't, or padding is wrong length\n if (expectedPadding !== actualPadding) {\n throw new Error(\"Invalid base64 padding\");\n }\n\n // Use built-in atob for base64 decoding\n const binaryString = atob(base64);\n const bytes = new Uint8Array(binaryString.length);\n for (let i = 0; i < binaryString.length; i++) {\n bytes[i] = binaryString.charCodeAt(i);\n }\n return bytes;\n}\n\n/**\n * Validates a date string has valid month/day values.\n * JavaScript Date is lenient and accepts invalid dates like 2023-02-30,\n * but Rust's Date::from_string rejects them.\n */\nfunction isValidDateString(dateStr: string): boolean {\n // Extract date components\n const dateMatch = /^(\\d{4})-(\\d{2})-(\\d{2})/.exec(dateStr);\n if (dateMatch === null) return false;\n\n const year = parseInt(dateMatch[1], 10);\n const month = parseInt(dateMatch[2], 10);\n const day = parseInt(dateMatch[3], 10);\n\n // Validate month (1-12)\n if (month < 1 || month > 12) return false;\n\n // Validate day (1-N where N depends on month)\n if (day < 1) return false;\n\n // Days in each month (non-leap year)\n const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\n\n // Adjust for leap year\n const isLeapYear = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n if (isLeapYear && month === 2) {\n if (day > 29) return false;\n } else {\n if (day > daysInMonth[month - 1]) return false;\n }\n\n // If there's a time component, validate it\n const timeMatch = /T(\\d{2}):(\\d{2}):(\\d{2})/.exec(dateStr);\n if (timeMatch !== null) {\n const hour = parseInt(timeMatch[1], 10);\n const minute = parseInt(timeMatch[2], 10);\n const second = parseInt(timeMatch[3], 10);\n\n if (hour < 0 || hour > 23) return false;\n if (minute < 0 || minute > 59) return false;\n if (second < 0 || second > 59) return false;\n }\n\n return true;\n}\n","/**\n * Copyright Β© 2023-2026 Blockchain Commons, LLC\n * Copyright Β© 2025-2026 Parity Technologies\n *\n *\n * @bcts/dcbor-parse - Parse module\n *\n * This is a 1:1 TypeScript port of bc-dcbor-parse-rust parse.rs\n *\n * @module dcbor-parse/parse\n */\n\nimport { type Cbor, cbor, CborMap, getGlobalTagsStore } from \"@bcts/dcbor\";\nimport { KnownValue, KNOWN_VALUES } from \"@bcts/known-values\";\nimport type { UR } from \"@bcts/uniform-resources\";\nimport {\n type Span,\n span,\n parseError as PE,\n type ParseResult,\n ok,\n err,\n isDefaultError,\n} from \"./error\";\nimport { type Token, Lexer } from \"./token\";\n\n/**\n * Parses a dCBOR item from a string input.\n *\n * This function takes a string slice containing a dCBOR diagnostic notation\n * encoded value and attempts to parse it into a `Cbor` object. If the input\n * contains extra tokens after a valid item, an error is returned.\n *\n * @param src - A string containing the dCBOR-encoded data.\n * @returns `Ok(Cbor)` if parsing is successful and the input contains exactly one\n * valid dCBOR item, which itself might be an atomic value like a number or\n * string, or a complex value like an array or map.\n * `Err(ParseError)` if parsing fails or if extra tokens are found after the item.\n *\n * @example\n * ```typescript\n * const result = parseDcborItem(\"[1, 2, 3]\");\n * if (result.ok) {\n * console.log(result.value.toDiagnostic()); // \"[1, 2, 3]\"\n * }\n * ```\n */\nexport function parseDcborItem(src: string): ParseResult {\n const lexer = new Lexer(src);\n const firstTokenResult = expectToken(lexer);\n\n if (!firstTokenResult.ok) {\n if (firstTokenResult.error.type === \"UnexpectedEndOfInput\") {\n return err(PE.emptyInput());\n }\n return firstTokenResult;\n }\n\n const parseResult = parseItemToken(firstTokenResult.value, lexer);\n if (!parseResult.ok) {\n return parseResult;\n }\n\n // Check for extra data\n const nextToken = lexer.next();\n if (nextToken !== undefined) {\n return err(PE.extraData(lexer.span()));\n }\n\n return parseResult;\n}\n\n/**\n * Parses a dCBOR item from the beginning of a string and returns the parsed\n * `Cbor` along with the number of bytes consumed.\n *\n * Unlike `parseDcborItem`, this function succeeds even if additional\n * characters follow the first item. The returned index points to the first\n * unparsed character after skipping any trailing whitespace or comments.\n *\n * @param src - A string containing the dCBOR-encoded data.\n * @returns `Ok([Cbor, number])` with the parsed item and bytes consumed.\n *\n * @example\n * ```typescript\n * const result = parseDcborItemPartial(\"true )\");\n * if (result.ok) {\n * const [cbor, used] = result.value;\n * console.log(cbor.toDiagnostic()); // \"true\"\n * console.log(used); // 5\n * }\n * ```\n */\nexport function parseDcborItemPartial(src: string): ParseResult<[Cbor, number]> {\n const lexer = new Lexer(src);\n const firstTokenResult = expectToken(lexer);\n\n if (!firstTokenResult.ok) {\n if (firstTokenResult.error.type === \"UnexpectedEndOfInput\") {\n return err(PE.emptyInput());\n }\n return firstTokenResult;\n }\n\n const parseResult = parseItemToken(firstTokenResult.value, lexer);\n if (!parseResult.ok) {\n return parseResult;\n }\n\n // Determine consumed bytes\n const nextToken = lexer.next();\n const consumed = nextToken !== undefined ? lexer.span().start : src.length;\n\n return ok([parseResult.value, consumed]);\n}\n\n// === Private Functions ===\n\nfunction parseItem(lexer: Lexer): ParseResult {\n const tokenResult = expectToken(lexer);\n if (!tokenResult.ok) {\n return tokenResult;\n }\n return parseItemToken(tokenResult.value, lexer);\n}\n\nfunction expectToken(lexer: Lexer): ParseResult {\n const spanBefore = lexer.span();\n const result = lexer.next();\n\n if (result === undefined) {\n return err(PE.unexpectedEndOfInput());\n }\n\n if (!result.ok) {\n if (isDefaultError(result.error)) {\n return err(PE.unrecognizedToken(spanBefore));\n }\n return result;\n }\n\n return result;\n}\n\nfunction parseItemToken(token: Token, lexer: Lexer): ParseResult {\n switch (token.type) {\n case \"Bool\":\n return ok(cbor(token.value));\n\n case \"Null\":\n return ok(cbor(null));\n\n case \"ByteStringHex\":\n return ok(cbor(token.value));\n\n case \"ByteStringBase64\":\n return ok(cbor(token.value));\n\n case \"DateLiteral\":\n return ok(cbor(token.value));\n\n case \"Number\":\n return ok(cbor(token.value));\n\n case \"NaN\":\n return ok(cbor(Number.NaN));\n\n case \"Infinity\":\n return ok(cbor(Number.POSITIVE_INFINITY));\n\n case \"NegInfinity\":\n return ok(cbor(Number.NEGATIVE_INFINITY));\n\n case \"String\":\n return parseString(token.value, lexer.span());\n\n case \"UR\":\n return parseUr(token.value, lexer.span());\n\n case \"TagValue\":\n return parseNumberTag(token.value, lexer);\n\n case \"TagName\":\n return parseNameTag(token.value, lexer);\n\n case \"KnownValueNumber\":\n return ok(new KnownValue(token.value).taggedCbor());\n\n case \"KnownValueName\": {\n // Empty string means Unit (value 0)\n if (token.value === \"\") {\n return ok(new KnownValue(0).taggedCbor());\n }\n\n const knownValue = knownValueForName(token.value);\n if (knownValue !== undefined) {\n return ok(knownValue.taggedCbor());\n }\n const tokenSpan = lexer.span();\n return err(\n PE.unknownKnownValueName(token.value, span(tokenSpan.start + 1, tokenSpan.end - 1)),\n );\n }\n\n case \"Unit\":\n return ok(new KnownValue(0).taggedCbor());\n\n case \"BracketOpen\":\n return parseArray(lexer);\n\n case \"BraceOpen\":\n return parseMap(lexer);\n\n // Syntactic tokens that cannot start an item\n case \"BraceClose\":\n case \"BracketClose\":\n case \"ParenthesisOpen\":\n case \"ParenthesisClose\":\n case \"Colon\":\n case \"Comma\":\n return err(PE.unexpectedToken(token, lexer.span()));\n }\n}\n\nfunction parseString(s: string, tokenSpan: Span): ParseResult {\n if (s.startsWith('\"') && s.endsWith('\"')) {\n // Remove quotes and return the inner string\n const inner = s.slice(1, -1);\n return ok(cbor(inner));\n }\n return err(PE.unrecognizedToken(tokenSpan));\n}\n\nfunction tagForName(name: string): number | bigint | undefined {\n return getGlobalTagsStore().tagForName(name)?.value;\n}\n\nfunction knownValueForName(name: string): KnownValue | undefined {\n return KNOWN_VALUES.get().knownValueNamed(name);\n}\n\nfunction parseUr(ur: UR, tokenSpan: Span): ParseResult {\n const urType = ur.urTypeStr();\n const tag = tagForName(urType);\n\n if (tag !== undefined) {\n return ok(cbor({ tag, value: ur.cbor() }));\n }\n\n return err(\n PE.unknownUrType(urType, span(tokenSpan.start + 3, tokenSpan.start + 3 + urType.length)),\n );\n}\n\nfunction parseNumberTag(tagValue: number | bigint, lexer: Lexer): ParseResult {\n const itemResult = parseItem(lexer);\n if (!itemResult.ok) {\n return itemResult;\n }\n\n const closeResult = expectToken(lexer);\n if (!closeResult.ok) {\n if (closeResult.error.type === \"UnexpectedEndOfInput\") {\n return err(PE.unmatchedParentheses(lexer.span()));\n }\n return closeResult;\n }\n\n if (closeResult.value.type === \"ParenthesisClose\") {\n // Pass the tag value through as-is: when it's a `bigint` (i.e. a\n // u64 outside the safe-integer range), dCBOR's `cbor({ tag, value })`\n // builder serialises it as a `bigint` tag β€” matching Rust which\n // accepts the full `0..=2^64-1` range natively.\n return ok(cbor({ tag: tagValue, value: itemResult.value }));\n }\n\n return err(PE.unmatchedParentheses(lexer.span()));\n}\n\nfunction parseNameTag(name: string, lexer: Lexer): ParseResult {\n const tagSpan = span(lexer.span().start, lexer.span().end - 1);\n\n const itemResult = parseItem(lexer);\n if (!itemResult.ok) {\n return itemResult;\n }\n\n const closeResult = expectToken(lexer);\n if (!closeResult.ok) {\n return closeResult;\n }\n\n if (closeResult.value.type === \"ParenthesisClose\") {\n const tag = tagForName(name);\n if (tag !== undefined) {\n return ok(cbor({ tag, value: itemResult.value }));\n }\n return err(PE.unknownTagName(name, tagSpan));\n }\n\n return err(PE.unmatchedParentheses(lexer.span()));\n}\n\nfunction parseArray(lexer: Lexer): ParseResult {\n const items: Cbor[] = [];\n let awaitsComma = false;\n let awaitsItem = false;\n\n while (true) {\n const tokenResult = expectToken(lexer);\n if (!tokenResult.ok) {\n return tokenResult;\n }\n\n const token = tokenResult.value;\n\n // Handle closing bracket\n if (token.type === \"BracketClose\" && !awaitsItem) {\n return ok(cbor(items));\n }\n\n // Handle comma\n if (token.type === \"Comma\" && awaitsComma) {\n awaitsItem = true;\n awaitsComma = false;\n continue;\n }\n\n // Expect an item when not awaiting comma\n if (awaitsComma) {\n return err(PE.expectedComma(lexer.span()));\n }\n\n // Parse the item\n const itemResult = parseItemToken(token, lexer);\n if (!itemResult.ok) {\n return itemResult;\n }\n\n items.push(itemResult.value);\n awaitsItem = false;\n awaitsComma = true;\n }\n}\n\nfunction parseMap(lexer: Lexer): ParseResult {\n const map = new CborMap();\n let awaitsComma = false;\n let awaitsKey = false;\n\n while (true) {\n const tokenResult = expectToken(lexer);\n if (!tokenResult.ok) {\n if (tokenResult.error.type === \"UnexpectedEndOfInput\") {\n return err(PE.unmatchedBraces(lexer.span()));\n }\n return tokenResult;\n }\n\n const token = tokenResult.value;\n\n // Handle closing brace\n if (token.type === \"BraceClose\" && !awaitsKey) {\n return ok(cbor(map));\n }\n\n // Handle comma\n if (token.type === \"Comma\" && awaitsComma) {\n awaitsKey = true;\n awaitsComma = false;\n continue;\n }\n\n // Expect a key when not awaiting comma\n if (awaitsComma) {\n return err(PE.expectedComma(lexer.span()));\n }\n\n // Parse the key\n const keyResult = parseItemToken(token, lexer);\n if (!keyResult.ok) {\n return keyResult;\n }\n\n const key = keyResult.value;\n const keySpan = lexer.span();\n\n // Check for duplicate key\n if (map.has(key)) {\n return err(PE.duplicateMapKey(keySpan));\n }\n\n // Expect colon.\n //\n // Mirrors Rust `parse.rs:382-395`:\n // ```\n // if let Ok(Token::Colon) = expect_token(lexer) { … }\n // else { return Err(Error::ExpectedColon(lexer.span())); }\n // ```\n // Rust's pattern collapses *every* non-Colon outcome β€” including\n // `UnexpectedEndOfInput`, `UnrecognizedToken`, and any other error\n // β€” into `ExpectedColon`. Earlier revisions of this port forwarded\n // the inner error verbatim, so `{1` reported `UnexpectedEndOfInput`\n // instead of `ExpectedColon`.\n const colonResult = expectToken(lexer);\n if (!colonResult.ok || colonResult.value.type !== \"Colon\") {\n return err(PE.expectedColon(lexer.span()));\n }\n\n // Parse the value.\n //\n // Rust `parse.rs:383-389` uses the inner `UnexpectedToken`'s **own**\n // span when it converts to `ExpectedMapKey`. Earlier revisions of\n // this port called `lexer.span()` here, which can drift if the\n // lexer has stepped past the offending `}`. We now use the\n // captured span from `valueResult.error` to preserve Rust's exact\n // span semantics.\n const valueResult = parseItem(lexer);\n if (!valueResult.ok) {\n if (valueResult.error.type === \"UnexpectedToken\") {\n const unexpected = valueResult.error;\n if (unexpected.token.type === \"BraceClose\") {\n return err(PE.expectedMapKey(unexpected.span));\n }\n }\n return valueResult;\n }\n\n map.set(key, valueResult.value);\n awaitsKey = false;\n awaitsComma = true;\n }\n}\n","/**\n * Copyright Β© 2023-2026 Blockchain Commons, LLC\n * Copyright Β© 2025-2026 Parity Technologies\n *\n *\n * @bcts/dcbor-parse - Compose module\n *\n * This is a 1:1 TypeScript port of bc-dcbor-parse-rust compose.rs\n *\n * @module dcbor-parse/compose\n */\n\nimport { type Cbor, cbor, CborMap } from \"@bcts/dcbor\";\nimport { type ParseError, errorMessage } from \"./error\";\nimport { parseDcborItem } from \"./parse\";\n\n/**\n * Compose error types.\n *\n * Corresponds to the Rust `Error` enum in compose.rs\n */\nexport type ComposeError =\n | { readonly type: \"OddMapLength\" }\n | { readonly type: \"DuplicateMapKey\" }\n | { readonly type: \"ParseError\"; readonly error: ParseError };\n\n// ComposeError constructors (lowercase to differentiate from the type)\nexport const composeError = {\n oddMapLength(): ComposeError {\n return { type: \"OddMapLength\" };\n },\n\n duplicateMapKey(): ComposeError {\n return { type: \"DuplicateMapKey\" };\n },\n\n parseError(error: ParseError): ComposeError {\n return { type: \"ParseError\", error };\n },\n};\n\n/**\n * Gets the error message for a compose error.\n *\n * Mirrors Rust `Error::Display` (`bc-dcbor-parse-rust/src/compose.rs`):\n * the `ParseError` arm uses `#[error(\"Invalid CBOR item: {0}\")]`, which\n * formats the inner error via its `Display` impl β€” *not* the variant\n * name. So `Error::ParseError(Error::EmptyInput)` formats as\n * `\"Invalid CBOR item: Empty input\"`, not\n * `\"Invalid CBOR item: EmptyInput\"`. We delegate to {@link errorMessage}\n * to get the same `Display`-style text.\n */\nexport function composeErrorMessage(error: ComposeError): string {\n switch (error.type) {\n case \"OddMapLength\":\n return \"Invalid odd map length\";\n case \"DuplicateMapKey\":\n return \"Duplicate map key\";\n case \"ParseError\":\n return `Invalid CBOR item: ${errorMessage(error.error)}`;\n }\n}\n\n/**\n * Result type for compose operations.\n *\n * Corresponds to Rust `Result`\n */\nexport type ComposeResult =\n { readonly ok: true; readonly value: T } | { readonly ok: false; readonly error: ComposeError };\n\n/**\n * Creates a successful compose result.\n */\nexport function composeOk(value: T): ComposeResult {\n return { ok: true, value };\n}\n\n/**\n * Creates an error compose result.\n */\nexport function composeErr(error: ComposeError): ComposeResult {\n return { ok: false, error };\n}\n\n/**\n * Composes a dCBOR array from a slice of string slices, and returns a CBOR\n * object representing the array.\n *\n * Each string slice is parsed as a dCBOR item.\n *\n * @param array - Array of strings, each representing a dCBOR item\n * @returns A CBOR array containing all parsed items\n *\n * @example\n * ```typescript\n * const result = composeDcborArray([\"1\", \"2\", \"3\"]);\n * if (result.ok) {\n * console.log(result.value.toDiagnostic()); // \"[1, 2, 3]\"\n * }\n * ```\n */\nexport function composeDcborArray(array: readonly string[]): ComposeResult {\n const result: Cbor[] = [];\n\n for (const item of array) {\n const parseResult = parseDcborItem(item);\n if (!parseResult.ok) {\n return composeErr(composeError.parseError(parseResult.error));\n }\n result.push(parseResult.value);\n }\n\n return composeOk(cbor(result));\n}\n\n/**\n * Composes a dCBOR map from a slice of string slices, and returns a CBOR\n * object representing the map.\n *\n * The length of the slice must be even, as each key must have a corresponding\n * value.\n *\n * Each string slice is parsed as a dCBOR item.\n *\n * @param array - Array of strings representing key-value pairs in alternating order\n * @returns A CBOR map containing all parsed key-value pairs\n *\n * @example\n * ```typescript\n * const result = composeDcborMap([\"1\", \"2\", \"3\", \"4\"]);\n * if (result.ok) {\n * console.log(result.value.toDiagnostic()); // \"{1: 2, 3: 4}\"\n * }\n * ```\n */\nexport function composeDcborMap(array: readonly string[]): ComposeResult {\n if (array.length % 2 !== 0) {\n return composeErr(composeError.oddMapLength());\n }\n\n const map = new CborMap();\n\n for (let i = 0; i < array.length; i += 2) {\n const keyStr = array[i];\n const valueStr = array[i + 1];\n\n const keyResult = parseDcborItem(keyStr);\n if (!keyResult.ok) {\n return composeErr(composeError.parseError(keyResult.error));\n }\n\n const valueResult = parseDcborItem(valueStr);\n if (!valueResult.ok) {\n return composeErr(composeError.parseError(valueResult.error));\n }\n\n // Check for duplicate key\n if (map.has(keyResult.value)) {\n return composeErr(composeError.duplicateMapKey());\n }\n\n map.set(keyResult.value, valueResult.value);\n }\n\n return composeOk(cbor(map));\n}\n"],"mappings":"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"}