@decimalturn/toml-patch 0.5.1 → 0.6.0

package/dist/toml-patch.es.js

@@ -1,4 +1,4 @@
-//! @decimalturn/toml-patch v0.5.1 - https://github.com/DecimalTurn/toml-patch - @license: MIT
+//! @decimalturn/toml-patch v0.6.0 - https://github.com/DecimalTurn/toml-patch - @license: MIT
 var NodeType;
 (function (NodeType) {
     NodeType["Document"] = "Document";
@@ -176,7 +176,7 @@ function getLine$1(input, position) {
     const lines = findLines(input);
     const start = lines[position.line - 2] || 0;
     const end = lines[position.line - 1] || input.length;
-    return input.substr(start, end - start);
+    return input.substring(start, end);
 }
 function findLines(input) {
     // exec is stateful, so create new regexp each time
@@ -416,6 +416,11 @@ function checkThree(input, current, check) {
     if (!has3) {
         return false;
     }
+    // Only check for escaping in basic strings (double quotes)
+    // Literal strings (single quotes) don't support escape sequences
+    if (check === SINGLE_QUOTE) {
+        return check; // No escaping in literal strings
+    }
     // Check if the sequence is escaped
     const precedingText = input.slice(0, current); // Get the text before the current position
     const backslashes = precedingText.match(/\\+$/); // Match trailing backslashes
@@ -564,11 +569,41 @@ function escapeDoubleQuotes(value) {
     }
     return result;
 }
+function isBackslashEscaped(source, backslashOffset) {
+    let precedingBackslashes = 0;
+    for (let i = backslashOffset - 1; i >= 0 && source[i] === '\\'; i--) {
+        precedingBackslashes++;
+    }
+    return precedingBackslashes % 2 !== 0;
+}
 function unescapeLargeUnicode(escaped) {
+    // TOML 1.1.0: Handle \xHH hex escapes (for codepoints < 255)
+    const HEX_ESCAPE = /\\x([a-fA-F0-9]{2})/g;
+    const hexEscapeSource = escaped;
+    let withHexEscapes = hexEscapeSource.replace(HEX_ESCAPE, (match, hex, offset) => {
+        if (isBackslashEscaped(hexEscapeSource, offset)) {
+            return match;
+        }
+        const codePoint = parseInt(hex, 16);
+        const asString = String.fromCharCode(codePoint);
+        // Escape for JSON if needed
+        if (codePoint < 0x20 || codePoint === 0x22 || codePoint === 0x5C) {
+            return trim(JSON.stringify(asString), 1);
+        }
+        return asString;
+    });
+    // TOML 1.1.0: Handle \e escape character (ESC = 0x1B)
+    const eEscapeSource = withHexEscapes;
+    withHexEscapes = eEscapeSource.replace(/\\e/g, (match, offset) => {
+        if (isBackslashEscaped(eEscapeSource, offset)) {
+            return match;
+        }
+        return '\\u001b';
+    });
     // JSON.parse handles everything except \UXXXXXXXX
     // replace those instances with code point, escape that, and then parse
     const LARGE_UNICODE = /\\U[a-fA-F0-9]{8}/g;
-    const json_escaped = escaped.replace(LARGE_UNICODE, value => {
+    const json_escaped = withHexEscapes.replace(LARGE_UNICODE, value => {
         const code_point = parseInt(value.replace('\\U', ''), 16);
         const as_string = String.fromCodePoint(code_point);
         return trim(JSON.stringify(as_string), 1);
@@ -789,14 +824,14 @@ class DateFormatHelper {
 }
 // Patterns for different date/time formats
 DateFormatHelper.IS_DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
-DateFormatHelper.IS_TIME_ONLY = /^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/;
-DateFormatHelper.IS_LOCAL_DATETIME_T = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?$/;
-DateFormatHelper.IS_LOCAL_DATETIME_SPACE = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)?$/;
-DateFormatHelper.IS_OFFSET_DATETIME_T = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[Zz]|[+-]\d{2}:\d{2})$/;
-DateFormatHelper.IS_OFFSET_DATETIME_SPACE = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[Zz]|[+-]\d{2}:\d{2})$/;
+DateFormatHelper.IS_TIME_ONLY = /^\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?$/;
+DateFormatHelper.IS_LOCAL_DATETIME_T = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?$/;
+DateFormatHelper.IS_LOCAL_DATETIME_SPACE = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}(?::\d{2})?(?:\.\d+)?$/;
+DateFormatHelper.IS_OFFSET_DATETIME_T = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:[Zz]|[+-]\d{2}:\d{2})$/;
+DateFormatHelper.IS_OFFSET_DATETIME_SPACE = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:[Zz]|[+-]\d{2}:\d{2})$/;
 // Legacy patterns from parse-toml.ts (for compatibility)
 DateFormatHelper.IS_FULL_DATE = /(\d{4})-(\d{2})-(\d{2})/;
-DateFormatHelper.IS_FULL_TIME = /(\d{2}):(\d{2}):(\d{2})/;
+DateFormatHelper.IS_FULL_TIME = /(\d{2}):(\d{2})(?::(\d{2}))?/;
 /**
  * Custom Date class for local dates (date-only).
  * Format: 1979-05-27
@@ -818,9 +853,15 @@ class LocalDate extends Date {
  */
 class LocalTime extends Date {
     constructor(value, originalFormat) {
-        // For local time, use a fixed date (1970-01-01) and the provided time
+        // Normalize time to include seconds if missing (TOML 1.1.0 allows optional seconds)
+        let normalizedValue = value;
+        if (!/:\d{2}:\d{2}/.test(value)) {
+            // No seconds present, add :00
+            normalizedValue = value + ':00';
+        }
+        // For local time, use year 0000 as the base (TOML spec compliance)
         // Add 'Z' to ensure it's parsed as UTC regardless of system timezone
-        super(`1970-01-01T${value}Z`);
+        super(`0000-01-01T${normalizedValue}Z`);
         this.originalFormat = originalFormat;
     }
     toISOString() {
@@ -852,8 +893,13 @@ class LocalTime extends Date {
  */
 class LocalDateTime extends Date {
     constructor(value, useSpaceSeparator = false, originalFormat) {
+        // Normalize time part to include seconds if missing (TOML 1.1.0 allows optional seconds)
+        let normalizedValue = value;
+        if (!/\d{2}:\d{2}:\d{2}/.test(value)) {
+            normalizedValue = value.replace(/(\d{2}:\d{2})([\s\-+TZ]|$)/, '$1:00$2');
+        }
         // Convert space to T for Date parsing, but remember the original format
-        super(value.replace(' ', 'T') + 'Z');
+        super(normalizedValue.replace(' ', 'T') + 'Z');
         this.useSpaceSeparator = false;
         this.useSpaceSeparator = useSpaceSeparator;
         this.originalFormat = originalFormat || value;
@@ -892,7 +938,12 @@ class LocalDateTime extends Date {
  */
 class OffsetDateTime extends Date {
     constructor(value, useSpaceSeparator = false) {
-        super(value.replace(' ', 'T'));
+        // Normalize time part to include seconds if missing (TOML 1.1.0 allows optional seconds)
+        let normalizedValue = value;
+        if (!/\d{2}:\d{2}:\d{2}/.test(value)) {
+            normalizedValue = value.replace(/(\d{2}:\d{2})([\s\-+TZ]|$)/, '$1:00$2');
+        }
+        super(normalizedValue.replace(' ', 'T'));
         this.useSpaceSeparator = false;
         this.useSpaceSeparator = useSpaceSeparator;
         this.originalFormat = value;
@@ -948,7 +999,7 @@ class OffsetDateTime extends Date {
 }
 
 // Create a shorter alias for convenience
-const dateFormatHelper$1 = DateFormatHelper;
+const dateFormatHelper = DateFormatHelper;
 const TRUE = 'true';
 const FALSE = 'false';
 const HAS_E = /e/i;
@@ -1004,7 +1055,7 @@ function* walkValue$1(cursor, input) {
         else if (cursor.value.raw === TRUE || cursor.value.raw === FALSE) {
             yield boolean(cursor);
         }
-        else if (dateFormatHelper$1.IS_FULL_DATE.test(cursor.value.raw) || dateFormatHelper$1.IS_FULL_TIME.test(cursor.value.raw)) {
+        else if (dateFormatHelper.IS_FULL_DATE.test(cursor.value.raw) || dateFormatHelper.IS_FULL_TIME.test(cursor.value.raw)) {
             yield datetime(cursor, input);
         }
         else if ((!cursor.peek().done && cursor.peek().value.type === TokenType.Dot) ||
@@ -1018,7 +1069,9 @@ function* walkValue$1(cursor, input) {
         }
     }
     else if (cursor.value.type === TokenType.Curly) {
-        yield inlineTable(cursor, input);
+        const [inline_table, comments] = inlineTable(cursor, input);
+        yield inline_table;
+        yield* comments;
     }
     else if (cursor.value.type === TokenType.Bracket) {
         const [inline_array, comments] = inlineArray(cursor, input);
@@ -1217,8 +1270,8 @@ function datetime(cursor, input) {
     // check if raw is full date and following is full time
     if (!cursor.peek().done &&
         cursor.peek().value.type === TokenType.Literal &&
-        dateFormatHelper$1.IS_FULL_DATE.test(raw) &&
-        dateFormatHelper$1.IS_FULL_TIME.test(cursor.peek().value.raw)) {
+        dateFormatHelper.IS_FULL_DATE.test(raw) &&
+        dateFormatHelper.IS_FULL_TIME.test(cursor.peek().value.raw)) {
         const start = loc.start;
         cursor.next();
         loc = { start, end: cursor.value.loc.end };
@@ -1234,9 +1287,9 @@ function datetime(cursor, input) {
         loc = { start, end: cursor.value.loc.end };
         raw += `.${cursor.value.raw}`;
     }
-    if (!dateFormatHelper$1.IS_FULL_DATE.test(raw)) {
+    if (!dateFormatHelper.IS_FULL_DATE.test(raw)) {
         // Local time only (e.g., "07:32:00" or "07:32:00.999")
-        if (dateFormatHelper$1.IS_TIME_ONLY.test(raw)) {
+        if (dateFormatHelper.IS_TIME_ONLY.test(raw)) {
             value = new LocalTime(raw, raw);
         }
         else {
@@ -1245,23 +1298,23 @@ function datetime(cursor, input) {
             value = new Date(`${local_date}T${raw}`);
         }
     }
-    else if (dateFormatHelper$1.IS_DATE_ONLY.test(raw)) {
+    else if (dateFormatHelper.IS_DATE_ONLY.test(raw)) {
         // Local date only (e.g., "1979-05-27")
         value = new LocalDate(raw);
     }
-    else if (dateFormatHelper$1.IS_LOCAL_DATETIME_T.test(raw)) {
+    else if (dateFormatHelper.IS_LOCAL_DATETIME_T.test(raw)) {
         // Local datetime with T separator (e.g., "1979-05-27T07:32:00")
         value = new LocalDateTime(raw, false);
     }
-    else if (dateFormatHelper$1.IS_LOCAL_DATETIME_SPACE.test(raw)) {
+    else if (dateFormatHelper.IS_LOCAL_DATETIME_SPACE.test(raw)) {
         // Local datetime with space separator (e.g., "1979-05-27 07:32:00")
         value = new LocalDateTime(raw, true);
     }
-    else if (dateFormatHelper$1.IS_OFFSET_DATETIME_T.test(raw)) {
+    else if (dateFormatHelper.IS_OFFSET_DATETIME_T.test(raw)) {
         // Offset datetime with T separator (e.g., "1979-05-27T07:32:00Z" or "1979-05-27T07:32:00-07:00")
         value = new OffsetDateTime(raw, false);
     }
-    else if (dateFormatHelper$1.IS_OFFSET_DATETIME_SPACE.test(raw)) {
+    else if (dateFormatHelper.IS_OFFSET_DATETIME_SPACE.test(raw)) {
         // Offset datetime with space separator (e.g., "1979-05-27 07:32:00Z")
         value = new OffsetDateTime(raw, true);
     }
@@ -1347,9 +1400,16 @@ function inlineTable(cursor, input) {
         loc: cloneLocation(cursor.value.loc),
         items: []
     };
+    const comments = [];
     cursor.next();
     while (!cursor.done &&
         !(cursor.value.type === TokenType.Curly && cursor.value.raw === '}')) {
+        // TOML 1.1.0: Handle comments in inline tables
+        if (cursor.value.type === TokenType.Comment) {
+            comments.push(comment(cursor));
+            cursor.next();
+            continue;
+        }
         if (cursor.value.type === TokenType.Comma) {
             const previous = value.items[value.items.length - 1];
             if (!previous) {
@@ -1360,7 +1420,7 @@ function inlineTable(cursor, input) {
             cursor.next();
             continue;
         }
-        const [item] = walkBlock(cursor, input);
+        const [item, ...additional_comments] = walkBlock(cursor, input);
         if (item.type !== NodeType.KeyValue) {
             throw new ParseError(input, cursor.value.loc.start, `Only key-values are supported in inline tables, found ${item.type}`);
         }
@@ -1371,6 +1431,7 @@ function inlineTable(cursor, input) {
             comma: false
         };
         value.items.push(inline_item);
+        merge(comments, additional_comments);
         cursor.next();
     }
     if (cursor.done ||
@@ -1379,7 +1440,7 @@ function inlineTable(cursor, input) {
         throw new ParseError(input, cursor.done ? value.loc.start : cursor.value.loc.start, `Expected "}", found ${cursor.done ? 'end of file' : cursor.value.raw}`);
     }
     value.loc.end = cursor.value.loc.end;
-    return value;
+    return [value, comments];
 }
 function inlineArray(cursor, input) {
     // 7. InlineArray
@@ -1499,8 +1560,6 @@ function traverse(ast, visitor) {
     }
 }
 
-// Create a shorter alias for convenience
-const dateFormatHelper = DateFormatHelper;
 const enter_offsets = new WeakMap();
 const getEnterOffsets = (root) => {
     if (!enter_offsets.has(root)) {
@@ -1515,65 +1574,8 @@ const getExitOffsets = (root) => {
     }
     return exit_offsets.get(root);
 };
-/**
- * Updates location information for a replacement string to match the existing string's position.
- * The actual formatting and escaping is done by generateString().
- *
- * @param existing - The existing string node with the original format and location
- * @param replacement - The replacement string node (already fully formatted by generateString)
- * @returns The replacement string node with updated location information
- */
-function fixStringLocation(existing, replacement) {
-    if (!isMultilineString(replacement.raw)) {
-        return replacement;
-    }
-    // Detect newline character to count lines correctly
-    const newlineChar = replacement.raw.includes('\r\n') ? '\r\n' : '\n';
-    const lineCount = (replacement.raw.match(new RegExp(newlineChar === '\r\n' ? '\\r\\n' : '\\n', 'g')) || []).length;
-    // Update location to match existing position and account for multiple lines
-    if (lineCount > 0) {
-        return Object.assign(Object.assign({}, replacement), { loc: {
-                start: existing.loc.start,
-                end: {
-                    line: existing.loc.start.line + lineCount,
-                    column: 3 // length of delimiter
-                }
-            } });
-    }
-    else {
-        return Object.assign(Object.assign({}, replacement), { loc: {
-                start: existing.loc.start,
-                end: {
-                    line: existing.loc.start.line,
-                    column: existing.loc.start.column + replacement.raw.length
-                }
-            } });
-    }
-}
 //TODO: Add getOffsets function to get all offsets contained in the tree
 function replace(root, parent, existing, replacement) {
-    // Special handling for String nodes to preserve multiline format by editing replacement values
-    if (isString$1(existing) && isString$1(replacement)) {
-        // Regenerate the replacement with proper escaping based on existing format
-        const escapedReplacement = generateString(replacement.value, existing.raw);
-        replacement = fixStringLocation(existing, escapedReplacement);
-    }
-    // Special handling for DateTime nodes to preserve original format by editing replacement values
-    if (isDateTime(existing) && isDateTime(replacement)) {
-        // Analyze the original raw format and create a properly formatted replacement
-        const originalRaw = existing.raw;
-        const newValue = replacement.value;
-        // Create a new date with the original format preserved
-        const formattedDate = dateFormatHelper.createDateWithOriginalFormat(newValue, originalRaw);
-        // Update the replacement with the properly formatted date
-        replacement.value = formattedDate;
-        replacement.raw = formattedDate.toISOString();
-        // Adjust the location information to match the new raw length
-        const lengthDiff = replacement.raw.length - originalRaw.length;
-        if (lengthDiff !== 0) {
-            replacement.loc.end.column = replacement.loc.start.column + replacement.raw.length;
-        }
-    }
     // First, replace existing node
     // (by index for items, item, or key/value)
     if (hasItems(parent)) {
@@ -2210,13 +2212,37 @@ function generateString(value, existingRaw) {
     else {
         raw = JSON.stringify(value);
     }
+    // Calculate proper end location for multiline strings
+    let endLocation;
+    if (raw.includes('\r\n') || (raw.includes('\n') && !raw.includes('\r\n'))) {
+        const newlineChar = raw.includes('\r\n') ? '\r\n' : '\n';
+        const lineCount = (raw.match(new RegExp(newlineChar === '\r\n' ? '\\r\\n' : '\\n', 'g')) || []).length;
+        if (lineCount > 0) {
+            endLocation = {
+                line: 1 + lineCount,
+                column: 3 // length of delimiter (""" or ''')
+            };
+        }
+        else {
+            endLocation = { line: 1, column: raw.length };
+        }
+    }
+    else {
+        endLocation = { line: 1, column: raw.length };
+    }
     return {
         type: NodeType.String,
-        loc: { start: zero(), end: { line: 1, column: raw.length } },
+        loc: { start: zero(), end: endLocation },
         raw,
         value
     };
 }
+/**
+ * Generates a new Integer node.
+ *
+ * @param value - The integer value.
+ * @returns A new Integer node.
+ */
 function generateInteger(value) {
     const raw = value.toString();
     return {
@@ -2307,6 +2333,7 @@ const DEFAULT_TRAILING_COMMA = false;
 const DEFAULT_BRACKET_SPACING = true;
 const DEFAULT_INLINE_TABLE_START = 1;
 const DEFAULT_TRUNCATE_ZERO_TIME_IN_DATES = false;
+const DEFAULT_USE_TABS_FOR_INDENTATION = false;
 // Detects if trailing commas are used in the existing TOML by examining the AST
 // Returns true if trailing commas are used, false if not or comma-separated structures found (ie. default to false)
 function detectTrailingComma(ast) {
@@ -2500,6 +2527,30 @@ function countTrailingNewlines(str, newlineChar) {
     }
     return count;
 }
+// Detects if tabs are used for indentation by checking the first few indented lines
+function detectTabsForIndentation(str) {
+    const lines = str.split(/\r?\n/);
+    let tabCount = 0;
+    let spaceCount = 0;
+    for (const line of lines) {
+        // Skip empty lines
+        if (line.length === 0)
+            continue;
+        // Check the first character of non-empty lines
+        if (line[0] === '\t') {
+            tabCount++;
+        }
+        else if (line[0] === ' ') {
+            spaceCount++;
+        }
+        // If we've seen enough evidence, make a decision
+        if (tabCount + spaceCount >= 5) {
+            break;
+        }
+    }
+    // Prefer tabs if we see more tabs than spaces
+    return tabCount > spaceCount;
+}
 /**
  * Validates a format object and warns about unsupported properties.
  * Throws errors for supported properties with invalid types.
@@ -2510,61 +2561,62 @@ function validateFormatObject(format) {
     if (!format || typeof format !== 'object') {
         return {};
     }
-    const supportedProperties = new Set(['newLine', 'trailingNewline', 'trailingComma', 'bracketSpacing', 'inlineTableStart', 'truncateZeroTimeInDates']);
+    const supportedProperties = new Set(['newLine', 'trailingNewline', 'trailingComma', 'bracketSpacing', 'inlineTableStart', 'truncateZeroTimeInDates', 'useTabsForIndentation']);
     const validatedFormat = {};
     const unsupportedProperties = [];
     const invalidTypeProperties = [];
-    // Check all enumerable properties of the format object
+    // Check all enumerable properties of the format object, including properties
+    // provided via the prototype chain (common in JS Object.create(...) patterns).
     for (const key in format) {
-        if (Object.prototype.hasOwnProperty.call(format, key)) {
-            if (supportedProperties.has(key)) {
-                const value = format[key];
-                // Type validation for each property
-                switch (key) {
-                    case 'newLine':
-                        if (typeof value === 'string') {
-                            validatedFormat.newLine = value;
-                        }
-                        else {
-                            invalidTypeProperties.push(`${key} (expected string, got ${typeof value})`);
-                        }
-                        break;
-                    case 'trailingNewline':
-                        if (typeof value === 'boolean' || typeof value === 'number') {
-                            validatedFormat.trailingNewline = value;
-                        }
-                        else {
-                            invalidTypeProperties.push(`${key} (expected boolean or number, got ${typeof value})`);
-                        }
-                        break;
-                    case 'trailingComma':
-                    case 'bracketSpacing':
-                    case 'truncateZeroTimeInDates':
-                        if (typeof value === 'boolean') {
-                            validatedFormat[key] = value;
-                        }
-                        else {
-                            invalidTypeProperties.push(`${key} (expected boolean, got ${typeof value})`);
-                        }
-                        break;
-                    case 'inlineTableStart':
-                        if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {
-                            validatedFormat.inlineTableStart = value;
-                        }
-                        else if (value === undefined || value === null) {
-                            // Allow undefined/null to use default
-                            validatedFormat.inlineTableStart = value;
-                        }
-                        else {
-                            invalidTypeProperties.push(`${key} (expected non-negative integer or undefined, got ${typeof value})`);
-                        }
-                        break;
-                }
-            }
-            else {
-                unsupportedProperties.push(key);
+        const isOwnEnumerable = Object.prototype.hasOwnProperty.call(format, key);
+        if (supportedProperties.has(key)) {
+            const value = format[key];
+            // Type validation for each property
+            switch (key) {
+                case 'newLine':
+                    if (typeof value === 'string') {
+                        validatedFormat.newLine = value;
+                    }
+                    else {
+                        invalidTypeProperties.push(`${key} (expected string, got ${typeof value})`);
+                    }
+                    break;
+                case 'trailingNewline':
+                    if (typeof value === 'boolean' || typeof value === 'number') {
+                        validatedFormat.trailingNewline = value;
+                    }
+                    else {
+                        invalidTypeProperties.push(`${key} (expected boolean or number, got ${typeof value})`);
+                    }
+                    break;
+                case 'trailingComma':
+                case 'bracketSpacing':
+                case 'truncateZeroTimeInDates':
+                case 'useTabsForIndentation':
+                    if (typeof value === 'boolean') {
+                        validatedFormat[key] = value;
+                    }
+                    else {
+                        invalidTypeProperties.push(`${key} (expected boolean, got ${typeof value})`);
+                    }
+                    break;
+                case 'inlineTableStart':
+                    if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {
+                        validatedFormat.inlineTableStart = value;
+                    }
+                    else if (value === undefined || value === null) {
+                        // Allow undefined/null to use default
+                        validatedFormat.inlineTableStart = value;
+                    }
+                    else {
+                        invalidTypeProperties.push(`${key} (expected non-negative integer or undefined, got ${typeof value})`);
+                    }
+                    break;
             }
         }
+        else if (isOwnEnumerable) {
+            unsupportedProperties.push(key);
+        }
     }
     // Warn about unsupported properties
     if (unsupportedProperties.length > 0) {
@@ -2585,7 +2637,7 @@ function validateFormatObject(format) {
  * @returns A resolved TomlFormat instance
  */
 function resolveTomlFormat(format, fallbackFormat) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
     if (format) {
         // If format is provided, validate and merge it with fallback
         if (format instanceof TomlFormat) {
@@ -2595,7 +2647,7 @@ function resolveTomlFormat(format, fallbackFormat) {
             // Validate the format object and warn about unsupported properties
             const validatedFormat = validateFormatObject(format);
             // Create a new TomlFormat instance with validated properties
-            return new TomlFormat((_a = validatedFormat.newLine) !== null && _a !== void 0 ? _a : fallbackFormat.newLine, (_b = validatedFormat.trailingNewline) !== null && _b !== void 0 ? _b : fallbackFormat.trailingNewline, (_c = validatedFormat.trailingComma) !== null && _c !== void 0 ? _c : fallbackFormat.trailingComma, (_d = validatedFormat.bracketSpacing) !== null && _d !== void 0 ? _d : fallbackFormat.bracketSpacing, validatedFormat.inlineTableStart !== undefined ? validatedFormat.inlineTableStart : fallbackFormat.inlineTableStart, (_e = validatedFormat.truncateZeroTimeInDates) !== null && _e !== void 0 ? _e : fallbackFormat.truncateZeroTimeInDates);
+            return new TomlFormat((_a = validatedFormat.newLine) !== null && _a !== void 0 ? _a : fallbackFormat.newLine, (_b = validatedFormat.trailingNewline) !== null && _b !== void 0 ? _b : fallbackFormat.trailingNewline, (_c = validatedFormat.trailingComma) !== null && _c !== void 0 ? _c : fallbackFormat.trailingComma, (_d = validatedFormat.bracketSpacing) !== null && _d !== void 0 ? _d : fallbackFormat.bracketSpacing, validatedFormat.inlineTableStart !== undefined ? validatedFormat.inlineTableStart : fallbackFormat.inlineTableStart, (_e = validatedFormat.truncateZeroTimeInDates) !== null && _e !== void 0 ? _e : fallbackFormat.truncateZeroTimeInDates, (_f = validatedFormat.useTabsForIndentation) !== null && _f !== void 0 ? _f : fallbackFormat.useTabsForIndentation);
         }
     }
     else {
@@ -2607,8 +2659,7 @@ class TomlFormat {
     // These options were part of the original TimHall's version and are not yet implemented
     //printWidth?: number;
     //tabWidth?: number;
-    //useTabs?: boolean;
-    constructor(newLine, trailingNewline, trailingComma, bracketSpacing, inlineTableStart, truncateZeroTimeInDates) {
+    constructor(newLine, trailingNewline, trailingComma, bracketSpacing, inlineTableStart, truncateZeroTimeInDates, useTabsForIndentation) {
         // Use provided values or fall back to defaults
         this.newLine = newLine !== null && newLine !== void 0 ? newLine : DEFAULT_NEWLINE;
         this.trailingNewline = trailingNewline !== null && trailingNewline !== void 0 ? trailingNewline : DEFAULT_TRAILING_NEWLINE;
@@ -2616,6 +2667,7 @@ class TomlFormat {
         this.bracketSpacing = bracketSpacing !== null && bracketSpacing !== void 0 ? bracketSpacing : DEFAULT_BRACKET_SPACING;
         this.inlineTableStart = inlineTableStart !== null && inlineTableStart !== void 0 ? inlineTableStart : DEFAULT_INLINE_TABLE_START;
         this.truncateZeroTimeInDates = truncateZeroTimeInDates !== null && truncateZeroTimeInDates !== void 0 ? truncateZeroTimeInDates : DEFAULT_TRUNCATE_ZERO_TIME_IN_DATES;
+        this.useTabsForIndentation = useTabsForIndentation !== null && useTabsForIndentation !== void 0 ? useTabsForIndentation : DEFAULT_USE_TABS_FOR_INDENTATION;
     }
     /**
      * Creates a new TomlFormat instance with default formatting preferences.
@@ -2629,7 +2681,7 @@ class TomlFormat {
      *   - truncateZeroTimeInDates: false
      */
     static default() {
-        return new TomlFormat(DEFAULT_NEWLINE, DEFAULT_TRAILING_NEWLINE, DEFAULT_TRAILING_COMMA, DEFAULT_BRACKET_SPACING, DEFAULT_INLINE_TABLE_START, DEFAULT_TRUNCATE_ZERO_TIME_IN_DATES);
+        return new TomlFormat(DEFAULT_NEWLINE, DEFAULT_TRAILING_NEWLINE, DEFAULT_TRAILING_COMMA, DEFAULT_BRACKET_SPACING, DEFAULT_INLINE_TABLE_START, DEFAULT_TRUNCATE_ZERO_TIME_IN_DATES, DEFAULT_USE_TABS_FOR_INDENTATION);
     }
     /**
      * Auto-detects formatting preferences from an existing TOML string.
@@ -2669,6 +2721,8 @@ class TomlFormat {
             format.trailingComma = DEFAULT_TRAILING_COMMA;
             format.bracketSpacing = DEFAULT_BRACKET_SPACING;
         }
+        // Detect if tabs are used for indentation
+        format.useTabsForIndentation = detectTabsForIndentation(tomlString);
         // inlineTableStart uses default value since auto-detection would require
         // complex analysis of nested table formatting preferences
         format.inlineTableStart = DEFAULT_INLINE_TABLE_START;
@@ -2998,71 +3052,85 @@ const BY_NEW_LINE = /(\r\n|\n)/g;
  * It preserves the original formatting, spacing, and structure of the TOML file.
  *
  * @param ast - The Abstract Syntax Tree representing the parsed TOML document
- * @param newline - The newline character(s) to use (\n by default)
- * @param options - Optional configuration object
- * @param options.trailingNewline - Number of trailing newlines to add (1 by default)
+ * @param format - The formatting options to use for the output
  * @returns The reconstructed TOML document as a string
  *
  * @example
  * ```typescript
- * const tomlString = toTOML(ast, '\n', { trailingNewline: 1 });
+ * const tomlString = toTOML(ast, TomlFormat.default());
  * ```
  */
 function toTOML(ast, format) {
     const lines = [];
+    const paddingChar = format.useTabsForIndentation ? '\t' : SPACE;
     traverse(ast, {
         [NodeType.TableKey](node) {
             const { start, end } = node.loc;
-            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '[');
-            write(lines, { start: { line: end.line, column: end.column - 1 }, end }, ']');
+            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '[', paddingChar);
+            write(lines, { start: { line: end.line, column: end.column - 1 }, end }, ']', paddingChar);
         },
         [NodeType.TableArrayKey](node) {
             const { start, end } = node.loc;
-            write(lines, { start, end: { line: start.line, column: start.column + 2 } }, '[[');
-            write(lines, { start: { line: end.line, column: end.column - 2 }, end }, ']]');
+            write(lines, { start, end: { line: start.line, column: start.column + 2 } }, '[[', paddingChar);
+            write(lines, { start: { line: end.line, column: end.column - 2 }, end }, ']]', paddingChar);
         },
         [NodeType.KeyValue](node) {
             const { start: { line } } = node.loc;
-            write(lines, { start: { line, column: node.equals }, end: { line, column: node.equals + 1 } }, '=');
+            write(lines, { start: { line, column: node.equals }, end: { line, column: node.equals + 1 } }, '=', paddingChar);
         },
         [NodeType.Key](node) {
-            write(lines, node.loc, node.raw);
+            write(lines, node.loc, node.raw, paddingChar);
         },
         [NodeType.String](node) {
-            write(lines, node.loc, node.raw);
+            write(lines, node.loc, node.raw, paddingChar);
         },
         [NodeType.Integer](node) {
-            write(lines, node.loc, node.raw);
+            write(lines, node.loc, node.raw, paddingChar);
         },
         [NodeType.Float](node) {
-            write(lines, node.loc, node.raw);
+            write(lines, node.loc, node.raw, paddingChar);
         },
         [NodeType.Boolean](node) {
-            write(lines, node.loc, node.value.toString());
+            write(lines, node.loc, node.value.toString(), paddingChar);
         },
         [NodeType.DateTime](node) {
-            write(lines, node.loc, node.raw);
+            write(lines, node.loc, node.raw, paddingChar);
         },
         [NodeType.InlineArray](node) {
             const { start, end } = node.loc;
-            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '[');
-            write(lines, { start: { line: end.line, column: end.column - 1 }, end }, ']');
+            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '[', paddingChar);
+            write(lines, { start: { line: end.line, column: end.column - 1 }, end }, ']', paddingChar);
         },
         [NodeType.InlineTable](node) {
             const { start, end } = node.loc;
-            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '{');
-            write(lines, { start: { line: end.line, column: end.column - 1 }, end }, '}');
+            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '{', paddingChar);
+            write(lines, { start: { line: end.line, column: end.column - 1 }, end }, '}', paddingChar);
         },
         [NodeType.InlineItem](node) {
             if (!node.comma)
                 return;
             const start = node.loc.end;
-            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, ',');
+            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, ',', paddingChar);
         },
         [NodeType.Comment](node) {
-            write(lines, node.loc, node.raw);
+            write(lines, node.loc, node.raw, paddingChar);
         }
     });
+    // Post-process: convert leading spaces to tabs if useTabsForIndentation is enabled
+    if (format.useTabsForIndentation) {
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Find the leading whitespace
+            const match = line.match(/^( +)/);
+            if (match) {
+                const leadingSpaces = match[1];
+                // Replace entire leading space sequence with equivalent tabs
+                // Each space becomes a tab (preserving the visual width)
+                const leadingTabs = '\t'.repeat(leadingSpaces.length);
+                lines[i] = leadingTabs + line.substring(leadingSpaces.length);
+            }
+        }
+    }
     return lines.join(format.newLine) + format.newLine.repeat(format.trailingNewline);
 }
 /**
@@ -3079,6 +3147,7 @@ function toTOML(ast, format) {
  *              - end: { line: number, column: number } - Ending position (1-indexed line, 0-indexed column)
  * @param raw - The raw string content to write at the specified location.
  *              Can contain multiple lines separated by \n or \r\n.
+ * @param paddingChar - The character to use for padding (space or tab)
  *
  * @throws {Error} When there's a mismatch between location span and raw string line count
  * @throws {Error} When attempting to write to an uninitialized line
@@ -3087,11 +3156,11 @@ function toTOML(ast, format) {
  * ```typescript
  * const lines = ['', ''];
  * const location = { start: { line: 1, column: 0 }, end: { line: 1, column: 3 } };
- * write(lines, location, 'key');
+ * write(lines, location, 'key', ' ');
  * // Result: lines[0] becomes 'key'
  * ```
  */
-function write(lines, loc, raw) {
+function write(lines, loc, raw, paddingChar = SPACE) {
     const raw_lines = raw.split(BY_NEW_LINE).filter(line => line !== '\n' && line !== '\r\n');
     const expected_lines = loc.end.line - loc.start.line + 1;
     if (raw_lines.length !== expected_lines) {
@@ -3105,10 +3174,19 @@ function write(lines, loc, raw) {
         }
         const is_start_line = i === loc.start.line;
         const is_end_line = i === loc.end.line;
-        const before = is_start_line
-            ? line.substr(0, loc.start.column).padEnd(loc.start.column, SPACE)
-            : '';
-        const after = is_end_line ? line.substr(loc.end.column) : '';
+        let before = '';
+        if (is_start_line) {
+            const existingBefore = line.substring(0, loc.start.column);
+            if (existingBefore.length < loc.start.column) {
+                // Need to pad - always use spaces during write phase
+                // Tab conversion happens in post-processing for leading indentation only
+                before = existingBefore.padEnd(loc.start.column, SPACE);
+            }
+            else {
+                before = existingBefore;
+            }
+        }
+        const after = is_end_line ? line.substring(loc.end.column) : '';
         lines[i - 1] = before + raw_lines[i - loc.start.line] + after;
     }
 }
@@ -3226,11 +3304,15 @@ function toValue(node) {
             return result;
         case NodeType.InlineArray:
             return node.items.map(item => toValue(item.item));
+        case NodeType.DateTime:
+            // Preserve TOML date/time custom classes so format is retained when
+            // round-tripping through stringify() (e.g. date-only, time-only, local vs offset).
+            // These classes extend Date, so JS users can still treat them as Dates.
+            return node.value;
         case NodeType.String:
         case NodeType.Integer:
         case NodeType.Float:
         case NodeType.Boolean:
-        case NodeType.DateTime:
             return node.value;
         default:
             throw new Error(`Unrecognized value type "${node.type}"`);
@@ -3470,13 +3552,29 @@ function findByPath(node, path) {
                     key = key.concat(array_index);
                 }
                 else if (isInlineItem(item) && isKeyValue(item.item)) {
+                    // For InlineItems wrapping KeyValues, extract the key
                     key = item.item.key.value;
                 }
                 else if (isInlineItem(item)) {
                     key = [index];
                 }
                 if (key.length && arraysEqual(key, path.slice(0, key.length))) {
-                    found = findByPath(item, path.slice(key.length));
+                    // For InlineItems containing KeyValues, we need to search within the value
+                    // but still return the InlineItem or its contents appropriately
+                    if (isInlineItem(item) && isKeyValue(item.item)) {
+                        if (path.length === key.length) {
+                            // If we've matched the full path, return the InlineItem itself
+                            // so it can be found and replaced in the parent's items array
+                            found = item;
+                        }
+                        else {
+                            // Continue searching within the KeyValue's value
+                            found = findByPath(item.item.value, path.slice(key.length));
+                        }
+                    }
+                    else {
+                        found = findByPath(item, path.slice(key.length));
+                    }
                     return true;
                 }
                 else {
@@ -3583,6 +3681,54 @@ function reorder(changes) {
     }
     return changes;
 }
+/**
+ * Preserves formatting from the existing node when applying it to the replacement node.
+ * This includes multiline string formats, trailing commas, DateTime formats, etc.
+ *
+ * @param existing - The existing node with formatting to preserve
+ * @param replacement - The replacement node to apply formatting to
+ */
+function preserveFormatting(existing, replacement) {
+    // Preserve multiline string format
+    if (isString$1(existing) && isString$1(replacement) && isMultilineString(existing.raw)) {
+        // Generate new string node with preserved multiline format
+        const newString = generateString(replacement.value, existing.raw);
+        replacement.raw = newString.raw;
+        replacement.loc = newString.loc;
+    }
+    // Preserve DateTime format
+    if (isDateTime(existing) && isDateTime(replacement)) {
+        // Analyze the original raw format and create a properly formatted replacement
+        const originalRaw = existing.raw;
+        const newValue = replacement.value;
+        // Create a new date with the original format preserved
+        const formattedDate = DateFormatHelper.createDateWithOriginalFormat(newValue, originalRaw);
+        // Update the replacement with the properly formatted date
+        replacement.value = formattedDate;
+        replacement.raw = formattedDate.toISOString();
+        // Adjust the location information to match the new raw length
+        const lengthDiff = replacement.raw.length - originalRaw.length;
+        if (lengthDiff !== 0) {
+            replacement.loc.end.column = replacement.loc.start.column + replacement.raw.length;
+        }
+    }
+    // Preserve array trailing comma format
+    if (isInlineArray(existing) && isInlineArray(replacement)) {
+        const originalHadTrailingCommas = arrayHadTrailingCommas(existing);
+        if (replacement.items.length > 0) {
+            const lastItem = replacement.items[replacement.items.length - 1];
+            lastItem.comma = originalHadTrailingCommas;
+        }
+    }
+    // Preserve inline table trailing comma format
+    if (isInlineTable(existing) && isInlineTable(replacement)) {
+        const originalHadTrailingCommas = tableHadTrailingCommas(existing);
+        if (replacement.items.length > 0) {
+            const lastItem = replacement.items[replacement.items.length - 1];
+            lastItem.comma = originalHadTrailingCommas;
+        }
+    }
+}
 /**
  * Applies a list of changes to the original TOML document AST while preserving formatting and structure.
  *
@@ -3715,7 +3861,13 @@ function applyChanges(original, updated, changes, format) {
                     insert(original, parent, child, undefined, true);
                 }
                 else {
-                    insert(original, parent, child);
+                    // Unwrap InlineItem if we're adding to a Table (not InlineTable)
+                    // InlineItems should only exist within InlineTables or InlineArrays
+                    let childToInsert = child;
+                    if (isInlineItem(child) && (isTable(parent) || isDocument(parent))) {
+                        childToInsert = child.item;
+                    }
+                    insert(original, parent, childToInsert);
                 }
             }
         }
@@ -3725,26 +3877,8 @@ function applyChanges(original, updated, changes, format) {
             let parent;
             if (isKeyValue(existing) && isKeyValue(replacement)) {
                 // Edit for key-value means value changes
-                // Special handling for arrays: preserve original trailing comma format
-                if (isInlineArray(existing.value) && isInlineArray(replacement.value)) {
-                    const originalHadTrailingCommas = arrayHadTrailingCommas(existing.value);
-                    const newArray = replacement.value;
-                    // Apply or remove trailing comma based on original format
-                    if (newArray.items.length > 0) {
-                        const lastItem = newArray.items[newArray.items.length - 1];
-                        lastItem.comma = originalHadTrailingCommas;
-                    }
-                }
-                // Special handling for inline tables: preserve original trailing comma format
-                if (isInlineTable(existing.value) && isInlineTable(replacement.value)) {
-                    const originalHadTrailingCommas = tableHadTrailingCommas(existing.value);
-                    const newTable = replacement.value;
-                    // Apply or remove trailing comma based on original format
-                    if (newTable.items.length > 0) {
-                        const lastItem = newTable.items[newTable.items.length - 1];
-                        lastItem.comma = originalHadTrailingCommas;
-                    }
-                }
+                // Preserve formatting from existing value in replacement value
+                preserveFormatting(existing.value, replacement.value);
                 parent = existing;
                 existing = existing.value;
                 replacement = replacement.value;
@@ -3762,6 +3896,14 @@ function applyChanges(original, updated, changes, format) {
                 parent = existing;
                 existing = existing.item;
             }
+            else if (isInlineItem(existing) && isInlineItem(replacement) && isKeyValue(existing.item) && isKeyValue(replacement.item)) {
+                // Both are InlineItems wrapping KeyValues (nested inline table edits)
+                // Preserve formatting and edit the value within
+                preserveFormatting(existing.item.value, replacement.item.value);
+                parent = existing.item;
+                existing = existing.item.value;
+                replacement = replacement.item.value;
+            }
             else {
                 parent = findParent(original, change.path);
                 // Special handling for array element edits