@decimalturn/toml-patch 3.3.2 → 3.3.3-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 (83) hide show
  1. package/dist/dev/comment-alignment.js +371 -0
  2. package/dist/dev/comment-alignment.js.map +1 -0
  3. package/dist/dev/comment-ownership.js +672 -0
  4. package/dist/dev/comment-ownership.js.map +1 -0
  5. package/dist/dev/cst-source.js +117 -0
  6. package/dist/dev/cst-source.js.map +1 -0
  7. package/dist/dev/cst.js +67 -0
  8. package/dist/dev/cst.js.map +1 -0
  9. package/dist/dev/cursor.js +65 -0
  10. package/dist/dev/cursor.js.map +1 -0
  11. package/dist/dev/date-format.js +286 -0
  12. package/dist/dev/date-format.js.map +1 -0
  13. package/dist/dev/decode-utf8.js +26 -0
  14. package/dist/dev/decode-utf8.js.map +1 -0
  15. package/dist/dev/diff-lite.js +107 -0
  16. package/dist/dev/diff-lite.js.map +1 -0
  17. package/dist/dev/diff.js +264 -0
  18. package/dist/dev/diff.js.map +1 -0
  19. package/dist/dev/encode-lite.js +209 -0
  20. package/dist/dev/encode-lite.js.map +1 -0
  21. package/dist/dev/escape-preference.js +165 -0
  22. package/dist/dev/escape-preference.js.map +1 -0
  23. package/dist/dev/find-by-path.js +114 -0
  24. package/dist/dev/find-by-path.js.map +1 -0
  25. package/dist/dev/formatter.js +297 -0
  26. package/dist/dev/formatter.js.map +1 -0
  27. package/dist/dev/generate.js +479 -0
  28. package/dist/dev/generate.js.map +1 -0
  29. package/dist/dev/inline-comma-space.js +12 -0
  30. package/dist/dev/inline-comma-space.js.map +1 -0
  31. package/dist/dev/inline-format.js +105 -0
  32. package/dist/dev/inline-format.js.map +1 -0
  33. package/dist/dev/inline-layout.js +106 -0
  34. package/dist/dev/inline-layout.js.map +1 -0
  35. package/dist/dev/line-ending-backslash.js +319 -0
  36. package/dist/dev/line-ending-backslash.js.map +1 -0
  37. package/dist/dev/literal-string.js +45 -0
  38. package/dist/dev/literal-string.js.map +1 -0
  39. package/dist/dev/location.js +103 -0
  40. package/dist/dev/location.js.map +1 -0
  41. package/dist/dev/parse-error.js +26 -0
  42. package/dist/dev/parse-error.js.map +1 -0
  43. package/dist/dev/parse-js.js +149 -0
  44. package/dist/dev/parse-js.js.map +1 -0
  45. package/dist/dev/parse-string.js +119 -0
  46. package/dist/dev/parse-string.js.map +1 -0
  47. package/dist/dev/parse-toml.js +713 -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 +96 -0
  51. package/dist/dev/patch-lite2.js.map +1 -0
  52. package/dist/dev/patch.js +3143 -0
  53. package/dist/dev/patch.js.map +1 -0
  54. package/dist/dev/smol-toml-date.js +60 -0
  55. package/dist/dev/smol-toml-date.js.map +1 -0
  56. package/dist/dev/to-js.js +307 -0
  57. package/dist/dev/to-js.js.map +1 -0
  58. package/dist/dev/to-toml.js +873 -0
  59. package/dist/dev/to-toml.js.map +1 -0
  60. package/dist/dev/tokenizer.js +224 -0
  61. package/dist/dev/tokenizer.js.map +1 -0
  62. package/dist/dev/toml-document.js +220 -0
  63. package/dist/dev/toml-document.js.map +1 -0
  64. package/dist/dev/toml-format.js +548 -0
  65. package/dist/dev/toml-format.js.map +1 -0
  66. package/dist/dev/toml-patch.js +93 -0
  67. package/dist/dev/toml-patch.js.map +1 -0
  68. package/dist/dev/traverse.js +60 -0
  69. package/dist/dev/traverse.js.map +1 -0
  70. package/dist/dev/truncate.js +63 -0
  71. package/dist/dev/truncate.js.map +1 -0
  72. package/dist/dev/update-order.js +234 -0
  73. package/dist/dev/update-order.js.map +1 -0
  74. package/dist/dev/utils.js +295 -0
  75. package/dist/dev/utils.js.map +1 -0
  76. package/dist/dev/writer.js +757 -0
  77. package/dist/dev/writer.js.map +1 -0
  78. package/dist/patch-lite.d.ts +16 -0
  79. package/dist/toml-patch.d.ts +0 -16
  80. package/package.json +16 -103
  81. package/LICENSE +0 -22
  82. package/README.md +0 -203
  83. package/dist/toml-patch.js +0 -84
