@decimalturn/toml-patch 0.3.7 → 0.4.0

package/dist/toml-patch.es.js

@@ -1,9 +1,13 @@
-//! @decimalturn/toml-patch v0.3.7 - https://github.com/DecimalTurn/toml-patch - @license: MIT
+//! @decimalturn/toml-patch v0.4.0 - https://github.com/DecimalTurn/toml-patch - @license: MIT
 var NodeType;
 (function (NodeType) {
     NodeType["Document"] = "Document";
     NodeType["Table"] = "Table";
     NodeType["TableKey"] = "TableKey";
+    /**
+     * Array of Tables node
+     * More info: https://toml.io/en/latest#array-of-tables
+     */
     NodeType["TableArray"] = "TableArray";
     NodeType["TableArrayKey"] = "TableArrayKey";
     NodeType["KeyValue"] = "KeyValue";
@@ -16,6 +20,10 @@ var NodeType;
     NodeType["InlineArray"] = "InlineArray";
     NodeType["InlineItem"] = "InlineItem";
     NodeType["InlineTable"] = "InlineTable";
+    /**
+     * Comment node
+     * More info: https://toml.io/en/latest#comment
+     */
     NodeType["Comment"] = "Comment";
 })(NodeType || (NodeType = {}));
 function isDocument(node) {
@@ -27,6 +35,11 @@ function isTable(node) {
 function isTableKey(node) {
     return node.type === NodeType.TableKey;
 }
+/**
+ * Is a TableArray (aka array of tables)
+ * @param node
+ * @returns
+ */
 function isTableArray(node) {
     return node.type === NodeType.TableArray;
 }
@@ -36,6 +49,9 @@ function isTableArrayKey(node) {
 function isKeyValue(node) {
     return node.type === NodeType.KeyValue;
 }
+function isDateTime(node) {
+    return node.type === NodeType.DateTime;
+}
 function isInlineArray(node) {
     return node.type === NodeType.InlineArray;
 }
@@ -161,11 +177,11 @@ function getLine$1(input, position) {
 }
 function findLines(input) {
     // exec is stateful, so create new regexp each time
-    const BY_NEW_LINE = /[\r\n|\n]/g;
+    const BY_NEW_LINE = /\r\n|\n/g;
     const indexes = [];
     let match;
     while ((match = BY_NEW_LINE.exec(input)) != null) {
-        indexes.push(match.index);
+        indexes.push(match.index + match[0].length - 1);
     }
     indexes.push(input.length + 1);
     return indexes;
@@ -176,6 +192,12 @@ function clonePosition(position) {
 function cloneLocation(location) {
     return { start: clonePosition(location.start), end: clonePosition(location.end) };
 }
+/**
+ * Returns a Position at line 1, column 0.
+ * This means that lines are 1-indexed and columns are 0-indexed.
+ *
+ * @returns A Position at line 1, column 0
+ */
 function zero() {
     return { line: 1, column: 0 };
 }
@@ -420,10 +442,10 @@ function isString(value) {
     return typeof value === 'string';
 }
 function isInteger(value) {
-    return typeof value === 'number' && value % 1 === 0;
+    return typeof value === 'number' && value % 1 === 0 && isFinite(value) && !Object.is(value, -0);
 }
 function isFloat(value) {
-    return typeof value === 'number' && !isInteger(value);
+    return typeof value === 'number' && (!isInteger(value) || !isFinite(value) || Object.is(value, -0));
 }
 function isBoolean(value) {
     return typeof value === 'boolean';
@@ -562,6 +584,359 @@ function lineEndingBackslash(value) {
     return value.replace(IS_LINE_ENDING_BACKSLASH, (match, group) => match.replace(group, ''));
 }
 
+/**
+ * Central module for TOML date/time format handling and custom date classes.
+ * This module provides all the patterns, classes, and utilities needed to work
+ * with the different date/time formats supported by the TOML specification.
+ */
+/**
+ * Helper class containing all date format patterns and utilities for TOML date/time handling
+ */
+class DateFormatHelper {
+    /**
+     * Creates a custom date/time object that preserves the original TOML date/time format.
+     *
+     * This method detects the TOML date/time format from the raw string and returns an appropriate
+     * custom date/time instance (e.g., LocalDate, LocalTime, LocalDateTime, OffsetDateTime) or a Date,
+     * using the provided new JavaScript Date value.
+     *
+     * @param {Date} newJSDate - The new JavaScript Date object representing the updated
+     * date/time value. This is used as the source for constructing the custom date/time object.
+     * In some cases, this may be a custom date/time object (e.g., LocalTime) instead of a native Date.
+     * @param {string} originalRaw - The original TOML date/time string as it appeared in the input.
+     * Used to detect the specific TOML date/time format and to extract formatting details (e.g., separator, offset).
+     *
+     * @returns {Date | LocalDate | LocalTime | LocalDateTime | OffsetDateTime}
+     * Returns a custom date/time object that matches the original TOML format:
+     * - LocalDate for date-only values (e.g., "2024-01-15")
+     * - LocalTime for time-only values (e.g., "10:30:00")
+     * - LocalDateTime for local datetimes (e.g., "2024-01-15T10:30:00" or "2024-01-15 10:30:00")
+     * - OffsetDateTime for datetimes with offsets (e.g., "2024-01-15T10:30:00+02:00")
+     * - Date (native JS Date) as a fallback if the format is unrecognized
+     *
+     * Format-specific behavior:
+     * - Date-only: Returns a LocalDate constructed from the date part of newJSDate.
+     * - Time-only: Returns a LocalTime, either from newJSDate (if already LocalTime) or constructed from its time part.
+     * - Local datetime: Returns a LocalDateTime, preserving the separator (T or space).
+     * - Offset datetime: Returns an OffsetDateTime, reconstructing the date/time with the original offset and separator.
+     * - Fallback: Returns newJSDate as-is.
+     */
+    static createDateWithOriginalFormat(newJSDate, originalRaw) {
+        if (DateFormatHelper.IS_DATE_ONLY.test(originalRaw)) {
+            // Local date (date-only) - format: 2024-01-15
+            // Check if newJSDate has time components - if so, upgrade appropriately
+            if (newJSDate.getUTCHours() !== 0 ||
+                newJSDate.getUTCMinutes() !== 0 ||
+                newJSDate.getUTCSeconds() !== 0 ||
+                newJSDate.getUTCMilliseconds() !== 0) {
+                // Check if the new value is an OffsetDateTime (has offset information)
+                if (newJSDate instanceof OffsetDateTime) {
+                    // Upgrade to OffsetDateTime - it already has the right format
+                    return newJSDate;
+                }
+                // Upgrade from date-only to local datetime with time components
+                // Use T separator as it's the more common format
+                let isoString = newJSDate.toISOString().replace('Z', '');
+                // Strip .000 milliseconds if present (don't show unnecessary precision)
+                isoString = isoString.replace(/\.000$/, '');
+                return new LocalDateTime(isoString, false);
+            }
+            const dateStr = newJSDate.toISOString().split('T')[0];
+            return new LocalDate(dateStr);
+        }
+        else if (DateFormatHelper.IS_TIME_ONLY.test(originalRaw)) {
+            // Local time (time-only) - format: 10:30:00
+            // For time-only values, we need to handle this more carefully
+            // The newJSDate might be a LocalTime object itself
+            if (newJSDate instanceof LocalTime) {
+                // If the new date is already a LocalTime, use its toISOString
+                return newJSDate;
+            }
+            else {
+                // Determine if originalRaw had milliseconds and how many digits
+                const msMatch = originalRaw.match(/\.(\d+)\s*$/);
+                // Extract time from a regular Date object
+                const isoString = newJSDate.toISOString();
+                if (isoString && isoString.includes('T')) {
+                    let newTime = isoString.split('T')[1].split('Z')[0];
+                    if (msMatch) {
+                        // Original had milliseconds, preserve the number of digits
+                        const msDigits = msMatch[1].length;
+                        const [h, m, sMs] = newTime.split(':');
+                        const [s] = sMs.split('.');
+                        const ms = String(newJSDate.getUTCMilliseconds()).padStart(3, '0').slice(0, msDigits);
+                        newTime = `${h}:${m}:${s}.${ms}`;
+                    }
+                    // If original had no milliseconds, keep newTime as-is (with milliseconds if present)
+                    return new LocalTime(newTime, originalRaw);
+                }
+                else {
+                    // Fallback: construct time from the Date object directly
+                    const hours = String(newJSDate.getUTCHours()).padStart(2, '0');
+                    const minutes = String(newJSDate.getUTCMinutes()).padStart(2, '0');
+                    const seconds = String(newJSDate.getUTCSeconds()).padStart(2, '0');
+                    const milliseconds = newJSDate.getUTCMilliseconds();
+                    let timeStr;
+                    if (msMatch) {
+                        const msDigits = msMatch[1].length;
+                        let ms = String(milliseconds).padStart(3, '0').slice(0, msDigits);
+                        timeStr = `${hours}:${minutes}:${seconds}.${ms}`;
+                    }
+                    else if (milliseconds > 0) {
+                        // No original milliseconds, but new value has them - include them
+                        // Note: milliseconds > 0 ensures we don't format ".0" for zero milliseconds
+                        const ms = String(milliseconds).padStart(3, '0').replace(/0+$/, '');
+                        timeStr = `${hours}:${minutes}:${seconds}.${ms}`;
+                    }
+                    else {
+                        timeStr = `${hours}:${minutes}:${seconds}`;
+                    }
+                    return new LocalTime(timeStr, originalRaw);
+                }
+            }
+        }
+        else if (DateFormatHelper.IS_LOCAL_DATETIME_T.test(originalRaw)) {
+            // Local datetime with T separator - format: 2024-01-15T10:30:00
+            // Determine if originalRaw had milliseconds and how many digits
+            const msMatch = originalRaw.match(/\.(\d+)\s*$/);
+            let isoString = newJSDate.toISOString().replace('Z', '');
+            if (msMatch) {
+                // Original had milliseconds, preserve the number of digits
+                const msDigits = msMatch[1].length;
+                // isoString is like "2024-01-15T10:30:00.123"
+                const [datePart, timePart] = isoString.split('T');
+                const [h, m, sMs] = timePart.split(':');
+                const [s] = sMs.split('.');
+                const ms = String(newJSDate.getUTCMilliseconds()).padStart(3, '0').slice(0, msDigits);
+                isoString = `${datePart}T${h}:${m}:${s}.${ms}`;
+            }
+            // If original had no milliseconds, keep isoString as-is (with milliseconds if present)
+            return new LocalDateTime(isoString, false, originalRaw);
+        }
+        else if (DateFormatHelper.IS_LOCAL_DATETIME_SPACE.test(originalRaw)) {
+            // Local datetime with space separator - format: 2024-01-15 10:30:00
+            const msMatch = originalRaw.match(/\.(\d+)\s*$/);
+            let isoString = newJSDate.toISOString().replace('Z', '').replace('T', ' ');
+            if (msMatch) {
+                const msDigits = msMatch[1].length;
+                // isoString is like "2024-01-15 10:30:00.123"
+                const [datePart, timePart] = isoString.split(' ');
+                const [h, m, sMs] = timePart.split(':');
+                const [s] = sMs.split('.');
+                const ms = String(newJSDate.getUTCMilliseconds()).padStart(3, '0').slice(0, msDigits);
+                isoString = `${datePart} ${h}:${m}:${s}.${ms}`;
+            }
+            // If original had no milliseconds, keep isoString as-is (with milliseconds if present)
+            return new LocalDateTime(isoString, true, originalRaw);
+        }
+        else if (DateFormatHelper.IS_OFFSET_DATETIME_T.test(originalRaw) || DateFormatHelper.IS_OFFSET_DATETIME_SPACE.test(originalRaw)) {
+            // Offset datetime - preserve the original timezone offset and separator
+            const offsetMatch = originalRaw.match(/([+-]\d{2}:\d{2}|[Zz])$/);
+            const originalOffset = offsetMatch ? (offsetMatch[1] === 'z' ? 'Z' : offsetMatch[1]) : 'Z';
+            const useSpaceSeparator = DateFormatHelper.IS_OFFSET_DATETIME_SPACE.test(originalRaw);
+            // Check if original had milliseconds and preserve precision
+            const msMatch = originalRaw.match(/\.(\d+)(?:[Zz]|[+-]\d{2}:\d{2})\s*$/);
+            // Convert UTC time to local time in the original timezone
+            const utcTime = newJSDate.getTime();
+            let offsetMinutes = 0;
+            if (originalOffset !== 'Z') {
+                const sign = originalOffset[0] === '+' ? 1 : -1;
+                const [hours, minutes] = originalOffset.slice(1).split(':');
+                offsetMinutes = sign * (parseInt(hours) * 60 + parseInt(minutes));
+            }
+            // Create local time by applying the offset to UTC
+            const localTime = new Date(utcTime + offsetMinutes * 60000);
+            // Format the local time components
+            const year = localTime.getUTCFullYear();
+            const month = String(localTime.getUTCMonth() + 1).padStart(2, '0');
+            const day = String(localTime.getUTCDate()).padStart(2, '0');
+            const hours = String(localTime.getUTCHours()).padStart(2, '0');
+            const minutes = String(localTime.getUTCMinutes()).padStart(2, '0');
+            const seconds = String(localTime.getUTCSeconds()).padStart(2, '0');
+            const milliseconds = localTime.getUTCMilliseconds();
+            const separator = useSpaceSeparator ? ' ' : 'T';
+            let timePart = `${hours}:${minutes}:${seconds}`;
+            // Handle millisecond precision
+            if (msMatch) {
+                const msDigits = msMatch[1].length;
+                const ms = String(milliseconds).padStart(3, '0').slice(0, msDigits);
+                timePart += `.${ms}`;
+            }
+            else if (milliseconds > 0) {
+                // Original had no milliseconds, but new value has them
+                const ms = String(milliseconds).padStart(3, '0').replace(/0+$/, '');
+                timePart += `.${ms}`;
+            }
+            const newDateTimeString = `${year}-${month}-${day}${separator}${timePart}${originalOffset}`;
+            return new OffsetDateTime(newDateTimeString, useSpaceSeparator);
+        }
+        else {
+            // Fallback to regular Date
+            return newJSDate;
+        }
+    }
+}
+// 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})$/;
+// 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})/;
+/**
+ * Custom Date class for local dates (date-only).
+ * Format: 1979-05-27
+ */
+class LocalDate extends Date {
+    constructor(value) {
+        super(value);
+    }
+    toISOString() {
+        const year = this.getUTCFullYear();
+        const month = String(this.getUTCMonth() + 1).padStart(2, '0');
+        const day = String(this.getUTCDate()).padStart(2, '0');
+        return `${year}-${month}-${day}`;
+    }
+}
+/**
+ * Custom Date class for local times (time-only)
+ * Format: 07:32:00 or 07:32:00.999
+ */
+class LocalTime extends Date {
+    constructor(value, originalFormat) {
+        // For local time, use a fixed date (1970-01-01) and the provided time
+        super(`1970-01-01T${value}`);
+        this.originalFormat = originalFormat;
+    }
+    toISOString() {
+        const hours = String(this.getUTCHours()).padStart(2, '0');
+        const minutes = String(this.getUTCMinutes()).padStart(2, '0');
+        const seconds = String(this.getUTCSeconds()).padStart(2, '0');
+        const milliseconds = this.getUTCMilliseconds();
+        // Check if the original format had milliseconds
+        const originalHadMs = this.originalFormat && this.originalFormat.includes('.');
+        if (originalHadMs) {
+            // Determine the number of millisecond digits from the original format
+            const msMatch = this.originalFormat.match(/\.(\d+)\s*$/);
+            const msDigits = msMatch ? msMatch[1].length : 3;
+            const ms = String(milliseconds).padStart(3, '0').slice(0, msDigits);
+            return `${hours}:${minutes}:${seconds}.${ms}`;
+        }
+        else if (milliseconds > 0) {
+            // Original had no milliseconds, but current has non-zero milliseconds
+            // Show them with trailing zeros removed
+            const ms = String(milliseconds).padStart(3, '0').replace(/0+$/, '');
+            return `${hours}:${minutes}:${seconds}.${ms}`;
+        }
+        return `${hours}:${minutes}:${seconds}`;
+    }
+}
+/**
+ * Custom Date class for local datetime (no timezone)
+ * Format: 1979-05-27T07:32:00 or 1979-05-27 07:32:00
+ */
+class LocalDateTime extends Date {
+    constructor(value, useSpaceSeparator = false, originalFormat) {
+        // Convert space to T for Date parsing, but remember the original format
+        super(value.replace(' ', 'T') + 'Z');
+        this.useSpaceSeparator = false;
+        this.useSpaceSeparator = useSpaceSeparator;
+        this.originalFormat = originalFormat || value;
+    }
+    toISOString() {
+        const year = this.getUTCFullYear();
+        const month = String(this.getUTCMonth() + 1).padStart(2, '0');
+        const day = String(this.getUTCDate()).padStart(2, '0');
+        const hours = String(this.getUTCHours()).padStart(2, '0');
+        const minutes = String(this.getUTCMinutes()).padStart(2, '0');
+        const seconds = String(this.getUTCSeconds()).padStart(2, '0');
+        const milliseconds = this.getUTCMilliseconds();
+        const datePart = `${year}-${month}-${day}`;
+        const separator = this.useSpaceSeparator ? ' ' : 'T';
+        // Check if the original format had milliseconds
+        const originalHadMs = this.originalFormat && this.originalFormat.includes('.');
+        if (originalHadMs) {
+            // Determine the number of millisecond digits from the original format
+            const msMatch = this.originalFormat.match(/\.(\d+)\s*$/);
+            const msDigits = msMatch ? msMatch[1].length : 3;
+            const ms = String(milliseconds).padStart(3, '0').slice(0, msDigits);
+            return `${datePart}${separator}${hours}:${minutes}:${seconds}.${ms}`;
+        }
+        else if (milliseconds > 0) {
+            // Original had no milliseconds, but current has non-zero milliseconds
+            // Show them with trailing zeros removed
+            const ms = String(milliseconds).padStart(3, '0').replace(/0+$/, '');
+            return `${datePart}${separator}${hours}:${minutes}:${seconds}.${ms}`;
+        }
+        return `${datePart}${separator}${hours}:${minutes}:${seconds}`;
+    }
+}
+/**
+ * Custom Date class for offset datetime that preserves space separator
+ * Format: 1979-05-27T07:32:00Z or 1979-05-27 07:32:00-07:00
+ */
+class OffsetDateTime extends Date {
+    constructor(value, useSpaceSeparator = false) {
+        super(value.replace(' ', 'T'));
+        this.useSpaceSeparator = false;
+        this.useSpaceSeparator = useSpaceSeparator;
+        this.originalFormat = value;
+        // Extract and preserve the original offset
+        const offsetMatch = value.match(/([+-]\d{2}:\d{2}|[Zz])$/);
+        if (offsetMatch) {
+            this.originalOffset = offsetMatch[1] === 'z' ? 'Z' : offsetMatch[1];
+        }
+    }
+    toISOString() {
+        if (this.originalOffset) {
+            // Calculate the local time in the original timezone
+            const utcTime = this.getTime();
+            let offsetMinutes = 0;
+            if (this.originalOffset !== 'Z') {
+                const sign = this.originalOffset[0] === '+' ? 1 : -1;
+                const [hours, minutes] = this.originalOffset.slice(1).split(':');
+                offsetMinutes = sign * (parseInt(hours) * 60 + parseInt(minutes));
+            }
+            const localTime = new Date(utcTime + offsetMinutes * 60000);
+            const year = localTime.getUTCFullYear();
+            const month = String(localTime.getUTCMonth() + 1).padStart(2, '0');
+            const day = String(localTime.getUTCDate()).padStart(2, '0');
+            const hours = String(localTime.getUTCHours()).padStart(2, '0');
+            const minutes = String(localTime.getUTCMinutes()).padStart(2, '0');
+            const seconds = String(localTime.getUTCSeconds()).padStart(2, '0');
+            const milliseconds = localTime.getUTCMilliseconds();
+            const datePart = `${year}-${month}-${day}`;
+            const separator = this.useSpaceSeparator ? ' ' : 'T';
+            // Check if the original format had milliseconds
+            const originalHadMs = this.originalFormat && this.originalFormat.includes('.');
+            if (originalHadMs) {
+                // Determine the number of millisecond digits from the original format
+                const msMatch = this.originalFormat.match(/\.(\d+)(?:[Zz]|[+-]\d{2}:\d{2})\s*$/);
+                const msDigits = msMatch ? msMatch[1].length : 3;
+                const ms = String(milliseconds).padStart(3, '0').slice(0, msDigits);
+                return `${datePart}${separator}${hours}:${minutes}:${seconds}.${ms}${this.originalOffset}`;
+            }
+            else if (milliseconds > 0) {
+                // Original had no milliseconds, but current has non-zero milliseconds
+                // Show them with trailing zeros removed
+                const ms = String(milliseconds).padStart(3, '0').replace(/0+$/, '');
+                return `${datePart}${separator}${hours}:${minutes}:${seconds}.${ms}${this.originalOffset}`;
+            }
+            return `${datePart}${separator}${hours}:${minutes}:${seconds}${this.originalOffset}`;
+        }
+        const isoString = super.toISOString();
+        if (this.useSpaceSeparator) {
+            return isoString.replace('T', ' ');
+        }
+        return isoString;
+    }
+}
+
+// Create a shorter alias for convenience
+const dateFormatHelper$1 = DateFormatHelper;
 const TRUE = 'true';
 const FALSE = 'false';
 const HAS_E = /e/i;
@@ -571,8 +946,6 @@ const IS_NAN = /nan/;
 const IS_HEX = /^0x/;
 const IS_OCTAL = /^0o/;
 const IS_BINARY = /^0b/;
-const IS_FULL_DATE = /(\d{4})-(\d{2})-(\d{2})/;
-const IS_FULL_TIME = /(\d{2}):(\d{2}):(\d{2})/;
 function* parseTOML(input) {
     const tokens = tokenize(input);
     const cursor = new Cursor(tokens);
@@ -580,6 +953,23 @@ function* parseTOML(input) {
         yield* walkBlock(cursor, input);
     }
 }
+/**
+ * Continues parsing TOML from a remaining string and appends the results to an existing AST.
+ *
+ * @param existingAst - The existing AST to append to
+ * @param remainingString - The remaining TOML string to parse
+ * @returns A new complete AST with both the existing and newly parsed items
+ */
+function* continueParsingTOML(existingAst, remainingString) {
+    // Yield all items from the existing AST
+    for (const item of existingAst) {
+        yield item;
+    }
+    // Parse and yield all items from the remaining string
+    for (const item of parseTOML(remainingString)) {
+        yield item;
+    }
+}
 function* walkBlock(cursor, input) {
     if (cursor.value.type === TokenType.Comment) {
         yield comment(cursor);
@@ -602,7 +992,7 @@ function* walkValue$1(cursor, input) {
         else if (cursor.value.raw === TRUE || cursor.value.raw === FALSE) {
             yield boolean(cursor);
         }
-        else if (IS_FULL_DATE.test(cursor.value.raw) || IS_FULL_TIME.test(cursor.value.raw)) {
+        else if (dateFormatHelper$1.IS_FULL_DATE.test(cursor.value.raw) || dateFormatHelper$1.IS_FULL_TIME.test(cursor.value.raw)) {
             yield datetime(cursor, input);
         }
         else if ((!cursor.peek().done && cursor.peek().value.type === TokenType.Dot) ||
@@ -815,8 +1205,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 &&
-        IS_FULL_DATE.test(raw) &&
-        IS_FULL_TIME.test(cursor.peek().value.raw)) {
+        dateFormatHelper$1.IS_FULL_DATE.test(raw) &&
+        dateFormatHelper$1.IS_FULL_TIME.test(cursor.peek().value.raw)) {
         const start = loc.start;
         cursor.next();
         loc = { start, end: cursor.value.loc.end };
@@ -832,12 +1222,39 @@ function datetime(cursor, input) {
         loc = { start, end: cursor.value.loc.end };
         raw += `.${cursor.value.raw}`;
     }
-    if (!IS_FULL_DATE.test(raw)) {
-        // For local time, use local ISO date
-        const [local_date] = new Date().toISOString().split('T');
-        value = new Date(`${local_date}T${raw}`);
+    if (!dateFormatHelper$1.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)) {
+            value = new LocalTime(raw, raw);
+        }
+        else {
+            // For other time formats, use local ISO date
+            const [local_date] = new Date().toISOString().split('T');
+            value = new Date(`${local_date}T${raw}`);
+        }
+    }
+    else if (dateFormatHelper$1.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)) {
+        // 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)) {
+        // 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)) {
+        // 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)) {
+        // Offset datetime with space separator (e.g., "1979-05-27 07:32:00Z")
+        value = new OffsetDateTime(raw, true);
     }
     else {
+        // Default: offset datetime with T separator or any other format
         value = new Date(raw.replace(' ', 'T'));
     }
     return {
@@ -1070,6 +1487,8 @@ 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)) {
@@ -1086,6 +1505,22 @@ const getExitOffsets = (root) => {
 };
 //TODO: Add getOffsets function to get all offsets contained in the tree
 function replace(root, parent, existing, replacement) {
+    // Special handling for DateTime nodes to preserve original 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;
+        }
+    }
     // First, replace existing node
     // (by index for items, item, or key/value)
     if (hasItems(parent)) {
@@ -1134,7 +1569,16 @@ function replace(root, parent, existing, replacement) {
     };
     addOffset(offset, getExitOffsets(root), replacement, existing);
 }
-function insert(root, parent, child, index) {
+/**
+ * Inserts a child node into the AST.
+ *
+ * @param root - The root node of the AST
+ * @param parent - The parent node to insert the child into
+ * @param child - The child node to insert
+ * @param index - The index at which to insert the child (optional)
+ * @param forceInline - Whether to force inline positioning even for document-level insertions (optional)
+ */
+function insert(root, parent, child, index, forceInline) {
     if (!hasItems(parent)) {
         throw new Error(`Unsupported parent type "${parent.type}" for insert`);
     }
@@ -1144,6 +1588,9 @@ function insert(root, parent, child, index) {
     if (isInlineArray(parent) || isInlineTable(parent)) {
         ({ shift, offset } = insertInline(parent, child, index));
     }
+    else if (forceInline && isDocument(parent)) {
+        ({ shift, offset } = insertInlineAtRoot(parent, child, index));
+    }
     else {
         ({ shift, offset } = insertOnNewLine(parent, child, index));
     }
@@ -1176,10 +1623,10 @@ function insertOnNewLine(parent, child, index) {
             column: !isComment(previous) ? previous.loc.start.column : parent.loc.start.column
         }
         : clonePosition(parent.loc.start);
-    const is_block = isTable(child) || isTableArray(child);
+    const isSquareBracketsStructure = isTable(child) || isTableArray(child);
     let leading_lines = 0;
     if (use_first_line) ;
-    else if (is_block) {
+    else if (isSquareBracketsStructure) {
         leading_lines = 2;
     }
     else {
@@ -1199,44 +1646,33 @@ function insertOnNewLine(parent, child, index) {
     return { shift, offset };
 }
 /**
- * Inserts an inline element into an inline array or table at the specified index.
- * This function handles positioning, comma management, and offset calculation for the inserted item.
+ * Calculates positioning (shift and offset) for inserting a child into a parent container.
+ * This function handles the core positioning logic used to insert an inline item inside a table (or at the document root level).
  *
- * @param parent - The inline array or table where the child will be inserted
- * @param child - The inline item to insert
- * @param index - The index position where to insert the child
- * @returns An object containing shift and offset spans:
- *          - shift: Adjustments needed to position the child correctly
- *          - offset: Adjustments needed for elements that follow the insertion
- * @throws Error if the child is not a compatible inline item type
+ * @param parent - The parent container (Document, InlineArray or InlineTable)
+ * @param child - The child node to be inserted
+ * @param index - The insertion index within the parent's items
+ * @param options - Configuration options for positioning calculation
+ * @param options.useNewLine - Whether to place the child on a new line
+ * @param options.skipCommaSpace - Number of columns to skip for comma + space (default: 2)
+ * @param options.skipBracketSpace - Number of columns to skip for bracket/space (default: 1)
+ * @param options.hasCommaHandling - Whether comma handling logic should be applied
+ * @param options.isLastElement - Whether this is the last element in the container
+ * @param options.hasSeparatingCommaBefore - Whether a comma should precede this element
+ * @param options.hasSeparatingCommaAfter - Whether a comma should follow this element
+ * @param options.hasTrailingComma - Whether the element has a trailing comma
+ * @returns Object containing shift (positioning adjustment for the child) and offset (adjustment for following elements)
  */
-function insertInline(parent, child, index) {
-    if (!isInlineItem(child)) {
-        throw new Error(`Incompatible child type "${child.type}"`);
-    }
-    // Store preceding node and insert
-    const previous = index != null ? parent.items[index - 1] : last(parent.items);
-    const is_last = index == null || index === parent.items.length;
-    parent.items.splice(index, 0, child);
-    // Add commas as-needed
-    const has_seperating_comma_before = !!previous;
-    const has_seperating_comma_after = !is_last;
-    const has_trailing_comma = is_last && child.comma === true;
-    if (has_seperating_comma_before) {
-        previous.comma = true;
-    }
-    if (has_seperating_comma_after) {
-        child.comma = true;
-    }
-    // Use a new line for documents, children of Table/TableArray,
-    // and if an inline table is using new lines
-    const use_new_line = isInlineArray(parent) && perLine(parent);
-    // Set start location from previous item or start of array
-    // (previous is undefined for empty array or inserting at first item)
+function calculateInlinePositioning(parent, child, index, options = {}) {
+    // Configuration options with default values
+    const { useNewLine = false, skipCommaSpace = 2, skipBracketSpace = 1, hasCommaHandling = false, isLastElement = false, hasSeparatingCommaBefore = false, hasSeparatingCommaAfter = false, hasTrailingComma = false } = options;
+    // Store preceding node
+    const previous = index > 0 ? parent.items[index - 1] : undefined;
+    // Set start location from previous item or start of parent
     const start = previous
         ? {
             line: previous.loc.end.line,
-            column: use_new_line
+            column: useNewLine
                 ? !isComment(previous)
                     ? previous.loc.start.column
                     : parent.loc.start.column
@@ -1244,13 +1680,18 @@ function insertInline(parent, child, index) {
         }
         : clonePosition(parent.loc.start);
     let leading_lines = 0;
-    if (use_new_line) {
+    if (useNewLine) {
         leading_lines = 1;
     }
     else {
-        const skip_comma = 2;
-        const skip_bracket = 1;
-        start.column += has_seperating_comma_before ? skip_comma : skip_bracket;
+        // Add spacing for inline positioning
+        const hasSpacing = hasSeparatingCommaBefore || (!hasCommaHandling && !!previous);
+        if (hasSpacing && hasCommaHandling) {
+            start.column += skipCommaSpace;
+        }
+        else if (hasSpacing || (hasCommaHandling && !previous)) {
+            start.column += skipBracketSpace;
+        }
     }
     start.line += leading_lines;
     const shift = {
@@ -1259,12 +1700,74 @@ function insertInline(parent, child, index) {
     };
     // Apply offsets after child node
     const child_span = getSpan(child.loc);
+    if (!hasCommaHandling) {
+        // For documents or contexts without comma handling, simpler offset calculation
+        const offset = {
+            lines: child_span.lines + (leading_lines - 1),
+            columns: child_span.columns
+        };
+        return { shift, offset };
+    }
+    // Special case: Fix trailing comma spacing issue for arrays that have trailing commas
+    const has_trailing_comma_spacing_bug = hasSeparatingCommaBefore &&
+        hasTrailingComma &&
+        !hasSeparatingCommaAfter &&
+        isLastElement;
+    let trailing_comma_offset_adjustment = 0;
+    if (has_trailing_comma_spacing_bug) {
+        trailing_comma_offset_adjustment = -1;
+    }
     const offset = {
         lines: child_span.lines + (leading_lines - 1),
-        columns: child_span.columns + (has_seperating_comma_before || has_seperating_comma_after ? 2 : 0) + (has_trailing_comma ? 1 : 0)
+        columns: child_span.columns +
+            (hasSeparatingCommaBefore || hasSeparatingCommaAfter ? skipCommaSpace : 0) +
+            (hasTrailingComma ? 1 + trailing_comma_offset_adjustment : 0)
     };
     return { shift, offset };
 }
+function insertInline(parent, child, index) {
+    if (!isInlineItem(child)) {
+        throw new Error(`Incompatible child type "${child.type}"`);
+    }
+    // Store preceding node and insert
+    const previous = index != null ? parent.items[index - 1] : last(parent.items);
+    const is_last = index == null || index === parent.items.length;
+    parent.items.splice(index, 0, child);
+    // Add commas as-needed
+    const has_separating_comma_before = !!previous;
+    const has_separating_comma_after = !is_last;
+    if (has_separating_comma_before) {
+        previous.comma = true;
+    }
+    if (has_separating_comma_after) {
+        child.comma = true;
+    }
+    // Use new line for inline arrays that span multiple lines
+    const use_new_line = isInlineArray(parent) && perLine(parent);
+    const has_trailing_comma = is_last && child.comma === true;
+    return calculateInlinePositioning(parent, child, index, {
+        useNewLine: use_new_line,
+        hasCommaHandling: true,
+        isLastElement: is_last,
+        hasSeparatingCommaBefore: has_separating_comma_before,
+        hasSeparatingCommaAfter: has_separating_comma_after,
+        hasTrailingComma: has_trailing_comma
+    });
+}
+/**
+ * Inserts a child into a Document with inline positioning behavior.
+ * This provides inline-style spacing while maintaining Document's Block item types.
+ */
+function insertInlineAtRoot(parent, child, index) {
+    // Calculate positioning as if inserting into an inline context
+    const result = calculateInlinePositioning(parent, child, index, {
+        useNewLine: false,
+        hasCommaHandling: false
+    });
+    // Insert the child directly into the Document (as a Block item)
+    parent.items.splice(index, 0, child);
+    return result;
+}
 function remove(root, parent, node) {
     // Remove an element from the parent's items
     // (supports Document, Table, TableArray, InlineTable, and InlineArray
@@ -1322,6 +1825,11 @@ function remove(root, parent, node) {
         lines: -(removed_span.lines - (keep_line ? 1 : 0)),
         columns: -removed_span.columns
     };
+    // If there is nothing left, don't perform any offsets
+    if (previous === undefined && next === undefined) {
+        offset.lines = 0;
+        offset.columns = 0;
+    }
     // Offset for comma and remove comma that appear in front of the element (if-needed)
     if (is_inline && previous_on_same_line) {
         offset.columns -= 2;
@@ -1331,7 +1839,15 @@ function remove(root, parent, node) {
         offset.columns -= 2;
     }
     if (is_inline && previous && !next) {
-        previous.comma = false;
+        // When removing the last element, preserve trailing comma preference
+        // If the removed element had a trailing comma, transfer it to the new last element
+        const removedHadTrailingComma = node.comma;
+        if (removedHadTrailingComma) {
+            previous.comma = true;
+        }
+        else {
+            previous.comma = false;
+        }
     }
     // Apply offsets after preceding node or before children of parent node
     const target = previous || parent;
@@ -1492,6 +2008,11 @@ function addOffset(offset, offsets, node, from) {
     offsets.set(node, offset);
 }
 
+/**
+ * Generates a new TOML document node.
+ *
+ * @returns A new Document node.
+ */
 function generateDocument() {
     return {
         type: NodeType.Document,
@@ -1571,7 +2092,7 @@ function generateKeyValue(key, value) {
         value
     };
 }
-const IS_BARE_KEY = /[\w,\d,\_,\-]+/;
+const IS_BARE_KEY = /^[\w-]+$/;
 function keyValueToRaw(value) {
     return value.map(part => (IS_BARE_KEY.test(part) ? part : JSON.stringify(part))).join('.');
 }
@@ -1603,7 +2124,22 @@ function generateInteger(value) {
     };
 }
 function generateFloat(value) {
-    const raw = value.toString();
+    let raw;
+    if (value === Infinity) {
+        raw = 'inf';
+    }
+    else if (value === -Infinity) {
+        raw = '-inf';
+    }
+    else if (Number.isNaN(value)) {
+        raw = 'nan';
+    }
+    else if (Object.is(value, -0)) {
+        raw = '-0.0';
+    }
+    else {
+        raw = value.toString();
+    }
     return {
         type: NodeType.Float,
         loc: { start: zero(), end: { line: 1, column: raw.length } },
@@ -1619,6 +2155,8 @@ function generateBoolean(value) {
     };
 }
 function generateDateTime(value) {
+    // Custom date classes have their own toISOString() implementations
+    // that return the properly formatted strings for each TOML date/time type
     const raw = value.toISOString();
     return {
         type: NodeType.DateTime,
@@ -1650,7 +2188,382 @@ function generateInlineTable() {
     };
 }
 
-function formatTopLevel(document) {
+// Default formatting values
+const DEFAULT_NEWLINE = '\n';
+const DEFAULT_TRAILING_NEWLINE = 1;
+const DEFAULT_TRAILING_COMMA = false;
+const DEFAULT_BRACKET_SPACING = true;
+const DEFAULT_INLINE_TABLE_START = 1;
+// 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) {
+    // Convert iterable to array and look for the first inline array or inline table to determine trailing comma preference
+    const items = Array.from(ast);
+    for (const item of items) {
+        const result = findTrailingCommaInNode(item);
+        if (result !== null) {
+            return result;
+        }
+    }
+    // Return default if no comma-separated structures are found
+    return DEFAULT_TRAILING_COMMA;
+}
+// Detects if bracket spacing is used in inline arrays and tables by examining the raw string
+// Returns true if bracket spacing is found, false if not or no bracket structures found (default to true)
+function detectBracketSpacing(tomlString, ast) {
+    // Convert iterable to array and look for inline arrays and tables
+    const items = Array.from(ast);
+    for (const item of items) {
+        const result = findBracketSpacingInNode(item, tomlString);
+        if (result !== null) {
+            return result;
+        }
+    }
+    // Return default if no bracket structures are found
+    return DEFAULT_BRACKET_SPACING;
+}
+// Helper function to recursively search for bracket spacing in a node
+function findBracketSpacingInNode(node, tomlString) {
+    if (!node || typeof node !== 'object') {
+        return null;
+    }
+    // Check if this is an InlineArray or InlineTable
+    if ((node.type === 'InlineArray' || node.type === 'InlineTable') && node.loc) {
+        const bracketSpacing = checkBracketSpacingInLocation(node.loc, tomlString);
+        if (bracketSpacing !== null) {
+            return bracketSpacing;
+        }
+    }
+    // Recursively check nested structures
+    if (node.items && Array.isArray(node.items)) {
+        for (const child of node.items) {
+            const result = findBracketSpacingInNode(child, tomlString);
+            if (result !== null) {
+                return result;
+            }
+            // Also check nested item if it exists
+            if (child.item) {
+                const nestedResult = findBracketSpacingInNode(child.item, tomlString);
+                if (nestedResult !== null) {
+                    return nestedResult;
+                }
+            }
+        }
+    }
+    // Check other properties that might contain nodes
+    for (const prop of ['value', 'key', 'item']) {
+        if (node[prop]) {
+            const result = findBracketSpacingInNode(node[prop], tomlString);
+            if (result !== null) {
+                return result;
+            }
+        }
+    }
+    return null;
+}
+// Helper function to check bracket spacing in a specific location
+function checkBracketSpacingInLocation(loc, tomlString) {
+    var _a;
+    if (!loc || !loc.start || !loc.end) {
+        return null;
+    }
+    // Extract the raw text for this location
+    const lines = tomlString.split(/\r?\n/);
+    const startLine = loc.start.line - 1; // Convert to 0-based
+    const endLine = loc.end.line - 1;
+    const startCol = loc.start.column;
+    const endCol = loc.end.column;
+    let rawText = '';
+    if (startLine === endLine) {
+        rawText = ((_a = lines[startLine]) === null || _a === void 0 ? void 0 : _a.substring(startCol, endCol + 1)) || '';
+    }
+    else {
+        // Multi-line case
+        if (lines[startLine]) {
+            rawText += lines[startLine].substring(startCol);
+        }
+        for (let i = startLine + 1; i < endLine; i++) {
+            rawText += '\n' + (lines[i] || '');
+        }
+        if (lines[endLine]) {
+            rawText += '\n' + lines[endLine].substring(0, endCol + 1);
+        }
+    }
+    // Check for bracket spacing patterns
+    // For arrays: [ elements ] vs [elements]
+    // For tables: { elements } vs {elements}
+    const arrayMatch = rawText.match(/^\[(\s*)/);
+    const tableMatch = rawText.match(/^\{(\s*)/);
+    if (arrayMatch) {
+        // Check if there's a space after the opening bracket
+        return arrayMatch[1].length > 0;
+    }
+    if (tableMatch) {
+        // Check if there's a space after the opening brace
+        return tableMatch[1].length > 0;
+    }
+    return null;
+}
+// Helper function to recursively search for comma usage in a node
+function findTrailingCommaInNode(node) {
+    if (!node || typeof node !== 'object') {
+        return null;
+    }
+    // Check if this is an InlineArray
+    if (node.type === 'InlineArray' && node.items && Array.isArray(node.items)) {
+        return checkTrailingCommaInItems(node.items);
+    }
+    // Check if this is an InlineTable
+    if (node.type === 'InlineTable' && node.items && Array.isArray(node.items)) {
+        return checkTrailingCommaInItems(node.items);
+    }
+    // Check if this is a KeyValue with a value that might contain arrays/tables
+    if (node.type === 'KeyValue' && node.value) {
+        return findTrailingCommaInNode(node.value);
+    }
+    // For other node types, recursively check any items array
+    if (node.items && Array.isArray(node.items)) {
+        for (const item of node.items) {
+            const result = findTrailingCommaInNode(item);
+            if (result !== null) {
+                return result;
+            }
+        }
+    }
+    return null;
+}
+// Check trailing comma usage in an array of inline items
+function checkTrailingCommaInItems(items) {
+    if (items.length === 0) {
+        return null;
+    }
+    // Check the last item to see if it has a trailing comma
+    const lastItem = items[items.length - 1];
+    if (lastItem && typeof lastItem === 'object' && 'comma' in lastItem) {
+        return lastItem.comma === true;
+    }
+    return false;
+}
+// Helper function to detect if an InlineArray originally had trailing commas
+function arrayHadTrailingCommas(node) {
+    if (!isInlineArray(node))
+        return false;
+    if (node.items.length === 0)
+        return false;
+    // Check if the last item has a trailing comma
+    const lastItem = node.items[node.items.length - 1];
+    return lastItem.comma === true;
+}
+// Helper function to detect if an InlineTable originally had trailing commas
+function tableHadTrailingCommas(node) {
+    if (!isInlineTable(node))
+        return false;
+    if (node.items.length === 0)
+        return false;
+    // Check if the last item has a trailing comma
+    const lastItem = node.items[node.items.length - 1];
+    return lastItem.comma === true;
+}
+// Returns the detected newline (\n or \r\n) from a string, defaulting to \n
+function detectNewline(str) {
+    const lfIndex = str.indexOf('\n');
+    if (lfIndex > 0 && str.substring(lfIndex - 1, lfIndex) === '\r') {
+        return '\r\n';
+    }
+    return '\n';
+}
+// Counts consecutive trailing newlines at the end of a string
+function countTrailingNewlines(str, newlineChar) {
+    let count = 0;
+    let pos = str.length;
+    while (pos >= newlineChar.length) {
+        if (str.substring(pos - newlineChar.length, pos) === newlineChar) {
+            count++;
+            pos -= newlineChar.length;
+        }
+        else {
+            break;
+        }
+    }
+    return count;
+}
+/**
+ * Validates a format object and warns about unsupported properties.
+ * Throws errors for supported properties with invalid types.
+ * @param format - The format object to validate
+ * @returns The validated format object with only supported properties and correct types
+ */
+function validateFormatObject(format) {
+    if (!format || typeof format !== 'object') {
+        return {};
+    }
+    const supportedProperties = new Set(['newLine', 'trailingNewline', 'trailingComma', 'bracketSpacing', 'inlineTableStart']);
+    const validatedFormat = {};
+    const unsupportedProperties = [];
+    const invalidTypeProperties = [];
+    // Check all enumerable properties of the format object
+    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':
+                        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);
+            }
+        }
+    }
+    // Warn about unsupported properties
+    if (unsupportedProperties.length > 0) {
+        console.warn(`toml-patch: Ignoring unsupported format properties: ${unsupportedProperties.join(', ')}. Supported properties are: ${Array.from(supportedProperties).join(', ')}`);
+    }
+    // Throw error for invalid types
+    if (invalidTypeProperties.length > 0) {
+        throw new TypeError(`Invalid types for format properties: ${invalidTypeProperties.join(', ')}`);
+    }
+    return validatedFormat;
+}
+/**
+ * Resolves a format parameter to a TomlFormat instance.
+ * Handles TomlFormat instances and partial TomlFormat objects as well as undefined.
+ *
+ * @param format - The format parameter to resolve (TomlFormat instance, partial format object, or undefined)
+ * @param fallbackFormat - The fallback TomlFormat to use when no format is provided
+ * @returns A resolved TomlFormat instance
+ */
+function resolveTomlFormat(format, fallbackFormat) {
+    var _a, _b, _c, _d;
+    if (format) {
+        // If format is provided, validate and merge it with fallback
+        if (format instanceof TomlFormat) {
+            return format;
+        }
+        else {
+            // 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);
+        }
+    }
+    else {
+        // Use fallback format when no format is provided
+        return fallbackFormat;
+    }
+}
+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) {
+        // 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;
+        this.trailingComma = trailingComma !== null && trailingComma !== void 0 ? trailingComma : DEFAULT_TRAILING_COMMA;
+        this.bracketSpacing = bracketSpacing !== null && bracketSpacing !== void 0 ? bracketSpacing : DEFAULT_BRACKET_SPACING;
+        this.inlineTableStart = inlineTableStart !== null && inlineTableStart !== void 0 ? inlineTableStart : DEFAULT_INLINE_TABLE_START;
+    }
+    /**
+     * Creates a new TomlFormat instance with default formatting preferences.
+     *
+     * @returns A new TomlFormat instance with default values:
+     *   - newLine: '\n'
+     *   - trailingNewline: 1
+     *   - trailingComma: false
+     *   - bracketSpacing: true
+     *   - inlineTableStart: 1
+     */
+    static default() {
+        return new TomlFormat(DEFAULT_NEWLINE, DEFAULT_TRAILING_NEWLINE, DEFAULT_TRAILING_COMMA, DEFAULT_BRACKET_SPACING, DEFAULT_INLINE_TABLE_START);
+    }
+    /**
+     * Auto-detects formatting preferences from an existing TOML string.
+     *
+     * This method analyzes the provided TOML string to determine formatting
+     * preferences such as line endings, trailing newlines, and comma usage.
+     *
+     * @param tomlString - The TOML string to analyze for formatting patterns
+     * @returns A new TomlFormat instance with detected formatting preferences
+     *
+     * @example
+     * ```typescript
+     * const toml = 'array = ["a", "b", "c",]\ntable = { x = 1, y = 2, }';
+     * const format = TomlFormat.autoDetectFormat(toml);
+     * // format.trailingComma will be true
+     * // format.newLine will be '\n'
+     * // format.trailingNewline will be 0 (no trailing newline)
+     * ```
+     */
+    static autoDetectFormat(tomlString) {
+        const format = TomlFormat.default();
+        // Detect line ending style
+        format.newLine = detectNewline(tomlString);
+        // Detect trailing newline count
+        format.trailingNewline = countTrailingNewlines(tomlString, format.newLine);
+        // Parse the TOML to detect comma and bracket spacing usage patterns
+        try {
+            const ast = parseTOML(tomlString);
+            // Convert to array once to avoid consuming the iterator multiple times
+            const astArray = Array.from(ast);
+            format.trailingComma = detectTrailingComma(astArray);
+            format.bracketSpacing = detectBracketSpacing(tomlString, astArray);
+        }
+        catch (error) {
+            // If parsing fails, fall back to defaults
+            // This ensures the method is robust against malformed TOML
+            format.trailingComma = DEFAULT_TRAILING_COMMA;
+            format.bracketSpacing = DEFAULT_BRACKET_SPACING;
+        }
+        // inlineTableStart uses default value since auto-detection would require
+        // complex analysis of nested table formatting preferences
+        format.inlineTableStart = DEFAULT_INLINE_TABLE_START;
+        return format;
+    }
+}
+function formatTopLevel(document, format) {
+    // If inlineTableStart is 0, convert all top-level tables to inline tables
+    if (format.inlineTableStart === 0) {
+        return document;
+    }
     const move_to_top_level = document.items.filter(item => {
         if (!isKeyValue(item))
             return false;
@@ -1658,7 +2571,12 @@ function formatTopLevel(document) {
         const is_inline_array = isInlineArray(item.value) &&
             item.value.items.length &&
             isInlineTable(item.value.items[0].item);
-        return is_inline_table || is_inline_array;
+        // Only move to top level if the depth is less than inlineTableStart
+        if (is_inline_table || is_inline_array) {
+            const depth = calculateTableDepth(item.key.value);
+            return format.inlineTableStart === undefined || depth < format.inlineTableStart;
+        }
+        return false;
     });
     move_to_top_level.forEach(node => {
         remove(document, document, node);
@@ -1694,6 +2612,109 @@ function formatTableArray(key_value) {
     applyWrites(root);
     return root.items;
 }
+/**
+ * Updates a table's location end position after removing inline table items.
+ * When inline table content is removed from a parent table, the parent table's
+ * end position needs to be adjusted to reflect where the content actually ends.
+ *
+ * @param table - The table whose end position should be updated
+ */
+function postInlineItemRemovalAdjustment(table) {
+    if (table.items.length > 0) {
+        const lastItem = table.items[table.items.length - 1];
+        table.loc.end.line = lastItem.loc.end.line;
+        table.loc.end.column = lastItem.loc.end.column;
+    }
+    else {
+        // If no items left, table ends at the header line
+        table.loc.end.line = table.key.loc.end.line;
+        table.loc.end.column = table.key.loc.end.column;
+    }
+}
+/**
+ * Calculates the nesting depth of a table based on its key path.
+ * Root level tables (e.g., [table]) have depth 0.
+ * First level nested tables (e.g., [table.nested]) have depth 1.
+ *
+ * @param keyPath - Array representing the table key path (e.g., ['table', 'nested'])
+ * @returns The nesting depth (0 for root level, 1+ for nested levels)
+ */
+function calculateTableDepth(keyPath) {
+    return Math.max(0, keyPath.length - 1);
+}
+/**
+ * Converts nested inline tables to separate table sections based on the inlineTableStart depth setting.
+ * This function recursively processes all tables in the document and extracts inline tables that are
+ * at a depth less than the inlineTableStart threshold.
+ */
+function formatNestedTablesMultiline(document, format) {
+    // If inlineTableStart is undefined, use the default behavior (no conversion)
+    // If inlineTableStart is 0, all should be inline (no conversion)
+    if (format.inlineTableStart === undefined || format.inlineTableStart === 0) {
+        return document;
+    }
+    const additionalTables = [];
+    // Process all existing tables for nested inline tables
+    for (const item of document.items) {
+        if (isKeyValue(item) && isInlineTable(item.value)) {
+            // This is a top-level inline table (depth 0)
+            const depth = calculateTableDepth(item.key.value);
+            if (depth < format.inlineTableStart) {
+                // Convert to a separate table
+                const table = formatTable(item);
+                // Remove the original inline table item
+                remove(document, document, item);
+                // Add the new table
+                insert(document, document, table);
+                // Process this table for further nested inlines
+                processTableForNestedInlines(table, additionalTables, format);
+            }
+        }
+        else if (item.type === 'Table') {
+            // Process existing table for nested inline tables
+            processTableForNestedInlines(item, additionalTables, format);
+        }
+    }
+    // Add all the additional tables to the document
+    for (const table of additionalTables) {
+        insert(document, document, table);
+    }
+    applyWrites(document);
+    return document;
+}
+/**
+ * Recursively processes a table for nested inline tables and extracts them as separate tables
+ * when they are at a depth less than the inlineTableStart threshold.
+ */
+function processTableForNestedInlines(table, additionalTables, format) {
+    var _a;
+    // Process from end to beginning to avoid index issues when removing items
+    for (let i = table.items.length - 1; i >= 0; i--) {
+        const item = table.items[i];
+        if (isKeyValue(item) && isInlineTable(item.value)) {
+            // Calculate the depth of this nested table
+            const nestedTableKey = [...table.key.item.value, ...item.key.value];
+            const depth = calculateTableDepth(nestedTableKey);
+            // Only convert to separate table if depth is less than inlineTableStart
+            if (depth < ((_a = format.inlineTableStart) !== null && _a !== void 0 ? _a : 1)) {
+                // Convert this inline table to a separate table section
+                const separateTable = generateTable(nestedTableKey);
+                // Move all items from the inline table to the separate table
+                for (const inlineItem of item.value.items) {
+                    insert(separateTable, separateTable, inlineItem.item);
+                }
+                // Remove this item from the original table
+                remove(table, table, item);
+                // Update the parent table's end position after removal
+                postInlineItemRemovalAdjustment(table);
+                // Add this table to be inserted into the document
+                additionalTables.push(separateTable);
+                // Recursively process the new table for further nested inlines
+                processTableForNestedInlines(separateTable, additionalTables, format);
+            }
+        }
+    }
+}
 function formatPrintWidth(document, format) {
     // TODO
     return document;
@@ -1718,13 +2739,7 @@ function formatEmptyLines(document) {
     return document;
 }
 
-const default_format = {
-    printWidth: 80,
-    trailingComma: false,
-    bracketSpacing: true
-};
-function parseJS(value, format = {}) {
-    format = Object.assign({}, default_format, format);
+function parseJS(value, format = TomlFormat.default()) {
     value = toJSON(value);
     // Reorder the elements in the object
     value = reorderElements(value);
@@ -1736,26 +2751,39 @@ function parseJS(value, format = {}) {
     // Heuristics:
     // 1. Top-level objects/arrays should be tables/table arrays
     // 2. Convert objects/arrays to tables/table arrays based on print width
-    const formatted = pipe(document, formatTopLevel, document => formatPrintWidth(document), formatEmptyLines);
-    return formatted;
+    // 3. Convert nested inline tables to separate tables based on preferNestedTablesMultiline
+    const formatted = pipe(document, document => formatTopLevel(document, format), document => formatNestedTablesMultiline(document, format), document => formatPrintWidth(document));
+    // Apply formatEmptyLines only once at the end
+    return formatEmptyLines(formatted);
 }
 /**
 This function makes sure that properties that are simple values (not objects or arrays) are ordered first,
 and that objects and arrays are ordered last. This makes parseJS more reliable and easier to test.
 */
 function reorderElements(value) {
-    let result = {};
-    // First add all simple values
-    for (const key in value) {
-        if (!isObject(value[key]) && !Array.isArray(value[key])) {
-            result[key] = value[key];
-        }
-    }
-    // Then add all objects and arrays
+    // Pre-sort keys to avoid multiple iterations
+    const simpleKeys = [];
+    const complexKeys = [];
+    // Separate keys in a single pass
     for (const key in value) {
         if (isObject(value[key]) || Array.isArray(value[key])) {
-            result[key] = value[key];
+            complexKeys.push(key);
         }
+        else {
+            simpleKeys.push(key);
+        }
+    }
+    // Create result with the correct order
+    const result = {};
+    // Add simple values first
+    for (let i = 0; i < simpleKeys.length; i++) {
+        const key = simpleKeys[i];
+        result[key] = value[key];
+    }
+    // Then add complex values
+    for (let i = 0; i < complexKeys.length; i++) {
+        const key = complexKeys[i];
+        result[key] = value[key];
     }
     return result;
 }
@@ -1841,7 +2869,25 @@ function toJSON(value) {
 }
 
 const BY_NEW_LINE = /(\r\n|\n)/g;
-function toTOML(ast, newline = '\n') {
+/**
+ * Converts an Abstract Syntax Tree (AST) back to TOML format string.
+ *
+ * This function traverses the AST and reconstructs the original TOML document
+ * by writing each node's raw content to the appropriate location coordinates.
+ * 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)
+ * @returns The reconstructed TOML document as a string
+ *
+ * @example
+ * ```typescript
+ * const tomlString = toTOML(ast, '\n', { trailingNewline: 1 });
+ * ```
+ */
+function toTOML(ast, format) {
     const lines = [];
     traverse(ast, {
         [NodeType.TableKey](node) {
@@ -1896,8 +2942,34 @@ function toTOML(ast, newline = '\n') {
             write(lines, node.loc, node.raw);
         }
     });
-    return lines.join(newline) + newline;
+    return lines.join(format.newLine) + format.newLine.repeat(format.trailingNewline);
 }
+/**
+ * Writes raw string content to specific location coordinates within a lines array.
+ *
+ * This function is responsible for placing TOML content at precise positions within
+ * the output lines, handling multi-line content and preserving existing content
+ * around the target location.
+ *
+ * @param lines - Array of string lines representing the TOML document being built.
+ *                Lines are 1-indexed but stored in 0-indexed array.
+ * @param loc - Location object specifying where to write the content, containing:
+ *              - start: { line: number, column: number } - Starting position (1-indexed line, 0-indexed column)
+ *              - 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.
+ *
+ * @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
+ *
+ * @example
+ * ```typescript
+ * const lines = ['', ''];
+ * const location = { start: { line: 1, column: 0 }, end: { line: 1, column: 3 } };
+ * write(lines, location, 'key');
+ * // Result: lines[0] becomes 'key'
+ * ```
+ */
 function write(lines, loc, raw) {
     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;
@@ -1906,6 +2978,10 @@ function write(lines, loc, raw) {
     }
     for (let i = loc.start.line; i <= loc.end.line; i++) {
         const line = getLine(lines, i);
+        //Throw if line is uninitialized
+        if (line === undefined) {
+            throw new Error(`Line ${i} is uninitialized when writing "${raw}" at ${loc.start.line}:${loc.start.column} to ${loc.end.line}:${loc.end.column}`);
+        }
         const is_start_line = i === loc.start.line;
         const is_end_line = i === loc.end.line;
         const before = is_start_line
@@ -1915,6 +2991,24 @@ function write(lines, loc, raw) {
         lines[i - 1] = before + raw_lines[i - loc.start.line] + after;
     }
 }
+/**
+ * Safely retrieves a line from the lines array, initializing empty lines as needed.
+ *
+ * This helper function handles the conversion between 1-indexed line numbers (used in locations)
+ * and 0-indexed array positions. It ensures that accessing a line that doesn't exist yet
+ * will initialize all preceding lines with empty strings.
+ *
+ * @param lines - Array of string lines representing the document
+ * @param index - 1-indexed line number to retrieve
+ * @returns The line content as a string, or empty string for new lines
+ *
+ * @example
+ * ```typescript
+ * const lines = ['first line'];
+ * const line = getLine(lines, 3); // Initializes lines[1] and lines[2] as empty strings
+ * // lines becomes ['first line', '', '']
+ * ```
+ */
 function getLine(lines, index) {
     if (!lines[index - 1]) {
         for (let i = 0; i < index; i++) {
@@ -1925,14 +3019,20 @@ function getLine(lines, index) {
     return lines[index - 1];
 }
 
+/**
+ * Converts the given AST to a JavaScript object.
+ *
+ * @param ast The abstract syntax tree to convert.
+ * @param input The original input string (used for error reporting).
+ * @returns The JavaScript object representation of the AST.
+ */
 function toJS(ast, input = '') {
     const result = blank();
     const tables = new Set();
     const table_arrays = new Set();
     const defined = new Set();
     let active = result;
-    let previous_active;
-    let skip = false;
+    let skip_depth = 0;
     traverse(ast, {
         [NodeType.Table](node) {
             const key = node.key.item.value;
@@ -1964,7 +3064,7 @@ function toJS(ast, input = '') {
         },
         [NodeType.KeyValue]: {
             enter(node) {
-                if (skip)
+                if (skip_depth > 0)
                     return;
                 const key = node.key.value;
                 try {
@@ -1978,24 +3078,15 @@ function toJS(ast, input = '') {
                 const target = key.length > 1 ? ensureTable(active, key.slice(0, -1)) : active;
                 target[last(key)] = value;
                 defined.add(joinKey(key));
-                if (isInlineTable(node.value)) {
-                    previous_active = active;
-                    active = value;
-                }
-            },
-            exit(node) {
-                if (isInlineTable(node.value)) {
-                    active = previous_active;
-                }
             }
         },
         [NodeType.InlineTable]: {
             enter() {
                 // Handled by toValue
-                skip = true;
+                skip_depth++;
             },
             exit() {
-                skip = false;
+                skip_depth--;
             }
         }
     });
@@ -2226,8 +3317,13 @@ function compareArrays(before, after, path = []) {
 }
 
 function findByPath(node, path) {
-    if (!path.length)
+    if (!path.length) {
+        // If this is an InlineItem containing a KeyValue, return the KeyValue
+        if (isInlineItem(node) && isKeyValue(node.item)) {
+            return node.item;
+        }
         return node;
+    }
     if (isKeyValue(node)) {
         return findByPath(node.value, path);
     }
@@ -2310,6 +3406,12 @@ function findParent(node, path) {
  */
 function patch(existing, updated, format) {
     const existing_ast = parseTOML(existing);
+    // Auto-detect formatting preferences from the existing TOML string for fallback
+    const autoDetectedFormat = TomlFormat.autoDetectFormat(existing);
+    const fmt = resolveTomlFormat(format, autoDetectedFormat);
+    return patchAst(existing_ast, updated, fmt).tomlString;
+}
+function patchAst(existing_ast, updated, format) {
     const items = [...existing_ast];
     const existing_js = toJS(items);
     const existing_document = {
@@ -2317,12 +3419,27 @@ function patch(existing, updated, format) {
         loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
         items
     };
-    const updated_document = parseJS(updated, format);
+    // Certain formatting options should not be applied to the updated document during patching, because it would
+    // override the existing formatting too aggressively. For example, preferNestedTablesMultiline would
+    // convert all nested tables to multiline, which is not be desired during patching.
+    // Therefore, we create a modified format for generating the updated document used for diffing.
+    const diffing_fmt = resolveTomlFormat(Object.assign(Object.assign({}, format), { inlineTableStart: undefined }), format);
+    const updated_document = parseJS(updated, diffing_fmt);
     const changes = reorder(diff(existing_js, updated));
-    const patched_document = applyChanges(existing_document, updated_document, changes);
+    if (changes.length === 0) {
+        return {
+            tomlString: toTOML(items, format),
+            document: existing_document
+        };
+    }
+    const patched_document = applyChanges(existing_document, updated_document, changes, format);
     // Validate the patched_document
+    // This would prevent overlapping element positions in the AST, but since those are handled at stringification time, we can skip this for now
     //validate(patched_document);
-    return toTOML(patched_document.items);
+    return {
+        tomlString: toTOML(patched_document.items, format),
+        document: patched_document
+    };
 }
 function reorder(changes) {
     for (let i = 0; i < changes.length; i++) {
@@ -2345,7 +3462,30 @@ function reorder(changes) {
     }
     return changes;
 }
-function applyChanges(original, updated, changes) {
+/**
+ * Applies a list of changes to the original TOML document AST while preserving formatting and structure.
+ *
+ * This function processes different types of changes (Add, Edit, Remove, Move, Rename) and applies them
+ * to the original document in a way that maintains the existing formatting preferences, comments, and
+ * structural elements as much as possible. Special handling is provided for different node types like
+ * inline tables, arrays, and table arrays to ensure proper formatting consistency.
+ *
+ * @param original - The original TOML document AST to be modified
+ * @param updated - The updated document AST containing new values for changes
+ * @param changes - Array of change objects describing what modifications to apply
+ * @param format - Formatting preferences to use for newly added elements
+ * @returns The modified original document with all changes applied
+ *
+ * @example
+ * ```typescript
+ * const changes = [
+ *   { type: 'add', path: ['newKey'], value: 'newValue' },
+ *   { type: 'edit', path: ['existingKey'], value: 'updatedValue' }
+ * ];
+ * const result = applyChanges(originalDoc, updatedDoc, changes, format);
+ * ```
+ */
+function applyChanges(original, updated, changes, format) {
     // Potential Changes:
     //
     // Add: Add key-value to object, add item to array
@@ -2367,6 +3507,7 @@ function applyChanges(original, updated, changes) {
                     is_table_array = true;
                 }
             }
+            // Determine the parent node where the new child will be inserted
             let parent;
             if (isTable(child)) {
                 parent = original;
@@ -2390,14 +3531,71 @@ function applyChanges(original, updated, changes) {
             }
             else {
                 parent = findParent(original, change.path);
-                if (isKeyValue(parent))
+                if (isKeyValue(parent)) {
                     parent = parent.value;
+                }
             }
             if (isTableArray(parent) || isInlineArray(parent) || isDocument(parent)) {
-                insert(original, parent, child, index);
+                // Special handling for InlineArray: preserve original trailing comma format
+                if (isInlineArray(parent)) {
+                    const originalHadTrailingCommas = arrayHadTrailingCommas(parent);
+                    // If this is an InlineItem being added to an array, check its comma setting
+                    if (isInlineItem(child)) {
+                        // The child comes from the updated document with global format applied
+                        // Override with the original array's format
+                        child.comma = originalHadTrailingCommas;
+                    }
+                }
+                // Check if we should convert nested inline tables to multiline tables
+                if (format.inlineTableStart !== undefined && format.inlineTableStart > 0 && isDocument(parent) && isTable(child)) {
+                    const additionalTables = convertNestedInlineTablesToMultiline(child, original, format);
+                    // Insert the main table first
+                    insert(original, parent, child, index);
+                    // Then insert all the additional tables
+                    for (const table of additionalTables) {
+                        insert(original, original, table, undefined);
+                    }
+                }
+                else {
+                    insert(original, parent, child, index);
+                }
+            }
+            else if (isInlineTable(parent)) {
+                // Special handling for adding KeyValue to InlineTable
+                // Preserve original trailing comma format
+                const originalHadTrailingCommas = tableHadTrailingCommas(parent);
+                // InlineTable items must be wrapped in InlineItem
+                if (isKeyValue(child)) {
+                    const inlineItem = generateInlineItem(child);
+                    // Override with the original table's format
+                    inlineItem.comma = originalHadTrailingCommas;
+                    insert(original, parent, inlineItem);
+                }
+                else {
+                    insert(original, parent, child);
+                }
             }
             else {
-                insert(original, parent, child);
+                // Check if we should convert inline tables to multiline tables when adding to existing tables
+                if (format.inlineTableStart !== undefined && format.inlineTableStart > 0 && isKeyValue(child) && isInlineTable(child.value) && isTable(parent)) {
+                    // Calculate the depth of the inline table that would be created
+                    const baseTableKey = parent.key.item.value;
+                    const nestedTableKey = [...baseTableKey, ...child.key.value];
+                    const depth = calculateTableDepth(nestedTableKey);
+                    // Convert to separate section only if depth is less than inlineTableStart
+                    if (depth < format.inlineTableStart) {
+                        convertInlineTableToSeparateSection(child, parent, original, format);
+                    }
+                    else {
+                        insert(original, parent, child);
+                    }
+                }
+                else if (format.inlineTableStart === 0 && isKeyValue(child) && isInlineTable(child.value) && isDocument(parent)) {
+                    insert(original, parent, child, undefined, true);
+                }
+                else {
+                    insert(original, parent, child);
+                }
             }
         }
         else if (isEdit(change)) {
@@ -2406,6 +3604,26 @@ function applyChanges(original, updated, changes) {
             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;
+                    }
+                }
                 parent = existing;
                 existing = existing.value;
                 replacement = replacement.value;
@@ -2417,8 +3635,23 @@ function applyChanges(original, updated, changes) {
                 existing = existing.value;
                 replacement = replacement.item.value;
             }
+            else if (isInlineItem(existing) && isKeyValue(replacement)) {
+                // Editing inline table item: existing is InlineItem, replacement is KeyValue
+                // We need to replace the KeyValue inside the InlineItem, preserving the InlineItem wrapper
+                parent = existing;
+                existing = existing.item;
+            }
             else {
                 parent = findParent(original, change.path);
+                // Special handling for array element edits
+                if (isKeyValue(parent)) {
+                    // Check if we're actually editing an array element
+                    const parentPath = change.path.slice(0, -1);
+                    const arrayNode = findByPath(original, parentPath);
+                    if (isKeyValue(arrayNode) && isInlineArray(arrayNode.value)) {
+                        parent = arrayNode.value;
+                    }
+                }
             }
             replace(original, parent, existing, replacement);
         }
@@ -2452,10 +3685,335 @@ function applyChanges(original, updated, changes) {
     applyWrites(original);
     return original;
 }
+/**
+ * Converts nested inline tables to separate table sections based on the inlineTableStart depth setting.
+ * This function recursively processes a table and extracts any inline tables within it,
+ * creating separate table sections with properly nested keys.
+ *
+ * @param table - The table to process for nested inline tables
+ * @param original - The original document for inserting new items
+ * @param format - The formatting options
+ * @returns Array of additional tables that should be added to the document
+ */
+function convertNestedInlineTablesToMultiline(table, original, format) {
+    const additionalTables = [];
+    const processTableForNestedInlines = (currentTable, tablesToAdd) => {
+        var _a;
+        for (let i = currentTable.items.length - 1; i >= 0; i--) {
+            const item = currentTable.items[i];
+            if (isKeyValue(item) && isInlineTable(item.value)) {
+                // Calculate the depth of this nested table
+                const nestedTableKey = [...currentTable.key.item.value, ...item.key.value];
+                const depth = calculateTableDepth(nestedTableKey);
+                // Only convert to separate table if depth is less than inlineTableStart
+                if (depth < ((_a = format.inlineTableStart) !== null && _a !== void 0 ? _a : 1) && format.inlineTableStart !== 0) {
+                    // Convert this inline table to a separate table section
+                    const separateTable = generateTable(nestedTableKey);
+                    // Move all items from the inline table to the separate table
+                    for (const inlineItem of item.value.items) {
+                        if (isInlineItem(inlineItem) && isKeyValue(inlineItem.item)) {
+                            insert(original, separateTable, inlineItem.item, undefined);
+                        }
+                    }
+                    // Remove this item from the original table
+                    currentTable.items.splice(i, 1);
+                    // Update the parent table's end position after removal
+                    postInlineItemRemovalAdjustment(currentTable);
+                    // Queue this table to be added to the document
+                    tablesToAdd.push(separateTable);
+                    // Recursively process the new table for further nested inlines
+                    processTableForNestedInlines(separateTable, tablesToAdd);
+                }
+            }
+        }
+    };
+    processTableForNestedInlines(table, additionalTables);
+    return additionalTables;
+}
+/**
+ * Converts an inline table to a separate table section when adding to an existing table.
+ * This function creates a new table section with the combined key path and moves all
+ * properties from the inline table to the separate table section.
+ *
+ * @param child - The KeyValue node with an InlineTable as its value
+ * @param parent - The parent table where the KeyValue would be added
+ * @param original - The original document for inserting new items
+ * @param format - The formatting options
+ */
+function convertInlineTableToSeparateSection(child, parent, original, format) {
+    // Convert the inline table to a separate table section
+    const baseTableKey = parent.key.item.value; // Get the parent table's key path
+    const nestedTableKey = [...baseTableKey, ...child.key.value]; // Combine with the new key
+    const separateTable = generateTable(nestedTableKey);
+    // We know child.value is an InlineTable from the calling context
+    if (isInlineTable(child.value)) {
+        // Move all items from the inline table to the separate table
+        for (const inlineItem of child.value.items) {
+            if (isInlineItem(inlineItem) && isKeyValue(inlineItem.item)) {
+                insert(original, separateTable, inlineItem.item, undefined);
+            }
+        }
+    }
+    // Add the separate table to the document
+    insert(original, original, separateTable, undefined);
+    // Update the parent table's end position since we're not adding the inline table to it
+    postInlineItemRemovalAdjustment(parent);
+    // Also handle any nested inline tables within the new table
+    const additionalTables = convertNestedInlineTablesToMultiline(separateTable, original, format);
+    for (const table of additionalTables) {
+        insert(original, original, table, undefined);
+    }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Compares two positions to determine their ordering.
+ * @param pos1 - First position
+ * @param pos2 - Second position
+ * @returns Negative if pos1 < pos2, 0 if equal, positive if pos1 > pos2
+ */
+function comparePositions(pos1, pos2) {
+    if (pos1.line !== pos2.line) {
+        return pos1.line - pos2.line;
+    }
+    return pos1.column - pos2.column;
+}
+/**
+ * Truncates an AST based on a position (line, column) in the source string.
+ *
+ * This function filters the AST to include only the nodes that end before
+ * the specified position. This ensures that blocks containing changes are
+ * excluded and can be reparsed. This is useful for incremental parsing scenarios
+ * where you want to keep only the unchanged portion of the AST.
+ *
+ * Special handling: If the truncation point falls within a Table or TableArray
+ * (e.g., in a comment inside the table), the entire table is excluded to ensure
+ * proper reparsing.
+ *
+ * @param ast - The AST to truncate
+ * @param line - The line number (1-indexed) at which to truncate
+ * @param column - The column number (0-indexed) at which to truncate
+ * @returns An object containing the truncated AST and the end position of the last included node
+ *
+ * @example
+ * ```typescript
+ * const ast = parseTOML(tomlString);
+ * // Get AST up to line 5, column 10 (only nodes that end before this position)
+ * const { truncatedAst, lastEndPosition } = truncateAst(ast, 5, 10);
+ * for (const node of truncatedAst) {
+ *   // process node
+ * }
+ * ```
+ */
+function truncateAst(ast, line, column) {
+    const limit = { line, column };
+    const nodes = [];
+    let lastEndPosition = null;
+    for (const node of ast) {
+        const nodeEndsBeforeLimit = comparePositions(node.loc.end, limit) < 0;
+        const nodeStartsBeforeLimit = comparePositions(node.loc.start, limit) < 0;
+        if (nodeEndsBeforeLimit) {
+            // Node completely ends before the limit - include it
+            nodes.push(node);
+            lastEndPosition = node.loc.end;
+        }
+        else if (nodeStartsBeforeLimit && !nodeEndsBeforeLimit) {
+            // Node starts before the limit but ends at or after it
+            // This means the truncation point is within this node
+            // For Table/TableArray nodes, don't include them if the change is inside
+            // This ensures the entire table gets reparsed
+            break;
+        }
+        else {
+            // Node starts at or after the limit - stop
+            break;
+        }
+    }
+    return {
+        truncatedAst: nodes,
+        lastEndPosition
+    };
+}
+
+var _TomlDocument_ast, _TomlDocument_currentTomlString, _TomlDocument_Format;
+/**
+ * TomlDocument encapsulates a TOML AST and provides methods to interact with it.
+ */
+class TomlDocument {
+    /**
+     * Initializes the TomlDocument with a TOML string, parsing it into an AST.
+     * @param tomlString - The TOML string to parse
+     */
+    constructor(tomlString) {
+        _TomlDocument_ast.set(this, void 0);
+        _TomlDocument_currentTomlString.set(this, void 0);
+        _TomlDocument_Format.set(this, void 0);
+        __classPrivateFieldSet(this, _TomlDocument_currentTomlString, tomlString, "f");
+        __classPrivateFieldSet(this, _TomlDocument_ast, Array.from(parseTOML(tomlString)), "f");
+        // Auto-detect formatting preferences from the original TOML string
+        __classPrivateFieldSet(this, _TomlDocument_Format, TomlFormat.autoDetectFormat(tomlString), "f");
+    }
+    get toTomlString() {
+        return __classPrivateFieldGet(this, _TomlDocument_currentTomlString, "f");
+    }
+    /**
+     * Returns the JavaScript object representation of the TOML document.
+     */
+    get toJsObject() {
+        const jsObject = toJS(__classPrivateFieldGet(this, _TomlDocument_ast, "f"));
+        // Convert custom date classes to regular JavaScript Date objects
+        return convertCustomDateClasses(jsObject);
+    }
+    /**
+     * Returns the internal AST (for testing purposes).
+     * @internal
+     */
+    get ast() {
+        return __classPrivateFieldGet(this, _TomlDocument_ast, "f");
+    }
+    /**
+     * Applies a patch to the current AST using a modified JS object.
+     * Updates the internal AST. Use toTomlString getter to retrieve the updated TOML string.
+     * @param updatedObject - The modified JS object to patch with
+     * @param format - Optional formatting options
+     */
+    patch(updatedObject, format) {
+        const fmt = resolveTomlFormat(format, __classPrivateFieldGet(this, _TomlDocument_Format, "f"));
+        const { tomlString, document } = patchAst(__classPrivateFieldGet(this, _TomlDocument_ast, "f"), updatedObject, fmt);
+        __classPrivateFieldSet(this, _TomlDocument_ast, document.items, "f");
+        __classPrivateFieldSet(this, _TomlDocument_currentTomlString, tomlString, "f");
+    }
+    /**
+     * Updates the internal document by supplying a modified tomlString.
+     * Use toJsObject getter to retrieve the updated JS object representation.
+     * @param tomlString - The modified TOML string to update with
+     */
+    update(tomlString) {
+        if (tomlString === this.toTomlString) {
+            return;
+        }
+        // Now, let's check where the first difference is
+        const existingLines = this.toTomlString.split(__classPrivateFieldGet(this, _TomlDocument_Format, "f").newLine);
+        const newLineChar = detectNewline(tomlString);
+        const newTextLines = tomlString.split(newLineChar);
+        let firstDiffLineIndex = 0;
+        while (firstDiffLineIndex < existingLines.length &&
+            firstDiffLineIndex < newTextLines.length &&
+            existingLines[firstDiffLineIndex] === newTextLines[firstDiffLineIndex]) {
+            firstDiffLineIndex++;
+        }
+        // Calculate the 1-based line number and 0-based column where the first difference occurs
+        let firstDiffColumn = 0;
+        // If we're within the bounds of both arrays, find the column where they differ
+        if (firstDiffLineIndex < existingLines.length && firstDiffLineIndex < newTextLines.length) {
+            const existingLine = existingLines[firstDiffLineIndex];
+            const newLine = newTextLines[firstDiffLineIndex];
+            // Find the first character position where the lines differ
+            for (let i = 0; i < Math.max(existingLine.length, newLine.length); i++) {
+                if (existingLine[i] !== newLine[i]) {
+                    firstDiffColumn = i;
+                    break;
+                }
+            }
+        }
+        let firstDiffLine = firstDiffLineIndex + 1; // Convert to 1-based
+        const { truncatedAst, lastEndPosition } = truncateAst(__classPrivateFieldGet(this, _TomlDocument_ast, "f"), firstDiffLine, firstDiffColumn);
+        // Determine where to continue parsing from in the new string
+        // If lastEndPosition exists, continue from there; otherwise from the start of the document
+        const continueFromLine = lastEndPosition ? lastEndPosition.line : 1;
+        const continueFromColumn = lastEndPosition ? lastEndPosition.column + 1 : 0;
+        // Based on the first difference, we can re-parse only the affected part
+        // We will need to supply the remaining string after where the AST was truncated
+        const remainingLines = newTextLines.slice(continueFromLine - 1);
+        // If there's a partial line match, we need to extract only the part after the continuation column
+        if (remainingLines.length > 0 && continueFromColumn > 0) {
+            remainingLines[0] = remainingLines[0].substring(continueFromColumn);
+        }
+        const remainingToml = remainingLines.join(__classPrivateFieldGet(this, _TomlDocument_Format, "f").newLine);
+        __classPrivateFieldSet(this, _TomlDocument_ast, Array.from(continueParsingTOML(truncatedAst, remainingToml)), "f");
+        __classPrivateFieldSet(this, _TomlDocument_currentTomlString, tomlString, "f");
+        // Update the auto-detected format with the new string's characteristics
+        __classPrivateFieldSet(this, _TomlDocument_Format, TomlFormat.autoDetectFormat(tomlString), "f");
+    }
+    /**
+     * Overwrites the internal AST by fully re-parsing the supplied tomlString.
+     * This is simpler but slower than update() which uses incremental parsing.
+     * @param tomlString - The TOML string to overwrite with
+     */
+    overwrite(tomlString) {
+        if (tomlString === this.toTomlString) {
+            return;
+        }
+        // Re-parse the entire document
+        __classPrivateFieldSet(this, _TomlDocument_ast, Array.from(parseTOML(tomlString)), "f");
+        __classPrivateFieldSet(this, _TomlDocument_currentTomlString, tomlString, "f");
+        // Update the auto-detected format with the new string's characteristics
+        __classPrivateFieldSet(this, _TomlDocument_Format, TomlFormat.autoDetectFormat(tomlString), "f");
+    }
+}
+_TomlDocument_ast = new WeakMap(), _TomlDocument_currentTomlString = new WeakMap(), _TomlDocument_Format = new WeakMap();
+/**
+ * Recursively converts custom date classes to regular JavaScript Date objects.
+ * This ensures that the toJsObject property returns standard Date objects
+ * while preserving the custom classes internally for TOML formatting.
+ */
+function convertCustomDateClasses(obj) {
+    if (obj instanceof Date) {
+        // Convert custom date classes to regular Date objects
+        return new Date(obj.getTime());
+    }
+    else if (Array.isArray(obj)) {
+        return obj.map(convertCustomDateClasses);
+    }
+    else if (obj && typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = convertCustomDateClasses(value);
+        }
+        return result;
+    }
+    return obj;
+}
 
 /**
  * Parses a TOML string into a JavaScript object.
  * The function converts TOML syntax to its JavaScript equivalent.
+ * This proceeds in two steps: first, it parses the TOML string into an AST,
+ * and then it converts the AST into a JavaScript object.
  *
  * @param value - The TOML string to parse
  * @returns The parsed JavaScript object
@@ -2471,8 +4029,9 @@ function parse(value) {
  * @returns The stringified TOML representation
  */
 function stringify(value, format) {
-    const document = parseJS(value, format);
-    return toTOML(document.items);
+    const fmt = resolveTomlFormat(format, TomlFormat.default());
+    const document = parseJS(value, fmt);
+    return toTOML(document.items, fmt);
 }
 
-export { parse, patch, stringify };
+export { TomlDocument, TomlFormat, parse, patch, stringify };