@decimalturn/toml-patch 3.3.1-lite → 3.3.2-dev

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (81) hide show
  1. package/dist/dev/comment-alignment.js +372 -0
  2. package/dist/dev/comment-alignment.js.map +1 -0
  3. package/dist/dev/comment-ownership.js +673 -0
  4. package/dist/dev/comment-ownership.js.map +1 -0
  5. package/dist/dev/cst-source.js +118 -0
  6. package/dist/dev/cst-source.js.map +1 -0
  7. package/dist/dev/cst.js +68 -0
  8. package/dist/dev/cst.js.map +1 -0
  9. package/dist/dev/cursor.js +66 -0
  10. package/dist/dev/cursor.js.map +1 -0
  11. package/dist/dev/date-format.js +287 -0
  12. package/dist/dev/date-format.js.map +1 -0
  13. package/dist/dev/decode-utf8.js +27 -0
  14. package/dist/dev/decode-utf8.js.map +1 -0
  15. package/dist/dev/diff-lite.js +108 -0
  16. package/dist/dev/diff-lite.js.map +1 -0
  17. package/dist/dev/diff.js +265 -0
  18. package/dist/dev/diff.js.map +1 -0
  19. package/dist/dev/encode-lite.js +210 -0
  20. package/dist/dev/encode-lite.js.map +1 -0
  21. package/dist/dev/escape-preference.js +166 -0
  22. package/dist/dev/escape-preference.js.map +1 -0
  23. package/dist/dev/find-by-path.js +115 -0
  24. package/dist/dev/find-by-path.js.map +1 -0
  25. package/dist/dev/formatter.js +298 -0
  26. package/dist/dev/formatter.js.map +1 -0
  27. package/dist/dev/generate.js +480 -0
  28. package/dist/dev/generate.js.map +1 -0
  29. package/dist/dev/inline-comma-space.js +13 -0
  30. package/dist/dev/inline-comma-space.js.map +1 -0
  31. package/dist/dev/inline-format.js +106 -0
  32. package/dist/dev/inline-format.js.map +1 -0
  33. package/dist/dev/inline-layout.js +107 -0
  34. package/dist/dev/inline-layout.js.map +1 -0
  35. package/dist/dev/line-ending-backslash.js +320 -0
  36. package/dist/dev/line-ending-backslash.js.map +1 -0
  37. package/dist/dev/literal-string.js +46 -0
  38. package/dist/dev/literal-string.js.map +1 -0
  39. package/dist/dev/location.js +104 -0
  40. package/dist/dev/location.js.map +1 -0
  41. package/dist/dev/parse-error.js +27 -0
  42. package/dist/dev/parse-error.js.map +1 -0
  43. package/dist/dev/parse-js.js +150 -0
  44. package/dist/dev/parse-js.js.map +1 -0
  45. package/dist/dev/parse-string.js +120 -0
  46. package/dist/dev/parse-string.js.map +1 -0
  47. package/dist/dev/parse-toml.js +714 -0
  48. package/dist/dev/parse-toml.js.map +1 -0
  49. package/dist/dev/patch-lite.js +4 -0
  50. package/dist/dev/patch-lite2.js +97 -0
  51. package/dist/dev/patch-lite2.js.map +1 -0
  52. package/dist/dev/patch.js +3128 -0
  53. package/dist/dev/patch.js.map +1 -0
  54. package/dist/dev/smol-toml-date.js +61 -0
  55. package/dist/dev/smol-toml-date.js.map +1 -0
  56. package/dist/dev/to-js.js +308 -0
  57. package/dist/dev/to-js.js.map +1 -0
  58. package/dist/dev/to-toml.js +874 -0
  59. package/dist/dev/to-toml.js.map +1 -0
  60. package/dist/dev/tokenizer.js +225 -0
  61. package/dist/dev/tokenizer.js.map +1 -0
  62. package/dist/dev/toml-document.js +221 -0
  63. package/dist/dev/toml-document.js.map +1 -0
  64. package/dist/dev/toml-format.js +549 -0
  65. package/dist/dev/toml-format.js.map +1 -0
  66. package/dist/dev/toml-patch.js +94 -0
  67. package/dist/dev/toml-patch.js.map +1 -0
  68. package/dist/dev/traverse.js +61 -0
  69. package/dist/dev/traverse.js.map +1 -0
  70. package/dist/dev/truncate.js +64 -0
  71. package/dist/dev/truncate.js.map +1 -0
  72. package/dist/dev/update-order.js +235 -0
  73. package/dist/dev/update-order.js.map +1 -0
  74. package/dist/dev/utils.js +296 -0
  75. package/dist/dev/utils.js.map +1 -0
  76. package/dist/dev/writer.js +758 -0
  77. package/dist/dev/writer.js.map +1 -0
  78. package/dist/toml-patch.d.ts +564 -0
  79. package/package.json +11 -6
  80. package/dist/patch.js +0 -20
  81. /package/dist/{patch.d.ts → patch-lite.d.ts} +0 -0