@@ -0,0 +1 @@
1
+ {"version":3,"file":"formatter.js","names":[],"sources":["../../src/formatter.ts"],"sourcesContent":["import {\n KeyValue,\n Table,\n InlineTable,\n TableArray,\n InlineArray,\n isInlineTable,\n isInlineArray,\n isKeyValue,\n isInlineItem,\n isTable,\n isTableArray,\n Document,\n Block,\n TreeNode\n} from './cst';\nimport { generateTable, generateDocument, generateTableArray } from './generate';\nimport { insert, remove, applyWrites, shiftNode, markStringifyRoot } from './writer';\nimport { TomlFormat } from './toml-format';\nimport { getInlineContainerLayout, hasStructuralMultilineRows } from './inline-format';\nimport { getCommaSpace } from './inline-comma-space';\n\n// Helper function to detect if an InlineArray originally had trailing commas\nexport function arrayHadTrailingCommas(node: TreeNode): boolean {\n if (!isInlineArray(node)) return false;\n if (node.items.length === 0) return false;\n // Check if the last item has a trailing comma\n const lastItem = node.items[node.items.length - 1];\n return lastItem.comma === true;\n}\n\n// Helper function to detect if an InlineTable originally had trailing commas\nexport function tableHadTrailingCommas(node: TreeNode): boolean {\n if (!isInlineTable(node)) return false;\n if (node.items.length === 0) return false;\n // Check if the last item has a trailing comma\n const lastItem = node.items[node.items.length - 1];\n return lastItem.comma === true;\n}\n\nexport function formatTopLevel(document: Document, format: TomlFormat): Document {\n\n // If inlineTableStart is 0, convert all top-level tables to inline tables\n if (format.inlineTableStart === 0) {\n return document;\n }\n\n const move_to_top_level = document.items.filter(item => {\n if (!isKeyValue(item)) return false;\n\n const is_inline_table = isInlineTable(item.value);\n const is_inline_array =\n isInlineArray(item.value) &&\n item.value.items.length > 0 &&\n item.value.items.every(i => isInlineTable(i.item));\n\n // Only move to top level if the depth is less than inlineTableStart\n if (is_inline_table || is_inline_array) {\n const depth = calculateTableDepth(item.key.value);\n return format.inlineTableStart === undefined || depth < format.inlineTableStart;\n }\n\n return false;\n }) as KeyValue[];\n\n move_to_top_level.forEach(node => {\n remove(document, document, node);\n\n if (isInlineTable(node.value)) {\n // Fast path: empty inline tables don't need the full formatTable\n // machinery (inline table copy, insert loop, applyWrites).\n if ((node.value as InlineTable).items.length === 0) {\n insert(document, document, generateTable(node.key.value));\n } else {\n insert(document, document, formatTable(node, format.bracketSpacing, format.escapeSequenceUpperCase));\n }\n } else {\n formatTableArray(node, format.bracketSpacing, format.escapeSequenceUpperCase).forEach(table_array => {\n insert(document, document, table_array);\n });\n }\n });\n\n applyWrites(document);\n return document;\n}\n\nfunction formatTable(key_value: KeyValue, bracketSpacing: boolean, escapeSequenceUpperCase: boolean): Table {\n const table = generateTable(key_value.key.value, escapeSequenceUpperCase);\n markStringifyRoot(table);\n\n for (const item of (key_value.value as InlineTable).items) {\n insert(table, table, item.item, undefined, undefined, undefined, undefined, true);\n }\n\n applyWrites(table);\n normalizeGeneratedInlineRows(table, 1, bracketSpacing);\n return table;\n}\n\nfunction formatTableArray(key_value: KeyValue, bracketSpacing: boolean, escapeSequenceUpperCase: boolean): TableArray[] {\n const root = generateDocument();\n markStringifyRoot(root);\n\n for (const inline_array_item of (key_value.value as InlineArray).items) {\n const table_array = generateTableArray(key_value.key.value, escapeSequenceUpperCase);\n insert(root, root, table_array);\n\n for (const inline_table_item of (inline_array_item.item as InlineTable).items) {\n insert(root, table_array, inline_table_item.item, undefined, undefined, undefined, undefined, true);\n }\n }\n\n applyWrites(root);\n for (const item of root.items) {\n if (isTable(item) || isTableArray(item)) normalizeGeneratedInlineRows(item, 1, bracketSpacing);\n }\n return root.items as TableArray[];\n}\n\n/**\n * Whether an inline container lays its items out one per row. A container\n * regenerated through a TOML round-trip carries no layout flag, so fall back to\n * the physical rows: a row on a later line than the previous item's end means\n * multiline. A compact container whose items merely SPAN several lines (because\n * one of them is a multiline value) stays compact — its closing bracket still\n * follows its last item.\n */\nfunction isMultilineInlineContainer(container: InlineArray | InlineTable): boolean {\n const layout = getInlineContainerLayout(container);\n return layout !== undefined ? layout : hasStructuralMultilineRows(container);\n}\n\n/**\n * Row indent for a container that is an array ELEMENT (no key of its own).\n * Keyless rows keep the historical minimum of two columns, matching\n * positionGeneratedNestedInlineTables so element rows and their closing\n * bracket stay aligned the same way no matter which path laid them out.\n */\nfunction elementIndentWidth(indentWidth: number): number {\n return Math.max(indentWidth, 2);\n}\n\n/**\n * Lays out a generated inline container so that its rows and closing bracket\n * line up with the key (or, for an array element, the element) that owns it:\n *\n * - a multiline container puts one row per line at `anchorColumn + indentWidth`\n * and its closing bracket at `anchorColumn`;\n * - a nested multiline container inside a row does the same, using that row's\n * key column as its own anchor.\n *\n * `anchorColumn` is the column of the owning key's start. It only has to be\n * correct for containers the generator built: containers parsed from an\n * existing document keep their own formatting, so callers must restrict this\n * to freshly generated/replaced subtrees.\n *\n * Returns whether a nested container's end position moved.\n */\nexport function normalizeInlineContainerRows(\n container: InlineArray | InlineTable,\n anchorColumn: number,\n indentWidth: number,\n bracketSpacing = true\n): boolean {\n const multiline = isMultilineInlineContainer(container);\n let nestedEndChanged = false;\n if (multiline) {\n const rowIndent = anchorColumn + indentWidth;\n for (const item of container.items) {\n shiftNode(item, { lines: 0, columns: rowIndent - item.loc.start.column });\n if (isInlineItem(item)) {\n if (isInlineArray(item.item) || isInlineTable(item.item)) {\n if (normalizeInlineContainerRows(item.item, item.item.loc.start.column, elementIndentWidth(indentWidth), bracketSpacing)) {\n item.loc.end = { ...item.item.loc.end };\n nestedEndChanged = true;\n }\n } else if (isKeyValue(item.item) &&\n (isInlineArray(item.item.value) || isInlineTable(item.item.value))) {\n // The nested container's rows hang off the ROW's key, so it has to\n // be laid out from the key's own column — not from the enclosing\n // container's indent (fuzz3 seed 18515).\n if (normalizeInlineContainerRows(item.item.value, item.item.loc.start.column, indentWidth, bracketSpacing)) {\n item.item.loc.end = { ...item.item.value.loc.end };\n item.loc.end = { ...item.item.loc.end };\n nestedEndChanged = true;\n }\n }\n }\n }\n container.loc.end.column = anchorColumn + 1;\n // The container's own closing bracket moved, so the enclosing item has to\n // re-sync its end from it (its comma is written at that end).\n nestedEndChanged = true;\n }\n\n for (const item of container.items) {\n if (!isInlineItem(item)) continue;\n if (isInlineArray(item.item) || isInlineTable(item.item)) {\n if (normalizeInlineContainerRows(item.item, item.item.loc.start.column, elementIndentWidth(indentWidth), bracketSpacing)) {\n item.loc.end = { ...item.item.loc.end };\n nestedEndChanged = true;\n }\n } else if (isKeyValue(item.item) &&\n (isInlineArray(item.item.value) || isInlineTable(item.item.value))) {\n const value = item.item.value;\n const anchorColumn = item.item.loc.start.column;\n const valueMultiline = isMultilineInlineContainer(value);\n if (normalizeInlineContainerRows(value, anchorColumn, indentWidth, bracketSpacing)) {\n // A MULTILINE nested value closes on its own row, level with the row's\n // key. A compact one closes right after its last item — that end was\n // already computed by its own pass, so snapping it to the key column\n // would place the closing bracket before the item it follows\n // (fuzz3 seed 14739).\n if (valueMultiline) value.loc.end.column = anchorColumn + 1;\n item.item.loc.end = { ...value.loc.end };\n item.loc.end = { ...item.item.loc.end };\n nestedEndChanged = true;\n }\n }\n }\n // A nested container that grew pushes its following siblings along: the\n // siblings were positioned against its OLD end, so the ones still sharing its\n // end row must be re-anchored to its new end before the container's own\n // closing bracket is placed from the last item.\n const commaSpace = getCommaSpace(container) ?? 2;\n for (let index = 1; index < container.items.length; index++) {\n const previous = container.items[index - 1];\n const next = container.items[index];\n if (previous.loc.end.line !== next.loc.start.line) continue;\n const targetColumn = previous.loc.end.column + (previous.comma ? commaSpace : 1);\n shiftNode(next, { lines: 0, columns: targetColumn - next.loc.start.column });\n }\n if (nestedEndChanged && !multiline && container.items.length > 0) {\n const lastItem = container.items[container.items.length - 1];\n container.loc.end = {\n line: lastItem.loc.end.line,\n column: lastItem.loc.end.column + (lastItem.comma ? 1 : 0) + (bracketSpacing ? 2 : 1)\n };\n }\n return nestedEndChanged;\n}\n\nexport function normalizeGeneratedInlineRows(\n block: Table | TableArray | KeyValue,\n indentWidth: number,\n bracketSpacing = true\n): void {\n // A root-level key-value is normalized like the rows of a table: its own key\n // column is the anchor the nested container hangs off.\n const rows: Block[] = isKeyValue(block) ? [block] : block.items;\n for (const item of rows) {\n if (!isKeyValue(item)) continue;\n if (isInlineArray(item.value) || isInlineTable(item.value)) {\n normalizeInlineContainerRows(item.value, item.loc.start.column, indentWidth, bracketSpacing);\n }\n }\n}\n\nexport function normalizeGeneratedInlineContainerRows(\n container: InlineArray | InlineTable,\n indentWidth: number\n): void {\n const normalize = (\n current: InlineArray | InlineTable,\n normalizeCurrent: boolean\n ): void => {\n if (normalizeCurrent) {\n delete (current as { range?: [number, number] }).range;\n const multiline = getInlineContainerLayout(current) === true ||\n hasStructuralMultilineRows(current);\n if (multiline) {\n const rowIndent = current.loc.start.column + indentWidth;\n for (const item of current.items) {\n shiftNode(item, { lines: 0, columns: rowIndent - item.loc.start.column });\n }\n current.loc.end.column = current.loc.start.column + 1;\n }\n }\n\n for (const item of current.items) {\n if (!isInlineItem(item)) continue;\n if (isInlineArray(item.item) || isInlineTable(item.item)) {\n normalize(item.item, isInlineArray(current) && isInlineTable(item.item));\n } else if (isKeyValue(item.item) &&\n (isInlineArray(item.item.value) || isInlineTable(item.item.value))) {\n normalize(item.item.value, false);\n }\n }\n };\n\n normalize(container, false);\n}\n\n/**\n * Updates a table's location end position after removing inline table items.\n * When inline table content is removed from a parent table, the parent table's \n * end position needs to be adjusted to reflect where the content actually ends.\n * \n * @param table - The table whose end position should be updated\n */\nexport function postInlineItemRemovalAdjustment(table: Table | TableArray): void {\n if (table.items.length > 0) {\n const lastItem = table.items[table.items.length - 1];\n table.loc.end.line = lastItem.loc.end.line;\n table.loc.end.column = lastItem.loc.end.column;\n } else {\n // If no items left, table ends at the header line\n table.loc.end.line = table.key.loc.end.line;\n table.loc.end.column = table.key.loc.end.column;\n }\n}\n\n/**\n * Calculates the nesting depth of a table based on its key path.\n * Root level tables (e.g., [table]) have depth 0.\n * First level nested tables (e.g., [table.nested]) have depth 1.\n * \n * @param keyPath - Array representing the table key path (e.g., ['table', 'nested'])\n * @returns The nesting depth (0 for root level, 1+ for nested levels)\n */\nexport function calculateTableDepth(keyPath: string[]): number {\n return Math.max(0, keyPath.length - 1);\n}\n\n/**\n * Converts nested inline tables to separate table sections based on the inlineTableStart depth setting.\n * This function recursively processes all tables in the document and extracts inline tables that are\n * at a depth less than the inlineTableStart threshold.\n */\nexport function formatNestedTablesMultiline(document: Document, format: TomlFormat): Document {\n // If inlineTableStart is undefined, use the default behavior (no conversion)\n // If inlineTableStart is 0, all should be inline (no conversion)\n if (format.inlineTableStart === undefined || format.inlineTableStart === 0) {\n return document;\n }\n\n const additionalTables: { table: Table; parent: Table | TableArray }[] = [];\n \n // Process all existing tables for nested inline tables\n for (const item of document.items) {\n if (isKeyValue(item) && isInlineTable(item.value)) {\n // This is a top-level inline table (depth 0)\n const depth = calculateTableDepth(item.key.value);\n if (depth < format.inlineTableStart) {\n // Convert to a separate table\n const table = formatTable(item, format.bracketSpacing, format.escapeSequenceUpperCase);\n remove(document, document, item);\n insert(document, document, table);\n \n processTableForNestedInlines(table, additionalTables, format);\n }\n } else if (item.type === 'Table') {\n processTableForNestedInlines(item as Table, additionalTables, format);\n } else if (isTableArray(item)) {\n processTableForNestedInlines(item, additionalTables, format);\n }\n }\n \n // Insert each extracted table immediately after its parent block, preserving\n // the parent-child positional relationship. A flat append at the document\n // end (the previous behaviour) misplaced a sub-table of an earlier entry —\n // e.g. `[tp6.k41]` (a sub-table of `[[tp6]]` entry 0) landed after `[[tp6]]`\n // entry 1, reassigning `k41` to the wrong entry. `additionalTables` is in\n // depth-first pre-order (a child is pushed before its own children), so\n // inserting in order with a per-parent counter keeps every sub-table after\n // its parent and before the parent's next sibling.\n const insertedAfter = new Map<Table | TableArray, number>();\n for (const { table, parent } of additionalTables) {\n const index = document.items.indexOf(parent);\n const offset = (insertedAfter.get(parent) ?? 0) + 1;\n insertedAfter.set(parent, offset);\n insert(document, document, table, index + offset);\n }\n\n applyWrites(document);\n return document;\n}\n\n/**\n * Recursively processes a table for nested inline tables and extracts them as separate tables\n * when they are at a depth less than the inlineTableStart threshold.\n */\nfunction processTableForNestedInlines(table: Table | TableArray, additionalTables: { table: Table; parent: Table | TableArray }[], format: TomlFormat): void {\n // Collect all inline tables that need extraction, then process in forward order\n // to preserve the original key order in the output.\n const toExtract: { item: KeyValue; nestedTableKey: string[] }[] = [];\n for (let i = 0; i < table.items.length; i++) {\n const item = table.items[i];\n if (isKeyValue(item) && isInlineTable(item.value)) {\n const nestedTableKey = [...table.key.item.value, ...item.key.value];\n const depth = calculateTableDepth(nestedTableKey);\n if (depth < (format.inlineTableStart ?? 1)) {\n toExtract.push({ item, nestedTableKey });\n }\n }\n }\n\n // Process in forward order. Each item reference captured above is stable\n // even after previous iterations call remove() — the KeyValue node itself\n // stays valid regardless of index shifts.\n for (const { item, nestedTableKey } of toExtract) {\n const separateTable = generateTable(nestedTableKey, format.escapeSequenceUpperCase);\n markStringifyRoot(separateTable);\n const inlineTable = item.value as InlineTable;\n\n for (const inlineItem of inlineTable.items) {\n insert(separateTable, separateTable, inlineItem.item);\n }\n // Finalize the separateTable's internal offsets and recalculate its span\n // so it can be safely inserted into the document later.\n applyWrites(separateTable);\n\n remove(table, table, item);\n postInlineItemRemovalAdjustment(table);\n\n additionalTables.push({ table: separateTable, parent: table });\n\n processTableForNestedInlines(separateTable, additionalTables, format);\n }\n // Apply removal offsets accumulated on this table so remaining items\n // (if any) are shifted to the correct positions.\n if (toExtract.length > 0) {\n applyWrites(table);\n }\n}\n\nexport function formatEmptyLines(document: Document): Document {\n let shift = 0;\n let previous = 0;\n for (const item of document.items) {\n if (previous === 0 && item.loc.start.line > 1) {\n // Remove leading newlines\n shift = 1 - item.loc.start.line;\n } else if (item.loc.start.line + shift > previous + 2) {\n shift += previous + 2 - (item.loc.start.line + shift);\n }\n\n shiftNode(item, {\n lines: shift,\n columns: 0\n });\n previous = item.loc.end.line;\n }\n\n return document;\n}\n"],"mappings":"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"}
@@ -0,0 +1,479 @@
1
+ //! @decimalturn/toml-patch v3.3.3 - https://github.com/DecimalTurn/toml-patch - @license: MIT
2
+ import { cloneLocation, clonePosition, zero } from "./location.js";
3
+ import { LocalDate, LocalTime, padFractionalSeconds } from "./date-format.js";
4
+ import { shiftNode } from "./writer.js";
5
+ import { rebuildLineContinuation } from "./line-ending-backslash.js";
6
+ import { IS_BARE_KEY } from "./tokenizer.js";
7
+ import { canUseLiteralString, canUseMultilineLiteral } from "./literal-string.js";
8
+ import { escapeStringContent, upperCaseHexEscapes } from "./escape-preference.js";
9
+ import { assertNoLoneSurrogate, isBasicString, isLiteralString, isMultilineBasicString, isMultilineLiteralString, isNegativeNan, temporalToTomlString } from "./utils.js";
10
+
11
+ // src/generate.ts
12
+ /**
13
+ * Generates a new TOML document node.
14
+ *
15
+ * @returns A new Document node.
16
+ */
17
+ function generateDocument() {
18
+ return {
19
+ type: "Document",
20
+ loc: {
21
+ start: zero(),
22
+ end: zero()
23
+ },
24
+ items: []
25
+ };
26
+ }
27
+ function generateTable(key, escapeSequenceUpperCase = true) {
28
+ const table_key = generateTableKey(key, escapeSequenceUpperCase);
29
+ return {
30
+ type: "Table",
31
+ loc: cloneLocation(table_key.loc),
32
+ key: table_key,
33
+ items: []
34
+ };
35
+ }
36
+ function generateTableKey(key, escapeSequenceUpperCase = true) {
37
+ const raw = keyValueToRaw(key, escapeSequenceUpperCase);
38
+ return {
39
+ type: "TableKey",
40
+ loc: {
41
+ start: zero(),
42
+ end: {
43
+ line: 1,
44
+ column: raw.length + 2
45
+ }
46
+ },
47
+ item: {
48
+ type: "Key",
49
+ loc: {
50
+ start: {
51
+ line: 1,
52
+ column: 1
53
+ },
54
+ end: {
55
+ line: 1,
56
+ column: raw.length + 1
57
+ }
58
+ },
59
+ value: key,
60
+ raw
61
+ }
62
+ };
63
+ }
64
+ function generateTableArray(key, escapeSequenceUpperCase = true) {
65
+ const table_array_key = generateTableArrayKey(key, escapeSequenceUpperCase);
66
+ return {
67
+ type: "TableArray",
68
+ loc: cloneLocation(table_array_key.loc),
69
+ key: table_array_key,
70
+ items: []
71
+ };
72
+ }
73
+ function generateTableArrayKey(key, escapeSequenceUpperCase = true) {
74
+ const raw = keyValueToRaw(key, escapeSequenceUpperCase);
75
+ return {
76
+ type: "TableArrayKey",
77
+ loc: {
78
+ start: zero(),
79
+ end: {
80
+ line: 1,
81
+ column: raw.length + 4
82
+ }
83
+ },
84
+ item: {
85
+ type: "Key",
86
+ loc: {
87
+ start: {
88
+ line: 1,
89
+ column: 2
90
+ },
91
+ end: {
92
+ line: 1,
93
+ column: raw.length + 2
94
+ }
95
+ },
96
+ value: key,
97
+ raw
98
+ }
99
+ };
100
+ }
101
+ function generateKeyValue(key, value, shiftGeneratedMultilineEnd = false, escapeSequenceUpperCase = true) {
102
+ const key_node = generateKey(key, escapeSequenceUpperCase);
103
+ const { column } = key_node.loc.end;
104
+ const equals = column + 1;
105
+ shiftNode(value, {
106
+ lines: 1 - value.loc.start.line,
107
+ columns: column + 3 - value.loc.start.column
108
+ }, {
109
+ first_line_only: true,
110
+ shift_generated_multiline_end: shiftGeneratedMultilineEnd
111
+ });
112
+ return {
113
+ type: "KeyValue",
114
+ loc: {
115
+ start: clonePosition(key_node.loc.start),
116
+ end: clonePosition(value.loc.end)
117
+ },
118
+ key: key_node,
119
+ equals,
120
+ value
121
+ };
122
+ }
123
+ function quoteTomlString(value, escapeSequenceUpperCase = true) {
124
+ const withDel = JSON.stringify(value).replace(/\x7f/g, "\\u007f");
125
+ return escapeSequenceUpperCase ? upperCaseHexEscapes(withDel) : withDel;
126
+ }
127
+ function keyValueToRaw(value, escapeSequenceUpperCase = true) {
128
+ return value.map((part) => {
129
+ assertNoLoneSurrogate(part, `Key ${JSON.stringify(part)}`);
130
+ return IS_BARE_KEY.test(part) ? part : quoteTomlString(part, escapeSequenceUpperCase);
131
+ }).join(".");
132
+ }
133
+ function generateKey(value, escapeSequenceUpperCase = true) {
134
+ const raw = keyValueToRaw(value, escapeSequenceUpperCase);
135
+ return {
136
+ type: "Key",
137
+ loc: {
138
+ start: zero(),
139
+ end: {
140
+ line: 1,
141
+ column: raw.length
142
+ }
143
+ },
144
+ raw,
145
+ value
146
+ };
147
+ }
148
+ /**
149
+ * Generates a new String node, preserving multiline format if existingRaw is provided.
150
+ *
151
+ * @param value - The string value.
152
+ * @param existingRaw - The existing raw string to determine multiline format (optional).
153
+ * @returns A new String node.
154
+ */
155
+ function generateString(value, existingRaw, escapeSequenceUpperCase = true) {
156
+ assertNoLoneSurrogate(value, "String value");
157
+ if (!existingRaw) return generateBasicString(value, void 0, escapeSequenceUpperCase);
158
+ return generateStringKeepFormatting(value, existingRaw, escapeSequenceUpperCase);
159
+ }
160
+ function generateStringKeepFormatting(value, existingRaw, escapeSequenceUpperCase) {
161
+ if (isBasicString(existingRaw)) return generateBasicString(value, existingRaw, escapeSequenceUpperCase);
162
+ if (isLiteralString(existingRaw)) {
163
+ if (canUseLiteralString(value)) return generateLiteralString(value);
164
+ if (canUseMultilineLiteral(value)) return generateMultilineLiteralString(value, `'''${existingRaw.slice(1, -1)}'''`);
165
+ return generateBasicString(value, void 0, escapeSequenceUpperCase);
166
+ }
167
+ if (isMultilineLiteralString(existingRaw)) {
168
+ if (canUseMultilineLiteral(value)) return generateMultilineLiteralString(value, existingRaw);
169
+ return generateMultilineBasicString(value, `"""${existingRaw.slice(3, -3)}"""`, escapeSequenceUpperCase);
170
+ }
171
+ if (isMultilineBasicString(existingRaw)) return generateMultilineBasicString(value, existingRaw, escapeSequenceUpperCase);
172
+ throw new Error(`Existing raw string value is not valid: ${existingRaw}`);
173
+ }
174
+ function generateBasicString(value, existingRaw, escapeSequenceUpperCase = true) {
175
+ let raw = "";
176
+ if (!existingRaw) raw = quoteTomlString(value, escapeSequenceUpperCase);
177
+ else raw = `"${escapeStringContent(value, existingRaw, "singleline-basic", escapeSequenceUpperCase)}"`;
178
+ return {
179
+ type: "String",
180
+ loc: {
181
+ start: zero(),
182
+ end: {
183
+ line: 1,
184
+ column: raw.length
185
+ }
186
+ },
187
+ raw,
188
+ value
189
+ };
190
+ }
191
+ function generateLiteralString(value) {
192
+ const raw = `'${value}'`;
193
+ let endLocation;
194
+ if (raw.includes("\n")) {
195
+ const lines = raw.split(/\r\n|\n/);
196
+ const lastLine = lines[lines.length - 1];
197
+ endLocation = {
198
+ line: lines.length,
199
+ column: lastLine.length
200
+ };
201
+ } else endLocation = {
202
+ line: 1,
203
+ column: raw.length
204
+ };
205
+ return {
206
+ type: "String",
207
+ loc: {
208
+ start: zero(),
209
+ end: endLocation
210
+ },
211
+ raw,
212
+ value
213
+ };
214
+ }
215
+ /**
216
+ * Returns the newline to write directly after a multiline delimiter.
217
+ *
218
+ * TOML drops a newline that immediately follows the opening delimiter, so a
219
+ * value that starts with one needs an extra, disposable newline in front of it
220
+ * to survive the round trip.
221
+ */
222
+ function multilineLeadingNewLine(existingRaw, delimiter, content) {
223
+ if (existingRaw.startsWith(delimiter + "\r\n")) return "\r\n";
224
+ if (existingRaw.startsWith(delimiter + "\n")) return "\n";
225
+ if (content.startsWith("\r\n")) return "\r\n";
226
+ return content.startsWith("\n") ? "\n" : "";
227
+ }
228
+ function generateMultilineBasicString(value, existingRaw, escapeSequenceUpperCase = true) {
229
+ const escaped = escapeStringContent(value, existingRaw, "multiline-basic", escapeSequenceUpperCase);
230
+ let raw = "\"\"\"" + multilineLeadingNewLine(existingRaw, "\"\"\"", escaped) + escaped + "\"\"\"";
231
+ const existingValue = existingRaw.slice(3, -3);
232
+ if (/(^|[^\\])(\\\\)*\\$/m.test(existingValue)) {
233
+ const rebuilt = rebuildLineContinuation(existingRaw, escaped);
234
+ if (rebuilt !== null) raw = rebuilt;
235
+ }
236
+ const endLocation = endlocation(raw);
237
+ return {
238
+ type: "String",
239
+ loc: {
240
+ start: zero(),
241
+ end: endLocation
242
+ },
243
+ raw,
244
+ value
245
+ };
246
+ }
247
+ function generateMultilineLiteralString(value, existingRaw) {
248
+ const raw = "'''" + multilineLeadingNewLine(existingRaw, "'''", value) + value + "'''";
249
+ const endLocation = endlocation(raw);
250
+ return {
251
+ type: "String",
252
+ loc: {
253
+ start: zero(),
254
+ end: endLocation
255
+ },
256
+ raw,
257
+ value
258
+ };
259
+ }
260
+ function endlocation(raw) {
261
+ if (raw.includes("\n")) {
262
+ const lines = raw.split(/\r\n|\n/);
263
+ const lastLine = lines[lines.length - 1];
264
+ return {
265
+ line: lines.length,
266
+ column: lastLine.length
267
+ };
268
+ } else return {
269
+ line: 1,
270
+ column: raw.length
271
+ };
272
+ }
273
+ /**
274
+ * Generates a new Integer node.
275
+ *
276
+ * @param value - The integer value.
277
+ * @returns A new Integer node.
278
+ */
279
+ function generateInteger(value) {
280
+ const raw = value.toString();
281
+ return {
282
+ type: "Integer",
283
+ loc: {
284
+ start: zero(),
285
+ end: {
286
+ line: 1,
287
+ column: raw.length
288
+ }
289
+ },
290
+ raw,
291
+ value
292
+ };
293
+ }
294
+ function generateFloat(value, minimumDecimals = 1) {
295
+ let raw;
296
+ let nanSign;
297
+ if (value === 1e400) raw = "inf";
298
+ else if (value === -1e400) raw = "-inf";
299
+ else if (Number.isNaN(value)) {
300
+ const isNegative = isNegativeNan(value);
301
+ nanSign = isNegative ? "-" : void 0;
302
+ raw = isNegative ? "-nan" : "nan";
303
+ } else if (Object.is(value, -0)) raw = "-0." + "0".repeat(Math.max(minimumDecimals, 1));
304
+ else {
305
+ raw = value.toString();
306
+ const exponentIndex = raw.search(/[eE]/);
307
+ if (exponentIndex !== -1) {
308
+ const mantissa = raw.slice(0, exponentIndex);
309
+ const exponent = raw.slice(exponentIndex);
310
+ const dotIndex = mantissa.indexOf(".");
311
+ if (dotIndex === -1) raw = `${mantissa}.${"0".repeat(Math.max(minimumDecimals, 1))}${exponent}`;
312
+ else {
313
+ const currentDecimals = mantissa.length - dotIndex - 1;
314
+ raw = currentDecimals < minimumDecimals ? `${mantissa}${"0".repeat(minimumDecimals - currentDecimals)}${exponent}` : `${mantissa}${exponent}`;
315
+ }
316
+ } else {
317
+ const dotIndex = raw.indexOf(".");
318
+ if (dotIndex === -1) raw += "." + "0".repeat(Math.max(minimumDecimals, 1));
319
+ else {
320
+ const currentDecimals = raw.length - dotIndex - 1;
321
+ if (currentDecimals < minimumDecimals) raw += "0".repeat(minimumDecimals - currentDecimals);
322
+ }
323
+ }
324
+ }
325
+ return {
326
+ type: "Float",
327
+ loc: {
328
+ start: zero(),
329
+ end: {
330
+ line: 1,
331
+ column: raw.length
332
+ }
333
+ },
334
+ raw,
335
+ value,
336
+ ...nanSign !== void 0 ? { nanSign } : {}
337
+ };
338
+ }
339
+ function generateBoolean(value) {
340
+ return {
341
+ type: "Boolean",
342
+ loc: {
343
+ start: zero(),
344
+ end: {
345
+ line: 1,
346
+ column: value ? 4 : 5
347
+ }
348
+ },
349
+ value
350
+ };
351
+ }
352
+ function generateDateTime(value, truncateZeroTimeInDates = false, minimumTimeDecimals = 0) {
353
+ if (truncateZeroTimeInDates && !(value instanceof LocalTime) && value.getUTCHours() === 0 && value.getUTCMinutes() === 0 && value.getUTCSeconds() === 0 && value.getUTCMilliseconds() === 0) value = new LocalDate(value.toISOString().split("T")[0]);
354
+ const raw = padFractionalSeconds(value.toISOString(), minimumTimeDecimals);
355
+ return {
356
+ type: "DateTime",
357
+ loc: {
358
+ start: zero(),
359
+ end: {
360
+ line: 1,
361
+ column: raw.length
362
+ }
363
+ },
364
+ raw,
365
+ value
366
+ };
367
+ }
368
+ /**
369
+ * Generates a DateTime CST node from a Temporal API object.
370
+ *
371
+ * Each Temporal type serializes to the corresponding TOML date/time format:
372
+ * - Temporal.PlainDate → "2024-01-15"
373
+ * - Temporal.PlainTime → "10:30:00.123"
374
+ * - Temporal.PlainDateTime → "2024-01-15T10:30:00.123"
375
+ * - Temporal.ZonedDateTime → "2024-01-15T10:30:00.123+05:30" (no IANA annotation)
376
+ *
377
+ * @param value - A Temporal object (PlainDate, PlainTime, PlainDateTime, or ZonedDateTime).
378
+ * @param truncateZeroTimeInDates - If true, a PlainDateTime with all-zero time is
379
+ * downgraded to a PlainDate (date-only output). Has no effect on other Temporal types.
380
+ */
381
+ function generateTemporalDateTime(value, truncateZeroTimeInDates = false, minimumTimeDecimals = 0) {
382
+ var _value$constructor;
383
+ const constructorName = ((_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name) ?? "";
384
+ const isPlainDate = constructorName === "Temporal.PlainDate" || constructorName === "PlainDate";
385
+ const isPlainTime = constructorName === "Temporal.PlainTime" || constructorName === "PlainTime";
386
+ const isPlainDateTime = constructorName === "Temporal.PlainDateTime" || constructorName === "PlainDateTime";
387
+ const isZonedDateTime = constructorName === "Temporal.ZonedDateTime" || constructorName === "ZonedDateTime";
388
+ let raw;
389
+ if (isPlainDate) raw = temporalToTomlString(value);
390
+ else if (isPlainTime) raw = temporalToTomlString(value);
391
+ else if (isPlainDateTime) {
392
+ if (truncateZeroTimeInDates) {
393
+ const T = globalThis.Temporal;
394
+ if (!T) throw new Error("Temporal API is not available in this runtime. Set temporal: false or use a runtime with Temporal support.");
395
+ const plainDate = T.PlainDate.from(value.toString().split("T")[0]);
396
+ if (plainDate.toString() + "T00:00:00" === value.toString().slice(0, 19)) {
397
+ raw = padFractionalSeconds(temporalToTomlString(plainDate), minimumTimeDecimals);
398
+ return {
399
+ type: "DateTime",
400
+ loc: {
401
+ start: zero(),
402
+ end: {
403
+ line: 1,
404
+ column: raw.length
405
+ }
406
+ },
407
+ raw,
408
+ value: plainDate
409
+ };
410
+ }
411
+ }
412
+ raw = temporalToTomlString(value);
413
+ } else if (isZonedDateTime) raw = temporalToTomlString(value);
414
+ else raw = temporalToTomlString(value);
415
+ raw = padFractionalSeconds(raw, minimumTimeDecimals);
416
+ return {
417
+ type: "DateTime",
418
+ loc: {
419
+ start: zero(),
420
+ end: {
421
+ line: 1,
422
+ column: raw.length
423
+ }
424
+ },
425
+ raw,
426
+ value
427
+ };
428
+ }
429
+ function generateInlineArray() {
430
+ return {
431
+ type: "InlineArray",
432
+ loc: {
433
+ start: zero(),
434
+ end: {
435
+ line: 1,
436
+ column: 2
437
+ }
438
+ },
439
+ items: []
440
+ };
441
+ }
442
+ function generateInlineItem(item) {
443
+ return {
444
+ type: "InlineItem",
445
+ loc: cloneLocation(item.loc),
446
+ item,
447
+ comma: false
448
+ };
449
+ }
450
+ function generateInlineTable() {
451
+ return {
452
+ type: "InlineTable",
453
+ loc: {
454
+ start: zero(),
455
+ end: {
456
+ line: 1,
457
+ column: 2
458
+ }
459
+ },
460
+ items: []
461
+ };
462
+ }
463
+ function generateComment(comment) {
464
+ if (!comment.startsWith("#")) comment = `# ${comment}`;
465
+ return {
466
+ type: "Comment",
467
+ loc: {
468
+ start: zero(),
469
+ end: {
470
+ line: 1,
471
+ column: comment.length
472
+ }
473
+ },
474
+ raw: comment
475
+ };
476
+ }
477
+
478
+ export { generateBoolean, generateComment, generateDateTime, generateDocument, generateFloat, generateInlineArray, generateInlineItem, generateInlineTable, generateInteger, generateKey, generateKeyValue, generateString, generateTable, generateTableArray, generateTableArrayKey, generateTableKey, generateTemporalDateTime };
479
+ //# sourceMappingURL=generate.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"generate.js","names":[],"sources":["../../src/generate.ts"],"sourcesContent":["/**\n * @file Helpers to generate and update TOML CST nodes.\n * @module generate\n */\n\nimport {\n NodeType,\n Document,\n Table,\n TableKey,\n TableArray,\n TableArrayKey,\n Value,\n KeyValue,\n Key,\n String,\n Integer,\n Float,\n Boolean,\n DateTime,\n InlineArray,\n InlineItem,\n InlineTable,\n Comment\n} from './cst';\nimport { zero, cloneLocation, clonePosition, Position } from './location';\nimport { LocalDate, LocalTime } from './parse-toml';\nimport { padFractionalSeconds } from './date-format';\nimport { shiftNode } from './writer';\nimport { rebuildLineContinuation } from './line-ending-backslash';\nimport { IS_BARE_KEY } from './tokenizer';\nimport { canUseLiteralString, canUseMultilineLiteral } from './literal-string';\nimport { escapeStringContent, upperCaseHexEscapes } from './escape-preference';\nimport { isBasicString, isMultilineBasicString, isLiteralString, isMultilineLiteralString, temporalToTomlString, assertNoLoneSurrogate, isNegativeNan } from './utils';\n\n/**\n * Generates a new TOML document node.\n *\n * @returns A new Document node.\n */\nexport function generateDocument(): Document {\n return {\n type: NodeType.Document,\n loc: { start: zero(), end: zero() },\n items: []\n };\n}\n\nexport function generateTable(key: string[], escapeSequenceUpperCase = true): Table {\n const table_key = generateTableKey(key, escapeSequenceUpperCase);\n\n return {\n type: NodeType.Table,\n loc: cloneLocation(table_key.loc),\n key: table_key,\n items: []\n };\n}\n\nexport function generateTableKey(key: string[], escapeSequenceUpperCase = true): TableKey {\n const raw = keyValueToRaw(key, escapeSequenceUpperCase);\n\n return {\n type: NodeType.TableKey,\n loc: {\n start: zero(),\n end: { line: 1, column: raw.length + 2 }\n },\n item: {\n type: NodeType.Key,\n loc: {\n start: { line: 1, column: 1 },\n end: { line: 1, column: raw.length + 1 }\n },\n value: key,\n raw\n }\n };\n}\n\nexport function generateTableArray(key: string[], escapeSequenceUpperCase = true): TableArray {\n const table_array_key = generateTableArrayKey(key, escapeSequenceUpperCase);\n\n return {\n type: NodeType.TableArray,\n loc: cloneLocation(table_array_key.loc),\n key: table_array_key,\n items: []\n };\n}\n\nexport function generateTableArrayKey(key: string[], escapeSequenceUpperCase = true): TableArrayKey {\n const raw = keyValueToRaw(key, escapeSequenceUpperCase);\n\n return {\n type: NodeType.TableArrayKey,\n loc: {\n start: zero(),\n end: { line: 1, column: raw.length + 4 }\n },\n item: {\n type: NodeType.Key,\n loc: {\n start: { line: 1, column: 2 },\n end: { line: 1, column: raw.length + 2 }\n },\n value: key,\n raw\n }\n };\n}\n\nexport function generateKeyValue(\n key: string[],\n value: Value,\n shiftGeneratedMultilineEnd = false,\n escapeSequenceUpperCase = true\n): KeyValue {\n const key_node = generateKey(key, escapeSequenceUpperCase);\n const { column } = key_node.loc.end;\n\n const equals = column + 1;\n\n // Align the fresh value with the generated key. The value's loc comes from\n // its own round-trip (regenerateValue), which can put it on a LATER line\n // than the key's line 1 — leaving the value one line below the `=` and\n // producing invalid TOML (fuzz seed 735).\n shiftNode(\n value,\n { lines: 1 - value.loc.start.line, columns: column + 3 - value.loc.start.column },\n {\n first_line_only: true,\n shift_generated_multiline_end: shiftGeneratedMultilineEnd\n }\n );\n\n return {\n type: NodeType.KeyValue,\n loc: {\n start: clonePosition(key_node.loc.start),\n end: clonePosition(value.loc.end)\n },\n key: key_node,\n equals,\n value\n };\n}\n\nfunction quoteTomlString(value: string, escapeSequenceUpperCase = true): string {\n // JSON.stringify leaves U+007F as a raw character, but TOML requires it escaped.\n const withDel = JSON.stringify(value).replace(/\\x7f/g, '\\\\u007f');\n return escapeSequenceUpperCase ? upperCaseHexEscapes(withDel) : withDel;\n}\n\nfunction keyValueToRaw(value: string[], escapeSequenceUpperCase = true): string {\n return value.map(part => {\n // Keys are encoded too, so a lone surrogate is just as invalid here as in a value.\n // JSON.stringify escapes the offending unit, so the message stays printable rather than\n // carrying the raw unpaired surrogate into logs.\n assertNoLoneSurrogate(part, `Key ${JSON.stringify(part)}`);\n return IS_BARE_KEY.test(part) ? part : quoteTomlString(part, escapeSequenceUpperCase);\n }).join('.');\n}\n\nexport function generateKey(value: string[], escapeSequenceUpperCase = true): Key {\n const raw = keyValueToRaw(value, escapeSequenceUpperCase);\n\n return {\n type: NodeType.Key,\n loc: { start: zero(), end: { line: 1, column: raw.length } },\n raw,\n value\n };\n}\n\n/**\n * Generates a new String node, preserving multiline format if existingRaw is provided.\n *\n * @param value - The string value.\n * @param existingRaw - The existing raw string to determine multiline format (optional).\n * @returns A new String node.\n */\nexport function generateString(value: string, existingRaw?: string, escapeSequenceUpperCase = true): String {\n // Single choke point for string values from both stringify and patch — reject unpaired\n // surrogates here rather than emitting a document that isn't valid UTF-8.\n assertNoLoneSurrogate(value, 'String value');\n\n if (!existingRaw) {\n return generateBasicString(value, undefined, escapeSequenceUpperCase);\n }\n return generateStringKeepFormatting(value, existingRaw, escapeSequenceUpperCase);\n}\n\nfunction generateStringKeepFormatting(value: string, existingRaw: string, escapeSequenceUpperCase: boolean): String {\n if (isBasicString(existingRaw)) {\n return generateBasicString(value, existingRaw, escapeSequenceUpperCase);\n }\n\n if (isLiteralString(existingRaw)) {\n // A literal string cannot escape anything, so the value has to be writable\n // verbatim. Move up to MLLS when only the single-line form is ruled out and\n // fall back to a basic string when the value cannot be literal at all.\n if (canUseLiteralString(value)) {\n return generateLiteralString(value);\n }\n if (canUseMultilineLiteral(value)) {\n const existingValue = existingRaw.slice(1, -1);\n const multilineRaw = `'''${existingValue}'''`;\n return generateMultilineLiteralString(value, multilineRaw);\n }\n return generateBasicString(value, undefined, escapeSequenceUpperCase);\n }\n\n if (isMultilineLiteralString(existingRaw)) {\n // Literal strings cannot hold ''' or a control character: fall back to a\n // basic multi-line string when the value needs escaping.\n if (canUseMultilineLiteral(value)) {\n return generateMultilineLiteralString(value, existingRaw);\n }\n const existingValue = existingRaw.slice(3, -3);\n const multilineRaw = `\"\"\"${existingValue}\"\"\"`;\n return generateMultilineBasicString(value, multilineRaw, escapeSequenceUpperCase);\n }\n\n if (isMultilineBasicString(existingRaw)) {\n return generateMultilineBasicString(value, existingRaw, escapeSequenceUpperCase);\n }\n\n // existingRaw is misformatted. This should be impossible\n throw new Error(`Existing raw string value is not valid: ${existingRaw}`);\n}\n\nfunction generateBasicString(value: string, existingRaw?: string, escapeSequenceUpperCase = true): String {\n let raw = '';\n if (!existingRaw) {\n raw = quoteTomlString(value, escapeSequenceUpperCase);\n } else {\n raw = `\"${escapeStringContent(value, existingRaw, 'singleline-basic', escapeSequenceUpperCase)}\"`;\n }\n \n return {\n type: NodeType.String,\n loc: { start: zero(), end: { line: 1, column: raw.length } },\n raw,\n value\n };\n}\n\nfunction generateLiteralString(value: string): String {\n const raw = `'${value}'`;\n\n let endLocation;\n if (raw.includes('\\n')) {\n const lines = raw.split(/\\r\\n|\\n/);\n const lastLine = lines[lines.length - 1];\n endLocation = {\n line: lines.length,\n column: lastLine.length\n };\n } else {\n endLocation = { line: 1, column: raw.length };\n }\n\n return {\n type: NodeType.String,\n loc: { start: zero(), end: endLocation },\n raw,\n value\n };\n}\n\n/**\n * Returns the newline to write directly after a multiline delimiter.\n *\n * TOML drops a newline that immediately follows the opening delimiter, so a\n * value that starts with one needs an extra, disposable newline in front of it\n * to survive the round trip.\n */\nfunction multilineLeadingNewLine(existingRaw: string, delimiter: string, content: string): string {\n if (existingRaw.startsWith(delimiter + '\\r\\n')) return '\\r\\n';\n if (existingRaw.startsWith(delimiter + '\\n')) return '\\n';\n if (content.startsWith('\\r\\n')) return '\\r\\n';\n return content.startsWith('\\n') ? '\\n' : '';\n}\n\nfunction generateMultilineBasicString(value: string, existingRaw: string, escapeSequenceUpperCase = true): String {\n const escaped = escapeStringContent(value, existingRaw, 'multiline-basic', escapeSequenceUpperCase);\n\n const leadingNewLine = multilineLeadingNewLine(existingRaw, '\"\"\"', escaped);\n\n let raw = '\"\"\"' + leadingNewLine + escaped + '\"\"\"';\n\n const existingValue = existingRaw.slice(3, -3);\n // Line continuation is indicated by an odd number of backslashes at the end of any line.\n // Match: (start-of-line or a non-backslash), then zero or more escaped-backslash pairs,\n // then a single trailing backslash at end-of-line.\n if (/(^|[^\\\\])(\\\\\\\\)*\\\\$/m.test(existingValue)) {\n const rebuilt = rebuildLineContinuation(existingRaw, escaped);\n if (rebuilt !== null) {\n raw = rebuilt;\n }\n }\n\n const endLocation = endlocation(raw);\n\n return {\n type: NodeType.String,\n loc: { start: zero(), end: endLocation },\n raw,\n value\n };\n}\n\nfunction generateMultilineLiteralString(value: string, existingRaw: string): String {\n\n const leadingNewLine = multilineLeadingNewLine(existingRaw, \"'''\", value);\n\n const raw = \"'''\" + leadingNewLine + value + \"'''\";\n const endLocation = endlocation(raw);\n return {\n type: NodeType.String,\n loc: { start: zero(), end: endLocation },\n raw,\n value\n };\n}\n\nfunction endlocation (raw: string): Position {\n if (raw.includes('\\n')) {\n const lines = raw.split(/\\r\\n|\\n/);\n const lastLine = lines[lines.length - 1];\n return {\n line: lines.length,\n column: lastLine.length\n };\n } else {\n return { line: 1, column: raw.length };\n }\n}\n\n\n/**\n * Generates a new Integer node.\n *\n * @param value - The integer value.\n * @returns A new Integer node.\n */\nexport function generateInteger(value: number | bigint): Integer {\n const raw = value.toString();\n return {\n type: NodeType.Integer,\n loc: { start: zero(), end: { line: 1, column: raw.length } },\n raw,\n value\n };\n}\n\nexport function generateFloat(value: number, minimumDecimals: number = 1): Float {\n let raw: string;\n let nanSign: '+' | '-' | undefined;\n \n if (value === Infinity) {\n raw = 'inf';\n } else if (value === -Infinity) {\n raw = '-inf';\n } else if (Number.isNaN(value)) {\n // Detect a negative NaN through its IEEE 754 sign bit.\n const isNegative = isNegativeNan(value);\n nanSign = isNegative ? '-' : undefined;\n raw = isNegative ? '-nan' : 'nan';\n } else if (Object.is(value, -0)) {\n raw = '-0.' + '0'.repeat(Math.max(minimumDecimals, 1));\n } else {\n raw = value.toString();\n const exponentIndex = raw.search(/[eE]/);\n\n if (exponentIndex !== -1) {\n const mantissa = raw.slice(0, exponentIndex);\n const exponent = raw.slice(exponentIndex);\n const dotIndex = mantissa.indexOf('.');\n\n if (dotIndex === -1) {\n raw = `${mantissa}.${'0'.repeat(Math.max(minimumDecimals, 1))}${exponent}`;\n } else {\n const currentDecimals = mantissa.length - dotIndex - 1;\n raw = currentDecimals < minimumDecimals\n ? `${mantissa}${'0'.repeat(minimumDecimals - currentDecimals)}${exponent}`\n : `${mantissa}${exponent}`;\n }\n } else {\n const dotIndex = raw.indexOf('.');\n if (dotIndex === -1) {\n raw += '.' + '0'.repeat(Math.max(minimumDecimals, 1));\n } else {\n const currentDecimals = raw.length - dotIndex - 1;\n if (currentDecimals < minimumDecimals) {\n raw += '0'.repeat(minimumDecimals - currentDecimals);\n }\n }\n }\n }\n\n return {\n type: NodeType.Float,\n loc: { start: zero(), end: { line: 1, column: raw.length } },\n raw,\n value,\n ...(nanSign !== undefined ? { nanSign } : {})\n };\n}\n\nexport function generateBoolean(value: boolean): Boolean {\n return {\n type: NodeType.Boolean,\n loc: { start: zero(), end: { line: 1, column: value ? 4 : 5 } },\n value\n };\n}\n\nexport function generateDateTime(value: Date, truncateZeroTimeInDates: boolean = false, minimumTimeDecimals: number = 0): DateTime {\n \n // Convert Date objects with zero time components to LocalDate\n // so they are serialized as date-only in TOML.\n // LocalTime is time-only (its internal date is a meaningless year-0000\n // base), so it must never be truncated — round-tripping a LocalTime with\n // truncateZeroTimeInDates enabled would otherwise collapse it to a\n // LocalDate(\"0000-01-01\") and emit `0NaN-NaN-NaN` (fuzz seed 299772).\n if (truncateZeroTimeInDates &&\n !(value instanceof LocalTime) &&\n value.getUTCHours() === 0 &&\n value.getUTCMinutes() === 0 &&\n value.getUTCSeconds() === 0 &&\n value.getUTCMilliseconds() === 0) {\n value = new LocalDate(value.toISOString().split('T')[0]);\n }\n \n // Custom date classes have their own toISOString() implementations\n // that return the properly formatted strings for each TOML date/time type\n const raw = padFractionalSeconds(value.toISOString(), minimumTimeDecimals);\n\n return {\n type: NodeType.DateTime,\n loc: { start: zero(), end: { line: 1, column: raw.length } },\n raw,\n value\n };\n}\n\n/**\n * Generates a DateTime CST node from a Temporal API object.\n *\n * Each Temporal type serializes to the corresponding TOML date/time format:\n * - Temporal.PlainDate → \"2024-01-15\"\n * - Temporal.PlainTime → \"10:30:00.123\"\n * - Temporal.PlainDateTime → \"2024-01-15T10:30:00.123\"\n * - Temporal.ZonedDateTime → \"2024-01-15T10:30:00.123+05:30\" (no IANA annotation)\n *\n * @param value - A Temporal object (PlainDate, PlainTime, PlainDateTime, or ZonedDateTime).\n * @param truncateZeroTimeInDates - If true, a PlainDateTime with all-zero time is\n * downgraded to a PlainDate (date-only output). Has no effect on other Temporal types.\n */\nexport function generateTemporalDateTime(\n value: any,\n truncateZeroTimeInDates: boolean = false,\n minimumTimeDecimals: number = 0\n): DateTime {\n const constructorName: string = value.constructor?.name ?? '';\n\n // Detect the Temporal type from the constructor name.\n // Supports both native (\"Temporal.PlainDate\") and polyfill (\"PlainDate\") naming.\n const isPlainDate = constructorName === 'Temporal.PlainDate' || constructorName === 'PlainDate';\n const isPlainTime = constructorName === 'Temporal.PlainTime' || constructorName === 'PlainTime';\n const isPlainDateTime = constructorName === 'Temporal.PlainDateTime' || constructorName === 'PlainDateTime';\n const isZonedDateTime = constructorName === 'Temporal.ZonedDateTime' || constructorName === 'ZonedDateTime';\n\n let raw: string;\n\n if (isPlainDate) {\n raw = temporalToTomlString(value);\n } else if (isPlainTime) {\n raw = temporalToTomlString(value);\n } else if (isPlainDateTime) {\n // Optionally truncate zero time components to date-only\n if (truncateZeroTimeInDates) {\n const T = (globalThis as any).Temporal;\n if (!T) {\n throw new Error(\n 'Temporal API is not available in this runtime. ' +\n 'Set temporal: false or use a runtime with Temporal support.'\n );\n }\n const plainDate = T.PlainDate.from(value.toString().split('T')[0]);\n if (plainDate.toString() + 'T00:00:00' === value.toString().slice(0, 19)) {\n raw = padFractionalSeconds(temporalToTomlString(plainDate), minimumTimeDecimals);\n return {\n type: NodeType.DateTime,\n loc: { start: zero(), end: { line: 1, column: raw.length } },\n raw,\n value: plainDate\n };\n }\n }\n raw = temporalToTomlString(value);\n } else if (isZonedDateTime) {\n // TOML only supports offset, not IANA timezone names.\n raw = temporalToTomlString(value);\n } else {\n // Unknown Temporal type — fall back to temporalToTomlString()\n raw = temporalToTomlString(value);\n }\n\n // A Temporal value carries its own precision, so this only ever pads.\n raw = padFractionalSeconds(raw, minimumTimeDecimals);\n\n return {\n type: NodeType.DateTime,\n loc: { start: zero(), end: { line: 1, column: raw.length } },\n raw,\n value\n };\n}\n\nexport function generateInlineArray(): InlineArray {\n return {\n type: NodeType.InlineArray,\n loc: { start: zero(), end: { line: 1, column: 2 } },\n items: []\n };\n}\n\nexport function generateInlineItem(item: KeyValue | Value): InlineItem {\n return {\n type: NodeType.InlineItem,\n loc: cloneLocation(item.loc),\n item,\n comma: false\n };\n}\n\nexport function generateInlineTable(): InlineTable {\n return {\n type: NodeType.InlineTable,\n loc: { start: zero(), end: { line: 1, column: 2 } },\n items: []\n };\n}\n\nexport function generateComment(comment: string): Comment {\n if (!comment.startsWith('#')) comment = `# ${comment}`;\n\n return {\n type: NodeType.Comment,\n loc: { start: zero(), end: { line: 1, column: comment.length } },\n raw: comment\n };\n}\n"],"mappings":"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"}
@@ -0,0 +1,12 @@
1
+ //! @decimalturn/toml-patch v3.3.3 - https://github.com/DecimalTurn/toml-patch - @license: MIT
2
+ // src/inline-comma-space.ts
3
+ const commaSpace = /* @__PURE__ */ new WeakMap();
4
+ function setCommaSpace(node, gap) {
5
+ commaSpace.set(node, gap);
6
+ }
7
+ function getCommaSpace(node) {
8
+ return commaSpace.get(node);
9
+ }
10
+
11
+ export { getCommaSpace, setCommaSpace };
12
+ //# sourceMappingURL=inline-comma-space.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"inline-comma-space.js","names":[],"sources":["../../src/inline-comma-space.ts"],"sourcesContent":["import { InlineArray, InlineTable } from './cst';\n\n// Parse-time comma spacing per inline container: the horizontal gap a\n// separating comma occupies between two adjacent elements (1 = compact\n// `[1,2]`, 2 = spaced `[1, 2]`). The parser records it here because the\n// writer needs this ORIGINAL spacing long after the items' own positions have\n// been shifted by pending edits (whose offsets are only resolved in\n// applyWrites). Kept out of the CST node shape so snapshots/structural\n// equality of parsed documents are unaffected.\nconst commaSpace = new WeakMap<InlineArray | InlineTable, number>();\n\nexport function setCommaSpace(node: InlineArray | InlineTable, gap: number): void {\n commaSpace.set(node, gap);\n}\n\nexport function getCommaSpace(node: InlineArray | InlineTable): number | undefined {\n return commaSpace.get(node);\n}\n"],"mappings":";;AASA,MAAM,6BAAa,IAAI,QAA2C;AAElE,SAAgB,cAAc,MAAiC,KAAmB;CAChF,WAAW,IAAI,MAAM,GAAG;AAC1B;AAEA,SAAgB,cAAc,MAAqD;CACjF,OAAO,WAAW,IAAI,IAAI;AAC5B"}