@decimalturn/toml-patch 0.5.2 → 0.6.0

package/dist/toml-patch.d.ts

@@ -1,4 +1,4 @@
-//! @decimalturn/toml-patch v0.5.2 - https://github.com/DecimalTurn/toml-patch - @license: MIT
+//! @decimalturn/toml-patch v0.6.0 - https://github.com/DecimalTurn/toml-patch - @license: MIT
 interface Location {
     start: Position;
     end: Position;
@@ -222,7 +222,17 @@ declare class TomlFormat {
      *
      */
     truncateZeroTimeInDates?: boolean;
-    constructor(newLine?: string, trailingNewline?: number, trailingComma?: boolean, bracketSpacing?: boolean, inlineTableStart?: number, truncateZeroTimeInDates?: boolean);
+    /**
+     * Whether to use tabs instead of spaces for indentation/padding.
+     * When enabled, lines that need to be indented will use tabs.
+     *
+     * @example
+     * - true:  Uses tabs for indentation
+     * - false: Uses spaces for indentation (default)
+     *
+     */
+    useTabsForIndentation?: boolean;
+    constructor(newLine?: string, trailingNewline?: number, trailingComma?: boolean, bracketSpacing?: boolean, inlineTableStart?: number, truncateZeroTimeInDates?: boolean, useTabsForIndentation?: boolean);
     /**
      * Creates a new TomlFormat instance with default formatting preferences.
      *

package/dist/toml-patch.es.js

@@ -1,4 +1,4 @@
-//! @decimalturn/toml-patch v0.5.2 - 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;
@@ -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);
@@ -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
@@ -2272,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) {
@@ -2465,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.
@@ -2475,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) {
@@ -2550,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) {
@@ -2560,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 {
@@ -2572,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;
@@ -2581,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.
@@ -2594,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.
@@ -2634,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;
@@ -2963,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);
 }
 /**
@@ -3044,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
@@ -3052,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) {
@@ -3070,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;
     }
 }
@@ -3191,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}"`);
@@ -3435,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 {
@@ -3728,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);
                 }
             }
         }
@@ -3757,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