@decimalturn/toml-patch 0.3.8 → 0.4.1

package/dist/toml-patch.es.js

@@ -1,9 +1,13 @@
-//! @decimalturn/toml-patch v0.3.8 - https://github.com/DecimalTurn/toml-patch - @license: MIT
+//! @decimalturn/toml-patch v0.4.1 - 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;
 }
@@ -568,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;
@@ -577,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);
@@ -586,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);
@@ -608,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) ||
@@ -821,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 };
@@ -838,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 {
@@ -1076,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)) {
@@ -1092,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)) {
@@ -1147,8 +1576,9 @@ function replace(root, parent, existing, replacement) {
  * @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) {
+function insert(root, parent, child, index, forceInline) {
     if (!hasItems(parent)) {
         throw new Error(`Unsupported parent type "${parent.type}" for insert`);
     }
@@ -1158,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));
     }
@@ -1190,11 +1623,10 @@ function insertOnNewLine(parent, child, index) {
             column: !isComment(previous) ? previous.loc.start.column : parent.loc.start.column
         }
         : clonePosition(parent.loc.start);
-    //TODO: Check the definition for block to see if using isBlock is more appropriate
-    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 {
@@ -1214,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
@@ -1259,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 = {
@@ -1274,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
@@ -1351,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;
@@ -1659,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,
@@ -1690,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;
@@ -1698,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);
@@ -1734,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;
@@ -1758,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);
@@ -1776,8 +2751,10 @@ 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,
@@ -1910,9 +2887,7 @@ const BY_NEW_LINE = /(\r\n|\n)/g;
  * const tomlString = toTOML(ast, '\n', { trailingNewline: 1 });
  * ```
  */
-function toTOML(ast, newline = '\n', options) {
-    var _a;
-    const trailingNewline = (_a = options === null || options === void 0 ? void 0 : options.trailingNewline) !== null && _a !== void 0 ? _a : 1;
+function toTOML(ast, format) {
     const lines = [];
     traverse(ast, {
         [NodeType.TableKey](node) {
@@ -1967,7 +2942,7 @@ function toTOML(ast, newline = '\n', options) {
             write(lines, node.loc, node.raw);
         }
     });
-    return lines.join(newline) + newline.repeat(trailingNewline);
+    return lines.join(format.newLine) + format.newLine.repeat(format.trailingNewline);
 }
 /**
  * Writes raw string content to specific location coordinates within a lines array.
@@ -2044,6 +3019,13 @@ 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();
@@ -2335,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);
     }
@@ -2419,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 = {
@@ -2426,35 +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);
-    // Detect the line ending style from the original file
-    let newline = '\n'; // Default to LF
-    const lfIndex = existing.indexOf('\n');
-    // Even if a LF is found, it could that there is a CR right before the LF
-    if (lfIndex > 0 && existing.substring(lfIndex - 1, lfIndex) === '\r') {
-        newline = '\r\n'; // File uses CRLF
-    }
-    // Count consecutive trailing newlines
-    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;
-    }
-    const trailingNewlineCount = countTrailingNewlines(existing, newline);
-    return toTOML(patched_document.items, newline, { trailingNewline: trailingNewlineCount });
+    return {
+        tomlString: toTOML(patched_document.items, format),
+        document: patched_document
+    };
 }
 function reorder(changes) {
     for (let i = 0; i < changes.length; i++) {
@@ -2477,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
@@ -2499,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;
@@ -2527,10 +3536,66 @@ function applyChanges(original, updated, changes) {
                 }
             }
             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)) {
@@ -2539,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;
@@ -2550,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);
         }
@@ -2585,6 +3685,329 @@ 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.
@@ -2606,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 };