@@ -0,0 +1 @@
1
+ {"version":3,"file":"line-ending-backslash.js","names":[],"sources":["../../src/line-ending-backslash.ts"],"sourcesContent":["/**\n * Line ending backslash (line-continuation) handling for basic multiline strings.\n *\n * In TOML, a backslash at the end of a line inside a `\"\"\"` string acts as a\n * line-continuation marker: the backslash, the following newline and any\n * leading whitespace on the next line are all trimmed, effectively joining\n * the two lines together.\n *\n * Literal multiline strings (`'''`) do NOT support this — backslashes there\n * are always literal characters.\n *\n * This module provides:\n * - `detectLineContinuation` — checks whether an existing raw string uses\n * line-continuation formatting.\n * - `rebuildLineContinuation` — rebuilds the raw TOML string with a new\n * escaped value while preserving the original line-continuation layout.\n */\n\ninterface Segment {\n indent: string;\n content: string;\n trailingWs: string;\n hasBackslash: boolean;\n isBlank: boolean;\n}\n\nfunction detectFirstStructuralNewline(value: string): '\\r\\n' | '\\n' {\n const match = value.match(/\\r\\n|\\n/);\n return match?.[0] === '\\r\\n' ? '\\r\\n' : '\\n';\n}\n\n/**\n * Rebuilds a basic multiline string (`\"\"\"`) that uses line ending backslash\n * (line-continuation) formatting.\n *\n * Handles all three opening formats:\n * - `\"\"\"\\<NL>content\\<NL>indent\"\"\"` (leading line-continuation)\n * - `\"\"\"<NL>content\\<NL>...\"\"\"` (leading newline)\n * - `\"\"\"content\\<NL>...\"\"\"` (no leading newline)\n *\n * Strategy:\n * 1. Detect the opening format and where the body starts.\n * 2. Parse body lines into segments (indent, content, trailing whitespace,\n * backslash flag), preserving blank lines.\n * 3. Measure the max content length from content lines.\n * 4. Detect \"blank-line paragraph style\": if the original uses blank lines to\n * separate paragraphs (non-backslash content line followed by a blank line),\n * split the new value on double-newlines and pack each paragraph separately,\n * rejoined by blank lines.\n * 5. Otherwise, encode newlines as `\\n` escape sequences and pack as a single group.\n * 6. Reassemble with the original opening format, per-line whitespace and\n * backslash placement.\n *\n * @param existingRaw - The full raw TOML string including delimiters (`\"\"\"`).\n * @param escaped - The new value already escaped for a basic multiline string\n * (backslashes doubled, control characters replaced with escape sequences).\n * May contain real newline characters; this function handles their encoding.\n * @param newlineChar - The newline character to use (`'\\n'` or `'\\r\\n'`).\n * @returns The reconstructed raw TOML string, or `null` if the value cannot be\n * represented in line-continuation format (e.g. values with leading spaces or\n * a trailing space count that doesn't match the original layout).\n */\nexport function rebuildLineContinuation(\n existingRaw: string,\n escaped: string\n): string | null {\n // Normalize existingRaw to the first structural line ending found in the\n // received multiline string so mixed-ending inputs are rebuilt consistently.\n // Replace all CRLF first, then any remaining bare LF, then re-introduce that\n // detected sequence.\n const newlineChar = detectFirstStructuralNewline(existingRaw);\n existingRaw = existingRaw.replace(/\\r\\n/g, '\\n').replace(/\\n/g, newlineChar);\n\n // Line-continuation is only valid in basic multiline strings.\n const delimiter = '\"\"\"';\n // Determine the opening format and where the body starts\n let bodyStart: number;\n let openingPrefix: string;\n\n if (existingRaw.startsWith(`${delimiter}\\\\${newlineChar}`)) {\n // \"\"\"\\<NL> format — delimiter followed by line-continuation\n bodyStart = delimiter.length + 1 + newlineChar.length;\n openingPrefix = `${delimiter}\\\\${newlineChar}`;\n } else if (existingRaw.startsWith(`${delimiter}${newlineChar}`)) {\n // \"\"\"<NL> format — delimiter followed by newline\n bodyStart = delimiter.length + newlineChar.length;\n openingPrefix = `${delimiter}${newlineChar}`;\n } else {\n // \"\"\"content format — no newline after delimiter\n bodyStart = delimiter.length;\n openingPrefix = delimiter;\n }\n\n const bodyEnd = existingRaw.length - delimiter.length;\n const body = existingRaw.slice(bodyStart, bodyEnd);\n const rawLines = body.split(newlineChar);\n\n // Determine closing format: does the closing delimiter sit on its own line?\n const lastLine = rawLines[rawLines.length - 1];\n const hasClosingIndent = rawLines.length > 1 && /^[\\t ]*$/.test(lastLine);\n const closingIndent = hasClosingIndent ? lastLine : '';\n const bodyLines = hasClosingIndent ? rawLines.slice(0, -1) : rawLines;\n\n const segments: Segment[] = bodyLines.map(line => {\n if (/^[\\t ]*$/.test(line)) {\n // Preserve the original whitespace-only line so it round-trips faithfully\n return { indent: line, content: '', trailingWs: '', hasBackslash: false, isBlank: true };\n }\n\n let stripped = line;\n // Count trailing backslashes: an odd count means the last one is a line-continuation\n // marker; an even count means they are all literal escaped backslashes.\n let backslashCount = 0;\n for (let i = stripped.length - 1; i >= 0 && stripped[i] === '\\\\'; i--) {\n backslashCount++;\n }\n const hasBackslash = backslashCount % 2 === 1;\n if (hasBackslash) {\n stripped = stripped.slice(0, -1);\n }\n\n const indent = stripped.match(/^[\\t ]*/)?.[0] ?? '';\n const afterIndent = stripped.slice(indent.length);\n const trailingMatch = afterIndent.match(/([\\t ]+)$/);\n const trailingWs = trailingMatch ? trailingMatch[1] : '';\n const content = afterIndent.slice(0, afterIndent.length - trailingWs.length);\n\n return { indent, content, trailingWs, hasBackslash, isBlank: false };\n });\n\n const contentSegments = segments.filter(s => !s.isBlank);\n\n // Measure max content width across all content lines (including the tail).\n // Width = content + trailing whitespace, because the trailing space is part of the\n // visible line before the line-continuation backslash.\n const maxLength = Math.max(...contentSegments.map(s => s.content.length + s.trailingWs.length), 1);\n\n // Determine which segment prototype to use for extra lines beyond the original count.\n // When the opening is `\"\"\"\\<NL>`, the continuation backslash is part of the opening\n // prefix (not the body), so continuationSegs and even contentSegments can be empty.\n const continuationSegs = contentSegments.filter(s => s.hasBackslash);\n const defaultProto: Segment = { indent: '', trailingWs: '', hasBackslash: false, content: '', isBlank: false };\n const contProto = continuationSegs[continuationSegs.length - 1]\n ?? contentSegments[contentSegments.length - 1]\n ?? defaultProto;\n const tailProto = contentSegments[contentSegments.length - 1] ?? contProto;\n\n // Record blank groups between consecutive content segments.\n // blankGroups[i] = the original blank lines (preserving their content) between\n // contentSegments[i] and [i+1].\n const blankGroups: string[][] = [];\n {\n let blanks: string[] = [];\n let ci = 0;\n for (const seg of segments) {\n if (seg.isBlank) {\n blanks.push(seg.indent);\n } else {\n if (ci > 0) blankGroups.push(blanks);\n blanks = [];\n ci++;\n }\n }\n }\n\n // Detect literal line-break style in the original source: a non-tail content segment\n // without a trailing backslash means the next newline is semantic (not line-continuation).\n // When present, we prefer preserving real source line breaks from the new value and avoid\n // turning them into \\n escapes where possible.\n const hasLiteralLineBreakStyle = contentSegments.some((seg, i) =>\n !seg.hasBackslash && i < contentSegments.length - 1\n );\n\n const isLeadingNewlineOpening = openingPrefix === `${delimiter}${newlineChar}`;\n // In `\"\"\"<NL>` mode, derive the first-line indent from the value's own leading\n // whitespace so packing sees only \"content\". In `\"\"\"\\<NL>` mode there is no\n // structural indent, so any leading space in the value must be rejected.\n const newFirstIndent = isLeadingNewlineOpening && contentSegments.length > 0\n ? escaped.match(/^[\\t ]*/)?.[0] ?? ''\n : '';\n\n // Helper: greedy word-packer. Splits content at whitespace boundaries to honour\n // maxLength, appending the whitespace run as trailing ws before the line-continuation.\n const packContent = (input: string): string[] => {\n const tokens = input.match(/\\S+| +/g) ?? [];\n const lines: string[] = [];\n let ti = 0;\n while (ti < tokens.length) {\n let line = tokens[ti++]; // always take at least one word token\n while (ti < tokens.length && tokens[ti][0] === ' ') {\n const spaceTok = tokens[ti];\n const nextWord = tokens[ti + 1];\n if (!nextWord) {\n // Trailing space with no following word — drop it\n ti++;\n break;\n }\n if (line.length + spaceTok.length + nextWord.length <= maxLength) {\n line += spaceTok + nextWord;\n ti += 2;\n } else {\n // Next word doesn't fit; append the space run so it becomes trailing\n // whitespace before the line-continuation backslash (preserved by TOML).\n line += spaceTok;\n ti++;\n break;\n }\n }\n lines.push(line);\n }\n if (lines.length === 0) lines.push('');\n return lines;\n };\n\n // Flat list of packed content strings and a set tracking logical line boundaries\n // (last packed line of a non-last logical line — no backslash).\n const newContentLines: string[] = [];\n // Reassembly buffer — populated either by the prefix-preservation early path or\n // by the main reassembly loop below.\n const rebuiltLines: string[] = [];\n const paraEndIndices = new Set<number>();\n const logicalLineStartIndices = new Set<number>();\n const logicalLineStartIndentByIndex = new Map<number, string>();\n let isLiteralLineBreakPath = false;\n\n // Guard: only use the literal-break path when the value's newlines are exactly\n // newlineChar. A CRLF value in an LF doc would have `escaped.includes('\\n')` true\n // (since \\r\\n contains \\n), but splitting on bare '\\n' would leave stray \\r at\n // the end of lines. So for LF docs, require the value has no \\r\\n sequences.\n const canUseLiteralBreak = hasLiteralLineBreakStyle && escaped.includes(newlineChar) &&\n (newlineChar === '\\r\\n' || !escaped.includes('\\r\\n'));\n\n if (canUseLiteralBreak) {\n // ── Literal line-break path ────────────────────────────────────────────────\n // Keep actual source newlines from the new value. Each logical line is packed\n // independently and boundaries are emitted as real line breaks (no backslash).\n // Since value newlines are not normalized, the decoded value preserves whatever\n // newline sequence was in the original JS value.\n isLiteralLineBreakPath = true;\n const logicalLines = escaped.split(newlineChar);\n\n // Guard: first logical line's content must not start with a space after stripping\n // the structural first-line indent.\n const firstLineInput = logicalLines[0].slice(newFirstIndent.length);\n if (firstLineInput.length > 0 && firstLineInput[0] === ' ') return null;\n\n // Guard: final logical line's trailing space count must match tailProto.\n const lastLineInput = logicalLines[logicalLines.length - 1];\n if (lastLineInput.length > 0) {\n const trailingSpaces = lastLineInput.length - lastLineInput.trimEnd().length;\n if (trailingSpaces !== tailProto.trailingWs.length) return null;\n }\n\n for (let li = 0; li < logicalLines.length; li++) {\n const rawLine = logicalLines[li];\n const adjusted = li === 0 ? rawLine.slice(newFirstIndent.length) : rawLine;\n const logicalLineIndent = adjusted.match(/^[\\t ]*/)?.[0] ?? '';\n const logicalLineContent = adjusted.slice(logicalLineIndent.length);\n const packedLines = packContent(logicalLineContent);\n const startIdx = newContentLines.length;\n logicalLineStartIndices.add(startIdx);\n if (li > 0) {\n // For literal line boundaries, preserve the next logical line's leading spaces\n // as actual source indentation on that boundary line.\n logicalLineStartIndentByIndex.set(startIdx, logicalLineIndent);\n }\n for (const l of packedLines) newContentLines.push(l);\n if (li < logicalLines.length - 1) {\n // Mark the last packed line of this non-last logical line.\n paraEndIndices.add(startIdx + packedLines.length - 1);\n }\n }\n } else {\n // ── Single-group path ────────────────────────────────────────────────────────\n // Encode newlines as TOML escape sequences so the decoded value exactly preserves\n // whatever newline sequence was in the original JS value. Encode \\r\\n first so\n // that the subsequent bare-\\n pass doesn't double-encode the \\n half of CRLF.\n const packInput = escaped\n .replace(/\\r\\n/g, '\\\\r\\\\n')\n .replace(/\\n/g, '\\\\n')\n .slice(newFirstIndent.length);\n\n // Guard: leading space would be silently consumed by LC indent mechanics.\n if (packInput.length > 0) {\n if (packInput[0] === ' ') return null;\n const trailingSpaces = packInput.length - packInput.trimEnd().length;\n if (trailingSpaces !== tailProto.trailingWs.length) return null;\n }\n\n // ── Prefix + suffix preservation ────────────────────────────────────────────\n // Identify unchanged leading and trailing segments so only the genuinely changed\n // middle slice needs to be repacked. This prevents a word swap in the middle (or\n // even at the very start) from pulling words out of later unchanged lines due to\n // the global maxLength being measured from the longest line in the string.\n if (!hasLiteralLineBreakStyle) {\n // Prefix: count segments from the start whose content+trailingWs appears\n // verbatim at the beginning of packInput.\n let preservedCount = 0;\n let consumedChars = 0;\n // Only consider segments up to (but not including) the tail segment.\n for (let k = 0; k < contentSegments.length - 1; k++) {\n const seg = contentSegments[k];\n if (!seg.hasBackslash) break; // non-continuation inner segment — stop\n const contrib = seg.content + seg.trailingWs;\n if (packInput.slice(consumedChars, consumedChars + contrib.length) === contrib) {\n preservedCount++;\n consumedChars += contrib.length;\n } else {\n break;\n }\n }\n\n // Suffix: working backwards from the tail, count segments whose content+trailingWs\n // appears verbatim at the END of packInput (not overlapping the prefix).\n // Structural segments with no content (e.g. a blank closing-indent segment) are\n // not matchable — they would always match the empty string and corrupt the output.\n let suffixCount = 0;\n let suffixChars = 0;\n for (let k = contentSegments.length - 1; k >= preservedCount; k--) {\n const seg = contentSegments[k];\n const contrib = seg.content + seg.trailingWs;\n if (contrib.length === 0) break; // structural segment — stop\n const start = packInput.length - suffixChars - contrib.length;\n if (start >= consumedChars && packInput.slice(start, start + contrib.length) === contrib) {\n suffixCount++;\n suffixChars += contrib.length;\n } else {\n break;\n }\n }\n\n // ── Prefix + middle + suffix early return ──────────────────────────────\n // Used when the suffix is non-empty. Pack only the changed middle section\n // using a local width budget derived from the original middle segments, so\n // the middle lines cannot absorb words that belong to the unchanged suffix.\n if (suffixCount > 0) {\n const middleInput = packInput.slice(consumedChars, packInput.length - suffixChars);\n // Guard: middle must not start with a space.\n if (middleInput.length === 0 || middleInput[0] !== ' ') {\n // 1. Emit preserved prefix lines verbatim (all have continuation backslash).\n for (let i = 0; i < preservedCount; i++) {\n const seg = contentSegments[i];\n rebuiltLines.push(`${seg.indent}${seg.content}${seg.trailingWs}\\\\`);\n if (i < preservedCount - 1 && i < blankGroups.length && blankGroups[i].length > 0) {\n for (const bl of blankGroups[i]) rebuiltLines.push(bl);\n }\n }\n\n // 2. Pack and emit the middle section (all lines need continuation backslash\n // because the suffix follows).\n if (middleInput.length > 0) {\n const midLines = packContent(middleInput);\n const joinedMid = midLines.join('');\n const hasEncodedNewlines = /(?<!\\\\)\\\\n/.test(joinedMid);\n // Blank group bridging last prefix segment and first middle line.\n if (preservedCount > 0 && !hasEncodedNewlines) {\n const bridgeIdx = preservedCount - 1;\n if (bridgeIdx < blankGroups.length && blankGroups[bridgeIdx].length > 0) {\n for (const bl of blankGroups[bridgeIdx]) rebuiltLines.push(bl);\n }\n }\n for (let j = 0; j < midLines.length; j++) {\n const newContent = midLines[j];\n const origIdx = preservedCount + j;\n const origSeg = origIdx < contentSegments.length ? contentSegments[origIdx] : null;\n const indent = origSeg\n ? (isLeadingNewlineOpening && origIdx === 0 ? newFirstIndent : origSeg.indent)\n : contProto.indent;\n const trailing = newContent.length > 0 && /\\s$/.test(newContent) ? '' : (middleInput.endsWith(' ') ? ' ' : '');\n rebuiltLines.push(`${indent}${newContent}${trailing}\\\\`);\n if (j < midLines.length - 1 && !hasEncodedNewlines) {\n const bgIdx = preservedCount + j;\n if (bgIdx < blankGroups.length && blankGroups[bgIdx].length > 0) {\n for (const bl of blankGroups[bgIdx]) rebuiltLines.push(bl);\n }\n }\n }\n // Blank group between the last middle line and the first suffix segment.\n const midToSuffixBgIdx = contentSegments.length - suffixCount - 1;\n if (!hasEncodedNewlines &&\n midToSuffixBgIdx >= 0 && midToSuffixBgIdx < blankGroups.length &&\n blankGroups[midToSuffixBgIdx].length > 0) {\n for (const bl of blankGroups[midToSuffixBgIdx]) rebuiltLines.push(bl);\n }\n } else if (preservedCount > 0) {\n // Empty middle: blank group bridging last prefix and first suffix.\n const bridgeIdx = preservedCount - 1;\n if (bridgeIdx < blankGroups.length && blankGroups[bridgeIdx].length > 0) {\n for (const bl of blankGroups[bridgeIdx]) rebuiltLines.push(bl);\n }\n }\n\n // 3. Emit preserved suffix lines verbatim.\n const suffixStart = contentSegments.length - suffixCount;\n for (let i = suffixStart; i < contentSegments.length; i++) {\n const seg = contentSegments[i];\n const isTail = i === contentSegments.length - 1;\n // Blank group between consecutive suffix segments (not the middle-to-first-suffix\n // bridge, which was handled above).\n if (i > suffixStart) {\n const bgIdx = i - 1;\n if (bgIdx < blankGroups.length && blankGroups[bgIdx].length > 0) {\n for (const bl of blankGroups[bgIdx]) rebuiltLines.push(bl);\n }\n }\n rebuiltLines.push(isTail\n ? `${seg.indent}${seg.content}${seg.trailingWs}${seg.hasBackslash && seg.content !== '' ? '\\\\' : ''}`\n : `${seg.indent}${seg.content}${seg.trailingWs}\\\\`);\n }\n\n const useClosingIndentEarly = hasClosingIndent && !(tailProto.hasBackslash && tailProto.content === '');\n if (useClosingIndentEarly) {\n return `${openingPrefix}${rebuiltLines.join(newlineChar)}${newlineChar}${closingIndent}${delimiter}`;\n }\n return `${openingPrefix}${rebuiltLines.join(newlineChar)}${delimiter}`;\n }\n }\n\n // ── Prefix-only early return ────────────────────────────────────────────\n // Used when the suffix is empty but the prefix is non-empty. Packs the\n // remaining (changed) tail portion at the global maxLength.\n const remainingInput = packInput.slice(consumedChars);\n if (\n preservedCount > 0 &&\n (consumedChars === packInput.length ||\n (remainingInput.length > 0 && remainingInput[0] !== ' '))\n ) {\n // Emit preserved original continuation lines verbatim.\n for (let i = 0; i < preservedCount; i++) {\n const seg = contentSegments[i];\n rebuiltLines.push(`${seg.indent}${seg.content}${seg.trailingWs}\\\\`);\n // Emit blank groups that fall between preserved segments.\n if (i < preservedCount - 1 && i < blankGroups.length && blankGroups[i].length > 0) {\n for (const bl of blankGroups[i]) rebuiltLines.push(bl);\n }\n }\n\n if (consumedChars === packInput.length) {\n // The new content ends exactly at the last preserved segment boundary.\n // Convert the last preserved line from continuation to tail.\n const lastSeg = contentSegments[preservedCount - 1];\n const backslash = tailProto.hasBackslash && lastSeg.content !== '' ? '\\\\' : '';\n rebuiltLines[rebuiltLines.length - 1] =\n `${lastSeg.indent}${lastSeg.content}${tailProto.trailingWs}${backslash}`;\n } else {\n // Pack only the remaining (changed) portion of the content.\n const newPackedLines = packContent(remainingInput);\n const joinedNew = newPackedLines.join('');\n const hasEncodedNewlines = /(?<!\\\\)\\\\n/.test(joinedNew);\n // Emit blank group bridging the last preserved segment and the first new line.\n const bridgeIdx = preservedCount - 1;\n if (!hasEncodedNewlines && bridgeIdx < blankGroups.length && blankGroups[bridgeIdx].length > 0) {\n for (const bl of blankGroups[bridgeIdx]) rebuiltLines.push(bl);\n }\n for (let j = 0; j < newPackedLines.length; j++) {\n const isLastNew = j === newPackedLines.length - 1;\n const newContent = newPackedLines[j];\n const origIdx = preservedCount + j;\n const origSeg = origIdx < contentSegments.length ? contentSegments[origIdx] : null;\n const indent = origSeg\n ? (isLeadingNewlineOpening && origIdx === 0 ? newFirstIndent : origSeg.indent)\n : (isLastNew ? tailProto.indent : contProto.indent);\n let trailing: string;\n let backslash: string;\n if (isLastNew) {\n trailing = tailProto.trailingWs;\n backslash = tailProto.hasBackslash && tailProto.content !== '' ? '\\\\' : '';\n } else {\n trailing = newContent.length > 0 && /\\s$/.test(newContent) ? '' : ' ';\n backslash = '\\\\';\n }\n rebuiltLines.push(`${indent}${newContent}${trailing}${backslash}`);\n // Emit blank groups for the new lines (index offset by preservedCount).\n if (!isLastNew) {\n const bgIdx = preservedCount + j;\n if (!hasEncodedNewlines && bgIdx < blankGroups.length && blankGroups[bgIdx].length > 0) {\n for (const bl of blankGroups[bgIdx]) rebuiltLines.push(bl);\n }\n }\n }\n }\n\n const useClosingIndentEarly = hasClosingIndent && !(tailProto.hasBackslash && tailProto.content === '');\n if (useClosingIndentEarly) {\n return `${openingPrefix}${rebuiltLines.join(newlineChar)}${newlineChar}${closingIndent}${delimiter}`;\n }\n return `${openingPrefix}${rebuiltLines.join(newlineChar)}${delimiter}`;\n }\n }\n\n const packed = packContent(packInput);\n for (const l of packed) newContentLines.push(l);\n }\n\n // Reassemble lines with correct indentation, trailing whitespace and backslash placement.\n for (let i = 0; i < newContentLines.length; i++) {\n const isGlobalLast = i === newContentLines.length - 1;\n const isParaEnd = paraEndIndices.has(i);\n // Paragraph-end lines and the global last line both use tail-like properties:\n // no backslash, tailProto trailing whitespace.\n const isTailLike = isGlobalLast || isParaEnd;\n\n const origSeg = i < contentSegments.length ? contentSegments[i] : null;\n // In `\"\"\"<NL>` mode the first segment's indent is part of the decoded value, so\n // we use the new value's own leading whitespace (newFirstIndent) for i === 0,\n // letting the value's leading whitespace differ from the original freely.\n const indent = isLiteralLineBreakPath && logicalLineStartIndices.has(i) && i > 0\n ? (logicalLineStartIndentByIndex.get(i) ?? '')\n : (origSeg\n ? (isLeadingNewlineOpening && i === 0 ? newFirstIndent : origSeg.indent)\n : (isTailLike ? tailProto.indent : contProto.indent));\n const newContent = newContentLines[i];\n\n let trailing: string;\n let backslash: string;\n if (isTailLike && isGlobalLast) {\n trailing = tailProto.trailingWs;\n backslash = tailProto.hasBackslash && tailProto.content !== '' ? '\\\\' : '';\n } else if (isTailLike) {\n // Paragraph-end line: no backslash so the following newline is literal,\n // creating a blank-line paragraph separator in the TOML source.\n trailing = tailProto.trailingWs;\n backslash = '';\n } else {\n // Continuation line within a paragraph.\n trailing = newContent.length > 0 && /\\s$/.test(newContent) ? '' : ' ';\n backslash = '\\\\';\n }\n rebuiltLines.push(`${indent}${newContent}${trailing}${backslash}`);\n\n // For literal line-break path, isParaEnd itself encodes the structural newline boundary\n // (no trailing backslash). No extra blank lines are inserted here.\n if (!isGlobalLast && !isParaEnd && !isLiteralLineBreakPath) {\n // Single-group path: insert original blank groups, but only when the packed content\n // contains no encoded newline escape sequences (those already represent paragraph\n // breaks inline, so blank-line placement from original positions would be misleading).\n const singleInput = newContentLines.join('');\n const hasEncodedNewlines = /(?<!\\\\)\\\\n/.test(singleInput);\n if (!hasEncodedNewlines && i < blankGroups.length && blankGroups[i].length > 0) {\n for (const blankLine of blankGroups[i]) rebuiltLines.push(blankLine);\n }\n }\n }\n\n // When the tail prototype had no content, its backslash was purely structural (it only\n // skipped whitespace before the closing delimiter). In that case close inline instead\n // of preserving the closing-indent format.\n const useClosingIndent = hasClosingIndent && !(tailProto.hasBackslash && tailProto.content === '');\n\n if (useClosingIndent) {\n return `${openingPrefix}${rebuiltLines.join(newlineChar)}${newlineChar}${closingIndent}${delimiter}`;\n }\n return `${openingPrefix}${rebuiltLines.join(newlineChar)}${delimiter}`;\n}\n"],"mappings":"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"}
@@ -0,0 +1,46 @@
1
+ //! @decimalturn/toml-patch v3.3.2 - https://github.com/DecimalTurn/toml-patch - @license: MIT
2
+ //#region src/literal-string.ts
3
+ /**
4
+ * @file Checks for whether a value can be written into a TOML literal string.
5
+ * @module literal-string
6
+ *
7
+ * Literal strings do not process escape sequences, so a value can only be
8
+ * written into one verbatim: it must not contain the string type's delimiter,
9
+ * and it must not contain a character TOML forbids in that string type.
10
+ *
11
+ * Both the full string generator and the lite value encoder gate their literal
12
+ * output on these checks, so a value that cannot be literal falls back the same
13
+ * way in both. Without them, `generateLiteralString` writes the value straight
14
+ * between the quotes and produces TOML that the parser rejects.
15
+ */
16
+ /**
17
+ * True when `value` can be written verbatim inside a single-line literal
18
+ * string: no apostrophe, no newline, and no control character other than tab.
19
+ */
20
+ function canUseLiteralString(value) {
21
+ if (value.includes("'")) return false;
22
+ for (let i = 0; i < value.length; i++) {
23
+ const code = value.charCodeAt(i);
24
+ if (code < 32 && code !== 9 || code === 127) return false;
25
+ }
26
+ return true;
27
+ }
28
+ /**
29
+ * True when `value` can be written verbatim inside a multiline literal string:
30
+ * no `'''`, no control characters other than tab, and no standalone carriage
31
+ * return (newlines must be LF or CRLF).
32
+ */
33
+ function canUseMultilineLiteral(value) {
34
+ if (value.includes("'''")) return false;
35
+ for (let i = 0; i < value.length; i++) {
36
+ const code = value.charCodeAt(i);
37
+ if (code === 13) {
38
+ if (value.charCodeAt(i + 1) !== 10) return false;
39
+ } else if (code < 32 && code !== 9 && code !== 10 || code === 127) return false;
40
+ }
41
+ return true;
42
+ }
43
+
44
+ //#endregion
45
+ export { canUseLiteralString, canUseMultilineLiteral };
46
+ //# sourceMappingURL=literal-string.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"literal-string.js","names":[],"sources":["../../src/literal-string.ts"],"sourcesContent":["/**\n * @file Checks for whether a value can be written into a TOML literal string.\n * @module literal-string\n *\n * Literal strings do not process escape sequences, so a value can only be\n * written into one verbatim: it must not contain the string type's delimiter,\n * and it must not contain a character TOML forbids in that string type.\n *\n * Both the full string generator and the lite value encoder gate their literal\n * output on these checks, so a value that cannot be literal falls back the same\n * way in both. Without them, `generateLiteralString` writes the value straight\n * between the quotes and produces TOML that the parser rejects.\n */\n\n/**\n * True when `value` can be written verbatim inside a single-line literal\n * string: no apostrophe, no newline, and no control character other than tab.\n */\nexport function canUseLiteralString(value: string): boolean {\n if (value.includes(\"'\")) return false;\n for (let i = 0; i < value.length; i++) {\n const code = value.charCodeAt(i);\n if ((code < 0x20 && code !== 0x09) || code === 0x7f) return false;\n }\n return true;\n}\n\n/**\n * True when `value` can be written verbatim inside a multiline literal string:\n * no `'''`, no control characters other than tab, and no standalone carriage\n * return (newlines must be LF or CRLF).\n */\nexport function canUseMultilineLiteral(value: string): boolean {\n if (value.includes(\"'''\")) return false;\n for (let i = 0; i < value.length; i++) {\n const code = value.charCodeAt(i);\n if (code === 0x0d) {\n if (value.charCodeAt(i + 1) !== 0x0a) return false;\n } else if ((code < 0x20 && code !== 0x09 && code !== 0x0a) || code === 0x7f) {\n return false;\n }\n }\n return true;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,oBAAoB,OAAwB;CAC1D,IAAI,MAAM,SAAS,GAAG,GAAG,OAAO;CAChC,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM,WAAW,CAAC;EAC/B,IAAK,OAAO,MAAQ,SAAS,KAAS,SAAS,KAAM,OAAO;CAC9D;CACA,OAAO;AACT;;;;;;AAOA,SAAgB,uBAAuB,OAAwB;CAC7D,IAAI,MAAM,SAAS,KAAK,GAAG,OAAO;CAClC,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM,WAAW,CAAC;EAC/B,IAAI,SAAS,IACX;OAAI,MAAM,WAAW,IAAI,CAAC,MAAM,IAAM,OAAO;EAAK,OAC7C,IAAK,OAAO,MAAQ,SAAS,KAAQ,SAAS,MAAS,SAAS,KACrE,OAAO;CAEX;CACA,OAAO;AACT"}
@@ -0,0 +1,104 @@
1
+ //! @decimalturn/toml-patch v3.3.2 - https://github.com/DecimalTurn/toml-patch - @license: MIT
2
+ //#region src/location.ts
3
+ let cachedInput;
4
+ let cachedLines;
5
+ function getCachedLines(input) {
6
+ if (cachedInput === input && cachedLines !== void 0) return cachedLines;
7
+ const lines = findLines(input);
8
+ cachedInput = input;
9
+ cachedLines = lines;
10
+ return lines;
11
+ }
12
+ /** Clears the line index cache so the parsed input is not retained after a parse. */
13
+ function clearCachedLines() {
14
+ cachedInput = void 0;
15
+ cachedLines = void 0;
16
+ }
17
+ function getSpan(location) {
18
+ return {
19
+ lines: location.end.line - location.start.line + 1,
20
+ columns: location.end.column - location.start.column
21
+ };
22
+ }
23
+ function findPosition(input, index) {
24
+ const lines = Array.isArray(input) ? input : findLines(input);
25
+ if (lines.length === 0) return {
26
+ line: 1,
27
+ column: index
28
+ };
29
+ let lo = 0;
30
+ let hi = lines.length - 1;
31
+ while (lo < hi) {
32
+ const mid = lo + hi >>> 1;
33
+ if (lines[mid] < index) lo = mid + 1;
34
+ else hi = mid;
35
+ }
36
+ if (lines[lo] < index) lo++;
37
+ const line = lo + 1;
38
+ return {
39
+ line,
40
+ column: index - (lines[line - 2] + 1 || 0)
41
+ };
42
+ }
43
+ /**
44
+ * Retrieves the line of text from the input string corresponding to the given position.
45
+ *
46
+ * @param input The input string containing the text
47
+ * @param position The position within the input string for which to retrieve the line
48
+ * @returns The line of text corresponding to the given position
49
+ */
50
+ function getLine(input, position) {
51
+ const lines = getCachedLines(input);
52
+ const start = lines[position.line - 2] !== void 0 ? lines[position.line - 2] + 1 : 0;
53
+ const end = lines[position.line - 1] || input.length;
54
+ return input.substring(start, end);
55
+ }
56
+ /**
57
+ * Finds the line break positions in the input string.
58
+ *
59
+ * @param input The input string in which to find line break positions
60
+ * @returns An array of indexes representing the positions of line breaks in the input string
61
+ */
62
+ function findLines(input) {
63
+ const indexes = [];
64
+ for (let i = 0; i < input.length; i++) {
65
+ const code = input.charCodeAt(i);
66
+ if (code === 10) indexes.push(i);
67
+ else if (code === 13) {
68
+ if (input.charCodeAt(i + 1) === 10) {
69
+ indexes.push(i + 1);
70
+ i++;
71
+ } else indexes.push(i);
72
+ }
73
+ }
74
+ indexes.push(input.length);
75
+ return indexes;
76
+ }
77
+ function clonePosition(position) {
78
+ return {
79
+ line: position.line,
80
+ column: position.column
81
+ };
82
+ }
83
+ function cloneLocation(location) {
84
+ return {
85
+ start: clonePosition(location.start),
86
+ end: clonePosition(location.end)
87
+ };
88
+ }
89
+ /**
90
+ * Returns a Position at line 1, column 0.
91
+ * This means that lines are 1-indexed and columns are 0-indexed.
92
+ *
93
+ * @returns A Position at line 1, column 0
94
+ */
95
+ function zero() {
96
+ return {
97
+ line: 1,
98
+ column: 0
99
+ };
100
+ }
101
+
102
+ //#endregion
103
+ export { clearCachedLines, cloneLocation, clonePosition, findLines, findPosition, getLine, getSpan, zero };
104
+ //# sourceMappingURL=location.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"location.js","names":[],"sources":["../../src/location.ts"],"sourcesContent":["export interface Location {\n start: Position;\n end: Position;\n}\n\nexport interface Position {\n // Note: line is 1-indexed while column is 0-indexed\n // Index is UTF-16 based (from cursor), but column display uses code points for UX\n line: number;\n column: number;\n}\n\nexport interface Span {\n lines: number;\n columns: number;\n}\n\n// Since getLine() is called repeatedly with the same input while parsing dotted keys,\n// we need to cache the line indexes for the ongoing input string.\nlet cachedInput: string | undefined;\nlet cachedLines: number[] | undefined;\n\nfunction getCachedLines(input: string): number[] {\n if (cachedInput === input && cachedLines !== undefined) {\n return cachedLines;\n }\n\n const lines = findLines(input);\n cachedInput = input;\n cachedLines = lines;\n\n return lines;\n}\n\n/** Clears the line index cache so the parsed input is not retained after a parse. */\nexport function clearCachedLines(): void {\n cachedInput = undefined;\n cachedLines = undefined;\n}\n\nexport function getSpan(location: Location): Span {\n return {\n lines: location.end.line - location.start.line + 1,\n columns: location.end.column - location.start.column\n };\n}\n\nexport type Locator = (start: number, end: number) => Location;\nexport function createLocate(input: string): Locator {\n const lines = findLines(input);\n\n return (start: number, end: number) => {\n return {\n start: findPosition(lines, start),\n end: findPosition(lines, end)\n };\n };\n}\n\nexport function findPosition(input: string | number[], index: number): Position {\n // abc\\ndef\\ng\n // 0123 4567 8\n // 012\n // 0\n //\n // lines = [3, 7, 9]\n //\n // c = 2: 0 -> 1, 2 - (undefined + 1 || 0) = 2\n // 3: 0 -> 1, 3 - (undefined + 1 || 0) = 3\n // e = 5: 1 -> 2, 5 - (3 + 1 || 0) = 1\n // g = 8: 2 -> 3, 8 - (7 + 1 || 0) = 0\n\n const lines = Array.isArray(input) ? input : findLines(input);\n\n if (lines.length === 0) {\n return { line: 1, column: index };\n }\n\n // Binary search: find first line_index where lines[line_index] >= index\n let lo = 0;\n let hi = lines.length - 1;\n while (lo < hi) {\n const mid = (lo + hi) >>> 1;\n if (lines[mid] < index) {\n lo = mid + 1;\n } else {\n hi = mid;\n }\n }\n\n // If index is past all recorded line endings (no sentinel), advance to next line\n if (lines[lo] < index) {\n lo++;\n }\n\n const line = lo + 1;\n const column = index - (lines[line - 2] + 1 || 0);\n\n return { line, column };\n}\n\n/**\n * Retrieves the line of text from the input string corresponding to the given position.\n * \n * @param input The input string containing the text\n * @param position The position within the input string for which to retrieve the line\n * @returns The line of text corresponding to the given position\n */\nexport function getLine(input: string, position: Position): string {\n const lines = getCachedLines(input);\n\n const start = lines[position.line - 2] !== undefined ? lines[position.line - 2] + 1 : 0;\n const end = lines[position.line - 1] || input.length;\n\n return input.substring(start, end);\n}\n\n/**\n * Finds the line break positions in the input string.\n * \n * @param input The input string in which to find line break positions\n * @returns An array of indexes representing the positions of line breaks in the input string\n */\nexport function findLines(input: string): number[] {\n const indexes: number[] = [];\n\n for (let i = 0; i < input.length; i++) {\n const code = input.charCodeAt(i);\n if (code === 0x0a) {\n // \\n\n indexes.push(i);\n } else if (code === 0x0d) {\n // \\r — handle \\r\\n as a single line break\n if (input.charCodeAt(i + 1) === 0x0a) {\n indexes.push(i + 1); // Position after \\r\\n\n i++; // Skip the \\n\n } else {\n indexes.push(i);\n }\n }\n }\n indexes.push(input.length);\n\n return indexes;\n}\n\nexport function clonePosition(position: Position): Position {\n return { line: position.line, column: position.column };\n}\n\nexport function cloneLocation(location: Location): Location {\n return { start: clonePosition(location.start), end: clonePosition(location.end) };\n}\n/**\n * Returns a Position at line 1, column 0.\n * This means that lines are 1-indexed and columns are 0-indexed.\n * \n * @returns A Position at line 1, column 0\n */\nexport function zero(): Position {\n return { line: 1, column: 0 };\n}\n"],"mappings":";;AAmBA,IAAI;AACJ,IAAI;AAEJ,SAAS,eAAe,OAAyB;CAC/C,IAAI,gBAAgB,SAAS,gBAAgB,QAC3C,OAAO;CAGT,MAAM,QAAQ,UAAU,KAAK;CAC7B,cAAc;CACd,cAAc;CAEd,OAAO;AACT;;AAGA,SAAgB,mBAAyB;CACvC,cAAc;CACd,cAAc;AAChB;AAEA,SAAgB,QAAQ,UAA0B;CAChD,OAAO;EACL,OAAO,SAAS,IAAI,OAAO,SAAS,MAAM,OAAO;EACjD,SAAS,SAAS,IAAI,SAAS,SAAS,MAAM;CAChD;AACF;AAcA,SAAgB,aAAa,OAA0B,OAAyB;CAa9E,MAAM,QAAQ,MAAM,QAAQ,KAAK,IAAI,QAAQ,UAAU,KAAK;CAE5D,IAAI,MAAM,WAAW,GACnB,OAAO;EAAE,MAAM;EAAG,QAAQ;CAAM;CAIlC,IAAI,KAAK;CACT,IAAI,KAAK,MAAM,SAAS;CACxB,OAAO,KAAK,IAAI;EACd,MAAM,MAAO,KAAK,OAAQ;EAC1B,IAAI,MAAM,OAAO,OACf,KAAK,MAAM;OAEX,KAAK;CAET;CAGA,IAAI,MAAM,MAAM,OACd;CAGF,MAAM,OAAO,KAAK;CAGlB,OAAO;EAAE;EAAM,QAFA,SAAS,MAAM,OAAO,KAAK,KAAK;CAEzB;AACxB;;;;;;;;AASA,SAAgB,QAAQ,OAAe,UAA4B;CACjE,MAAM,QAAQ,eAAe,KAAK;CAElC,MAAM,QAAQ,MAAM,SAAS,OAAO,OAAO,SAAY,MAAM,SAAS,OAAO,KAAK,IAAI;CACtF,MAAM,MAAM,MAAM,SAAS,OAAO,MAAM,MAAM;CAE9C,OAAO,MAAM,UAAU,OAAO,GAAG;AACnC;;;;;;;AAQA,SAAgB,UAAU,OAAyB;CACjD,MAAM,UAAoB,CAAC;CAE3B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM,WAAW,CAAC;EAC/B,IAAI,SAAS,IAEX,QAAQ,KAAK,CAAC;OACT,IAAI,SAAS,IAAM;GAExB,IAAI,MAAM,WAAW,IAAI,CAAC,MAAM,IAAM;IACpC,QAAQ,KAAK,IAAI,CAAC;IAClB;GACF,OACE,QAAQ,KAAK,CAAC;EAElB;CACF;CACA,QAAQ,KAAK,MAAM,MAAM;CAEzB,OAAO;AACT;AAEA,SAAgB,cAAc,UAA8B;CAC1D,OAAO;EAAE,MAAM,SAAS;EAAM,QAAQ,SAAS;CAAO;AACxD;AAEA,SAAgB,cAAc,UAA8B;CAC1D,OAAO;EAAE,OAAO,cAAc,SAAS,KAAK;EAAG,KAAK,cAAc,SAAS,GAAG;CAAE;AAClF;;;;;;;AAOA,SAAgB,OAAiB;CAC/B,OAAO;EAAE,MAAM;EAAG,QAAQ;CAAE;AAC9B"}
@@ -0,0 +1,27 @@
1
+ //! @decimalturn/toml-patch v3.3.2 - https://github.com/DecimalTurn/toml-patch - @license: MIT
2
+ import { getLine } from "./location.js";
3
+
4
+ //#region src/parse-error.ts
5
+ var ParseError = class extends Error {
6
+ line;
7
+ column;
8
+ constructor(input, position, message) {
9
+ let error_message = `Error parsing TOML (${position.line}, ${position.column + 1}):\n`;
10
+ if (input) {
11
+ const line = getLine(input, position);
12
+ const pointer = `${whitespace(position.column)}^`;
13
+ if (line) error_message += `${line}\n${pointer}\n`;
14
+ }
15
+ error_message += message;
16
+ super(error_message);
17
+ this.line = position.line;
18
+ this.column = position.column;
19
+ }
20
+ };
21
+ function whitespace(count, character = " ") {
22
+ return character.repeat(count);
23
+ }
24
+
25
+ //#endregion
26
+ export { ParseError as default };
27
+ //# sourceMappingURL=parse-error.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"parse-error.js","names":[],"sources":["../../src/parse-error.ts"],"sourcesContent":["import { Position, getLine } from './location';\n\nexport default class ParseError extends Error {\n line: number;\n column: number;\n\n constructor(input: string, position: Position, message: string) {\n let error_message = `Error parsing TOML (${position.line}, ${position.column + 1}):\\n`;\n\n if (input) {\n const line = getLine(input, position);\n const pointer = `${whitespace(position.column)}^`;\n\n if (line) error_message += `${line}\\n${pointer}\\n`;\n }\n error_message += message;\n\n super(error_message);\n\n this.line = position.line;\n this.column = position.column;\n }\n}\n\nexport function isParseError(error: Error): error is ParseError {\n return error && Object.prototype.hasOwnProperty.call(error, 'line');\n}\n\nfunction whitespace(count: number, character: string = ' '): string {\n return character.repeat(count);\n}\n"],"mappings":";;;;AAEA,IAAqB,aAArB,cAAwC,MAAM;CAC5C;CACA;CAEA,YAAY,OAAe,UAAoB,SAAiB;EAC9D,IAAI,gBAAgB,uBAAuB,SAAS,KAAK,IAAI,SAAS,SAAS,EAAE;EAEjF,IAAI,OAAO;GACT,MAAM,OAAO,QAAQ,OAAO,QAAQ;GACpC,MAAM,UAAU,GAAG,WAAW,SAAS,MAAM,EAAE;GAE/C,IAAI,MAAM,iBAAiB,GAAG,KAAK,IAAI,QAAQ;EACjD;EACA,iBAAiB;EAEjB,MAAM,aAAa;EAEnB,KAAK,OAAO,SAAS;EACrB,KAAK,SAAS,SAAS;CACzB;AACF;AAMA,SAAS,WAAW,OAAe,YAAoB,KAAa;CAClE,OAAO,UAAU,OAAO,KAAK;AAC/B"}
@@ -0,0 +1,150 @@
1
+ //! @decimalturn/toml-patch v3.3.2 - https://github.com/DecimalTurn/toml-patch - @license: MIT
2
+ import { isInlineArray, isInlineTable, isKeyValue } from "./cst.js";
3
+ import { isBigInt, isBoolean, isDate, isFloat, isInteger, isObject, isString, isTemporal } from "./utils.js";
4
+ import { TomlFormat } from "./toml-format.js";
5
+ import { resolveInlineContainerLayout, setInlineContainerLayout } from "./inline-format.js";
6
+ import { applyBracketSpacing, applyTrailingComma, applyWrites, insert, markStringifyRoot, setRootIndentWidth, shiftNode } from "./writer.js";
7
+ import { generateBoolean, generateDateTime, generateDocument, generateFloat, generateInlineArray, generateInlineItem, generateInlineTable, generateInteger, generateKeyValue, generateString, generateTemporalDateTime } from "./generate.js";
8
+ import { formatEmptyLines, formatNestedTablesMultiline, formatTopLevel, normalizeGeneratedInlineRows } from "./formatter.js";
9
+ import { isSmolTomlDate, smolTomlDateToNative } from "./smol-toml-date.js";
10
+ import { prepareInsertedNestedInlineContainer } from "./inline-layout.js";
11
+
12
+ //#region src/parse-js.ts
13
+ /**
14
+ * Parses a JavaScript object into a CST Document, applying formatting options from TomlFormat.
15
+ * @param value - The JavaScript object to parse.
16
+ * @param format - The formatting options to apply.
17
+ * @returns The resulting CST Document.
18
+ */
19
+ function parseJS(value, format = TomlFormat.default(), depth = 0, parentIsMultiline = false) {
20
+ value = toJSON(value);
21
+ const document = generateDocument();
22
+ markStringifyRoot(document);
23
+ setRootIndentWidth(document, format.indentWidth);
24
+ for (const item of walkObject(value, format, depth, parentIsMultiline)) insert(document, document, item);
25
+ applyWrites(document);
26
+ formatTopLevel(document, format);
27
+ if ((format.inlineTableStart ?? 1) > 1) formatNestedTablesMultiline(document, format);
28
+ if (format.multilineTable !== "auto" || format.multilineArray !== "auto") {
29
+ for (const item of document.items) if (item.type === "Table" || item.type === "TableArray") normalizeGeneratedInlineRows(item, format.indentWidth, format.bracketSpacing);
30
+ else if (isKeyValue(item) && (isInlineArray(item.value) || isInlineTable(item.value))) normalizeGeneratedInlineRows(item, format.indentWidth, format.bracketSpacing);
31
+ }
32
+ return formatEmptyLines(document);
33
+ }
34
+ function* walkObject(object, format, depth = 0, parentIsMultiline = false) {
35
+ for (const key of Object.keys(object)) {
36
+ const rawValue = object[key];
37
+ if (rawValue === void 0) continue;
38
+ const value = toJSON(rawValue);
39
+ if (value === void 0) continue;
40
+ yield generateKeyValue([key], walkValue(value, format, depth, parentIsMultiline), depth > 0 && !parentIsMultiline, format.escapeSequenceUpperCase);
41
+ }
42
+ }
43
+ function appendCompactInlineItem(parent, child, format) {
44
+ const previous = parent.items[parent.items.length - 1];
45
+ if (previous) previous.comma = true;
46
+ const start = previous ? {
47
+ line: previous.loc.end.line,
48
+ column: previous.loc.end.column + 2
49
+ } : {
50
+ line: parent.loc.start.line,
51
+ column: parent.loc.start.column + (format.bracketSpacing ? 2 : 1)
52
+ };
53
+ shiftNode(child, {
54
+ lines: start.line - child.loc.start.line,
55
+ columns: start.column - child.loc.start.column
56
+ });
57
+ parent.items.push(child);
58
+ child.comma = false;
59
+ parent.loc.end = {
60
+ line: child.loc.end.line,
61
+ column: child.loc.end.column + (format.bracketSpacing ? 2 : 1)
62
+ };
63
+ }
64
+ function walkValue(value, format, depth, parentIsMultiline) {
65
+ const minimumDecimals = format.minimumDecimals ?? 0;
66
+ if (value === null) throw new Error("\"null\" values are not supported");
67
+ if (value === void 0) throw new Error("\"undefined\" values are not supported inside arrays");
68
+ if (isString(value)) return generateString(value, void 0, format.escapeSequenceUpperCase);
69
+ else if (isBigInt(value)) return generateInteger(value);
70
+ else if (isInteger(value)) return minimumDecimals > 0 ? generateFloat(value, minimumDecimals) : generateInteger(value);
71
+ else if (isFloat(value)) return generateFloat(value, Math.max(minimumDecimals, 1));
72
+ else if (isBoolean(value)) return generateBoolean(value);
73
+ else if (isTemporal(value)) return generateTemporalDateTime(value, format.truncateZeroTimeInDates, format.minimumTimeDecimals ?? 0);
74
+ else if (isSmolTomlDate(value)) return generateDateTime(smolTomlDateToNative(value), format.truncateZeroTimeInDates, format.minimumTimeDecimals ?? 0);
75
+ else if (isDate(value)) return generateDateTime(value, format.truncateZeroTimeInDates, format.minimumTimeDecimals ?? 0);
76
+ else if (Array.isArray(value)) return walkInlineArray(value, format, depth, parentIsMultiline);
77
+ else return walkInlineTable(value, format, depth, parentIsMultiline);
78
+ }
79
+ function walkInlineArray(value, format, depth, parentIsMultiline) {
80
+ const inline_array = generateInlineArray();
81
+ const multiline = !(value.length === 0 && depth > 0) && resolveInlineContainerLayout("array", depth, parentIsMultiline, format);
82
+ setInlineContainerLayout(inline_array, multiline);
83
+ setRootIndentWidth(inline_array, format.indentWidth);
84
+ markStringifyRoot(inline_array);
85
+ if (!multiline) {
86
+ for (const element of value) {
87
+ const item = walkValue(element, format, depth + 1, multiline);
88
+ appendCompactInlineItem(inline_array, generateInlineItem(item), format);
89
+ }
90
+ if (inline_array.items.length > 0 && format.trailingComma) {
91
+ const last = inline_array.items[inline_array.items.length - 1];
92
+ last.comma = true;
93
+ inline_array.loc.end.column++;
94
+ }
95
+ return inline_array;
96
+ }
97
+ for (const element of value) {
98
+ const item = walkValue(element, format, depth + 1, multiline);
99
+ const inline_array_item = generateInlineItem(item);
100
+ prepareInsertedNestedInlineContainer(inline_array, inline_array_item, format.indentWidth);
101
+ insert(inline_array, inline_array, inline_array_item);
102
+ }
103
+ applyBracketSpacing(inline_array, inline_array, format.bracketSpacing);
104
+ applyTrailingComma(inline_array, inline_array, format.trailingComma);
105
+ applyWrites(inline_array);
106
+ return inline_array;
107
+ }
108
+ function walkInlineTable(value, format, depth, parentIsMultiline) {
109
+ value = toJSON(value);
110
+ if (!isObject(value)) return walkValue(value, format, depth, parentIsMultiline);
111
+ const inline_table = generateInlineTable();
112
+ const multiline = !(Object.keys(value).length === 0 && depth > 0) && resolveInlineContainerLayout("table", depth, parentIsMultiline, format);
113
+ setInlineContainerLayout(inline_table, multiline);
114
+ setRootIndentWidth(inline_table, format.indentWidth);
115
+ markStringifyRoot(inline_table);
116
+ if (!multiline) {
117
+ for (const item of walkObject(value, format, depth + 1, multiline)) appendCompactInlineItem(inline_table, generateInlineItem(item), format);
118
+ if (inline_table.items.length > 0 && format.trailingComma) {
119
+ const last = inline_table.items[inline_table.items.length - 1];
120
+ last.comma = true;
121
+ inline_table.loc.end.column++;
122
+ }
123
+ return inline_table;
124
+ }
125
+ for (const item of walkObject(value, format, depth + 1, multiline)) {
126
+ const inline_table_item = generateInlineItem(item);
127
+ insert(inline_table, inline_table, inline_table_item);
128
+ }
129
+ applyBracketSpacing(inline_table, inline_table, format.bracketSpacing);
130
+ applyTrailingComma(inline_table, inline_table, format.trailingComma);
131
+ applyWrites(inline_table);
132
+ return inline_table;
133
+ }
134
+ /**
135
+ * Handles custom object serialization by checking for and using toJSON methods
136
+ *
137
+ * @param value - The value to potentially convert
138
+ * @returns The result of value.toJSON() if available, otherwise the original value
139
+ */
140
+ function toJSON(value) {
141
+ if (!value) return value;
142
+ if (isDate(value)) return value;
143
+ if (isTemporal(value)) return value;
144
+ if (typeof value.toJSON === "function") return value.toJSON();
145
+ return value;
146
+ }
147
+
148
+ //#endregion
149
+ export { parseJS as default };
150
+ //# sourceMappingURL=parse-js.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"parse-js.js","names":[],"sources":["../../src/parse-js.ts"],"sourcesContent":["import { Value, KeyValue, Document, InlineArray, InlineTable, InlineItem, isKeyValue, isInlineArray, isInlineTable } from './cst';\nimport {\n generateDocument,\n generateKeyValue,\n generateInlineItem,\n generateString,\n generateInteger,\n generateFloat,\n generateBoolean,\n generateDateTime,\n generateTemporalDateTime,\n generateInlineArray,\n generateInlineTable\n} from './generate';\nimport { TomlFormat } from './toml-format';\nimport { formatTopLevel, formatEmptyLines, formatNestedTablesMultiline, normalizeGeneratedInlineRows } from './formatter';\nimport { isObject, isString, isBigInt, isInteger, isFloat, isBoolean, isDate, isTemporal } from './utils';\nimport { isSmolTomlDate, smolTomlDateToNative } from './smol-toml-date';\nimport { insert, applyWrites, applyBracketSpacing, applyTrailingComma, markStringifyRoot, setRootIndentWidth, shiftNode } from './writer';\nimport { prepareInsertedNestedInlineContainer } from './inline-layout';\nimport { resolveInlineContainerLayout, setInlineContainerLayout } from './inline-format';\n\n/**\n * Parses a JavaScript object into a CST Document, applying formatting options from TomlFormat.\n * @param value - The JavaScript object to parse.\n * @param format - The formatting options to apply.\n * @returns The resulting CST Document.\n */\nexport default function parseJS(\n value: any,\n format: TomlFormat = TomlFormat.default(),\n depth = 0,\n parentIsMultiline = false\n): Document {\n value = toJSON(value);\n\n const document = generateDocument();\n // Enable stringify fast paths in the writer — no comments, no removals.\n markStringifyRoot(document);\n setRootIndentWidth(document, format.indentWidth);\n for (const item of walkObject(value, format, depth, parentIsMultiline)) {\n insert(document, document, item);\n }\n applyWrites(document);\n\n // Heuristics:\n // 1. Top-level objects/arrays should be tables/table arrays\n // 2. Convert nested inline tables to separate tables based on preferNestedTablesMultiline\n formatTopLevel(document, format);\n\n // `formatNestedTablesMultiline` only extracts tables when inlineTableStart > 1\n // (depth-0 tables were already handled by formatTopLevel), and\n // `normalizeGeneratedInlineRows` only moves rows when a multiline container\n // was generated. Skip both full-tree passes when the format cannot trigger\n // them, which is the common default-format case.\n if ((format.inlineTableStart ?? 1) > 1) {\n formatNestedTablesMultiline(document, format);\n }\n if (format.multilineTable !== 'auto' || format.multilineArray !== 'auto') {\n for (const item of document.items) {\n if (item.type === 'Table' || item.type === 'TableArray') {\n normalizeGeneratedInlineRows(item, format.indentWidth, format.bracketSpacing);\n } else if (isKeyValue(item) && (isInlineArray(item.value) || isInlineTable(item.value))) {\n // Root key-values stay key-values when `inlineTableStart` is 0, so they\n // never reach formatTopLevel/formatNestedTablesMultiline. Their nested\n // multiline containers still need the same row/key alignment as the rows\n // of a converted table (fuzz3 seed 18515).\n normalizeGeneratedInlineRows(item, format.indentWidth, format.bracketSpacing);\n }\n }\n }\n\n return formatEmptyLines(document);\n}\n\nfunction* walkObject(\n object: any,\n format: TomlFormat,\n depth = 0,\n parentIsMultiline = false\n): IterableIterator<KeyValue> {\n for (const key of Object.keys(object)) {\n const rawValue = object[key];\n if (rawValue === undefined) continue;\n const value = toJSON(rawValue);\n if (value === undefined) continue;\n yield generateKeyValue(\n [key],\n walkValue(value, format, depth, parentIsMultiline),\n depth > 0 && !parentIsMultiline,\n format.escapeSequenceUpperCase\n );\n }\n}\n\nfunction appendCompactInlineItem(\n parent: InlineArray | InlineTable,\n child: InlineItem,\n format: TomlFormat\n): void {\n const previous = parent.items[parent.items.length - 1];\n if (previous) previous.comma = true;\n\n const start = previous\n ? {\n line: previous.loc.end.line,\n column: previous.loc.end.column + 2\n }\n : {\n line: parent.loc.start.line,\n column: parent.loc.start.column + (format.bracketSpacing ? 2 : 1)\n };\n\n shiftNode(child, {\n lines: start.line - child.loc.start.line,\n columns: start.column - child.loc.start.column\n });\n (parent.items as InlineItem[]).push(child);\n\n child.comma = false;\n parent.loc.end = {\n line: child.loc.end.line,\n column: child.loc.end.column + (format.bracketSpacing ? 2 : 1)\n };\n}\n\nfunction walkValue(\n value: any,\n format: TomlFormat,\n depth: number,\n parentIsMultiline: boolean\n): Value {\n const minimumDecimals = format.minimumDecimals ?? 0;\n\n if (value === null) {\n throw new Error('\"null\" values are not supported');\n }\n if (value === undefined) {\n throw new Error('\"undefined\" values are not supported inside arrays');\n }\n\n if (isString(value)) {\n return generateString(value, undefined, format.escapeSequenceUpperCase);\n } else if (isBigInt(value)) {\n return generateInteger(value);\n } else if (isInteger(value)) {\n return minimumDecimals > 0 ? generateFloat(value, minimumDecimals) : generateInteger(value);\n } else if (isFloat(value)) {\n return generateFloat(value, Math.max(minimumDecimals, 1));\n } else if (isBoolean(value)) {\n return generateBoolean(value);\n } else if (isTemporal(value)) {\n return generateTemporalDateTime(value, format.truncateZeroTimeInDates, format.minimumTimeDecimals ?? 0);\n } else if (isSmolTomlDate(value)) {\n // smol-toml's TomlDate renders zero fractions as `.000`, which would not\n // compare equal to a value parsed from TOML without a fraction. Convert to\n // the matching toml-patch class first so stringify and patching emit the\n // canonical form.\n return generateDateTime(smolTomlDateToNative(value), format.truncateZeroTimeInDates, format.minimumTimeDecimals ?? 0);\n } else if (isDate(value)) {\n return generateDateTime(value, format.truncateZeroTimeInDates, format.minimumTimeDecimals ?? 0);\n } else if (Array.isArray(value)) {\n return walkInlineArray(value, format, depth, parentIsMultiline);\n } else {\n return walkInlineTable(value, format, depth, parentIsMultiline);\n }\n}\n\nfunction walkInlineArray(\n value: Array<any>,\n format: TomlFormat,\n depth: number,\n parentIsMultiline: boolean\n): InlineArray {\n const inline_array = generateInlineArray();\n const multiline = !(value.length === 0 && depth > 0) &&\n resolveInlineContainerLayout('array', depth, parentIsMultiline, format);\n setInlineContainerLayout(inline_array, multiline);\n setRootIndentWidth(inline_array, format.indentWidth);\n markStringifyRoot(inline_array);\n if (!multiline) {\n for (const element of value) {\n const item = walkValue(element, format, depth + 1, multiline);\n const inline_array_item = generateInlineItem(item);\n\n appendCompactInlineItem(inline_array, inline_array_item, format);\n }\n if (inline_array.items.length > 0 && format.trailingComma) {\n const last = inline_array.items[inline_array.items.length - 1];\n last.comma = true;\n inline_array.loc.end.column++;\n }\n return inline_array;\n }\n for (const element of value) {\n const item = walkValue(element, format, depth + 1, multiline);\n const inline_array_item = generateInlineItem(item);\n\n prepareInsertedNestedInlineContainer(inline_array, inline_array_item, format.indentWidth);\n insert(inline_array, inline_array, inline_array_item);\n }\n applyBracketSpacing(inline_array, inline_array, format.bracketSpacing);\n applyTrailingComma(inline_array, inline_array, format.trailingComma);\n applyWrites(inline_array);\n\n return inline_array;\n}\n\nfunction walkInlineTable(\n value: object,\n format: TomlFormat,\n depth: number,\n parentIsMultiline: boolean\n): InlineTable | Value {\n value = toJSON(value);\n if (!isObject(value)) return walkValue(value, format, depth, parentIsMultiline);\n\n const inline_table = generateInlineTable();\n const multiline = !(Object.keys(value).length === 0 && depth > 0) &&\n resolveInlineContainerLayout('table', depth, parentIsMultiline, format);\n setInlineContainerLayout(inline_table, multiline);\n setRootIndentWidth(inline_table, format.indentWidth);\n markStringifyRoot(inline_table);\n if (!multiline) {\n for (const item of walkObject(value, format, depth + 1, multiline)) {\n appendCompactInlineItem(inline_table, generateInlineItem(item), format);\n }\n if (inline_table.items.length > 0 && format.trailingComma) {\n const last = inline_table.items[inline_table.items.length - 1];\n last.comma = true;\n inline_table.loc.end.column++;\n }\n return inline_table;\n }\n for (const item of walkObject(value, format, depth + 1, multiline)) {\n const inline_table_item = generateInlineItem(item);\n\n insert(inline_table, inline_table, inline_table_item);\n }\n applyBracketSpacing(inline_table, inline_table, format.bracketSpacing);\n applyTrailingComma(inline_table, inline_table, format.trailingComma);\n applyWrites(inline_table);\n\n return inline_table;\n}\n\n/**\n * Handles custom object serialization by checking for and using toJSON methods\n * \n * @param value - The value to potentially convert\n * @returns The result of value.toJSON() if available, otherwise the original value\n */\nfunction toJSON(value: any): any {\n // Skip null/undefined values\n if (!value) {\n return value;\n }\n \n // Skip Date objects (they have special handling)\n if (isDate(value)) {\n return value;\n }\n\n // Skip Temporal objects (they represent themselves, don't call toJSON())\n if (isTemporal(value)) {\n return value;\n }\n \n // Use object's custom toJSON method if available\n if (typeof value.toJSON === 'function') {\n return value.toJSON();\n }\n \n // Otherwise return unmodified\n return value;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA4BA,SAAwB,QACtB,OACA,SAAqB,WAAW,QAAQ,GACxC,QAAQ,GACR,oBAAoB,OACV;CACV,QAAQ,OAAO,KAAK;CAEpB,MAAM,WAAW,iBAAiB;CAElC,kBAAkB,QAAQ;CAC1B,mBAAmB,UAAU,OAAO,WAAW;CAC/C,KAAK,MAAM,QAAQ,WAAW,OAAO,QAAQ,OAAO,iBAAiB,GACnE,OAAO,UAAU,UAAU,IAAI;CAEjC,YAAY,QAAQ;CAKpB,eAAe,UAAU,MAAM;CAO/B,KAAK,OAAO,oBAAoB,KAAK,GACnC,4BAA4B,UAAU,MAAM;CAE9C,IAAI,OAAO,mBAAmB,UAAU,OAAO,mBAAmB,QAChE;OAAK,MAAM,QAAQ,SAAS,OAC1B,IAAI,KAAK,SAAS,WAAW,KAAK,SAAS,cACzC,6BAA6B,MAAM,OAAO,aAAa,OAAO,cAAc;OACvE,IAAI,WAAW,IAAI,MAAM,cAAc,KAAK,KAAK,KAAK,cAAc,KAAK,KAAK,IAKnF,6BAA6B,MAAM,OAAO,aAAa,OAAO,cAAc;CAEhF;CAGF,OAAO,iBAAiB,QAAQ;AAClC;AAEA,UAAU,WACR,QACA,QACA,QAAQ,GACR,oBAAoB,OACQ;CAC5B,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,GAAG;EACrC,MAAM,WAAW,OAAO;EACxB,IAAI,aAAa,QAAW;EAC5B,MAAM,QAAQ,OAAO,QAAQ;EAC7B,IAAI,UAAU,QAAW;EACzB,MAAM,iBACJ,CAAC,GAAG,GACJ,UAAU,OAAO,QAAQ,OAAO,iBAAiB,GACjD,QAAQ,KAAK,CAAC,mBACd,OAAO,uBACT;CACF;AACF;AAEA,SAAS,wBACP,QACA,OACA,QACM;CACN,MAAM,WAAW,OAAO,MAAM,OAAO,MAAM,SAAS;CACpD,IAAI,UAAU,SAAS,QAAQ;CAE/B,MAAM,QAAQ,WACV;EACE,MAAM,SAAS,IAAI,IAAI;EACvB,QAAQ,SAAS,IAAI,IAAI,SAAS;CACpC,IACA;EACE,MAAM,OAAO,IAAI,MAAM;EACvB,QAAQ,OAAO,IAAI,MAAM,UAAU,OAAO,iBAAiB,IAAI;CACjE;CAEJ,UAAU,OAAO;EACf,OAAO,MAAM,OAAO,MAAM,IAAI,MAAM;EACpC,SAAS,MAAM,SAAS,MAAM,IAAI,MAAM;CAC1C,CAAC;CACD,AAAC,OAAO,MAAuB,KAAK,KAAK;CAEzC,MAAM,QAAQ;CACd,OAAO,IAAI,MAAM;EACf,MAAM,MAAM,IAAI,IAAI;EACpB,QAAQ,MAAM,IAAI,IAAI,UAAU,OAAO,iBAAiB,IAAI;CAC9D;AACF;AAEA,SAAS,UACP,OACA,QACA,OACA,mBACO;CACP,MAAM,kBAAkB,OAAO,mBAAmB;CAElD,IAAI,UAAU,MACZ,MAAM,IAAI,MAAM,mCAAiC;CAEnD,IAAI,UAAU,QACZ,MAAM,IAAI,MAAM,sDAAoD;CAGtE,IAAI,SAAS,KAAK,GAChB,OAAO,eAAe,OAAO,QAAW,OAAO,uBAAuB;MACjE,IAAI,SAAS,KAAK,GACvB,OAAO,gBAAgB,KAAK;MACvB,IAAI,UAAU,KAAK,GACxB,OAAO,kBAAkB,IAAI,cAAc,OAAO,eAAe,IAAI,gBAAgB,KAAK;MACrF,IAAI,QAAQ,KAAK,GACtB,OAAO,cAAc,OAAO,KAAK,IAAI,iBAAiB,CAAC,CAAC;MACnD,IAAI,UAAU,KAAK,GACxB,OAAO,gBAAgB,KAAK;MACvB,IAAI,WAAW,KAAK,GACzB,OAAO,yBAAyB,OAAO,OAAO,yBAAyB,OAAO,uBAAuB,CAAC;MACjG,IAAI,eAAe,KAAK,GAK7B,OAAO,iBAAiB,qBAAqB,KAAK,GAAG,OAAO,yBAAyB,OAAO,uBAAuB,CAAC;MAC/G,IAAI,OAAO,KAAK,GACrB,OAAO,iBAAiB,OAAO,OAAO,yBAAyB,OAAO,uBAAuB,CAAC;MACzF,IAAI,MAAM,QAAQ,KAAK,GAC5B,OAAO,gBAAgB,OAAO,QAAQ,OAAO,iBAAiB;MAE9D,OAAO,gBAAgB,OAAO,QAAQ,OAAO,iBAAiB;AAElE;AAEA,SAAS,gBACP,OACA,QACA,OACA,mBACa;CACb,MAAM,eAAe,oBAAoB;CACzC,MAAM,YAAY,EAAE,MAAM,WAAW,KAAK,QAAQ,MAChD,6BAA6B,SAAS,OAAO,mBAAmB,MAAM;CACxE,yBAAyB,cAAc,SAAS;CAChD,mBAAmB,cAAc,OAAO,WAAW;CACnD,kBAAkB,YAAY;CAC9B,IAAI,CAAC,WAAW;EACd,KAAK,MAAM,WAAW,OAAO;GAC3B,MAAM,OAAO,UAAU,SAAS,QAAQ,QAAQ,GAAG,SAAS;GAG5D,wBAAwB,cAFE,mBAAmB,IAES,GAAG,MAAM;EACjE;EACA,IAAI,aAAa,MAAM,SAAS,KAAK,OAAO,eAAe;GACzD,MAAM,OAAO,aAAa,MAAM,aAAa,MAAM,SAAS;GAC5D,KAAK,QAAQ;GACb,aAAa,IAAI,IAAI;EACvB;EACA,OAAO;CACT;CACA,KAAK,MAAM,WAAW,OAAO;EAC3B,MAAM,OAAO,UAAU,SAAS,QAAQ,QAAQ,GAAG,SAAS;EAC5D,MAAM,oBAAoB,mBAAmB,IAAI;EAEjD,qCAAqC,cAAc,mBAAmB,OAAO,WAAW;EACxF,OAAO,cAAc,cAAc,iBAAiB;CACtD;CACA,oBAAoB,cAAc,cAAc,OAAO,cAAc;CACrE,mBAAmB,cAAc,cAAc,OAAO,aAAa;CACnE,YAAY,YAAY;CAExB,OAAO;AACT;AAEA,SAAS,gBACP,OACA,QACA,OACA,mBACqB;CACrB,QAAQ,OAAO,KAAK;CACpB,IAAI,CAAC,SAAS,KAAK,GAAG,OAAO,UAAU,OAAO,QAAQ,OAAO,iBAAiB;CAE9E,MAAM,eAAe,oBAAoB;CACzC,MAAM,YAAY,EAAE,OAAO,KAAK,KAAK,CAAC,CAAC,WAAW,KAAK,QAAQ,MAC7D,6BAA6B,SAAS,OAAO,mBAAmB,MAAM;CACxE,yBAAyB,cAAc,SAAS;CAChD,mBAAmB,cAAc,OAAO,WAAW;CACnD,kBAAkB,YAAY;CAC9B,IAAI,CAAC,WAAW;EACd,KAAK,MAAM,QAAQ,WAAW,OAAO,QAAQ,QAAQ,GAAG,SAAS,GAC/D,wBAAwB,cAAc,mBAAmB,IAAI,GAAG,MAAM;EAExE,IAAI,aAAa,MAAM,SAAS,KAAK,OAAO,eAAe;GACzD,MAAM,OAAO,aAAa,MAAM,aAAa,MAAM,SAAS;GAC5D,KAAK,QAAQ;GACb,aAAa,IAAI,IAAI;EACvB;EACA,OAAO;CACT;CACA,KAAK,MAAM,QAAQ,WAAW,OAAO,QAAQ,QAAQ,GAAG,SAAS,GAAG;EAClE,MAAM,oBAAoB,mBAAmB,IAAI;EAEjD,OAAO,cAAc,cAAc,iBAAiB;CACtD;CACA,oBAAoB,cAAc,cAAc,OAAO,cAAc;CACrE,mBAAmB,cAAc,cAAc,OAAO,aAAa;CACnE,YAAY,YAAY;CAExB,OAAO;AACT;;;;;;;AAQA,SAAS,OAAO,OAAiB;CAE/B,IAAI,CAAC,OACH,OAAO;CAIT,IAAI,OAAO,KAAK,GACd,OAAO;CAIT,IAAI,WAAW,KAAK,GAClB,OAAO;CAIT,IAAI,OAAO,MAAM,WAAW,YAC1B,OAAO,MAAM,OAAO;CAItB,OAAO;AACT"}
@@ -0,0 +1,120 @@
1
+ //! @decimalturn/toml-patch v3.3.2 - https://github.com/DecimalTurn/toml-patch - @license: MIT
2
+ //#region src/parse-string.ts
3
+ const TRIPLE_DOUBLE_QUOTE = `"""`;
4
+ const TRIPLE_SINGLE_QUOTE = `'''`;
5
+ const HEX_VAL = /* @__PURE__ */ new Int8Array(128);
6
+ HEX_VAL.fill(-1);
7
+ for (let i = 0; i < 10; i++) HEX_VAL[48 + i] = i;
8
+ for (let i = 0; i < 6; i++) {
9
+ HEX_VAL[65 + i] = 10 + i;
10
+ HEX_VAL[97 + i] = 10 + i;
11
+ }
12
+ function isHex(ch) {
13
+ const c = ch.charCodeAt(0);
14
+ return c < 128 && HEX_VAL[c] !== -1;
15
+ }
16
+ function hexVal4(s, i) {
17
+ return HEX_VAL[s.charCodeAt(i)] << 12 | HEX_VAL[s.charCodeAt(i + 1)] << 8 | HEX_VAL[s.charCodeAt(i + 2)] << 4 | HEX_VAL[s.charCodeAt(i + 3)];
18
+ }
19
+ function parseString(raw) {
20
+ if (raw.startsWith(TRIPLE_SINGLE_QUOTE)) return trimLeadingNewline(raw.slice(3, raw.length - 3));
21
+ else if (raw.startsWith("'")) return raw.slice(1, raw.length - 1);
22
+ else if (raw.startsWith(TRIPLE_DOUBLE_QUOTE)) return unescapeBasicString(trimLeadingNewline(raw.slice(3, raw.length - 3)), true);
23
+ else if (raw.startsWith("\"")) return unescapeBasicString(raw.slice(1, raw.length - 1), false);
24
+ else return raw;
25
+ }
26
+ /**
27
+ * Single-pass unescape for TOML basic strings (double-quoted).
28
+ * Handles all escape sequences including \uXXXX, \UXXXXXXXX, \xHH, \e,
29
+ * and the standard JSON-compatible escapes (\b, \t, \n, \f, \r, \\, \").
30
+ * For multiline strings, also handles line-ending backslashes and literal newlines.
31
+ */
32
+ function unescapeBasicString(value, multiline) {
33
+ const len = value.length;
34
+ if (!multiline && value.indexOf("\\") === -1) return value;
35
+ const parts = [];
36
+ let start = 0;
37
+ for (let i = 0; i < len; i++) {
38
+ if (value[i] !== "\\") continue;
39
+ if (i > start) parts.push(value.slice(start, i));
40
+ i++;
41
+ if (i >= len) throw new Error("Trailing backslash");
42
+ const esc = value[i];
43
+ switch (esc) {
44
+ case "b":
45
+ parts.push("\b");
46
+ break;
47
+ case "t":
48
+ parts.push(" ");
49
+ break;
50
+ case "n":
51
+ parts.push("\n");
52
+ break;
53
+ case "f":
54
+ parts.push("\f");
55
+ break;
56
+ case "r":
57
+ parts.push("\r");
58
+ break;
59
+ case "\"":
60
+ parts.push("\"");
61
+ break;
62
+ case "\\":
63
+ parts.push("\\");
64
+ break;
65
+ case "e":
66
+ parts.push("\x1B");
67
+ break;
68
+ case "u": {
69
+ if (i + 4 > len || !isHex(value[i + 1]) || !isHex(value[i + 2]) || !isHex(value[i + 3]) || !isHex(value[i + 4])) throw new Error(`Invalid Unicode escape: \\u${value.slice(i + 1, i + 5)}`);
70
+ const cp = hexVal4(value, i + 1);
71
+ if (cp >= 55296 && cp <= 57343) throw new Error(`Invalid \\u${value.slice(i + 1, i + 5)}: surrogates not allowed`);
72
+ parts.push(String.fromCharCode(cp));
73
+ i += 4;
74
+ break;
75
+ }
76
+ case "U": {
77
+ if (i + 8 > len) throw new Error(`Invalid Unicode escape: \\U${value.slice(i + 1, i + 9)}`);
78
+ for (let j = 1; j <= 8; j++) if (!isHex(value[i + j])) throw new Error(`Invalid Unicode escape: \\U${value.slice(i + 1, i + 9)}`);
79
+ const cp = parseInt(value.slice(i + 1, i + 9), 16);
80
+ if (cp >= 55296 && cp <= 57343) throw new Error(`Invalid \\U${value.slice(i + 1, i + 9)}: surrogates not allowed`);
81
+ parts.push(String.fromCodePoint(cp));
82
+ i += 8;
83
+ break;
84
+ }
85
+ case "x": {
86
+ if (i + 2 > len || !isHex(value[i + 1]) || !isHex(value[i + 2])) throw new Error(`Invalid hex escape: \\x${value.slice(i + 1, i + 3)}`);
87
+ const cp = HEX_VAL[value.charCodeAt(i + 1)] << 4 | HEX_VAL[value.charCodeAt(i + 2)];
88
+ parts.push(String.fromCharCode(cp));
89
+ i += 2;
90
+ break;
91
+ }
92
+ default:
93
+ if (multiline && (esc === "\n" || esc === "\r" || esc === " " || esc === " ")) {
94
+ let hasNewline = esc === "\n" || esc === "\r";
95
+ let j = i;
96
+ while (j < len && (value[j] === " " || value[j] === " " || value[j] === "\n" || value[j] === "\r")) {
97
+ if (value[j] === "\n" || value[j] === "\r") hasNewline = true;
98
+ j++;
99
+ }
100
+ if (!hasNewline) throw new Error(`Invalid escape sequence: \\${esc}`);
101
+ i = j - 1;
102
+ break;
103
+ }
104
+ throw new Error(`Invalid escape sequence: \\${esc}`);
105
+ }
106
+ start = i + 1;
107
+ }
108
+ if (start === 0) return value;
109
+ if (start < len) parts.push(value.slice(start));
110
+ return parts.join("");
111
+ }
112
+ function trimLeadingNewline(value) {
113
+ if (value.charCodeAt(0) === 10) return value.slice(1);
114
+ if (value.charCodeAt(0) === 13 && value.charCodeAt(1) === 10) return value.slice(2);
115
+ return value;
116
+ }
117
+
118
+ //#endregion
119
+ export { parseString };
120
+ //# sourceMappingURL=parse-string.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"parse-string.js","names":[],"sources":["../../src/parse-string.ts"],"sourcesContent":["import { SINGLE_QUOTE, DOUBLE_QUOTE } from './tokenizer';\n\nconst TRIPLE_DOUBLE_QUOTE = `\"\"\"`;\nconst TRIPLE_SINGLE_QUOTE = `'''`;\n\n// Hex digit lookup (returns -1 for non-hex chars)\nconst HEX_VAL = new Int8Array(128);\nHEX_VAL.fill(-1);\nfor (let i = 0; i < 10; i++) HEX_VAL[0x30 + i] = i; // '0'-'9'\nfor (let i = 0; i < 6; i++) { HEX_VAL[0x41 + i] = 10 + i; HEX_VAL[0x61 + i] = 10 + i; } // A-F, a-f\n\nfunction isHex(ch: string): boolean {\n const c = ch.charCodeAt(0);\n return c < 128 && HEX_VAL[c] !== -1;\n}\n\nfunction hexVal4(s: string, i: number): number {\n return (HEX_VAL[s.charCodeAt(i)] << 12) |\n (HEX_VAL[s.charCodeAt(i + 1)] << 8) |\n (HEX_VAL[s.charCodeAt(i + 2)] << 4) |\n HEX_VAL[s.charCodeAt(i + 3)];\n}\n\nexport function parseString(raw: string): string {\n if (raw.startsWith(TRIPLE_SINGLE_QUOTE)) {\n return trimLeadingNewline(raw.slice(3, raw.length - 3));\n } else if (raw.startsWith(SINGLE_QUOTE)) {\n return raw.slice(1, raw.length - 1);\n } else if (raw.startsWith(TRIPLE_DOUBLE_QUOTE)) {\n return unescapeBasicString(trimLeadingNewline(raw.slice(3, raw.length - 3)), true);\n } else if (raw.startsWith(DOUBLE_QUOTE)) {\n return unescapeBasicString(raw.slice(1, raw.length - 1), false);\n } else {\n return raw;\n }\n}\n\n/**\n * Single-pass unescape for TOML basic strings (double-quoted).\n * Handles all escape sequences including \\uXXXX, \\UXXXXXXXX, \\xHH, \\e,\n * and the standard JSON-compatible escapes (\\b, \\t, \\n, \\f, \\r, \\\\, \\\").\n * For multiline strings, also handles line-ending backslashes and literal newlines.\n */\nfunction unescapeBasicString(value: string, multiline: boolean): string {\n const len = value.length;\n // Fast path: no backslash means no escapes to process\n // For non-multiline this is sufficient; for multiline we still need it\n // because literal newlines are valid content\n if (!multiline && value.indexOf('\\\\') === -1) {\n return value;\n }\n\n const parts: string[] = [];\n let start = 0; // start of current unescaped run\n\n for (let i = 0; i < len; i++) {\n const ch = value[i];\n\n if (ch !== '\\\\') continue;\n\n // Flush the unescaped run before this backslash\n if (i > start) parts.push(value.slice(start, i));\n\n i++; // advance past backslash\n if (i >= len) throw new Error('Trailing backslash');\n\n const esc = value[i];\n switch (esc) {\n case 'b': parts.push('\\b'); break;\n case 't': parts.push('\\t'); break;\n case 'n': parts.push('\\n'); break;\n case 'f': parts.push('\\f'); break;\n case 'r': parts.push('\\r'); break;\n case '\"': parts.push('\"'); break;\n case '\\\\': parts.push('\\\\'); break;\n case 'e': parts.push('\\u001b'); break; // TOML 1.1.0 ESC\n\n case 'u': {\n // \\uXXXX — 4 hex digits\n if (i + 4 > len || !isHex(value[i+1]) || !isHex(value[i+2]) || !isHex(value[i+3]) || !isHex(value[i+4])) {\n throw new Error(`Invalid Unicode escape: \\\\u${value.slice(i + 1, i + 5)}`);\n }\n const cp = hexVal4(value, i + 1);\n if (cp >= 0xD800 && cp <= 0xDFFF) {\n throw new Error(`Invalid \\\\u${value.slice(i + 1, i + 5)}: surrogates not allowed`);\n }\n parts.push(String.fromCharCode(cp));\n i += 4;\n break;\n }\n\n case 'U': {\n // \\UXXXXXXXX — 8 hex digits\n if (i + 8 > len) {\n throw new Error(`Invalid Unicode escape: \\\\U${value.slice(i + 1, i + 9)}`);\n }\n for (let j = 1; j <= 8; j++) {\n if (!isHex(value[i + j])) {\n throw new Error(`Invalid Unicode escape: \\\\U${value.slice(i + 1, i + 9)}`);\n }\n }\n const cp = parseInt(value.slice(i + 1, i + 9), 16);\n // Same restriction as the \\u form above. Unlike an out-of-range code point, a\n // surrogate is accepted by String.fromCodePoint (it just yields an unpaired code\n // unit), so it has to be rejected explicitly.\n if (cp >= 0xD800 && cp <= 0xDFFF) {\n throw new Error(`Invalid \\\\U${value.slice(i + 1, i + 9)}: surrogates not allowed`);\n }\n parts.push(String.fromCodePoint(cp));\n i += 8;\n break;\n }\n\n case 'x': {\n // \\xHH — 2 hex digits (TOML 1.1.0)\n if (i + 2 > len || !isHex(value[i+1]) || !isHex(value[i+2])) {\n throw new Error(`Invalid hex escape: \\\\x${value.slice(i + 1, i + 3)}`);\n }\n const cp = (HEX_VAL[value.charCodeAt(i + 1)] << 4) | HEX_VAL[value.charCodeAt(i + 2)];\n parts.push(String.fromCharCode(cp));\n i += 2;\n break;\n }\n\n default:\n // Multiline: line-ending backslash — skip backslash + whitespace + newline + whitespace\n // A line-ending backslash is only valid if there is at least one newline\n // in the whitespace that follows the backslash.\n if (multiline && (esc === '\\n' || esc === '\\r' || esc === ' ' || esc === '\\t')) {\n // Scan forward through whitespace; must find at least one newline\n let hasNewline = esc === '\\n' || esc === '\\r';\n let j = i;\n while (j < len && (value[j] === ' ' || value[j] === '\\t' || value[j] === '\\n' || value[j] === '\\r')) {\n if (value[j] === '\\n' || value[j] === '\\r') hasNewline = true;\n j++;\n }\n if (!hasNewline) {\n // No newline found — not a valid line-ending backslash\n throw new Error(`Invalid escape sequence: \\\\${esc}`);\n }\n i = j - 1; // will be incremented by the for loop\n break;\n }\n throw new Error(`Invalid escape sequence: \\\\${esc}`);\n }\n\n start = i + 1;\n }\n\n // Flush any remaining unescaped content\n if (start === 0) return value; // no escapes were found\n if (start < len) parts.push(value.slice(start));\n\n return parts.join('');\n}\n\nexport function escape(value: string): string {\n const s = JSON.stringify(value);\n return s.slice(1, s.length - 1);\n}\n\nfunction trimLeadingNewline(value: string): string {\n if (value.charCodeAt(0) === 0x0a) return value.slice(1); // \\n\n if (value.charCodeAt(0) === 0x0d && value.charCodeAt(1) === 0x0a) // \\r\\n\n return value.slice(2);\n return value;\n}\n"],"mappings":"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"}