@decimalturn/toml-patch 0.6.0 → 1.0.0

package/dist/toml-patch.es.js

@@ -1,4300 +0,0 @@
-//! @decimalturn/toml-patch v0.6.0 - https://github.com/DecimalTurn/toml-patch - @license: MIT
-var NodeType;
-(function (NodeType) {
-    NodeType["Document"] = "Document";
-    NodeType["Table"] = "Table";
-    NodeType["TableKey"] = "TableKey";
-    /**
-     * Array of Tables node
-     * More info: https://toml.io/en/latest#array-of-tables
-     */
-    NodeType["TableArray"] = "TableArray";
-    NodeType["TableArrayKey"] = "TableArrayKey";
-    NodeType["KeyValue"] = "KeyValue";
-    NodeType["Key"] = "Key";
-    NodeType["String"] = "String";
-    NodeType["Integer"] = "Integer";
-    NodeType["Float"] = "Float";
-    NodeType["Boolean"] = "Boolean";
-    NodeType["DateTime"] = "DateTime";
-    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) {
-    return node.type === NodeType.Document;
-}
-function isTable(node) {
-    return node.type === NodeType.Table;
-}
-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;
-}
-function isTableArrayKey(node) {
-    return node.type === NodeType.TableArrayKey;
-}
-function isKeyValue(node) {
-    return node.type === NodeType.KeyValue;
-}
-function isString$1(node) {
-    return node.type === NodeType.String;
-}
-function isDateTime(node) {
-    return node.type === NodeType.DateTime;
-}
-function isInlineArray(node) {
-    return node.type === NodeType.InlineArray;
-}
-function isInlineItem(node) {
-    return node.type === NodeType.InlineItem;
-}
-function isInlineTable(node) {
-    return node.type === NodeType.InlineTable;
-}
-function isComment(node) {
-    return node.type === NodeType.Comment;
-}
-function hasItems(node) {
-    return (isDocument(node) ||
-        isTable(node) ||
-        isTableArray(node) ||
-        isInlineTable(node) ||
-        isInlineArray(node));
-}
-function hasItem(node) {
-    return isTableKey(node) || isTableArrayKey(node) || isInlineItem(node);
-}
-function isBlock(node) {
-    return isKeyValue(node) || isTable(node) || isTableArray(node) || isComment(node);
-}
-
-function iterator(value) {
-    return value[Symbol.iterator]();
-}
-/**
- * Cursor<T>
- *
- * A utility class that wraps an iterator and provides additional functionality
- * such as peeking at the next value without advancing the iterator, tracking
- * the current index, and iterating over the values.
- *
- * @template T - The type of elements in the iterator.
- *
- * Properties:
- * - `iterator`: The underlying iterator being wrapped.
- * - `index`: The current index of the iterator (starts at -1).
- * - `value`: The current value of the iterator.
- * - `done`: A boolean indicating whether the iterator is complete.
- * - `peeked`: The result of peeking at the next value without advancing.
- *
- * Methods:
- * - `next()`: Advances the iterator and returns the next value.
- * - `peek()`: Returns the next value without advancing the iterator.
- * - `[Symbol.iterator]`: Makes the Cursor itself iterable.
- */
-class Cursor {
-    constructor(iterator) {
-        this.iterator = iterator;
-        this.index = -1;
-        this.value = undefined;
-        this.done = false;
-        this.peeked = null;
-    }
-    next() {
-        var _a;
-        if (this.done)
-            return done();
-        const result = this.peeked || this.iterator.next();
-        this.index += 1;
-        this.value = result.value;
-        this.done = (_a = result.done) !== null && _a !== void 0 ? _a : false;
-        this.peeked = null;
-        return result;
-    }
-    peek() {
-        if (this.done)
-            return done();
-        if (this.peeked)
-            return this.peeked;
-        this.peeked = this.iterator.next();
-        return this.peeked;
-    }
-    [Symbol.iterator]() {
-        return this;
-    }
-}
-function done() {
-    return { value: undefined, done: true };
-}
-
-function getSpan(location) {
-    return {
-        lines: location.end.line - location.start.line + 1,
-        columns: location.end.column - location.start.column
-    };
-}
-function createLocate(input) {
-    const lines = findLines(input);
-    return (start, end) => {
-        return {
-            start: findPosition(lines, start),
-            end: findPosition(lines, end)
-        };
-    };
-}
-function findPosition(input, index) {
-    // abc\ndef\ng
-    // 0123 4567 8
-    //      012
-    //           0
-    //
-    // lines = [3, 7, 9]
-    //
-    // c = 2: 0 -> 1, 2 - (undefined + 1 || 0) = 2
-    //     3: 0 -> 1, 3 - (undefined + 1 || 0) = 3
-    // e = 5: 1 -> 2, 5 - (3 + 1 || 0) = 1
-    // g = 8: 2 -> 3, 8 - (7 + 1 || 0) = 0
-    const lines = Array.isArray(input) ? input : findLines(input);
-    const line = lines.findIndex(line_index => line_index >= index) + 1;
-    const column = index - (lines[line - 2] + 1 || 0);
-    return { line, column };
-}
-function getLine$1(input, position) {
-    const lines = findLines(input);
-    const start = lines[position.line - 2] || 0;
-    const end = lines[position.line - 1] || input.length;
-    return input.substring(start, end);
-}
-function findLines(input) {
-    // exec is stateful, so create new regexp each time
-    const BY_NEW_LINE = /\r\n|\n/g;
-    const indexes = [];
-    let match;
-    while ((match = BY_NEW_LINE.exec(input)) != null) {
-        indexes.push(match.index + match[0].length - 1);
-    }
-    indexes.push(input.length + 1);
-    return indexes;
-}
-function clonePosition(position) {
-    return { line: position.line, column: position.column };
-}
-function cloneLocation(location) {
-    return { start: clonePosition(location.start), end: clonePosition(location.end) };
-}
-/**
- * Returns a Position at line 1, column 0.
- * This means that lines are 1-indexed and columns are 0-indexed.
- *
- * @returns A Position at line 1, column 0
- */
-function zero() {
-    return { line: 1, column: 0 };
-}
-
-class ParseError extends Error {
-    constructor(input, position, message) {
-        let error_message = `Error parsing TOML (${position.line}, ${position.column + 1}):\n`;
-        if (input) {
-            const line = getLine$1(input, position);
-            const pointer = `${whitespace(position.column)}^`;
-            if (line)
-                error_message += `${line}\n${pointer}\n`;
-        }
-        error_message += message;
-        super(error_message);
-        this.line = position.line;
-        this.column = position.column;
-    }
-}
-function whitespace(count, character = ' ') {
-    return character.repeat(count);
-}
-
-var TokenType;
-(function (TokenType) {
-    TokenType["Bracket"] = "Bracket";
-    TokenType["Curly"] = "Curly";
-    TokenType["Equal"] = "Equal";
-    TokenType["Comma"] = "Comma";
-    TokenType["Dot"] = "Dot";
-    TokenType["Comment"] = "Comment";
-    TokenType["Literal"] = "Literal";
-})(TokenType || (TokenType = {}));
-const IS_WHITESPACE = /\s/;
-const IS_NEW_LINE = /(\r\n|\n)/;
-const DOUBLE_QUOTE = `"`;
-const SINGLE_QUOTE = `'`;
-const SPACE = ' ';
-const ESCAPE = '\\';
-const IS_VALID_LEADING_CHARACTER = /[\w,\d,\",\',\+,\-,\_]/;
-function* tokenize(input) {
-    const cursor = new Cursor(iterator(input));
-    cursor.next();
-    const locate = createLocate(input);
-    while (!cursor.done) {
-        if (IS_WHITESPACE.test(cursor.value)) ;
-        else if (cursor.value === '[' || cursor.value === ']') {
-            // Handle special characters: [, ], {, }, =, comma
-            yield specialCharacter(cursor, locate, TokenType.Bracket);
-        }
-        else if (cursor.value === '{' || cursor.value === '}') {
-            yield specialCharacter(cursor, locate, TokenType.Curly);
-        }
-        else if (cursor.value === '=') {
-            yield specialCharacter(cursor, locate, TokenType.Equal);
-        }
-        else if (cursor.value === ',') {
-            yield specialCharacter(cursor, locate, TokenType.Comma);
-        }
-        else if (cursor.value === '.') {
-            yield specialCharacter(cursor, locate, TokenType.Dot);
-        }
-        else if (cursor.value === '#') {
-            // Handle comments = # -> EOL
-            yield comment$1(cursor, locate);
-        }
-        else {
-            const multiline_char = checkThree(input, cursor.index, SINGLE_QUOTE) ||
-                checkThree(input, cursor.index, DOUBLE_QUOTE);
-            if (multiline_char) {
-                // Multi-line literals or strings = no escaping
-                yield multiline(cursor, locate, multiline_char, input);
-            }
-            else {
-                yield string$1(cursor, locate, input);
-            }
-        }
-        cursor.next();
-    }
-}
-function specialCharacter(cursor, locate, type) {
-    return { type, raw: cursor.value, loc: locate(cursor.index, cursor.index + 1) };
-}
-function comment$1(cursor, locate) {
-    const start = cursor.index;
-    let raw = cursor.value;
-    while (!cursor.peek().done && !IS_NEW_LINE.test(cursor.peek().value)) {
-        cursor.next();
-        raw += cursor.value;
-    }
-    // Early exit is ok for comment, no closing conditions
-    return {
-        type: TokenType.Comment,
-        raw,
-        loc: locate(start, cursor.index + 1)
-    };
-}
-function multiline(cursor, locate, multiline_char, input) {
-    const start = cursor.index;
-    let quotes = multiline_char + multiline_char + multiline_char;
-    let raw = quotes;
-    // Skip over quotes
-    cursor.next();
-    cursor.next();
-    cursor.next();
-    // The reason why we need to check if there is more than three is because we have to match the last 3 quotes, not the first 3 that appears consecutively
-    // See spec-string-basic-multiline-9.toml
-    while (!cursor.done && (!checkThree(input, cursor.index, multiline_char) || CheckMoreThanThree(input, cursor.index, multiline_char))) {
-        raw += cursor.value;
-        cursor.next();
-    }
-    if (cursor.done) {
-        throw new ParseError(input, findPosition(input, cursor.index), `Expected close of multiline string with ${quotes}, reached end of file`);
-    }
-    raw += quotes;
-    cursor.next();
-    cursor.next();
-    return {
-        type: TokenType.Literal,
-        raw,
-        loc: locate(start, cursor.index + 1)
-    };
-}
-function string$1(cursor, locate, input) {
-    // Remaining possibilities: keys, strings, literals, integer, float, boolean
-    //
-    // Special cases:
-    // "..." -> quoted
-    // '...' -> quoted
-    // "...".'...' -> bare
-    // 0000-00-00 00:00:00 -> bare
-    //
-    // See https://github.com/toml-lang/toml#offset-date-time
-    //
-    // | For the sake of readability, you may replace the T delimiter between date and time with a space (as permitted by RFC 3339 section 5.6).
-    // | `odt4 = 1979-05-27 07:32:00Z`
-    //
-    // From RFC 3339:
-    //
-    // | NOTE: ISO 8601 defines date and time separated by "T".
-    // | Applications using this syntax may choose, for the sake of
-    // | readability, to specify a full-date and full-time separated by
-    // | (say) a space character.
-    // First, check for invalid characters
-    if (!IS_VALID_LEADING_CHARACTER.test(cursor.value)) {
-        throw new ParseError(input, findPosition(input, cursor.index), `Unsupported character "${cursor.value}". Expected ALPHANUMERIC, ", ', +, -, or _`);
-    }
-    const start = cursor.index;
-    let raw = cursor.value;
-    let double_quoted = cursor.value === DOUBLE_QUOTE;
-    let single_quoted = cursor.value === SINGLE_QUOTE;
-    const isFinished = (cursor) => {
-        if (cursor.peek().done)
-            return true;
-        const next_item = cursor.peek().value;
-        return (!(double_quoted || single_quoted) &&
-            (IS_WHITESPACE.test(next_item) ||
-                next_item === ',' ||
-                next_item === '.' ||
-                next_item === ']' ||
-                next_item === '}' ||
-                next_item === '=' ||
-                next_item === '#'));
-    };
-    while (!cursor.done && !isFinished(cursor)) {
-        cursor.next();
-        if (cursor.value === DOUBLE_QUOTE)
-            double_quoted = !double_quoted;
-        if (cursor.value === SINGLE_QUOTE && !double_quoted)
-            single_quoted = !single_quoted;
-        raw += cursor.value;
-        if (cursor.peek().done)
-            break;
-        let next_item = cursor.peek().value;
-        // If next character is escape and currently double-quoted,
-        // check for escaped quote
-        if (double_quoted && cursor.value === ESCAPE) {
-            if (next_item === DOUBLE_QUOTE) {
-                raw += DOUBLE_QUOTE;
-                cursor.next();
-            }
-            else if (next_item === ESCAPE) {
-                raw += ESCAPE;
-                cursor.next();
-            }
-        }
-    }
-    if (double_quoted || single_quoted) {
-        throw new ParseError(input, findPosition(input, start), `Expected close of string with ${double_quoted ? DOUBLE_QUOTE : SINGLE_QUOTE}`);
-    }
-    return {
-        type: TokenType.Literal,
-        raw,
-        loc: locate(start, cursor.index + 1)
-    };
-}
-/**
- * Check if the current character and the next two characters are the same
- * and not escaped.
- *
- * @param input - The input string.
- * @param current - The current index in the input string.
- * @param check - The character to check for.
- * @returns ⚠️The character if found, otherwise false.
- */
-function checkThree(input, current, check) {
-    if (!check) {
-        return false;
-    }
-    const has3 = input[current] === check &&
-        input[current + 1] === check &&
-        input[current + 2] === check;
-    if (!has3) {
-        return false;
-    }
-    // Only check for escaping in basic strings (double quotes)
-    // Literal strings (single quotes) don't support escape sequences
-    if (check === SINGLE_QUOTE) {
-        return check; // No escaping in literal strings
-    }
-    // Check if the sequence is escaped
-    const precedingText = input.slice(0, current); // Get the text before the current position
-    const backslashes = precedingText.match(/\\+$/); // Match trailing backslashes
-    if (!backslashes) {
-        return check; // No backslashes means not escaped
-    }
-    const isEscaped = backslashes[0].length % 2 !== 0; // Odd number of backslashes means escaped
-    return isEscaped ? false : check; // Return `check` if not escaped, otherwise `false`
-}
-function CheckMoreThanThree(input, current, check) {
-    if (!check) {
-        return false;
-    }
-    return (input[current] === check &&
-        input[current + 1] === check &&
-        input[current + 2] === check &&
-        input[current + 3] === check);
-}
-
-function last(values) {
-    return values[values.length - 1];
-}
-function blank() {
-    return Object.create(null);
-}
-function isString(value) {
-    return typeof value === 'string';
-}
-function isInteger(value) {
-    return typeof value === 'number' && value % 1 === 0 && isFinite(value) && !Object.is(value, -0);
-}
-function isFloat(value) {
-    return typeof value === 'number' && (!isInteger(value) || !isFinite(value) || Object.is(value, -0));
-}
-function isBoolean(value) {
-    return typeof value === 'boolean';
-}
-function isDate(value) {
-    return Object.prototype.toString.call(value) === '[object Date]';
-}
-function isObject(value) {
-    return value && typeof value === 'object' && !isDate(value) && !Array.isArray(value);
-}
-function isIterable(value) {
-    return value != null && typeof value[Symbol.iterator] === 'function';
-}
-function has(object, key) {
-    return Object.prototype.hasOwnProperty.call(object, key);
-}
-function arraysEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
-}
-function datesEqual(a, b) {
-    return isDate(a) && isDate(b) && a.toISOString() === b.toISOString();
-}
-function pipe(value, ...fns) {
-    return fns.reduce((value, fn) => fn(value), value);
-}
-function stableStringify(object) {
-    if (isObject(object)) {
-        const key_values = Object.keys(object)
-            .sort()
-            .map(key => `${JSON.stringify(key)}:${stableStringify(object[key])}`);
-        return `{${key_values.join(',')}}`;
-    }
-    else if (Array.isArray(object)) {
-        return `[${object.map(stableStringify).join(',')}]`;
-    }
-    else {
-        return JSON.stringify(object);
-    }
-}
-function merge(target, values) {
-    // __mutating__: merge values into target
-    // Reference: https://dev.to/uilicious/javascript-array-push-is-945x-faster-than-array-concat-1oki
-    const original_length = target.length;
-    const added_length = values.length;
-    target.length = original_length + added_length;
-    for (let i = 0; i < added_length; i++) {
-        target[original_length + i] = values[i];
-    }
-}
-/**
- * Checks if a string is a multiline string (starts with """ or ''')
- * @param raw The raw string value including quotes
- * @returns true if the string is multiline, false otherwise
- */
-function isMultilineString(raw) {
-    return raw.startsWith('"""') || raw.startsWith("'''");
-}
-
-const TRIPLE_DOUBLE_QUOTE = `"""`;
-const TRIPLE_SINGLE_QUOTE = `'''`;
-const LF = '\\n';
-const CRLF = '\\r\\n';
-const IS_CRLF = /\r\n/g;
-const IS_LF = /\n/g;
-const IS_LEADING_NEW_LINE = /^(\r\n|\n)/;
-// This regex is used to match an odd number of backslashes followed by a line ending
-// It uses a negative lookbehind to ensure that the backslash is not preceded by another backslash.
-// We need an odd number of backslashes so that the last one is not escaped.
-const IS_LINE_ENDING_BACKSLASH = /(?<!\\)(?:\\\\)*(\\\s*[\n\r\n]\s*)/g;
-function parseString(raw) {
-    if (raw.startsWith(TRIPLE_SINGLE_QUOTE)) {
-        return pipe(trim(raw, 3), trimLeadingWhitespace);
-    }
-    else if (raw.startsWith(SINGLE_QUOTE)) {
-        return trim(raw, 1);
-    }
-    else if (raw.startsWith(TRIPLE_DOUBLE_QUOTE)) {
-        return pipe(trim(raw, 3), trimLeadingWhitespace, lineEndingBackslash, escapeNewLines, escapeDoubleQuotes, unescapeLargeUnicode);
-    }
-    else if (raw.startsWith(DOUBLE_QUOTE)) {
-        return pipe(trim(raw, 1), unescapeLargeUnicode);
-    }
-    else {
-        return raw;
-    }
-}
-function escapeDoubleQuotes(value) {
-    let result = '';
-    let precedingBackslashes = 0;
-    for (let i = 0; i < value.length; i++) {
-        const char = value[i];
-        if (char === '"' && precedingBackslashes % 2 === 0) {
-            // If the current character is a quote and it is not escaped, escape it
-            result += '\\"';
-        }
-        else {
-            // Otherwise, add the character as is
-            result += char;
-        }
-        // Update the count of consecutive backslashes
-        if (char === '\\') {
-            precedingBackslashes++;
-        }
-        else {
-            precedingBackslashes = 0; // Reset if the character is not a backslash
-        }
-    }
-    return result;
-}
-function isBackslashEscaped(source, backslashOffset) {
-    let precedingBackslashes = 0;
-    for (let i = backslashOffset - 1; i >= 0 && source[i] === '\\'; i--) {
-        precedingBackslashes++;
-    }
-    return precedingBackslashes % 2 !== 0;
-}
-function unescapeLargeUnicode(escaped) {
-    // TOML 1.1.0: Handle \xHH hex escapes (for codepoints < 255)
-    const HEX_ESCAPE = /\\x([a-fA-F0-9]{2})/g;
-    const hexEscapeSource = escaped;
-    let withHexEscapes = hexEscapeSource.replace(HEX_ESCAPE, (match, hex, offset) => {
-        if (isBackslashEscaped(hexEscapeSource, offset)) {
-            return match;
-        }
-        const codePoint = parseInt(hex, 16);
-        const asString = String.fromCharCode(codePoint);
-        // Escape for JSON if needed
-        if (codePoint < 0x20 || codePoint === 0x22 || codePoint === 0x5C) {
-            return trim(JSON.stringify(asString), 1);
-        }
-        return asString;
-    });
-    // TOML 1.1.0: Handle \e escape character (ESC = 0x1B)
-    const eEscapeSource = withHexEscapes;
-    withHexEscapes = eEscapeSource.replace(/\\e/g, (match, offset) => {
-        if (isBackslashEscaped(eEscapeSource, offset)) {
-            return match;
-        }
-        return '\\u001b';
-    });
-    // JSON.parse handles everything except \UXXXXXXXX
-    // replace those instances with code point, escape that, and then parse
-    const LARGE_UNICODE = /\\U[a-fA-F0-9]{8}/g;
-    const json_escaped = withHexEscapes.replace(LARGE_UNICODE, value => {
-        const code_point = parseInt(value.replace('\\U', ''), 16);
-        const as_string = String.fromCodePoint(code_point);
-        return trim(JSON.stringify(as_string), 1);
-    });
-    const fixed_json_escaped = escapeTabsForJSON(json_escaped);
-    // Parse the properly escaped JSON string
-    const parsed = JSON.parse(`"${fixed_json_escaped}"`);
-    return parsed;
-}
-function escapeTabsForJSON(value) {
-    return value
-        .replace(/\t/g, '\\t');
-}
-function trim(value, count) {
-    return value.slice(count, value.length - count);
-}
-function trimLeadingWhitespace(value) {
-    return value.replace(IS_LEADING_NEW_LINE, '');
-}
-function escapeNewLines(value) {
-    return value.replace(IS_CRLF, CRLF).replace(IS_LF, LF);
-}
-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) {
-        // Normalize time to include seconds if missing (TOML 1.1.0 allows optional seconds)
-        let normalizedValue = value;
-        if (!/:\d{2}:\d{2}/.test(value)) {
-            // No seconds present, add :00
-            normalizedValue = value + ':00';
-        }
-        // For local time, use year 0000 as the base (TOML spec compliance)
-        // Add 'Z' to ensure it's parsed as UTC regardless of system timezone
-        super(`0000-01-01T${normalizedValue}Z`);
-        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) {
-        // Normalize time part to include seconds if missing (TOML 1.1.0 allows optional seconds)
-        let normalizedValue = value;
-        if (!/\d{2}:\d{2}:\d{2}/.test(value)) {
-            normalizedValue = value.replace(/(\d{2}:\d{2})([\s\-+TZ]|$)/, '$1:00$2');
-        }
-        // Convert space to T for Date parsing, but remember the original format
-        super(normalizedValue.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) {
-        // Normalize time part to include seconds if missing (TOML 1.1.0 allows optional seconds)
-        let normalizedValue = value;
-        if (!/\d{2}:\d{2}:\d{2}/.test(value)) {
-            normalizedValue = value.replace(/(\d{2}:\d{2})([\s\-+TZ]|$)/, '$1:00$2');
-        }
-        super(normalizedValue.replace(' ', 'T'));
-        this.useSpaceSeparator = false;
-        this.useSpaceSeparator = useSpaceSeparator;
-        this.originalFormat = value;
-        // 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 = DateFormatHelper;
-const TRUE = 'true';
-const FALSE = 'false';
-const HAS_E = /e/i;
-const IS_DIVIDER = /\_/g;
-const IS_INF = /inf/;
-const IS_NAN = /nan/;
-const IS_HEX = /^0x/;
-const IS_OCTAL = /^0o/;
-const IS_BINARY = /^0b/;
-function* parseTOML(input) {
-    const tokens = tokenize(input);
-    const cursor = new Cursor(tokens);
-    while (!cursor.next().done) {
-        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);
-    }
-    else if (cursor.value.type === TokenType.Bracket) {
-        yield table(cursor, input);
-    }
-    else if (cursor.value.type === TokenType.Literal) {
-        yield* keyValue(cursor, input);
-    }
-    else {
-        throw new ParseError(input, cursor.value.loc.start, `Unexpected token "${cursor.value.type}". Expected Comment, Bracket, or String`);
-    }
-}
-function* walkValue$1(cursor, input) {
-    if (cursor.value.type === TokenType.Literal) {
-        if (cursor.value.raw[0] === DOUBLE_QUOTE || cursor.value.raw[0] === SINGLE_QUOTE) {
-            yield string(cursor);
-        }
-        else if (cursor.value.raw === TRUE || cursor.value.raw === FALSE) {
-            yield boolean(cursor);
-        }
-        else if (dateFormatHelper.IS_FULL_DATE.test(cursor.value.raw) || dateFormatHelper.IS_FULL_TIME.test(cursor.value.raw)) {
-            yield datetime(cursor, input);
-        }
-        else if ((!cursor.peek().done && cursor.peek().value.type === TokenType.Dot) ||
-            IS_INF.test(cursor.value.raw) ||
-            IS_NAN.test(cursor.value.raw) ||
-            (HAS_E.test(cursor.value.raw) && !IS_HEX.test(cursor.value.raw))) {
-            yield float(cursor, input);
-        }
-        else {
-            yield integer(cursor);
-        }
-    }
-    else if (cursor.value.type === TokenType.Curly) {
-        const [inline_table, comments] = inlineTable(cursor, input);
-        yield inline_table;
-        yield* comments;
-    }
-    else if (cursor.value.type === TokenType.Bracket) {
-        const [inline_array, comments] = inlineArray(cursor, input);
-        yield inline_array;
-        yield* comments;
-    }
-    else {
-        throw new ParseError(input, cursor.value.loc.start, `Unrecognized token type "${cursor.value.type}". Expected String, Curly, or Bracket`);
-    }
-}
-function comment(cursor) {
-    // # line comment
-    // ^------------^ Comment
-    return {
-        type: NodeType.Comment,
-        loc: cursor.value.loc,
-        raw: cursor.value.raw
-    };
-}
-function table(cursor, input) {
-    // Table or TableArray
-    //
-    // [ key ]
-    // ^-----^    TableKey
-    //   ^-^      Key
-    //
-    // [[ key ]]
-    // ^ ------^  TableArrayKey
-    //    ^-^     Key
-    //
-    // a = "b"  < Items
-    // # c      |
-    // d = "f"  <
-    //
-    // ...
-    const type = !cursor.peek().done && cursor.peek().value.type === TokenType.Bracket
-        ? NodeType.TableArray
-        : NodeType.Table;
-    const is_table = type === NodeType.Table;
-    if (is_table && cursor.value.raw !== '[') {
-        throw new ParseError(input, cursor.value.loc.start, `Expected table opening "[", found ${cursor.value.raw}`);
-    }
-    if (!is_table && (cursor.value.raw !== '[' || cursor.peek().value.raw !== '[')) {
-        throw new ParseError(input, cursor.value.loc.start, `Expected array of tables opening "[[", found ${cursor.value.raw + cursor.peek().value.raw}`);
-    }
-    // Set start location from opening tag
-    const key = is_table
-        ? {
-            type: NodeType.TableKey,
-            loc: cursor.value.loc
-        }
-        : {
-            type: NodeType.TableArrayKey,
-            loc: cursor.value.loc
-        };
-    // Skip to cursor.value for key value
-    cursor.next();
-    if (type === NodeType.TableArray)
-        cursor.next();
-    if (cursor.done) {
-        throw new ParseError(input, key.loc.start, `Expected table key, reached end of file`);
-    }
-    key.item = {
-        type: NodeType.Key,
-        loc: cloneLocation(cursor.value.loc),
-        raw: cursor.value.raw,
-        value: [parseString(cursor.value.raw)]
-    };
-    while (!cursor.peek().done && cursor.peek().value.type === TokenType.Dot) {
-        cursor.next();
-        const dot = cursor.value;
-        cursor.next();
-        const before = ' '.repeat(dot.loc.start.column - key.item.loc.end.column);
-        const after = ' '.repeat(cursor.value.loc.start.column - dot.loc.end.column);
-        key.item.loc.end = cursor.value.loc.end;
-        key.item.raw += `${before}.${after}${cursor.value.raw}`;
-        key.item.value.push(parseString(cursor.value.raw));
-    }
-    cursor.next();
-    if (is_table && (cursor.done || cursor.value.raw !== ']')) {
-        throw new ParseError(input, cursor.done ? key.item.loc.end : cursor.value.loc.start, `Expected table closing "]", found ${cursor.done ? 'end of file' : cursor.value.raw}`);
-    }
-    if (!is_table &&
-        (cursor.done ||
-            cursor.peek().done ||
-            cursor.value.raw !== ']' ||
-            cursor.peek().value.raw !== ']')) {
-        throw new ParseError(input, cursor.done || cursor.peek().done ? key.item.loc.end : cursor.value.loc.start, `Expected array of tables closing "]]", found ${cursor.done || cursor.peek().done
-            ? 'end of file'
-            : cursor.value.raw + cursor.peek().value.raw}`);
-    }
-    // Set end location from closing tag
-    if (!is_table)
-        cursor.next();
-    key.loc.end = cursor.value.loc.end;
-    // Add child items
-    let items = [];
-    while (!cursor.peek().done && cursor.peek().value.type !== TokenType.Bracket) {
-        cursor.next();
-        merge(items, [...walkBlock(cursor, input)]);
-    }
-    return {
-        type: is_table ? NodeType.Table : NodeType.TableArray,
-        loc: {
-            start: clonePosition(key.loc.start),
-            end: items.length
-                ? clonePosition(items[items.length - 1].loc.end)
-                : clonePosition(key.loc.end)
-        },
-        key: key,
-        items
-    };
-}
-function keyValue(cursor, input) {
-    // 3. KeyValue
-    //
-    // key = value
-    // ^-^          key
-    //     ^        equals
-    //       ^---^  value
-    const key = {
-        type: NodeType.Key,
-        loc: cloneLocation(cursor.value.loc),
-        raw: cursor.value.raw,
-        value: [parseString(cursor.value.raw)]
-    };
-    while (!cursor.peek().done && cursor.peek().value.type === TokenType.Dot) {
-        cursor.next();
-        cursor.next();
-        key.loc.end = cursor.value.loc.end;
-        key.raw += `.${cursor.value.raw}`;
-        key.value.push(parseString(cursor.value.raw));
-    }
-    cursor.next();
-    if (cursor.done || cursor.value.type !== TokenType.Equal) {
-        throw new ParseError(input, cursor.done ? key.loc.end : cursor.value.loc.start, `Expected "=" for key-value, found ${cursor.done ? 'end of file' : cursor.value.raw}`);
-    }
-    const equals = cursor.value.loc.start.column;
-    cursor.next();
-    if (cursor.done) {
-        throw new ParseError(input, key.loc.start, `Expected value for key-value, reached end of file`);
-    }
-    const [value, ...comments] = walkValue$1(cursor, input);
-    return [
-        {
-            type: NodeType.KeyValue,
-            key,
-            value: value,
-            loc: {
-                start: clonePosition(key.loc.start),
-                end: clonePosition(value.loc.end)
-            },
-            equals
-        },
-        ...comments
-    ];
-}
-function string(cursor) {
-    return {
-        type: NodeType.String,
-        loc: cursor.value.loc,
-        raw: cursor.value.raw,
-        value: parseString(cursor.value.raw)
-    };
-}
-function boolean(cursor) {
-    return {
-        type: NodeType.Boolean,
-        loc: cursor.value.loc,
-        value: cursor.value.raw === TRUE
-    };
-}
-function datetime(cursor, input) {
-    // Possible values:
-    //
-    // Offset Date-Time
-    // | odt1 = 1979-05-27T07:32:00Z
-    // | odt2 = 1979-05-27T00:32:00-07:00
-    // | odt3 = 1979-05-27T00:32:00.999999-07:00
-    // | odt4 = 1979-05-27 07:32:00Z
-    //
-    // Local Date-Time
-    // | ldt1 = 1979-05-27T07:32:00
-    // | ldt2 = 1979-05-27T00:32:00.999999
-    //
-    // Local Date
-    // | ld1 = 1979-05-27
-    //
-    // Local Time
-    // | lt1 = 07:32:00
-    // | lt2 = 00:32:00.999999
-    let loc = cursor.value.loc;
-    let raw = cursor.value.raw;
-    let value;
-    // If next token is string,
-    // check if raw is full date and following is full time
-    if (!cursor.peek().done &&
-        cursor.peek().value.type === TokenType.Literal &&
-        dateFormatHelper.IS_FULL_DATE.test(raw) &&
-        dateFormatHelper.IS_FULL_TIME.test(cursor.peek().value.raw)) {
-        const start = loc.start;
-        cursor.next();
-        loc = { start, end: cursor.value.loc.end };
-        raw += ` ${cursor.value.raw}`;
-    }
-    if (!cursor.peek().done && cursor.peek().value.type === TokenType.Dot) {
-        const start = loc.start;
-        cursor.next();
-        if (cursor.peek().done || cursor.peek().value.type !== TokenType.Literal) {
-            throw new ParseError(input, cursor.value.loc.end, `Expected fractional value for DateTime`);
-        }
-        cursor.next();
-        loc = { start, end: cursor.value.loc.end };
-        raw += `.${cursor.value.raw}`;
-    }
-    if (!dateFormatHelper.IS_FULL_DATE.test(raw)) {
-        // Local time only (e.g., "07:32:00" or "07:32:00.999")
-        if (dateFormatHelper.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.IS_DATE_ONLY.test(raw)) {
-        // Local date only (e.g., "1979-05-27")
-        value = new LocalDate(raw);
-    }
-    else if (dateFormatHelper.IS_LOCAL_DATETIME_T.test(raw)) {
-        // Local datetime with T separator (e.g., "1979-05-27T07:32:00")
-        value = new LocalDateTime(raw, false);
-    }
-    else if (dateFormatHelper.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.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.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 {
-        type: NodeType.DateTime,
-        loc,
-        raw,
-        value
-    };
-}
-function float(cursor, input) {
-    let loc = cursor.value.loc;
-    let raw = cursor.value.raw;
-    let value;
-    if (IS_INF.test(raw)) {
-        value = raw === '-inf' ? -Infinity : Infinity;
-    }
-    else if (IS_NAN.test(raw)) {
-        value = raw === '-nan' ? -NaN : NaN;
-    }
-    else if (!cursor.peek().done && cursor.peek().value.type === TokenType.Dot) {
-        const start = loc.start;
-        // From spec:
-        // | A fractional part is a decimal point followed by one or more digits.
-        //
-        // -> Don't have to handle "4." (i.e. nothing behind decimal place)
-        cursor.next();
-        if (cursor.peek().done || cursor.peek().value.type !== TokenType.Literal) {
-            throw new ParseError(input, cursor.value.loc.end, `Expected fraction value for Float`);
-        }
-        cursor.next();
-        raw += `.${cursor.value.raw}`;
-        loc = { start, end: cursor.value.loc.end };
-        value = Number(raw.replace(IS_DIVIDER, ''));
-    }
-    else {
-        value = Number(raw.replace(IS_DIVIDER, ''));
-    }
-    return { type: NodeType.Float, loc, raw, value };
-}
-function integer(cursor) {
-    // > Integer values -0 and +0 are valid and identical to an unprefixed zero
-    if (cursor.value.raw === '-0' || cursor.value.raw === '+0') {
-        return {
-            type: NodeType.Integer,
-            loc: cursor.value.loc,
-            raw: cursor.value.raw,
-            value: 0
-        };
-    }
-    let radix = 10;
-    if (IS_HEX.test(cursor.value.raw)) {
-        radix = 16;
-    }
-    else if (IS_OCTAL.test(cursor.value.raw)) {
-        radix = 8;
-    }
-    else if (IS_BINARY.test(cursor.value.raw)) {
-        radix = 2;
-    }
-    const value = parseInt(cursor
-        .value.raw.replace(IS_DIVIDER, '')
-        .replace(IS_OCTAL, '')
-        .replace(IS_BINARY, ''), radix);
-    return {
-        type: NodeType.Integer,
-        loc: cursor.value.loc,
-        raw: cursor.value.raw,
-        value
-    };
-}
-function inlineTable(cursor, input) {
-    if (cursor.value.raw !== '{') {
-        throw new ParseError(input, cursor.value.loc.start, `Expected "{" for inline table, found ${cursor.value.raw}`);
-    }
-    // 6. InlineTable
-    const value = {
-        type: NodeType.InlineTable,
-        loc: cloneLocation(cursor.value.loc),
-        items: []
-    };
-    const comments = [];
-    cursor.next();
-    while (!cursor.done &&
-        !(cursor.value.type === TokenType.Curly && cursor.value.raw === '}')) {
-        // TOML 1.1.0: Handle comments in inline tables
-        if (cursor.value.type === TokenType.Comment) {
-            comments.push(comment(cursor));
-            cursor.next();
-            continue;
-        }
-        if (cursor.value.type === TokenType.Comma) {
-            const previous = value.items[value.items.length - 1];
-            if (!previous) {
-                throw new ParseError(input, cursor.value.loc.start, 'Found "," without previous value in inline table');
-            }
-            previous.comma = true;
-            previous.loc.end = cursor.value.loc.start;
-            cursor.next();
-            continue;
-        }
-        const [item, ...additional_comments] = walkBlock(cursor, input);
-        if (item.type !== NodeType.KeyValue) {
-            throw new ParseError(input, cursor.value.loc.start, `Only key-values are supported in inline tables, found ${item.type}`);
-        }
-        const inline_item = {
-            type: NodeType.InlineItem,
-            loc: cloneLocation(item.loc),
-            item,
-            comma: false
-        };
-        value.items.push(inline_item);
-        merge(comments, additional_comments);
-        cursor.next();
-    }
-    if (cursor.done ||
-        cursor.value.type !== TokenType.Curly ||
-        cursor.value.raw !== '}') {
-        throw new ParseError(input, cursor.done ? value.loc.start : cursor.value.loc.start, `Expected "}", found ${cursor.done ? 'end of file' : cursor.value.raw}`);
-    }
-    value.loc.end = cursor.value.loc.end;
-    return [value, comments];
-}
-function inlineArray(cursor, input) {
-    // 7. InlineArray
-    if (cursor.value.raw !== '[') {
-        throw new ParseError(input, cursor.value.loc.start, `Expected "[" for inline array, found ${cursor.value.raw}`);
-    }
-    const value = {
-        type: NodeType.InlineArray,
-        loc: cloneLocation(cursor.value.loc),
-        items: []
-    };
-    let comments = [];
-    cursor.next();
-    while (!cursor.done &&
-        !(cursor.value.type === TokenType.Bracket && cursor.value.raw === ']')) {
-        if (cursor.value.type === TokenType.Comma) {
-            const previous = value.items[value.items.length - 1];
-            if (!previous) {
-                throw new ParseError(input, cursor.value.loc.start, 'Found "," without previous value for inline array');
-            }
-            previous.comma = true;
-            previous.loc.end = cursor.value.loc.start;
-        }
-        else if (cursor.value.type === TokenType.Comment) {
-            comments.push(comment(cursor));
-        }
-        else {
-            const [item, ...additional_comments] = walkValue$1(cursor, input);
-            const inline_item = {
-                type: NodeType.InlineItem,
-                loc: cloneLocation(item.loc),
-                item,
-                comma: false
-            };
-            value.items.push(inline_item);
-            merge(comments, additional_comments);
-        }
-        cursor.next();
-    }
-    if (cursor.done ||
-        cursor.value.type !== TokenType.Bracket ||
-        cursor.value.raw !== ']') {
-        throw new ParseError(input, cursor.done ? value.loc.start : cursor.value.loc.start, `Expected "]", found ${cursor.done ? 'end of file' : cursor.value.raw}`);
-    }
-    value.loc.end = cursor.value.loc.end;
-    return [value, comments];
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// The traverse function is used to walk the AST and call the visitor functions
-////////////////////////////////////////////////////////////////////////////////
-function traverse(ast, visitor) {
-    if (isIterable(ast)) {
-        traverseArray(ast, null);
-    }
-    else {
-        traverseNode(ast, null);
-    }
-    function traverseArray(array, parent) {
-        for (const node of array) {
-            traverseNode(node, parent);
-        }
-    }
-    function traverseNode(node, parent) {
-        const visit = visitor[node.type];
-        if (visit && typeof visit === 'function') {
-            visit(node, parent);
-        }
-        if (visit && visit.enter) {
-            visit.enter(node, parent);
-        }
-        switch (node.type) {
-            case NodeType.Document:
-                traverseArray(node.items, node);
-                break;
-            case NodeType.Table:
-                traverseNode(node.key, node);
-                traverseArray(node.items, node);
-                break;
-            case NodeType.TableKey:
-                traverseNode(node.item, node);
-                break;
-            case NodeType.TableArray:
-                traverseNode(node.key, node);
-                traverseArray(node.items, node);
-                break;
-            case NodeType.TableArrayKey:
-                traverseNode(node.item, node);
-                break;
-            case NodeType.KeyValue:
-                traverseNode(node.key, node);
-                traverseNode(node.value, node);
-                break;
-            case NodeType.InlineArray:
-                traverseArray(node.items, node);
-                break;
-            case NodeType.InlineItem:
-                traverseNode(node.item, node);
-                break;
-            case NodeType.InlineTable:
-                traverseArray(node.items, node);
-                break;
-            case NodeType.Key:
-            case NodeType.String:
-            case NodeType.Integer:
-            case NodeType.Float:
-            case NodeType.Boolean:
-            case NodeType.DateTime:
-            case NodeType.Comment:
-                break;
-            default:
-                throw new Error(`Unrecognized node type "${node.type}"`);
-        }
-        if (visit && visit.exit) {
-            visit.exit(node, parent);
-        }
-    }
-}
-
-const enter_offsets = new WeakMap();
-const getEnterOffsets = (root) => {
-    if (!enter_offsets.has(root)) {
-        enter_offsets.set(root, new WeakMap());
-    }
-    return enter_offsets.get(root);
-};
-const exit_offsets = new WeakMap();
-const getExitOffsets = (root) => {
-    if (!exit_offsets.has(root)) {
-        exit_offsets.set(root, new WeakMap());
-    }
-    return exit_offsets.get(root);
-};
-//TODO: Add getOffsets function to get all offsets contained in the tree
-function replace(root, parent, existing, replacement) {
-    // First, replace existing node
-    // (by index for items, item, or key/value)
-    if (hasItems(parent)) {
-        const index = parent.items.indexOf(existing);
-        if (index < 0) {
-            throw new Error(`Could not find existing item in parent node for replace`);
-        }
-        parent.items.splice(index, 1, replacement);
-        // This next case is a special case for Inline-Table item
-        // however due to the fact that both replacement of the whole Inline-Table and Inline-Table element will have the same parent,
-        // we need to make sure it's not an Inline-Table 
-    }
-    else if (isKeyValue(parent) && isInlineTable(parent.value) && !isInlineTable(existing)) {
-        const index = parent.value.items.indexOf(existing);
-        if (index < 0) {
-            throw new Error(`Could not find existing item in parent node for replace`);
-        }
-        parent.value.items.splice(index, 1, replacement);
-    }
-    else if (hasItem(parent)) {
-        parent.item = replacement;
-    }
-    else if (isKeyValue(parent)) {
-        if (parent.key === existing) {
-            parent.key = replacement;
-        }
-        else {
-            parent.value = replacement;
-        }
-    }
-    else {
-        throw new Error(`Unsupported parent type "${parent.type}" for replace`);
-    }
-    // Shift the replacement node into the same start position as existing
-    const shift = {
-        lines: existing.loc.start.line - replacement.loc.start.line,
-        columns: existing.loc.start.column - replacement.loc.start.column
-    };
-    shiftNode(replacement, shift);
-    // Apply offsets after replacement node
-    const existing_span = getSpan(existing.loc);
-    const replacement_span = getSpan(replacement.loc);
-    const offset = {
-        lines: replacement_span.lines - existing_span.lines,
-        columns: replacement_span.columns - existing_span.columns
-    };
-    addOffset(offset, getExitOffsets(root), replacement, existing);
-}
-/**
- * Inserts a child node into the AST.
- *
- * @param root - The root node of the AST
- * @param parent - The parent node to insert the child into
- * @param child - The child node to insert
- * @param index - The index at which to insert the child (optional)
- * @param forceInline - Whether to force inline positioning even for document-level insertions (optional)
- */
-function insert(root, parent, child, index, forceInline) {
-    if (!hasItems(parent)) {
-        throw new Error(`Unsupported parent type "${parent.type}" for insert`);
-    }
-    index = (index != null && typeof index === 'number') ? index : parent.items.length;
-    let shift;
-    let offset;
-    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));
-    }
-    shiftNode(child, shift);
-    // The child element is placed relative to the previous element,
-    // if the previous element has an offset, need to position relative to that
-    // -> Move previous offset to child's offset
-    const previous = parent.items[index - 1];
-    const previous_offset = previous && getExitOffsets(root).get(previous);
-    if (previous_offset) {
-        offset.lines += previous_offset.lines;
-        offset.columns += previous_offset.columns;
-        getExitOffsets(root).delete(previous);
-    }
-    const offsets = getExitOffsets(root);
-    offsets.set(child, offset);
-}
-function insertOnNewLine(parent, child, index) {
-    if (!isBlock(child)) {
-        throw new Error(`Incompatible child type "${child.type}"`);
-    }
-    const previous = parent.items[index - 1];
-    const use_first_line = isDocument(parent) && !parent.items.length;
-    parent.items.splice(index, 0, child);
-    // Set start location from previous item or start of array
-    // (previous is undefined for empty array or inserting at first item)
-    const start = previous
-        ? {
-            line: previous.loc.end.line,
-            column: !isComment(previous) ? previous.loc.start.column : parent.loc.start.column
-        }
-        : clonePosition(parent.loc.start);
-    const isSquareBracketsStructure = isTable(child) || isTableArray(child);
-    let leading_lines = 0;
-    if (use_first_line) ;
-    else if (isSquareBracketsStructure) {
-        leading_lines = 2;
-    }
-    else {
-        leading_lines = 1;
-    }
-    start.line += leading_lines;
-    const shift = {
-        lines: start.line - child.loc.start.line,
-        columns: start.column - child.loc.start.column
-    };
-    // Apply offsets after child node
-    const child_span = getSpan(child.loc);
-    const offset = {
-        lines: child_span.lines + (leading_lines - 1),
-        columns: child_span.columns
-    };
-    return { shift, offset };
-}
-/**
- * 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 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 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: useNewLine
-                ? !isComment(previous)
-                    ? previous.loc.start.column
-                    : parent.loc.start.column
-                : previous.loc.end.column
-        }
-        : clonePosition(parent.loc.start);
-    let leading_lines = 0;
-    if (useNewLine) {
-        leading_lines = 1;
-    }
-    else {
-        // 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 = {
-        lines: start.line - child.loc.start.line,
-        columns: start.column - child.loc.start.column
-    };
-    // 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 +
-            (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
-    //
-    //      X
-    // [ 1, 2, 3 ]
-    //    ^-^
-    // -> Remove element 2 and apply 0,-3 offset to 1
-    //
-    // [table]
-    // a = 1
-    // b = 2 # X
-    // c = 3
-    // -> Remove element 2 and apply -1,0 offset to 1
-    if (!hasItems(parent)) {
-        throw new Error(`Unsupported parent type "${parent.type}" for remove`);
-    }
-    let index = parent.items.indexOf(node);
-    if (index < 0) {
-        // Try again, looking at child items for nodes like InlineArrayItem
-        index = parent.items.findIndex(item => hasItem(item) && item.item === node);
-        if (index < 0) {
-            throw new Error('Could not find node in parent for removal');
-        }
-        node = parent.items[index];
-    }
-    const previous = parent.items[index - 1];
-    let next = parent.items[index + 1];
-    // Remove node
-    parent.items.splice(index, 1);
-    let removed_span = getSpan(node.loc);
-    // Remove an associated comment that appears on the same line
-    //
-    // [table]
-    // a = 1
-    // b = 2 # remove this too
-    // c = 3
-    //
-    // TODO InlineTable - this only applies to comments in Table/TableArray
-    if (next && isComment(next) && next.loc.start.line === node.loc.end.line) {
-        // Add comment to removed
-        removed_span = getSpan({ start: node.loc.start, end: next.loc.end });
-        // Shift to next item
-        // (use same index since node has already been removed)
-        next = parent.items[index + 1];
-        // Remove comment
-        parent.items.splice(index, 1);
-    }
-    // For inline tables and arrays, check whether the line should be kept
-    const is_inline = previous && isInlineItem(previous) || next && isInlineItem(next);
-    const previous_on_same_line = previous && previous.loc.end.line === node.loc.start.line;
-    const next_on_sameLine = next && next.loc.start.line === node.loc.end.line;
-    const keep_line = is_inline && (previous_on_same_line || next_on_sameLine);
-    const offset = {
-        lines: -(removed_span.lines - (keep_line ? 1 : 0)),
-        columns: -removed_span.columns
-    };
-    // If there is nothing left, don't perform any offsets
-    if (previous === undefined && next === undefined) {
-        offset.lines = 0;
-        offset.columns = 0;
-    }
-    // Offset for comma and remove comma that appear in front of the element (if-needed)
-    if (is_inline && previous_on_same_line) {
-        offset.columns -= 2;
-    }
-    // If first element in array/inline-table, remove space for comma and space after element
-    if (is_inline && !previous && next) {
-        offset.columns -= 2;
-    }
-    if (is_inline && previous && !next) {
-        // 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;
-    const target_offsets = previous ? getExitOffsets(root) : getEnterOffsets(root);
-    const node_offsets = getExitOffsets(root);
-    const previous_offset = target_offsets.get(target);
-    if (previous_offset) {
-        offset.lines += previous_offset.lines;
-        offset.columns += previous_offset.columns;
-    }
-    const removed_offset = node_offsets.get(node);
-    if (removed_offset) {
-        offset.lines += removed_offset.lines;
-        offset.columns += removed_offset.columns;
-    }
-    target_offsets.set(target, offset);
-}
-function applyBracketSpacing(root, node, bracket_spacing = true) {
-    // Can only add bracket spacing currently
-    if (!bracket_spacing)
-        return;
-    if (!node.items.length)
-        return;
-    // Apply enter to node so that items are affected
-    addOffset({ lines: 0, columns: 1 }, getEnterOffsets(root), node);
-    // Apply exit to last node in items
-    const last_item = last(node.items);
-    addOffset({ lines: 0, columns: 1 }, getExitOffsets(root), last_item);
-}
-function applyTrailingComma(root, node, trailing_commas = false) {
-    // Can only add trailing comma currently
-    if (!trailing_commas)
-        return;
-    if (!node.items.length)
-        return;
-    const last_item = last(node.items);
-    last_item.comma = true;
-    addOffset({ lines: 0, columns: 1 }, getExitOffsets(root), last_item);
-}
-/**
- * Applies all accumulated write offsets (enter and exit) to the given AST node.
- * This function adjusts the start and end locations of each node in the tree based on
- * the offsets stored in the `enter` and `exit` maps. It ensures that the tree's location
- * data is consistent after modifications.
- *
- * @param root - The root node of the AST tree to which the write offsets will be applied.
- */
-function applyWrites(root) {
-    const enter = getEnterOffsets(root);
-    const exit = getExitOffsets(root);
-    const offset = {
-        lines: 0,
-        columns: {}
-    };
-    function shiftStart(node) {
-        const lineOffset = offset.lines;
-        node.loc.start.line += lineOffset;
-        const columnOffset = offset.columns[node.loc.start.line] || 0;
-        node.loc.start.column += columnOffset;
-        const entering = enter.get(node);
-        if (entering) {
-            offset.lines += entering.lines;
-            offset.columns[node.loc.start.line] =
-                (offset.columns[node.loc.start.line] || 0) + entering.columns;
-        }
-    }
-    function shiftEnd(node) {
-        const lineOffset = offset.lines;
-        node.loc.end.line += lineOffset;
-        const columnOffset = offset.columns[node.loc.end.line] || 0;
-        node.loc.end.column += columnOffset;
-        const exiting = exit.get(node);
-        if (exiting) {
-            offset.lines += exiting.lines;
-            offset.columns[node.loc.end.line] =
-                (offset.columns[node.loc.end.line] || 0) + exiting.columns;
-        }
-    }
-    const shiftLocation = {
-        enter: shiftStart,
-        exit: shiftEnd
-    };
-    traverse(root, {
-        [NodeType.Document]: shiftLocation,
-        [NodeType.Table]: shiftLocation,
-        [NodeType.TableArray]: shiftLocation,
-        [NodeType.InlineTable]: shiftLocation,
-        [NodeType.InlineArray]: shiftLocation,
-        [NodeType.InlineItem]: shiftLocation,
-        [NodeType.TableKey]: shiftLocation,
-        [NodeType.TableArrayKey]: shiftLocation,
-        [NodeType.KeyValue]: {
-            enter(node) {
-                const start_line = node.loc.start.line + offset.lines;
-                const key_offset = exit.get(node.key);
-                node.equals += (offset.columns[start_line] || 0) + (key_offset ? key_offset.columns : 0);
-                shiftStart(node);
-            },
-            exit: shiftEnd
-        },
-        [NodeType.Key]: shiftLocation,
-        [NodeType.String]: shiftLocation,
-        [NodeType.Integer]: shiftLocation,
-        [NodeType.Float]: shiftLocation,
-        [NodeType.Boolean]: shiftLocation,
-        [NodeType.DateTime]: shiftLocation,
-        [NodeType.Comment]: shiftLocation
-    });
-    enter_offsets.delete(root);
-    exit_offsets.delete(root);
-}
-function shiftNode(node, span, options = {}) {
-    const { first_line_only = false } = options;
-    const start_line = node.loc.start.line;
-    const { lines, columns } = span;
-    const move = (node) => {
-        if (!first_line_only || node.loc.start.line === start_line) {
-            node.loc.start.column += columns;
-            node.loc.end.column += columns;
-        }
-        node.loc.start.line += lines;
-        node.loc.end.line += lines;
-    };
-    traverse(node, {
-        [NodeType.Table]: move,
-        [NodeType.TableKey]: move,
-        [NodeType.TableArray]: move,
-        [NodeType.TableArrayKey]: move,
-        [NodeType.KeyValue](node) {
-            move(node);
-            node.equals += columns;
-        },
-        [NodeType.Key]: move,
-        [NodeType.String]: move,
-        [NodeType.Integer]: move,
-        [NodeType.Float]: move,
-        [NodeType.Boolean]: move,
-        [NodeType.DateTime]: move,
-        [NodeType.InlineArray]: move,
-        [NodeType.InlineItem]: move,
-        [NodeType.InlineTable]: move,
-        [NodeType.Comment]: move
-    });
-    return node;
-}
-function perLine(array) {
-    if (!array.items.length)
-        return false;
-    const span = getSpan(array.loc);
-    return span.lines > array.items.length;
-}
-function addOffset(offset, offsets, node, from) {
-    const previous_offset = offsets.get(from || node);
-    if (previous_offset) {
-        offset.lines += previous_offset.lines;
-        offset.columns += previous_offset.columns;
-    }
-    offsets.set(node, offset);
-}
-
-/**
- * Generates a new TOML document node.
- *
- * @returns A new Document node.
- */
-function generateDocument() {
-    return {
-        type: NodeType.Document,
-        loc: { start: zero(), end: zero() },
-        items: []
-    };
-}
-function generateTable(key) {
-    const table_key = generateTableKey(key);
-    return {
-        type: NodeType.Table,
-        loc: cloneLocation(table_key.loc),
-        key: table_key,
-        items: []
-    };
-}
-function generateTableKey(key) {
-    const raw = keyValueToRaw(key);
-    return {
-        type: NodeType.TableKey,
-        loc: {
-            start: zero(),
-            end: { line: 1, column: raw.length + 2 }
-        },
-        item: {
-            type: NodeType.Key,
-            loc: {
-                start: { line: 1, column: 1 },
-                end: { line: 1, column: raw.length + 1 }
-            },
-            value: key,
-            raw
-        }
-    };
-}
-function generateTableArray(key) {
-    const table_array_key = generateTableArrayKey(key);
-    return {
-        type: NodeType.TableArray,
-        loc: cloneLocation(table_array_key.loc),
-        key: table_array_key,
-        items: []
-    };
-}
-function generateTableArrayKey(key) {
-    const raw = keyValueToRaw(key);
-    return {
-        type: NodeType.TableArrayKey,
-        loc: {
-            start: zero(),
-            end: { line: 1, column: raw.length + 4 }
-        },
-        item: {
-            type: NodeType.Key,
-            loc: {
-                start: { line: 1, column: 2 },
-                end: { line: 1, column: raw.length + 2 }
-            },
-            value: key,
-            raw
-        }
-    };
-}
-function generateKeyValue(key, value) {
-    const key_node = generateKey(key);
-    const { column } = key_node.loc.end;
-    const equals = column + 1;
-    shiftNode(value, { lines: 0, columns: column + 3 - value.loc.start.column }, { first_line_only: true });
-    return {
-        type: NodeType.KeyValue,
-        loc: {
-            start: clonePosition(key_node.loc.start),
-            end: clonePosition(value.loc.end)
-        },
-        key: key_node,
-        equals,
-        value
-    };
-}
-const IS_BARE_KEY = /^[\w-]+$/;
-function keyValueToRaw(value) {
-    return value.map(part => (IS_BARE_KEY.test(part) ? part : JSON.stringify(part))).join('.');
-}
-function generateKey(value) {
-    const raw = keyValueToRaw(value);
-    return {
-        type: NodeType.Key,
-        loc: { start: zero(), end: { line: 1, column: raw.length } },
-        raw,
-        value
-    };
-}
-/**
- * Generates a new String node, preserving multiline format if existingRaw is provided.
- *
- * @param value - The string value.
- * @param existingRaw - The existing raw string to determine multiline format (optional).
- * @returns A new String node.
- */
-function generateString(value, existingRaw) {
-    let raw;
-    if (existingRaw && isMultilineString(existingRaw)) {
-        // Preserve multiline format
-        let isLiteral = existingRaw.startsWith("'''");
-        // Literal strings cannot contain ''' - convert to basic string if needed
-        if (isLiteral && value.includes("'''")) {
-            isLiteral = false;
-        }
-        const delimiter = isLiteral ? "'''" : '"""';
-        // Detect newline character from existing raw
-        const newlineChar = existingRaw.includes('\r\n') ? '\r\n' : '\n';
-        const hasLeadingNewline = existingRaw.startsWith(`${delimiter}${newlineChar}`) ||
-            ((existingRaw.startsWith("'''\n") || existingRaw.startsWith("'''\r\n")) && !isLiteral);
-        let escaped;
-        if (isLiteral) {
-            // Literal strings: no escaping needed (we already checked for ''' above)
-            escaped = value;
-        }
-        else {
-            // Basic multiline strings: escape backslashes, control characters, and triple quotes
-            escaped = value
-                .replace(/\\/g, '\\\\') // Escape backslashes first
-                .replace(/\x08/g, '\\b') // Backspace (U+0008)
-                .replace(/\f/g, '\\f') // Form feed (U+000C)
-                .replace(/\t/g, '\\t') // Tab (U+0009)
-                .replace(/[\x00-\x07\x0B\x0E-\x1F\x7F]/g, (char) => {
-                // Escape other control characters
-                const code = char.charCodeAt(0);
-                return '\\u' + code.toString(16).padStart(4, '0').toUpperCase();
-            })
-                // Escape triple quotes safely: two literal quotes + escaped quote
-                .replace(/"""/g, '""\\\"');
-        }
-        // Format with or without leading newline based on original
-        if (hasLeadingNewline) {
-            raw = `${delimiter}${newlineChar}${escaped}${delimiter}`;
-        }
-        else {
-            raw = `${delimiter}${escaped}${delimiter}`;
-        }
-    }
-    else {
-        raw = JSON.stringify(value);
-    }
-    // Calculate proper end location for multiline strings
-    let endLocation;
-    if (raw.includes('\r\n') || (raw.includes('\n') && !raw.includes('\r\n'))) {
-        const newlineChar = raw.includes('\r\n') ? '\r\n' : '\n';
-        const lineCount = (raw.match(new RegExp(newlineChar === '\r\n' ? '\\r\\n' : '\\n', 'g')) || []).length;
-        if (lineCount > 0) {
-            endLocation = {
-                line: 1 + lineCount,
-                column: 3 // length of delimiter (""" or ''')
-            };
-        }
-        else {
-            endLocation = { line: 1, column: raw.length };
-        }
-    }
-    else {
-        endLocation = { line: 1, column: raw.length };
-    }
-    return {
-        type: NodeType.String,
-        loc: { start: zero(), end: endLocation },
-        raw,
-        value
-    };
-}
-/**
- * Generates a new Integer node.
- *
- * @param value - The integer value.
- * @returns A new Integer node.
- */
-function generateInteger(value) {
-    const raw = value.toString();
-    return {
-        type: NodeType.Integer,
-        loc: { start: zero(), end: { line: 1, column: raw.length } },
-        raw,
-        value
-    };
-}
-function generateFloat(value) {
-    let raw;
-    if (value === Infinity) {
-        raw = 'inf';
-    }
-    else if (value === -Infinity) {
-        raw = '-inf';
-    }
-    else if (Number.isNaN(value)) {
-        raw = 'nan';
-    }
-    else if (Object.is(value, -0)) {
-        raw = '-0.0';
-    }
-    else {
-        raw = value.toString();
-    }
-    return {
-        type: NodeType.Float,
-        loc: { start: zero(), end: { line: 1, column: raw.length } },
-        raw,
-        value
-    };
-}
-function generateBoolean(value) {
-    return {
-        type: NodeType.Boolean,
-        loc: { start: zero(), end: { line: 1, column: value ? 4 : 5 } },
-        value
-    };
-}
-function generateDateTime(value, format) {
-    // Convert Date objects with zero time components to LocalDate
-    // so they are serialized as date-only in TOML
-    if (format.truncateZeroTimeInDates &&
-        value.getUTCHours() === 0 &&
-        value.getUTCMinutes() === 0 &&
-        value.getUTCSeconds() === 0 &&
-        value.getUTCMilliseconds() === 0) {
-        value = new LocalDate(value.toISOString().split('T')[0]);
-    }
-    // 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,
-        loc: { start: zero(), end: { line: 1, column: raw.length } },
-        raw,
-        value
-    };
-}
-function generateInlineArray() {
-    return {
-        type: NodeType.InlineArray,
-        loc: { start: zero(), end: { line: 1, column: 2 } },
-        items: []
-    };
-}
-function generateInlineItem(item) {
-    return {
-        type: NodeType.InlineItem,
-        loc: cloneLocation(item.loc),
-        item,
-        comma: false
-    };
-}
-function generateInlineTable() {
-    return {
-        type: NodeType.InlineTable,
-        loc: { start: zero(), end: { line: 1, column: 2 } },
-        items: []
-    };
-}
-
-// 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;
-const DEFAULT_TRUNCATE_ZERO_TIME_IN_DATES = false;
-const DEFAULT_USE_TABS_FOR_INDENTATION = false;
-// Detects if trailing commas are used in the existing TOML by examining the AST
-// Returns true if trailing commas are used, false if not or comma-separated structures found (ie. default to false)
-function detectTrailingComma(ast) {
-    // 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;
-}
-// Detects if tabs are used for indentation by checking the first few indented lines
-function detectTabsForIndentation(str) {
-    const lines = str.split(/\r?\n/);
-    let tabCount = 0;
-    let spaceCount = 0;
-    for (const line of lines) {
-        // Skip empty lines
-        if (line.length === 0)
-            continue;
-        // Check the first character of non-empty lines
-        if (line[0] === '\t') {
-            tabCount++;
-        }
-        else if (line[0] === ' ') {
-            spaceCount++;
-        }
-        // If we've seen enough evidence, make a decision
-        if (tabCount + spaceCount >= 5) {
-            break;
-        }
-    }
-    // Prefer tabs if we see more tabs than spaces
-    return tabCount > spaceCount;
-}
-/**
- * Validates a format object and warns about unsupported properties.
- * Throws errors for supported properties with invalid types.
- * @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', 'truncateZeroTimeInDates', 'useTabsForIndentation']);
-    const validatedFormat = {};
-    const unsupportedProperties = [];
-    const invalidTypeProperties = [];
-    // Check all enumerable properties of the format object, including properties
-    // provided via the prototype chain (common in JS Object.create(...) patterns).
-    for (const key in format) {
-        const isOwnEnumerable = Object.prototype.hasOwnProperty.call(format, key);
-        if (supportedProperties.has(key)) {
-            const value = format[key];
-            // Type validation for each property
-            switch (key) {
-                case 'newLine':
-                    if (typeof value === 'string') {
-                        validatedFormat.newLine = value;
-                    }
-                    else {
-                        invalidTypeProperties.push(`${key} (expected string, got ${typeof value})`);
-                    }
-                    break;
-                case 'trailingNewline':
-                    if (typeof value === 'boolean' || typeof value === 'number') {
-                        validatedFormat.trailingNewline = value;
-                    }
-                    else {
-                        invalidTypeProperties.push(`${key} (expected boolean or number, got ${typeof value})`);
-                    }
-                    break;
-                case 'trailingComma':
-                case 'bracketSpacing':
-                case 'truncateZeroTimeInDates':
-                case 'useTabsForIndentation':
-                    if (typeof value === 'boolean') {
-                        validatedFormat[key] = value;
-                    }
-                    else {
-                        invalidTypeProperties.push(`${key} (expected boolean, got ${typeof value})`);
-                    }
-                    break;
-                case 'inlineTableStart':
-                    if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {
-                        validatedFormat.inlineTableStart = value;
-                    }
-                    else if (value === undefined || value === null) {
-                        // Allow undefined/null to use default
-                        validatedFormat.inlineTableStart = value;
-                    }
-                    else {
-                        invalidTypeProperties.push(`${key} (expected non-negative integer or undefined, got ${typeof value})`);
-                    }
-                    break;
-            }
-        }
-        else if (isOwnEnumerable) {
-            unsupportedProperties.push(key);
-        }
-    }
-    // Warn about unsupported properties
-    if (unsupportedProperties.length > 0) {
-        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, _e, _f;
-    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, (_e = validatedFormat.truncateZeroTimeInDates) !== null && _e !== void 0 ? _e : fallbackFormat.truncateZeroTimeInDates, (_f = validatedFormat.useTabsForIndentation) !== null && _f !== void 0 ? _f : fallbackFormat.useTabsForIndentation);
-        }
-    }
-    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;
-    constructor(newLine, trailingNewline, trailingComma, bracketSpacing, inlineTableStart, truncateZeroTimeInDates, useTabsForIndentation) {
-        // Use provided values or fall back to defaults
-        this.newLine = newLine !== null && newLine !== void 0 ? newLine : DEFAULT_NEWLINE;
-        this.trailingNewline = trailingNewline !== null && trailingNewline !== void 0 ? trailingNewline : DEFAULT_TRAILING_NEWLINE;
-        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;
-        this.truncateZeroTimeInDates = truncateZeroTimeInDates !== null && truncateZeroTimeInDates !== void 0 ? truncateZeroTimeInDates : DEFAULT_TRUNCATE_ZERO_TIME_IN_DATES;
-        this.useTabsForIndentation = useTabsForIndentation !== null && useTabsForIndentation !== void 0 ? useTabsForIndentation : DEFAULT_USE_TABS_FOR_INDENTATION;
-    }
-    /**
-     * Creates a new TomlFormat instance with default formatting preferences.
-     *
-     * @returns A new TomlFormat instance with default values:
-     *   - newLine: '\n'
-     *   - trailingNewline: 1
-     *   - trailingComma: false
-     *   - bracketSpacing: true
-     *   - inlineTableStart: 1
-     *   - truncateZeroTimeInDates: false
-     */
-    static default() {
-        return new TomlFormat(DEFAULT_NEWLINE, DEFAULT_TRAILING_NEWLINE, DEFAULT_TRAILING_COMMA, DEFAULT_BRACKET_SPACING, DEFAULT_INLINE_TABLE_START, DEFAULT_TRUNCATE_ZERO_TIME_IN_DATES, DEFAULT_USE_TABS_FOR_INDENTATION);
-    }
-    /**
-     * 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;
-        }
-        // Detect if tabs are used for indentation
-        format.useTabsForIndentation = detectTabsForIndentation(tomlString);
-        // inlineTableStart uses default value since auto-detection would require
-        // complex analysis of nested table formatting preferences
-        format.inlineTableStart = DEFAULT_INLINE_TABLE_START;
-        // truncateZeroTimeInDates uses default value as well
-        // We could always implement detection logic if needed
-        // That would imply checking if all dates have no time component in the TOML.
-        // However, it's not because all dates have no time component that a new key-value can't be introduced where the time component corresponds to midnight.
-        format.truncateZeroTimeInDates = DEFAULT_TRUNCATE_ZERO_TIME_IN_DATES;
-        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;
-        const is_inline_table = isInlineTable(item.value);
-        const is_inline_array = isInlineArray(item.value) &&
-            item.value.items.length &&
-            isInlineTable(item.value.items[0].item);
-        // 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);
-        if (isInlineTable(node.value)) {
-            insert(document, document, formatTable(node));
-        }
-        else {
-            formatTableArray(node).forEach(table_array => {
-                insert(document, document, table_array);
-            });
-        }
-    });
-    applyWrites(document);
-    return document;
-}
-function formatTable(key_value) {
-    const table = generateTable(key_value.key.value);
-    for (const item of key_value.value.items) {
-        insert(table, table, item.item);
-    }
-    applyWrites(table);
-    return table;
-}
-function formatTableArray(key_value) {
-    const root = generateDocument();
-    for (const inline_array_item of key_value.value.items) {
-        const table_array = generateTableArray(key_value.key.value);
-        insert(root, root, table_array);
-        for (const inline_table_item of inline_array_item.item.items) {
-            insert(root, table_array, inline_table_item.item);
-        }
-    }
-    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;
-}
-function formatEmptyLines(document) {
-    let shift = 0;
-    let previous = 0;
-    for (const item of document.items) {
-        if (previous === 0 && item.loc.start.line > 1) {
-            // Remove leading newlines
-            shift = 1 - item.loc.start.line;
-        }
-        else if (item.loc.start.line + shift > previous + 2) {
-            shift += previous + 2 - (item.loc.start.line + shift);
-        }
-        shiftNode(item, {
-            lines: shift,
-            columns: 0
-        });
-        previous = item.loc.end.line;
-    }
-    return document;
-}
-
-function parseJS(value, format = TomlFormat.default()) {
-    value = toJSON(value);
-    // Reorder the elements in the object
-    value = reorderElements(value);
-    const document = generateDocument();
-    for (const item of walkObject(value, format)) {
-        insert(document, document, item);
-    }
-    applyWrites(document);
-    // Heuristics:
-    // 1. Top-level objects/arrays should be tables/table arrays
-    // 2. Convert objects/arrays to tables/table arrays based on print width
-    // 3. Convert nested inline tables to separate tables based on preferNestedTablesMultiline
-    const formatted = pipe(document, document => formatTopLevel(document, format), document => formatNestedTablesMultiline(document, format), document => formatPrintWidth(document));
-    // Apply formatEmptyLines only once at the end
-    return formatEmptyLines(formatted);
-}
-/**
-This function makes sure that properties that are simple values (not objects or arrays) are ordered first,
-and that objects and arrays are ordered last. This makes parseJS more reliable and easier to test.
-*/
-function reorderElements(value) {
-    // Pre-sort keys to avoid multiple iterations
-    const simpleKeys = [];
-    const complexKeys = [];
-    // Separate keys in a single pass
-    for (const key in value) {
-        if (isObject(value[key]) || Array.isArray(value[key])) {
-            complexKeys.push(key);
-        }
-        else {
-            simpleKeys.push(key);
-        }
-    }
-    // Create result with the correct order
-    const result = {};
-    // Add simple values first
-    for (let i = 0; i < simpleKeys.length; i++) {
-        const key = simpleKeys[i];
-        result[key] = value[key];
-    }
-    // Then add complex values
-    for (let i = 0; i < complexKeys.length; i++) {
-        const key = complexKeys[i];
-        result[key] = value[key];
-    }
-    return result;
-}
-function* walkObject(object, format) {
-    for (const key of Object.keys(object)) {
-        yield generateKeyValue([key], walkValue(object[key], format));
-    }
-}
-function walkValue(value, format) {
-    if (value == null) {
-        throw new Error('"null" and "undefined" values are not supported');
-    }
-    if (isString(value)) {
-        return generateString(value);
-    }
-    else if (isInteger(value)) {
-        return generateInteger(value);
-    }
-    else if (isFloat(value)) {
-        return generateFloat(value);
-    }
-    else if (isBoolean(value)) {
-        return generateBoolean(value);
-    }
-    else if (isDate(value)) {
-        return generateDateTime(value, format);
-    }
-    else if (Array.isArray(value)) {
-        return walkInlineArray(value, format);
-    }
-    else {
-        return walkInlineTable(value, format);
-    }
-}
-function walkInlineArray(value, format) {
-    const inline_array = generateInlineArray();
-    for (const element of value) {
-        const item = walkValue(element, format);
-        const inline_array_item = generateInlineItem(item);
-        insert(inline_array, inline_array, inline_array_item);
-    }
-    applyBracketSpacing(inline_array, inline_array, format.bracketSpacing);
-    applyTrailingComma(inline_array, inline_array, format.trailingComma);
-    applyWrites(inline_array);
-    return inline_array;
-}
-function walkInlineTable(value, format) {
-    value = toJSON(value);
-    if (!isObject(value))
-        return walkValue(value, format);
-    const inline_table = generateInlineTable();
-    const items = [...walkObject(value, format)];
-    for (const item of items) {
-        const inline_table_item = generateInlineItem(item);
-        insert(inline_table, inline_table, inline_table_item);
-    }
-    applyBracketSpacing(inline_table, inline_table, format.bracketSpacing);
-    applyTrailingComma(inline_table, inline_table, format.trailingComma);
-    applyWrites(inline_table);
-    return inline_table;
-}
-/**
- * Handles custom object serialization by checking for and using toJSON methods
- *
- * @param value - The value to potentially convert
- * @returns The result of value.toJSON() if available, otherwise the original value
- */
-function toJSON(value) {
-    // Skip null/undefined values
-    if (!value) {
-        return value;
-    }
-    // Skip Date objects (they have special handling)
-    if (isDate(value)) {
-        return value;
-    }
-    // Use object's custom toJSON method if available
-    if (typeof value.toJSON === 'function') {
-        return value.toJSON();
-    }
-    // Otherwise return unmodified
-    return value;
-}
-
-const BY_NEW_LINE = /(\r\n|\n)/g;
-/**
- * Converts an Abstract Syntax Tree (AST) back to TOML format string.
- *
- * This function traverses the AST and reconstructs the original TOML document
- * by writing each node's raw content to the appropriate location coordinates.
- * It preserves the original formatting, spacing, and structure of the TOML file.
- *
- * @param ast - The Abstract Syntax Tree representing the parsed TOML document
- * @param format - The formatting options to use for the output
- * @returns The reconstructed TOML document as a string
- *
- * @example
- * ```typescript
- * const tomlString = toTOML(ast, TomlFormat.default());
- * ```
- */
-function toTOML(ast, format) {
-    const lines = [];
-    const paddingChar = format.useTabsForIndentation ? '\t' : SPACE;
-    traverse(ast, {
-        [NodeType.TableKey](node) {
-            const { start, end } = node.loc;
-            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '[', paddingChar);
-            write(lines, { start: { line: end.line, column: end.column - 1 }, end }, ']', paddingChar);
-        },
-        [NodeType.TableArrayKey](node) {
-            const { start, end } = node.loc;
-            write(lines, { start, end: { line: start.line, column: start.column + 2 } }, '[[', paddingChar);
-            write(lines, { start: { line: end.line, column: end.column - 2 }, end }, ']]', paddingChar);
-        },
-        [NodeType.KeyValue](node) {
-            const { start: { line } } = node.loc;
-            write(lines, { start: { line, column: node.equals }, end: { line, column: node.equals + 1 } }, '=', paddingChar);
-        },
-        [NodeType.Key](node) {
-            write(lines, node.loc, node.raw, paddingChar);
-        },
-        [NodeType.String](node) {
-            write(lines, node.loc, node.raw, paddingChar);
-        },
-        [NodeType.Integer](node) {
-            write(lines, node.loc, node.raw, paddingChar);
-        },
-        [NodeType.Float](node) {
-            write(lines, node.loc, node.raw, paddingChar);
-        },
-        [NodeType.Boolean](node) {
-            write(lines, node.loc, node.value.toString(), paddingChar);
-        },
-        [NodeType.DateTime](node) {
-            write(lines, node.loc, node.raw, paddingChar);
-        },
-        [NodeType.InlineArray](node) {
-            const { start, end } = node.loc;
-            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '[', paddingChar);
-            write(lines, { start: { line: end.line, column: end.column - 1 }, end }, ']', paddingChar);
-        },
-        [NodeType.InlineTable](node) {
-            const { start, end } = node.loc;
-            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '{', paddingChar);
-            write(lines, { start: { line: end.line, column: end.column - 1 }, end }, '}', paddingChar);
-        },
-        [NodeType.InlineItem](node) {
-            if (!node.comma)
-                return;
-            const start = node.loc.end;
-            write(lines, { start, end: { line: start.line, column: start.column + 1 } }, ',', paddingChar);
-        },
-        [NodeType.Comment](node) {
-            write(lines, node.loc, node.raw, paddingChar);
-        }
-    });
-    // Post-process: convert leading spaces to tabs if useTabsForIndentation is enabled
-    if (format.useTabsForIndentation) {
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            // Find the leading whitespace
-            const match = line.match(/^( +)/);
-            if (match) {
-                const leadingSpaces = match[1];
-                // Replace entire leading space sequence with equivalent tabs
-                // Each space becomes a tab (preserving the visual width)
-                const leadingTabs = '\t'.repeat(leadingSpaces.length);
-                lines[i] = leadingTabs + line.substring(leadingSpaces.length);
-            }
-        }
-    }
-    return lines.join(format.newLine) + format.newLine.repeat(format.trailingNewline);
-}
-/**
- * Writes raw string content to specific location coordinates within a lines array.
- *
- * This function is responsible for placing TOML content at precise positions within
- * the output lines, handling multi-line content and preserving existing content
- * around the target location.
- *
- * @param lines - Array of string lines representing the TOML document being built.
- *                Lines are 1-indexed but stored in 0-indexed array.
- * @param loc - Location object specifying where to write the content, containing:
- *              - start: { line: number, column: number } - Starting position (1-indexed line, 0-indexed column)
- *              - end: { line: number, column: number } - Ending position (1-indexed line, 0-indexed column)
- * @param raw - The raw string content to write at the specified location.
- *              Can contain multiple lines separated by \n or \r\n.
- * @param paddingChar - The character to use for padding (space or tab)
- *
- * @throws {Error} When there's a mismatch between location span and raw string line count
- * @throws {Error} When attempting to write to an uninitialized line
- *
- * @example
- * ```typescript
- * const lines = ['', ''];
- * const location = { start: { line: 1, column: 0 }, end: { line: 1, column: 3 } };
- * write(lines, location, 'key', ' ');
- * // Result: lines[0] becomes 'key'
- * ```
- */
-function write(lines, loc, raw, paddingChar = SPACE) {
-    const raw_lines = raw.split(BY_NEW_LINE).filter(line => line !== '\n' && line !== '\r\n');
-    const expected_lines = loc.end.line - loc.start.line + 1;
-    if (raw_lines.length !== expected_lines) {
-        throw new Error(`Mismatch between location and raw string, expected ${expected_lines} lines for "${raw}"`);
-    }
-    for (let i = loc.start.line; i <= loc.end.line; i++) {
-        const line = getLine(lines, i);
-        //Throw if line is uninitialized
-        if (line === undefined) {
-            throw new Error(`Line ${i} is uninitialized when writing "${raw}" at ${loc.start.line}:${loc.start.column} to ${loc.end.line}:${loc.end.column}`);
-        }
-        const is_start_line = i === loc.start.line;
-        const is_end_line = i === loc.end.line;
-        let before = '';
-        if (is_start_line) {
-            const existingBefore = line.substring(0, loc.start.column);
-            if (existingBefore.length < loc.start.column) {
-                // Need to pad - always use spaces during write phase
-                // Tab conversion happens in post-processing for leading indentation only
-                before = existingBefore.padEnd(loc.start.column, SPACE);
-            }
-            else {
-                before = existingBefore;
-            }
-        }
-        const after = is_end_line ? line.substring(loc.end.column) : '';
-        lines[i - 1] = before + raw_lines[i - loc.start.line] + after;
-    }
-}
-/**
- * Safely retrieves a line from the lines array, initializing empty lines as needed.
- *
- * This helper function handles the conversion between 1-indexed line numbers (used in locations)
- * and 0-indexed array positions. It ensures that accessing a line that doesn't exist yet
- * will initialize all preceding lines with empty strings.
- *
- * @param lines - Array of string lines representing the document
- * @param index - 1-indexed line number to retrieve
- * @returns The line content as a string, or empty string for new lines
- *
- * @example
- * ```typescript
- * const lines = ['first line'];
- * const line = getLine(lines, 3); // Initializes lines[1] and lines[2] as empty strings
- * // lines becomes ['first line', '', '']
- * ```
- */
-function getLine(lines, index) {
-    if (!lines[index - 1]) {
-        for (let i = 0; i < index; i++) {
-            if (!lines[i])
-                lines[i] = '';
-        }
-    }
-    return lines[index - 1];
-}
-
-/**
- * Converts the given AST to a JavaScript object.
- *
- * @param ast The abstract syntax tree to convert.
- * @param input The original input string (used for error reporting).
- * @returns The JavaScript object representation of the AST.
- */
-function toJS(ast, input = '') {
-    const result = blank();
-    const tables = new Set();
-    const table_arrays = new Set();
-    const defined = new Set();
-    let active = result;
-    let skip_depth = 0;
-    traverse(ast, {
-        [NodeType.Table](node) {
-            const key = node.key.item.value;
-            try {
-                validateKey(result, key, node.type, { tables, table_arrays, defined });
-            }
-            catch (err) {
-                const e = err;
-                throw new ParseError(input, node.key.loc.start, e.message);
-            }
-            const joined_key = joinKey(key);
-            tables.add(joined_key);
-            defined.add(joined_key);
-            active = ensureTable(result, key);
-        },
-        [NodeType.TableArray](node) {
-            const key = node.key.item.value;
-            try {
-                validateKey(result, key, node.type, { tables, table_arrays, defined });
-            }
-            catch (err) {
-                const e = err;
-                throw new ParseError(input, node.key.loc.start, e.message);
-            }
-            const joined_key = joinKey(key);
-            table_arrays.add(joined_key);
-            defined.add(joined_key);
-            active = ensureTableArray(result, key);
-        },
-        [NodeType.KeyValue]: {
-            enter(node) {
-                if (skip_depth > 0)
-                    return;
-                const key = node.key.value;
-                try {
-                    validateKey(active, key, node.type, { tables, table_arrays, defined });
-                }
-                catch (err) {
-                    const e = err;
-                    throw new ParseError(input, node.key.loc.start, e.message);
-                }
-                const value = toValue(node.value);
-                const target = key.length > 1 ? ensureTable(active, key.slice(0, -1)) : active;
-                target[last(key)] = value;
-                defined.add(joinKey(key));
-            }
-        },
-        [NodeType.InlineTable]: {
-            enter() {
-                // Handled by toValue
-                skip_depth++;
-            },
-            exit() {
-                skip_depth--;
-            }
-        }
-    });
-    return result;
-}
-function toValue(node) {
-    switch (node.type) {
-        case NodeType.InlineTable:
-            const result = blank();
-            node.items.forEach(({ item }) => {
-                const key = item.key.value;
-                const value = toValue(item.value);
-                const target = key.length > 1 ? ensureTable(result, key.slice(0, -1)) : result;
-                target[last(key)] = value;
-            });
-            return result;
-        case NodeType.InlineArray:
-            return node.items.map(item => toValue(item.item));
-        case NodeType.DateTime:
-            // Preserve TOML date/time custom classes so format is retained when
-            // round-tripping through stringify() (e.g. date-only, time-only, local vs offset).
-            // These classes extend Date, so JS users can still treat them as Dates.
-            return node.value;
-        case NodeType.String:
-        case NodeType.Integer:
-        case NodeType.Float:
-        case NodeType.Boolean:
-            return node.value;
-        default:
-            throw new Error(`Unrecognized value type "${node.type}"`);
-    }
-}
-function validateKey(object, key, type, state) {
-    // 1. Cannot override primitive value
-    let parts = [];
-    let index = 0;
-    for (const part of key) {
-        parts.push(part);
-        if (!has(object, part))
-            return;
-        if (isPrimitive(object[part])) {
-            throw new Error(`Invalid key, a value has already been defined for ${parts.join('.')}`);
-        }
-        const joined_parts = joinKey(parts);
-        if (Array.isArray(object[part]) && !state.table_arrays.has(joined_parts)) {
-            throw new Error(`Invalid key, cannot add to a static array at ${joined_parts}`);
-        }
-        const next_is_last = index++ < key.length - 1;
-        object = Array.isArray(object[part]) && next_is_last ? last(object[part]) : object[part];
-    }
-    const joined_key = joinKey(key);
-    // 2. Cannot override table
-    if (object && type === NodeType.Table && state.defined.has(joined_key)) {
-        throw new Error(`Invalid key, a table has already been defined named ${joined_key}`);
-    }
-    // 3. Cannot add table array to static array or table
-    if (object && type === NodeType.TableArray && !state.table_arrays.has(joined_key)) {
-        throw new Error(`Invalid key, cannot add an array of tables to a table at ${joined_key}`);
-    }
-}
-function ensureTable(object, key) {
-    const target = ensure(object, key.slice(0, -1));
-    const last_key = last(key);
-    if (!target[last_key]) {
-        target[last_key] = blank();
-    }
-    return target[last_key];
-}
-function ensureTableArray(object, key) {
-    const target = ensure(object, key.slice(0, -1));
-    const last_key = last(key);
-    if (!target[last_key]) {
-        target[last_key] = [];
-    }
-    const next = blank();
-    target[last(key)].push(next);
-    return next;
-}
-function ensure(object, keys) {
-    return keys.reduce((active, subkey) => {
-        if (!active[subkey]) {
-            active[subkey] = blank();
-        }
-        return Array.isArray(active[subkey]) ? last(active[subkey]) : active[subkey];
-    }, object);
-}
-function isPrimitive(value) {
-    return typeof value !== 'object' && !isDate(value);
-}
-function joinKey(key) {
-    return key.join('.');
-}
-
-var ChangeType;
-(function (ChangeType) {
-    ChangeType["Add"] = "Add";
-    ChangeType["Edit"] = "Edit";
-    ChangeType["Remove"] = "Remove";
-    ChangeType["Move"] = "Move";
-    ChangeType["Rename"] = "Rename";
-})(ChangeType || (ChangeType = {}));
-function isAdd(change) {
-    return change.type === ChangeType.Add;
-}
-function isEdit(change) {
-    return change.type === ChangeType.Edit;
-}
-function isRemove(change) {
-    return change.type === ChangeType.Remove;
-}
-function isMove(change) {
-    return change.type === ChangeType.Move;
-}
-function isRename(change) {
-    return change.type === ChangeType.Rename;
-}
-function diff(before, after, path = []) {
-    if (before === after || datesEqual(before, after)) {
-        return [];
-    }
-    if (Array.isArray(before) && Array.isArray(after)) {
-        return compareArrays(before, after, path);
-    }
-    else if (isObject(before) && isObject(after)) {
-        return compareObjects(before, after, path);
-    }
-    else {
-        return [
-            {
-                type: ChangeType.Edit,
-                path
-            }
-        ];
-    }
-}
-function compareObjects(before, after, path = []) {
-    let changes = [];
-    // 1. Get keys and stable values
-    const before_keys = Object.keys(before);
-    const before_stable = before_keys.map(key => stableStringify(before[key]));
-    const after_keys = Object.keys(after);
-    const after_stable = after_keys.map(key => stableStringify(after[key]));
-    // Check for rename by seeing if object is in both before and after
-    // and that key is no longer used in after
-    const isRename = (stable, search) => {
-        const index = search.indexOf(stable);
-        if (index < 0)
-            return false;
-        const before_key = before_keys[before_stable.indexOf(stable)];
-        return !after_keys.includes(before_key);
-    };
-    // 2. Check for changes, rename, and removed
-    before_keys.forEach((key, index) => {
-        const sub_path = path.concat(key);
-        if (after_keys.includes(key)) {
-            merge(changes, diff(before[key], after[key], sub_path));
-        }
-        else if (isRename(before_stable[index], after_stable)) {
-            const to = after_keys[after_stable.indexOf(before_stable[index])];
-            changes.push({
-                type: ChangeType.Rename,
-                path,
-                from: key,
-                to
-            });
-        }
-        else {
-            changes.push({
-                type: ChangeType.Remove,
-                path: sub_path
-            });
-        }
-    });
-    // 3. Check for additions
-    after_keys.forEach((key, index) => {
-        if (!before_keys.includes(key) && !isRename(after_stable[index], before_stable)) {
-            changes.push({
-                type: ChangeType.Add,
-                path: path.concat(key)
-            });
-        }
-    });
-    return changes;
-}
-function compareArrays(before, after, path = []) {
-    let changes = [];
-    // 1. Convert arrays to stable objects
-    const before_stable = before.map(stableStringify);
-    const after_stable = after.map(stableStringify);
-    // 2. Step through after array making changes to before array as-needed
-    after_stable.forEach((value, index) => {
-        const overflow = index >= before_stable.length;
-        // Check if items are the same
-        if (!overflow && before_stable[index] === value) {
-            return;
-        }
-        // Check if item has been moved -> shift into place
-        const from = before_stable.indexOf(value, index + 1);
-        if (!overflow && from > -1) {
-            changes.push({
-                type: ChangeType.Move,
-                path,
-                from,
-                to: index
-            });
-            const move = before_stable.splice(from, 1);
-            before_stable.splice(index, 0, ...move);
-            return;
-        }
-        // Check if item is removed -> assume it's been edited and replace
-        const removed = !after_stable.includes(before_stable[index]);
-        if (!overflow && removed) {
-            merge(changes, diff(before[index], after[index], path.concat(index)));
-            before_stable[index] = value;
-            return;
-        }
-        // Add as new item and shift existing
-        changes.push({
-            type: ChangeType.Add,
-            path: path.concat(index)
-        });
-        before_stable.splice(index, 0, value);
-    });
-    // 3. Remove any remaining overflow items
-    for (let i = after_stable.length; i < before_stable.length; i++) {
-        changes.push({
-            type: ChangeType.Remove,
-            path: path.concat(i)
-        });
-    }
-    return changes;
-}
-
-function findByPath(node, path) {
-    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);
-    }
-    const indexes = {};
-    let found;
-    if (hasItems(node)) {
-        node.items.some((item, index) => {
-            try {
-                let key = [];
-                if (isKeyValue(item)) {
-                    key = item.key.value;
-                }
-                else if (isTable(item)) {
-                    key = item.key.item.value;
-                }
-                else if (isTableArray(item)) {
-                    key = item.key.item.value;
-                    const key_string = stableStringify(key);
-                    if (!indexes[key_string]) {
-                        indexes[key_string] = 0;
-                    }
-                    const array_index = indexes[key_string]++;
-                    key = key.concat(array_index);
-                }
-                else if (isInlineItem(item) && isKeyValue(item.item)) {
-                    // For InlineItems wrapping KeyValues, extract the key
-                    key = item.item.key.value;
-                }
-                else if (isInlineItem(item)) {
-                    key = [index];
-                }
-                if (key.length && arraysEqual(key, path.slice(0, key.length))) {
-                    // For InlineItems containing KeyValues, we need to search within the value
-                    // but still return the InlineItem or its contents appropriately
-                    if (isInlineItem(item) && isKeyValue(item.item)) {
-                        if (path.length === key.length) {
-                            // If we've matched the full path, return the InlineItem itself
-                            // so it can be found and replaced in the parent's items array
-                            found = item;
-                        }
-                        else {
-                            // Continue searching within the KeyValue's value
-                            found = findByPath(item.item.value, path.slice(key.length));
-                        }
-                    }
-                    else {
-                        found = findByPath(item, path.slice(key.length));
-                    }
-                    return true;
-                }
-                else {
-                    return false;
-                }
-            }
-            catch (err) {
-                return false;
-            }
-        });
-    }
-    if (!found) {
-        throw new Error(`Could not find node at path ${path.join('.')}`);
-    }
-    return found;
-}
-function tryFindByPath(node, path) {
-    try {
-        return findByPath(node, path);
-    }
-    catch (err) { }
-}
-function findParent(node, path) {
-    let parent_path = path;
-    let parent;
-    while (parent_path.length && !parent) {
-        parent_path = parent_path.slice(0, -1);
-        parent = tryFindByPath(node, parent_path);
-    }
-    if (!parent) {
-        throw new Error(`Count not find parent node for path ${path.join('.')}`);
-    }
-    return parent;
-}
-
-/**
- * Applies modifications to a TOML document by comparing an existing TOML string with updated JavaScript data.
- *
- * This function preserves formatting and comments from the existing TOML document while
- * applying changes from the updated data structure. It performs a diff between the existing
- * and updated data, then strategically applies only the necessary changes to maintain the
- * original document structure as much as possible.
- *
- * @param existing - The original TOML document as a string
- * @param updated - The updated JavaScript object with desired changes
- * @param format - Optional formatting options to apply to new or modified sections
- * @returns A new TOML string with the changes applied
- */
-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 = {
-        type: NodeType.Document,
-        loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-        items
-    };
-    // 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));
-    if (changes.length === 0) {
-        return {
-            tomlString: toTOML(items, format),
-            document: existing_document
-        };
-    }
-    const patched_document = applyChanges(existing_document, updated_document, changes, format);
-    // Validate the patched_document
-    // This would prevent overlapping element positions in the AST, but since those are handled at stringification time, we can skip this for now
-    //validate(patched_document);
-    return {
-        tomlString: toTOML(patched_document.items, format),
-        document: patched_document
-    };
-}
-function reorder(changes) {
-    for (let i = 0; i < changes.length; i++) {
-        const change = changes[i];
-        if (isRemove(change)) {
-            let j = i + 1;
-            while (j < changes.length) {
-                const next_change = changes[j];
-                if (isRemove(next_change) && next_change.path[0] === change.path[0] &&
-                    next_change.path[1] > change.path[1]) {
-                    changes.splice(j, 1);
-                    changes.splice(i, 0, next_change);
-                    // We reset i to the beginning of the loop to avoid skipping any changes
-                    i = 0;
-                    break;
-                }
-                j++;
-            }
-        }
-    }
-    return changes;
-}
-/**
- * Preserves formatting from the existing node when applying it to the replacement node.
- * This includes multiline string formats, trailing commas, DateTime formats, etc.
- *
- * @param existing - The existing node with formatting to preserve
- * @param replacement - The replacement node to apply formatting to
- */
-function preserveFormatting(existing, replacement) {
-    // Preserve multiline string format
-    if (isString$1(existing) && isString$1(replacement) && isMultilineString(existing.raw)) {
-        // Generate new string node with preserved multiline format
-        const newString = generateString(replacement.value, existing.raw);
-        replacement.raw = newString.raw;
-        replacement.loc = newString.loc;
-    }
-    // Preserve DateTime format
-    if (isDateTime(existing) && isDateTime(replacement)) {
-        // Analyze the original raw format and create a properly formatted replacement
-        const originalRaw = existing.raw;
-        const newValue = replacement.value;
-        // Create a new date with the original format preserved
-        const formattedDate = DateFormatHelper.createDateWithOriginalFormat(newValue, originalRaw);
-        // Update the replacement with the properly formatted date
-        replacement.value = formattedDate;
-        replacement.raw = formattedDate.toISOString();
-        // Adjust the location information to match the new raw length
-        const lengthDiff = replacement.raw.length - originalRaw.length;
-        if (lengthDiff !== 0) {
-            replacement.loc.end.column = replacement.loc.start.column + replacement.raw.length;
-        }
-    }
-    // Preserve array trailing comma format
-    if (isInlineArray(existing) && isInlineArray(replacement)) {
-        const originalHadTrailingCommas = arrayHadTrailingCommas(existing);
-        if (replacement.items.length > 0) {
-            const lastItem = replacement.items[replacement.items.length - 1];
-            lastItem.comma = originalHadTrailingCommas;
-        }
-    }
-    // Preserve inline table trailing comma format
-    if (isInlineTable(existing) && isInlineTable(replacement)) {
-        const originalHadTrailingCommas = tableHadTrailingCommas(existing);
-        if (replacement.items.length > 0) {
-            const lastItem = replacement.items[replacement.items.length - 1];
-            lastItem.comma = originalHadTrailingCommas;
-        }
-    }
-}
-/**
- * Applies a list of changes to the original TOML document AST while preserving formatting and structure.
- *
- * 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
-    // Edit: Change in value
-    // Remove: Remove key-value from object, remove item from array
-    // Move: Move item in array
-    // Rename: Rename key in key-value
-    //
-    // Special consideration, inline comments need to move as-needed
-    changes.forEach(change => {
-        if (isAdd(change)) {
-            const child = findByPath(updated, change.path);
-            const parent_path = change.path.slice(0, -1);
-            let index = last(change.path);
-            let is_table_array = isTableArray(child);
-            if (isInteger(index) && !parent_path.some(isInteger)) {
-                const sibling = tryFindByPath(original, parent_path.concat(0));
-                if (sibling && isTableArray(sibling)) {
-                    is_table_array = true;
-                }
-            }
-            // Determine the parent node where the new child will be inserted
-            let parent;
-            if (isTable(child)) {
-                parent = original;
-            }
-            else if (is_table_array) {
-                parent = original;
-                // The index needs to be updated to top-level items
-                // to properly account for other items, comments, and nesting
-                const document = original;
-                const before = tryFindByPath(document, parent_path.concat(index - 1));
-                const after = tryFindByPath(document, parent_path.concat(index));
-                if (after) {
-                    index = document.items.indexOf(after);
-                }
-                else if (before) {
-                    index = document.items.indexOf(before) + 1;
-                }
-                else {
-                    index = document.items.length;
-                }
-            }
-            else {
-                parent = findParent(original, change.path);
-                if (isKeyValue(parent)) {
-                    parent = parent.value;
-                }
-            }
-            if (isTableArray(parent) || isInlineArray(parent) || isDocument(parent)) {
-                // 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 {
-                // 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 {
-                    // Unwrap InlineItem if we're adding to a Table (not InlineTable)
-                    // InlineItems should only exist within InlineTables or InlineArrays
-                    let childToInsert = child;
-                    if (isInlineItem(child) && (isTable(parent) || isDocument(parent))) {
-                        childToInsert = child.item;
-                    }
-                    insert(original, parent, childToInsert);
-                }
-            }
-        }
-        else if (isEdit(change)) {
-            let existing = findByPath(original, change.path);
-            let replacement = findByPath(updated, change.path);
-            let parent;
-            if (isKeyValue(existing) && isKeyValue(replacement)) {
-                // Edit for key-value means value changes
-                // Preserve formatting from existing value in replacement value
-                preserveFormatting(existing.value, replacement.value);
-                parent = existing;
-                existing = existing.value;
-                replacement = replacement.value;
-            }
-            else if (isKeyValue(existing) && isInlineItem(replacement) && isKeyValue(replacement.item)) {
-                // Sometimes, the replacement looks like it could be an inline item, but the original is a key-value
-                // In this case, we convert the replacement to a key-value to match the original
-                parent = existing;
-                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 if (isInlineItem(existing) && isInlineItem(replacement) && isKeyValue(existing.item) && isKeyValue(replacement.item)) {
-                // Both are InlineItems wrapping KeyValues (nested inline table edits)
-                // Preserve formatting and edit the value within
-                preserveFormatting(existing.item.value, replacement.item.value);
-                parent = existing.item;
-                existing = existing.item.value;
-                replacement = replacement.item.value;
-            }
-            else {
-                parent = findParent(original, change.path);
-                // Special handling for array element edits
-                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);
-        }
-        else if (isRemove(change)) {
-            let parent = findParent(original, change.path);
-            if (isKeyValue(parent))
-                parent = parent.value;
-            const node = findByPath(original, change.path);
-            remove(original, parent, node);
-        }
-        else if (isMove(change)) {
-            let parent = findByPath(original, change.path);
-            if (hasItem(parent))
-                parent = parent.item;
-            if (isKeyValue(parent))
-                parent = parent.value;
-            const node = parent.items[change.from];
-            remove(original, parent, node);
-            insert(original, parent, node, change.to);
-        }
-        else if (isRename(change)) {
-            let parent = findByPath(original, change.path.concat(change.from));
-            let replacement = findByPath(updated, change.path.concat(change.to));
-            if (hasItem(parent))
-                parent = parent.item;
-            if (hasItem(replacement))
-                replacement = replacement.item;
-            replace(original, parent, parent.key, replacement.key);
-        }
-    });
-    applyWrites(original);
-    return original;
-}
-/**
- * Converts nested inline tables to separate table sections based on the inlineTableStart depth setting.
- * This function recursively processes a table and extracts any inline tables within it,
- * creating separate table sections with properly nested keys.
- *
- * @param table - The table to process for nested inline tables
- * @param original - The original document for inserting new items
- * @param format - The formatting options
- * @returns Array of additional tables that should be added to the document
- */
-function convertNestedInlineTablesToMultiline(table, original, format) {
-    const additionalTables = [];
-    const processTableForNestedInlines = (currentTable, tablesToAdd) => {
-        var _a;
-        for (let i = currentTable.items.length - 1; i >= 0; i--) {
-            const item = currentTable.items[i];
-            if (isKeyValue(item) && isInlineTable(item.value)) {
-                // Calculate the depth of this nested table
-                const nestedTableKey = [...currentTable.key.item.value, ...item.key.value];
-                const depth = calculateTableDepth(nestedTableKey);
-                // Only convert to separate table if depth is less than inlineTableStart
-                if (depth < ((_a = format.inlineTableStart) !== null && _a !== void 0 ? _a : 1) && format.inlineTableStart !== 0) {
-                    // Convert this inline table to a separate table section
-                    const separateTable = generateTable(nestedTableKey);
-                    // Move all items from the inline table to the separate table
-                    for (const inlineItem of item.value.items) {
-                        if (isInlineItem(inlineItem) && isKeyValue(inlineItem.item)) {
-                            insert(original, separateTable, inlineItem.item, undefined);
-                        }
-                    }
-                    // Remove this item from the original table
-                    currentTable.items.splice(i, 1);
-                    // Update the parent table's end position after removal
-                    postInlineItemRemovalAdjustment(currentTable);
-                    // Queue this table to be added to the document
-                    tablesToAdd.push(separateTable);
-                    // Recursively process the new table for further nested inlines
-                    processTableForNestedInlines(separateTable, tablesToAdd);
-                }
-            }
-        }
-    };
-    processTableForNestedInlines(table, additionalTables);
-    return additionalTables;
-}
-/**
- * Converts an inline table to a separate table section when adding to an existing table.
- * This function creates a new table section with the combined key path and moves all
- * properties from the inline table to the separate table section.
- *
- * @param child - The KeyValue node with an InlineTable as its value
- * @param parent - The parent table where the KeyValue would be added
- * @param original - The original document for inserting new items
- * @param format - The formatting options
- */
-function convertInlineTableToSeparateSection(child, parent, original, format) {
-    // Convert the inline table to a separate table section
-    const baseTableKey = parent.key.item.value; // Get the parent table's key path
-    const nestedTableKey = [...baseTableKey, ...child.key.value]; // Combine with the new key
-    const separateTable = generateTable(nestedTableKey);
-    // We know child.value is an InlineTable from the calling context
-    if (isInlineTable(child.value)) {
-        // Move all items from the inline table to the separate table
-        for (const inlineItem of child.value.items) {
-            if (isInlineItem(inlineItem) && isKeyValue(inlineItem.item)) {
-                insert(original, separateTable, inlineItem.item, undefined);
-            }
-        }
-    }
-    // Add the separate table to the document
-    insert(original, original, separateTable, undefined);
-    // Update the parent table's end position since we're not adding the inline table to it
-    postInlineItemRemovalAdjustment(parent);
-    // Also handle any nested inline tables within the new table
-    const additionalTables = convertNestedInlineTablesToMultiline(separateTable, original, format);
-    for (const table of additionalTables) {
-        insert(original, original, table, undefined);
-    }
-}
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-/**
- * Compares two positions to determine their ordering.
- * @param pos1 - First position
- * @param pos2 - Second position
- * @returns Negative if pos1 < pos2, 0 if equal, positive if pos1 > pos2
- */
-function comparePositions(pos1, pos2) {
-    if (pos1.line !== pos2.line) {
-        return pos1.line - pos2.line;
-    }
-    return pos1.column - pos2.column;
-}
-/**
- * Truncates an AST based on a position (line, column) in the source string.
- *
- * This function filters the AST to include only the nodes that end before
- * the specified position. This ensures that blocks containing changes are
- * excluded and can be reparsed. This is useful for incremental parsing scenarios
- * where you want to keep only the unchanged portion of the AST.
- *
- * Special handling: If the truncation point falls within a Table or TableArray
- * (e.g., in a comment inside the table), the entire table is excluded to ensure
- * proper reparsing.
- *
- * @param ast - The AST to truncate
- * @param line - The line number (1-indexed) at which to truncate
- * @param column - The column number (0-indexed) at which to truncate
- * @returns An object containing the truncated AST and the end position of the last included node
- *
- * @example
- * ```typescript
- * const ast = parseTOML(tomlString);
- * // Get AST up to line 5, column 10 (only nodes that end before this position)
- * const { truncatedAst, lastEndPosition } = truncateAst(ast, 5, 10);
- * for (const node of truncatedAst) {
- *   // process node
- * }
- * ```
- */
-function truncateAst(ast, line, column) {
-    const limit = { line, column };
-    const nodes = [];
-    let lastEndPosition = null;
-    for (const node of ast) {
-        const nodeEndsBeforeLimit = comparePositions(node.loc.end, limit) < 0;
-        const nodeStartsBeforeLimit = comparePositions(node.loc.start, limit) < 0;
-        if (nodeEndsBeforeLimit) {
-            // Node completely ends before the limit - include it
-            nodes.push(node);
-            lastEndPosition = node.loc.end;
-        }
-        else if (nodeStartsBeforeLimit && !nodeEndsBeforeLimit) {
-            // Node starts before the limit but ends at or after it
-            // This means the truncation point is within this node
-            // For Table/TableArray nodes, don't include them if the change is inside
-            // This ensures the entire table gets reparsed
-            break;
-        }
-        else {
-            // Node starts at or after the limit - stop
-            break;
-        }
-    }
-    return {
-        truncatedAst: nodes,
-        lastEndPosition
-    };
-}
-
-var _TomlDocument_ast, _TomlDocument_currentTomlString, _TomlDocument_Format;
-/**
- * TomlDocument encapsulates a TOML AST and provides methods to interact with it.
- */
-class TomlDocument {
-    /**
-     * Initializes the TomlDocument with a TOML string, parsing it into an AST.
-     * @param tomlString - The TOML string to parse
-     */
-    constructor(tomlString) {
-        _TomlDocument_ast.set(this, void 0);
-        _TomlDocument_currentTomlString.set(this, void 0);
-        _TomlDocument_Format.set(this, void 0);
-        __classPrivateFieldSet(this, _TomlDocument_currentTomlString, tomlString, "f");
-        __classPrivateFieldSet(this, _TomlDocument_ast, Array.from(parseTOML(tomlString)), "f");
-        // Auto-detect formatting preferences from the original TOML string
-        __classPrivateFieldSet(this, _TomlDocument_Format, TomlFormat.autoDetectFormat(tomlString), "f");
-    }
-    get toTomlString() {
-        return __classPrivateFieldGet(this, _TomlDocument_currentTomlString, "f");
-    }
-    /**
-     * Returns the JavaScript object representation of the TOML document.
-     */
-    get toJsObject() {
-        const jsObject = toJS(__classPrivateFieldGet(this, _TomlDocument_ast, "f"));
-        // Convert custom date classes to regular JavaScript Date objects
-        return convertCustomDateClasses(jsObject);
-    }
-    /**
-     * Returns the internal AST (for testing purposes).
-     * @internal
-     */
-    get ast() {
-        return __classPrivateFieldGet(this, _TomlDocument_ast, "f");
-    }
-    /**
-     * Applies a patch to the current AST using a modified JS object.
-     * Updates the internal AST. Use toTomlString getter to retrieve the updated TOML string.
-     * @param updatedObject - The modified JS object to patch with
-     * @param format - Optional formatting options
-     */
-    patch(updatedObject, format) {
-        const fmt = resolveTomlFormat(format, __classPrivateFieldGet(this, _TomlDocument_Format, "f"));
-        const { tomlString, document } = patchAst(__classPrivateFieldGet(this, _TomlDocument_ast, "f"), updatedObject, fmt);
-        __classPrivateFieldSet(this, _TomlDocument_ast, document.items, "f");
-        __classPrivateFieldSet(this, _TomlDocument_currentTomlString, tomlString, "f");
-    }
-    /**
-     * Updates the internal document by supplying a modified tomlString.
-     * Use toJsObject getter to retrieve the updated JS object representation.
-     * @param tomlString - The modified TOML string to update with
-     */
-    update(tomlString) {
-        if (tomlString === this.toTomlString) {
-            return;
-        }
-        // Now, let's check where the first difference is
-        const existingLines = this.toTomlString.split(__classPrivateFieldGet(this, _TomlDocument_Format, "f").newLine);
-        const newLineChar = detectNewline(tomlString);
-        const newTextLines = tomlString.split(newLineChar);
-        let firstDiffLineIndex = 0;
-        while (firstDiffLineIndex < existingLines.length &&
-            firstDiffLineIndex < newTextLines.length &&
-            existingLines[firstDiffLineIndex] === newTextLines[firstDiffLineIndex]) {
-            firstDiffLineIndex++;
-        }
-        // Calculate the 1-based line number and 0-based column where the first difference occurs
-        let firstDiffColumn = 0;
-        // If we're within the bounds of both arrays, find the column where they differ
-        if (firstDiffLineIndex < existingLines.length && firstDiffLineIndex < newTextLines.length) {
-            const existingLine = existingLines[firstDiffLineIndex];
-            const newLine = newTextLines[firstDiffLineIndex];
-            // Find the first character position where the lines differ
-            for (let i = 0; i < Math.max(existingLine.length, newLine.length); i++) {
-                if (existingLine[i] !== newLine[i]) {
-                    firstDiffColumn = i;
-                    break;
-                }
-            }
-        }
-        let firstDiffLine = firstDiffLineIndex + 1; // Convert to 1-based
-        const { truncatedAst, lastEndPosition } = truncateAst(__classPrivateFieldGet(this, _TomlDocument_ast, "f"), firstDiffLine, firstDiffColumn);
-        // Determine where to continue parsing from in the new string
-        // If lastEndPosition exists, continue from there; otherwise from the start of the document
-        const continueFromLine = lastEndPosition ? lastEndPosition.line : 1;
-        const continueFromColumn = lastEndPosition ? lastEndPosition.column + 1 : 0;
-        // Based on the first difference, we can re-parse only the affected part
-        // We will need to supply the remaining string after where the AST was truncated
-        const remainingLines = newTextLines.slice(continueFromLine - 1);
-        // If there's a partial line match, we need to extract only the part after the continuation column
-        if (remainingLines.length > 0 && continueFromColumn > 0) {
-            remainingLines[0] = remainingLines[0].substring(continueFromColumn);
-        }
-        const remainingToml = remainingLines.join(__classPrivateFieldGet(this, _TomlDocument_Format, "f").newLine);
-        __classPrivateFieldSet(this, _TomlDocument_ast, Array.from(continueParsingTOML(truncatedAst, remainingToml)), "f");
-        __classPrivateFieldSet(this, _TomlDocument_currentTomlString, tomlString, "f");
-        // Update the auto-detected format with the new string's characteristics
-        __classPrivateFieldSet(this, _TomlDocument_Format, TomlFormat.autoDetectFormat(tomlString), "f");
-    }
-    /**
-     * Overwrites the internal AST by fully re-parsing the supplied tomlString.
-     * This is simpler but slower than update() which uses incremental parsing.
-     * @param tomlString - The TOML string to overwrite with
-     */
-    overwrite(tomlString) {
-        if (tomlString === this.toTomlString) {
-            return;
-        }
-        // Re-parse the entire document
-        __classPrivateFieldSet(this, _TomlDocument_ast, Array.from(parseTOML(tomlString)), "f");
-        __classPrivateFieldSet(this, _TomlDocument_currentTomlString, tomlString, "f");
-        // Update the auto-detected format with the new string's characteristics
-        __classPrivateFieldSet(this, _TomlDocument_Format, TomlFormat.autoDetectFormat(tomlString), "f");
-    }
-}
-_TomlDocument_ast = new WeakMap(), _TomlDocument_currentTomlString = new WeakMap(), _TomlDocument_Format = new WeakMap();
-/**
- * Recursively converts custom date classes to regular JavaScript Date objects.
- * This ensures that the toJsObject property returns standard Date objects
- * while preserving the custom classes internally for TOML formatting.
- */
-function convertCustomDateClasses(obj) {
-    if (obj instanceof Date) {
-        // Convert custom date classes to regular Date objects
-        return new Date(obj.getTime());
-    }
-    else if (Array.isArray(obj)) {
-        return obj.map(convertCustomDateClasses);
-    }
-    else if (obj && typeof obj === 'object') {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)) {
-            result[key] = convertCustomDateClasses(value);
-        }
-        return result;
-    }
-    return obj;
-}
-
-/**
- * Parses a TOML string into a JavaScript object.
- * The function converts TOML syntax to its JavaScript equivalent.
- * This proceeds in two steps: first, it parses the TOML string into an AST,
- * and then it converts the AST into a JavaScript object.
- *
- * @param value - The TOML string to parse
- * @returns The parsed JavaScript object
- */
-function parse(value) {
-    return toJS(parseTOML(value), value);
-}
-/**
- * Converts a JavaScript object to a TOML string.
- *
- * @param value - The JavaScript object to stringify
- * @param format - Optional formatting options for the resulting TOML
- * @returns The stringified TOML representation
- */
-function stringify(value, format) {
-    const fmt = resolveTomlFormat(format, TomlFormat.default());
-    const document = parseJS(value, fmt);
-    return toTOML(document.items, fmt);
-}
-
-export { TomlDocument, TomlFormat, parse, patch, stringify };