@decimalturn/toml-patch 0.3.2 → 0.3.7

package/dist/toml-patch.umd.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"toml-patch.umd.min.js","sources":["../src/ast.ts","../src/tokenizer.ts","../src/cursor.ts","../src/location.ts","../src/parse-error.ts","../src/utils.ts","../src/parse-string.ts","../src/parse-toml.ts","../src/traverse.ts","../src/writer.ts","../src/generate.ts","../src/format.ts","../src/parse-js.ts","../src/to-toml.ts","../src/to-js.ts","../src/diff.ts","../src/find-by-path.ts","../src/index.ts","../src/patch.ts"],"sourcesContent":["import { Location } from './location';\n\nexport enum NodeType {\n  Document = 'Document',\n  Table = 'Table',\n  TableKey = 'TableKey',\n  TableArray = 'TableArray',\n  TableArrayKey = 'TableArrayKey',\n  KeyValue = 'KeyValue',\n  Key = 'Key',\n  String = 'String',\n  Integer = 'Integer',\n  Float = 'Float',\n  Boolean = 'Boolean',\n  DateTime = 'DateTime',\n  InlineArray = 'InlineArray',\n  InlineItem = 'InlineItem',\n  InlineTable = 'InlineTable',\n  Comment = 'Comment'\n}\n\n//\n// Abstract Syntax Tree\n//\n// AST nodes are used to represent TOML data\n//\nexport type AST = Iterable<Block>;\n\n//\n// Document\n//\n// Top-level document that stores AST nodes\n//\nexport interface Document extends TreeNode {\n  type: NodeType.Document;\n  items: Array<Block>;\n}\nexport function isDocument(node: TreeNode): node is Document {\n  return node.type === NodeType.Document;\n}\n\n//\n// Table\n//\n// Top-level object\n//\n// v-------|\n// [table] |\n// b = \"c\" |\n//         |\n// # note  |\n//      ^--|\n// [b]\n//\nexport interface Table extends TreeNode {\n  type: NodeType.Table;\n  key: TableKey;\n  items: Array<KeyValue | Comment>;\n}\nexport function isTable(node: TreeNode): node is Table {\n  return node.type === NodeType.Table;\n}\n\n//\n// TableKey\n//\n// Used to store bracket information for Table keys\n//\n// loc includes brackets\n//\n// [  key  ]\n// ^-------^\n//\nexport interface TableKey extends TreeNode {\n  type: NodeType.TableKey;\n  item: Key;\n}\nexport function isTableKey(node: TreeNode): node is TableKey {\n  return node.type === NodeType.TableKey;\n}\n\n//\n// TableArray\n//\n// Top-level array item\n//\n// v---------|\n// [[array]] |\n// a=\"b\"     |\n//           |\n// # details |\n//         ^-|\n// [[array]]\n//\nexport interface TableArray extends TreeNode {\n  type: NodeType.TableArray;\n  key: TableArrayKey;\n  items: Array<KeyValue | Comment>;\n}\nexport function isTableArray(node: TreeNode): node is TableArray {\n  return node.type === NodeType.TableArray;\n}\n\n//\n// TableArrayKey\n//\n// Used to store bracket information for TableArray keys\n// loc includes brackets\n//\n// [[  key  ]]\n// ^---------^\n//\nexport interface TableArrayKey extends TreeNode {\n  type: NodeType.TableArrayKey;\n  item: Key;\n}\nexport function isTableArrayKey(node: TreeNode): node is TableArrayKey {\n  return node.type === NodeType.TableArrayKey;\n}\n\n//\n// KeyValue\n//\n// Key and Value nodes, with position information on equals sign\n//\n// key=\"value\" # note\n// ^---------^\n//\nexport interface KeyValue extends TreeNode {\n  type: NodeType.KeyValue;\n  key: Key;\n  value: Value;\n\n  // Column index (0-based) of the equals sign\n  equals: number;\n}\nexport function isKeyValue(node: TreeNode): node is KeyValue {\n  return node.type === NodeType.KeyValue;\n}\n\n//\n// Key\n//\n// Store raw key and parts (from dots)\n//\nexport interface Key extends TreeNode {\n  type: NodeType.Key;\n  raw: string;\n\n  // Note: Array for keys with dots\n  // e.g. a.b -> raw = 'a.b', value = ['a', 'b']\n  value: string[];\n}\nexport function isKey(node: TreeNode): node is Key {\n  return node.type === NodeType.Key;\n}\n\n//\n// String\n//\n// loc includes quotes\n//\n// a = \"string\"\n//     ^------^\n//\nexport interface String extends TreeNode {\n  type: NodeType.String;\n  raw: string;\n  value: string;\n}\nexport function isString(node: TreeNode): node is String {\n  return node.type === NodeType.String;\n}\n\n//\n// Integer\n//\nexport interface Integer extends TreeNode {\n  type: NodeType.Integer;\n  raw: string;\n  value: number;\n}\nexport function isInteger(node: TreeNode): node is Integer {\n  return node.type === NodeType.Integer;\n}\n\n//\n// Float\n//\nexport interface Float extends TreeNode {\n  type: NodeType.Float;\n  raw: string;\n  value: number;\n}\nexport function isFloat(node: TreeNode): node is Float {\n  return node.type === NodeType.Float;\n}\n\n//\n// Boolean\n//\nexport interface Boolean extends TreeNode {\n  type: NodeType.Boolean;\n\n  // Only `true` and `false` are permitted\n  // -> don't need separate raw and value\n  value: boolean;\n}\nexport function isBoolean(node: TreeNode): node is Boolean {\n  return node.type === NodeType.Boolean;\n}\n\n//\n// DateTime\n//\n// Note: Currently, Offset Date-Time, Local Date-Time, Local Date, and Local Time\n// are handled via raw\n//\nexport interface DateTime extends TreeNode {\n  type: NodeType.DateTime;\n  raw: string;\n  value: Date;\n}\nexport function isDateTime(node: TreeNode): node is DateTime {\n  return node.type === NodeType.DateTime;\n}\n\n//\n// InlineArray\n//\nexport interface InlineArray<TItem = TreeNode> extends TreeNode {\n  type: NodeType.InlineArray;\n  items: InlineArrayItem<TItem>[];\n}\nexport function isInlineArray(node: TreeNode): node is InlineArray {\n  return node.type === NodeType.InlineArray;\n}\n\n//\n// InlineArrayItem\n//\n// loc for InlineArrayItem is from start of value to before comma\n// or end-of-value if no comma\n//\n// [ \"a\"  ,\"b\", \"c\"  ]\n//   ^---^ ^-^  ^-^\n//\nexport interface InlineItem<TItem = TreeNode> extends TreeNode {\n  type: NodeType.InlineItem;\n  item: TItem;\n  comma: boolean;\n}\nexport function isInlineItem(node: TreeNode): node is InlineItem {\n  return node.type === NodeType.InlineItem;\n}\n\nexport interface InlineArrayItem<TItem = TreeNode> extends InlineItem<TItem> {}\n\n//\n// InlineTable\n//\nexport interface InlineTable extends TreeNode {\n  type: NodeType.InlineTable;\n  items: InlineTableItem[];\n}\nexport function isInlineTable(node: TreeNode): node is InlineTable {\n  return node.type === NodeType.InlineTable;\n}\n\n//\n// InlineTableItem\n//\n// loc for InlineTableItem follows InlineArrayItem\n//\n// { a=\"b\"   ,    c =    \"d\"   }\n//   ^------^     ^--------^\n//\nexport interface InlineTableItem extends InlineItem<KeyValue> {}\n\n//\n// Comment\n//\n// loc starts at \"#\" and goes to end of comment (trailing whitespace ignored)\n//\n// # comment here\n// ^------------^\n//\nexport interface Comment extends TreeNode {\n  type: NodeType.Comment;\n  raw: string;\n}\nexport function isComment(node: TreeNode): node is Comment {\n  return node.type === NodeType.Comment;\n}\n\n//\n// Combinations\n//\n\nexport interface WithItems extends TreeNode {\n  items: TreeNode[];\n}\nexport function hasItems(node: TreeNode): node is WithItems {\n  return (\n    isDocument(node) ||\n    isTable(node) ||\n    isTableArray(node) ||\n    isInlineTable(node) ||\n    isInlineArray(node)\n  );\n}\n\nexport interface WithItem extends TreeNode {\n  item: TreeNode;\n}\nexport function hasItem(node: TreeNode): node is WithItem {\n  return isTableKey(node) || isTableArrayKey(node) || isInlineItem(node);\n}\n\nexport type Block = KeyValue | Table | TableArray | Comment;\nexport function isBlock(node: TreeNode): node is Block {\n  return isKeyValue(node) || isTable(node) || isTableArray(node) || isComment(node);\n}\n\nexport type Value<TInlineArrayItem = TreeNode> =\n  | String\n  | Integer\n  | Float\n  | Boolean\n  | DateTime\n  | InlineArray<TInlineArrayItem>\n  | InlineTable;\nexport function isValue(node: TreeNode): node is Value {\n  return (\n    isString(node) ||\n    isInteger(node) ||\n    isFloat(node) ||\n    isBoolean(node) ||\n    isDateTime(node) ||\n    isInlineArray(node) ||\n    isInlineTable(node)\n  );\n}\n\nexport interface TreeNode {\n  type: NodeType;\n  loc: Location;\n}\n","import Cursor, { iterator } from './cursor';\nimport { Location, Locator, createLocate, findPosition } from './location';\nimport ParseError from './parse-error';\n\nexport enum TokenType {\n  Bracket = 'Bracket',\n  Curly = 'Curly',\n  Equal = 'Equal',\n  Comma = 'Comma',\n  Dot = 'Dot',\n  Comment = 'Comment',\n  Literal = 'Literal'\n}\n\nexport interface Token {\n  type: TokenType;\n  raw: string;\n  loc: Location;\n}\n\nexport const IS_WHITESPACE = /\\s/;\nexport const IS_NEW_LINE = /(\\r\\n|\\n)/;\nexport const DOUBLE_QUOTE = `\"`;\nexport const SINGLE_QUOTE = `'`;\nexport const SPACE = ' ';\nexport const ESCAPE = '\\\\';\n\nconst IS_VALID_LEADING_CHARACTER = /[\\w,\\d,\\\",\\',\\+,\\-,\\_]/;\n\nexport function* tokenize(input: string): IterableIterator<Token> {\n  const cursor = new Cursor(iterator(input));\n  cursor.next();\n\n  const locate = createLocate(input);\n\n  while (!cursor.done) {\n    if (IS_WHITESPACE.test(cursor.value!)) {\n      // (skip whitespace)\n    } else if (cursor.value === '[' || cursor.value === ']') {\n      // Handle special characters: [, ], {, }, =, comma\n      yield specialCharacter(cursor, locate, TokenType.Bracket);\n    } else if (cursor.value === '{' || cursor.value === '}') {\n      yield specialCharacter(cursor, locate, TokenType.Curly);\n    } else if (cursor.value === '=') {\n      yield specialCharacter(cursor, locate, TokenType.Equal);\n    } else if (cursor.value === ',') {\n      yield specialCharacter(cursor, locate, TokenType.Comma);\n    } else if (cursor.value === '.') {\n      yield specialCharacter(cursor, locate, TokenType.Dot);\n    } else if (cursor.value === '#') {\n      // Handle comments = # -> EOL\n      yield comment(cursor, locate);\n    } else {\n      const multiline_char =\n        checkThree(input, cursor.index, SINGLE_QUOTE) ||\n        checkThree(input, cursor.index, DOUBLE_QUOTE);\n\n      if (multiline_char) {\n        // Multi-line literals or strings = no escaping\n        yield multiline(cursor, locate, multiline_char, input);\n      } else {\n        yield string(cursor, locate, input);\n      }\n    }\n\n    cursor.next();\n  }\n}\n\nfunction specialCharacter(cursor: Cursor<string>, locate: Locator, type: TokenType): Token {\n  return { type, raw: cursor.value!, loc: locate(cursor.index, cursor.index + 1) };\n}\n\nfunction comment(cursor: Cursor<string>, locate: Locator): Token {\n  const start = cursor.index;\n  let raw = cursor.value!;\n  while (!cursor.peek().done && !IS_NEW_LINE.test(cursor.peek().value!)) {\n    cursor.next();\n    raw += cursor.value!;\n  }\n\n  // Early exit is ok for comment, no closing conditions\n\n  return {\n    type: TokenType.Comment,\n    raw,\n    loc: locate(start, cursor.index + 1)\n  };\n}\n\nfunction multiline(\n  cursor: Cursor<string>,\n  locate: Locator,\n  multiline_char: string,\n  input: string\n): Token {\n  const start = cursor.index;\n  let quotes = multiline_char + multiline_char + multiline_char;\n  let raw = quotes;\n\n  // Skip over quotes\n  cursor.next();\n  cursor.next();\n  cursor.next();\n\n  // 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\n  // See spec-string-basic-multiline-9.toml\n  while (!cursor.done && (!checkThree(input, cursor.index, multiline_char) || CheckMoreThanThree(input, cursor.index, multiline_char))) {\n    raw += cursor.value;\n    cursor.next();\n  }\n\n  if (cursor.done) {\n    throw new ParseError(\n      input,\n      findPosition(input, cursor.index),\n      `Expected close of multiline string with ${quotes}, reached end of file`\n    );\n  }\n\n  raw += quotes;\n\n  cursor.next();\n  cursor.next();\n\n  return {\n    type: TokenType.Literal,\n    raw,\n    loc: locate(start, cursor.index + 1)\n  };\n}\n\nfunction string(cursor: Cursor<string>, locate: Locator, input: string): Token {\n  // Remaining possibilities: keys, strings, literals, integer, float, boolean\n  //\n  // Special cases:\n  // \"...\" -> quoted\n  // '...' -> quoted\n  // \"...\".'...' -> bare\n  // 0000-00-00 00:00:00 -> bare\n  //\n  // See https://github.com/toml-lang/toml#offset-date-time\n  //\n  // | 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).\n  // | `odt4 = 1979-05-27 07:32:00Z`\n  //\n  // From RFC 3339:\n  //\n  // | NOTE: ISO 8601 defines date and time separated by \"T\".\n  // | Applications using this syntax may choose, for the sake of\n  // | readability, to specify a full-date and full-time separated by\n  // | (say) a space character.\n\n  // First, check for invalid characters\n  if (!IS_VALID_LEADING_CHARACTER.test(cursor.value!)) {\n    throw new ParseError(\n      input,\n      findPosition(input, cursor.index),\n      `Unsupported character \"${cursor.value}\". Expected ALPHANUMERIC, \", ', +, -, or _`\n    );\n  }\n\n  const start = cursor.index;\n  let raw = cursor.value!;\n  let double_quoted = cursor.value === DOUBLE_QUOTE;\n  let single_quoted = cursor.value === SINGLE_QUOTE;\n\n  const isFinished = (cursor: Cursor<string>) => {\n    if (cursor.peek().done) return true;\n    const next_item = cursor.peek().value!;\n\n    return (\n      !(double_quoted || single_quoted) &&\n      (IS_WHITESPACE.test(next_item) ||\n        next_item === ',' ||\n        next_item === '.' ||\n        next_item === ']' ||\n        next_item === '}' ||\n        next_item === '=' ||\n        next_item === '#'\n      )\n    );\n  };\n\n  while (!cursor.done && !isFinished(cursor)) {\n    cursor.next();\n\n    if (cursor.value === DOUBLE_QUOTE) double_quoted = !double_quoted;\n    if (cursor.value === SINGLE_QUOTE && !double_quoted) single_quoted = !single_quoted;\n\n    raw += cursor.value!;\n\n    if (cursor.peek().done) break;\n    let next_item = cursor.peek().value!;\n\n    // If next character is escape and currently double-quoted,\n    // check for escaped quote\n    if (double_quoted && cursor.value === ESCAPE) {\n      if (next_item === DOUBLE_QUOTE) {\n        raw += DOUBLE_QUOTE;\n        cursor.next();\n      } else if (next_item === ESCAPE) {\n        raw += ESCAPE;\n        cursor.next();\n      }\n    }\n  }\n\n  if (double_quoted || single_quoted) {\n    throw new ParseError(\n      input,\n      findPosition(input, start),\n      `Expected close of string with ${double_quoted ? DOUBLE_QUOTE : SINGLE_QUOTE}`\n    );\n  }\n\n  return {\n    type: TokenType.Literal,\n    raw,\n    loc: locate(start, cursor.index + 1)\n  };\n}\n\n/**\n * Check if the current character and the next two characters are the same\n * and not escaped.\n *\n * @param input - The input string.\n * @param current - The current index in the input string.\n * @param check - The character to check for.\n * @returns ⚠️The character if found, otherwise false.\n */\nfunction checkThree(input: string, current: number, check: string): false | string {\n  if (!check) {\n    return false;\n  }\n\n  const has3 =\n    input[current] === check &&\n    input[current + 1] === check &&\n    input[current + 2] === check;\n\n  if (!has3) {\n    return false;\n  }\n\n  // Check if the sequence is escaped\n  const precedingText = input.slice(0, current); // Get the text before the current position\n  const backslashes  = precedingText.match(/\\\\+$/); // Match trailing backslashes\n\n  if (!backslashes) {\n    return check; // No backslashes means not escaped\n  }\n \n  const isEscaped = backslashes[0].length % 2 !== 0; // Odd number of backslashes means escaped\n\n  return isEscaped ? false : check; // Return `check` if not escaped, otherwise `false`\n}\n\nexport function CheckMoreThanThree(input: string, current: number, check: string): boolean {\n  \n  if (!check) {\n    return false;\n  }\n\n  return (\n    input[current] === check &&\n    input[current + 1] === check &&\n    input[current + 2] === check &&\n    input[current + 3] === check\n  )\n\n}\n","export function iterator<T>(value: Iterable<T>): Iterator<T> {\n  return value[Symbol.iterator]();\n}\n\n/**\n * Cursor<T>\n * \n * A utility class that wraps an iterator and provides additional functionality\n * such as peeking at the next value without advancing the iterator, tracking\n * the current index, and iterating over the values.\n * \n * @template T - The type of elements in the iterator.\n * \n * Properties:\n * - `iterator`: The underlying iterator being wrapped.\n * - `index`: The current index of the iterator (starts at -1).\n * - `value`: The current value of the iterator.\n * - `done`: A boolean indicating whether the iterator is complete.\n * - `peeked`: The result of peeking at the next value without advancing.\n * \n * Methods:\n * - `next()`: Advances the iterator and returns the next value.\n * - `peek()`: Returns the next value without advancing the iterator.\n * - `[Symbol.iterator]`: Makes the Cursor itself iterable.\n */\nexport default class Cursor<T> implements Iterator<T | undefined> {\n  iterator: Iterator<T>;\n  index: number;\n  value?: T;\n  done: boolean;\n  peeked: IteratorResult<T | undefined> | null;\n\n  constructor(iterator: Iterator<T>) {\n    this.iterator = iterator;\n    this.index = -1;\n    this.value = undefined;\n    this.done = false;\n    this.peeked = null;\n  }\n\n  next(): IteratorResult<T | undefined> {\n    if (this.done) return done();\n\n    const result = this.peeked || this.iterator.next();\n\n    this.index += 1;\n    this.value = result.value;\n    this.done = result.done ?? false;\n    this.peeked = null;\n\n    return result;\n  }\n\n  peek(): IteratorResult<T | undefined> {\n    if (this.done) return done();\n    if (this.peeked) return this.peeked;\n\n    this.peeked = this.iterator.next();\n    return this.peeked;\n  }\n\n  [Symbol.iterator]() {\n    return this;\n  }\n}\n\nfunction done(): IteratorResult<undefined> {\n  return { value: undefined, done: true };\n}\n","export interface Location {\n  start: Position;\n  end: Position;\n}\n\nexport interface Position {\n  // Note: line is 1-indexed while column is 0-indexed\n  line: number;\n  column: number;\n}\n\nexport interface Span {\n  lines: number;\n  columns: number;\n}\n\nexport function getSpan(location: Location): Span {\n  return {\n    lines: location.end.line - location.start.line + 1,\n    columns: location.end.column - location.start.column\n  };\n}\n\nexport type Locator = (start: number, end: number) => Location;\nexport function createLocate(input: string): Locator {\n  const lines = findLines(input);\n\n  return (start: number, end: number) => {\n    return {\n      start: findPosition(lines, start),\n      end: findPosition(lines, end)\n    };\n  };\n}\n\nexport function findPosition(input: string | number[], index: number): Position {\n  // abc\\ndef\\ng\n  // 0123 4567 8\n  //      012\n  //           0\n  //\n  // lines = [3, 7, 9]\n  //\n  // c = 2: 0 -> 1, 2 - (undefined + 1 || 0) = 2\n  //     3: 0 -> 1, 3 - (undefined + 1 || 0) = 3\n  // e = 5: 1 -> 2, 5 - (3 + 1 || 0) = 1\n  // g = 8: 2 -> 3, 8 - (7 + 1 || 0) = 0\n\n  const lines = Array.isArray(input) ? input : findLines(input);\n  const line = lines.findIndex(line_index => line_index >= index) + 1;\n  const column = index - (lines[line - 2] + 1 || 0);\n\n  return { line, column };\n}\n\nexport function getLine(input: string, position: Position): string {\n  const lines = findLines(input);\n  const start = lines[position.line - 2] || 0;\n  const end = lines[position.line - 1] || input.length;\n\n  return input.substr(start, end - start);\n}\n\nexport function findLines(input: string): number[] {\n  // exec is stateful, so create new regexp each time\n  const BY_NEW_LINE = /[\\r\\n|\\n]/g;\n  const indexes: number[] = [];\n\n  let match;\n  while ((match = BY_NEW_LINE.exec(input)) != null) {\n    indexes.push(match.index);\n  }\n  indexes.push(input.length + 1);\n\n  return indexes;\n}\n\nexport function clonePosition(position: Position): Position {\n  return { line: position.line, column: position.column };\n}\n\nexport function cloneLocation(location: Location): Location {\n  return { start: clonePosition(location.start), end: clonePosition(location.end) };\n}\n\nexport function zero(): Position {\n  return { line: 1, column: 0 };\n}\n","import { Position, getLine } from './location';\n\nexport default class ParseError extends Error {\n  line: number;\n  column: number;\n\n  constructor(input: string, position: Position, message: string) {\n    let error_message = `Error parsing TOML (${position.line}, ${position.column + 1}):\\n`;\n\n    if (input) {\n      const line = getLine(input, position);\n      const pointer = `${whitespace(position.column)}^`;\n\n      if (line) error_message += `${line}\\n${pointer}\\n`;\n    }\n    error_message += message;\n\n    super(error_message);\n\n    this.line = position.line;\n    this.column = position.column;\n  }\n}\n\nexport function isParseError(error: Error): error is ParseError {\n  return error && Object.prototype.hasOwnProperty.call(error, 'line');\n}\n\nfunction whitespace(count: number, character: string = ' '): string {\n  return character.repeat(count);\n}\n","export function last<TValue>(values: TValue[]): TValue | undefined {\n  return values[values.length - 1];\n}\n\nexport type BlankObject = { [key: string]: any };\n\nexport function blank(): BlankObject {\n  return Object.create(null);\n}\n\nexport function isString(value: any): value is string {\n  return typeof value === 'string';\n}\n\nexport function isInteger(value: any): value is number {\n  return typeof value === 'number' && value % 1 === 0;\n}\n\nexport function isFloat(value: any): value is number {\n  return typeof value === 'number' && !isInteger(value);\n}\n\nexport function isBoolean(value: any): value is boolean {\n  return typeof value === 'boolean';\n}\n\nexport function isDate(value: any): value is Date {\n  return Object.prototype.toString.call(value) === '[object Date]';\n}\n\nexport function isObject(value: any): boolean {\n  return value && typeof value === 'object' && !isDate(value) && !Array.isArray(value);\n}\n\nexport function isIterable<T>(value: any): value is Iterable<T> {\n  return value != null && typeof value[Symbol.iterator] === 'function';\n}\n\nexport function has(object: any, key: string): boolean {\n  return Object.prototype.hasOwnProperty.call(object, key);\n}\n\nexport function arraysEqual<TItem>(a: TItem[], b: TItem[]): boolean {\n  if (a.length !== b.length) return false;\n\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n\n  return true;\n}\n\nexport function datesEqual(a: any, b: any): boolean {\n  return isDate(a) && isDate(b) && a.toISOString() === b.toISOString();\n}\n\nexport function pipe<TValue>(value: TValue, ...fns: Array<(value: TValue) => TValue>): TValue {\n  return fns.reduce((value, fn) => fn(value), value);\n}\n\nexport function stableStringify(object: any): string {\n  if (isObject(object)) {\n    const key_values = Object.keys(object)\n      .sort()\n      .map(key => `${JSON.stringify(key)}:${stableStringify(object[key])}`);\n\n    return `{${key_values.join(',')}}`;\n  } else if (Array.isArray(object)) {\n    return `[${object.map(stableStringify).join(',')}]`;\n  } else {\n    return JSON.stringify(object);\n  }\n}\n\nexport function merge<TValue>(target: TValue[], values: TValue[]) {\n  // __mutating__: merge values into target\n  // Reference: https://dev.to/uilicious/javascript-array-push-is-945x-faster-than-array-concat-1oki\n  const original_length = target.length;\n  const added_length = values.length;\n  target.length = original_length + added_length;\n\n  for (let i = 0; i < added_length; i++) {\n    target[original_length + i] = values[i];\n  }\n}\n","import { SINGLE_QUOTE, DOUBLE_QUOTE } from './tokenizer';\nimport { pipe } from './utils';\n\nconst TRIPLE_DOUBLE_QUOTE = `\"\"\"`;\nconst TRIPLE_SINGLE_QUOTE = `'''`;\nconst LF = '\\\\n';\nconst CRLF = '\\\\r\\\\n';\nconst IS_CRLF = /\\r\\n/g;\nconst IS_LF = /\\n/g;\nconst IS_LEADING_NEW_LINE = /^(\\r\\n|\\n)/;\n// This regex is used to match an odd number of backslashes followed by a line ending\n// It uses a negative lookbehind to ensure that the backslash is not preceded by another backslash.\n// We need an odd number of backslashes so that the last one is not escaped.\nconst IS_LINE_ENDING_BACKSLASH = /(?<!\\\\)(?:\\\\\\\\)*(\\\\\\s*[\\n\\r\\n]\\s*)/g;\n\nexport function parseString(raw: string): string {\n  if (raw.startsWith(TRIPLE_SINGLE_QUOTE)) {\n    return pipe(\n      trim(raw, 3),\n      trimLeadingWhitespace\n    );\n  } else if (raw.startsWith(SINGLE_QUOTE)) {\n    return trim(raw, 1);\n  } else if (raw.startsWith(TRIPLE_DOUBLE_QUOTE)) {\n    return pipe(\n      trim(raw, 3),\n      trimLeadingWhitespace,\n      lineEndingBackslash,\n      escapeNewLines,\n      escapeDoubleQuotes,\n      unescapeLargeUnicode\n    );\n  } else if (raw.startsWith(DOUBLE_QUOTE)) {\n    return pipe(\n      trim(raw, 1),\n      unescapeLargeUnicode\n    );\n  } else {\n    return raw;\n  }\n}\n\nexport function escapeDoubleQuotes(value: string): string {\n  let result = '';\n  let precedingBackslashes = 0;\n\n  for (let i = 0; i < value.length; i++) {\n    const char = value[i];\n\n    if (char === '\"' && precedingBackslashes % 2 === 0) {\n      // If the current character is a quote and it is not escaped, escape it\n      result += '\\\\\"';\n    } else {\n      // Otherwise, add the character as is\n      result += char;\n    }\n\n    // Update the count of consecutive backslashes\n    if (char === '\\\\') {\n      precedingBackslashes++;\n    } else {\n      precedingBackslashes = 0; // Reset if the character is not a backslash\n    }\n  }\n\n  return result;\n}\n\nexport function unescapeLargeUnicode(escaped: string): string {\n  // JSON.parse handles everything except \\UXXXXXXXX\n  // replace those instances with code point, escape that, and then parse\n  const LARGE_UNICODE = /\\\\U[a-fA-F0-9]{8}/g;\n  const json_escaped = escaped.replace(LARGE_UNICODE, value => {\n    const code_point = parseInt(value.replace('\\\\U', ''), 16);\n    const as_string = String.fromCodePoint(code_point);\n\n    return trim(JSON.stringify(as_string), 1);\n  });\n\n  const fixed_json_escaped = escapeTabsForJSON(json_escaped);\n\n  // Parse the properly escaped JSON string\n  const parsed = JSON.parse(`\"${fixed_json_escaped}\"`);\n  return parsed;\n}\n\nfunction escapeTabsForJSON(value: string): string {\n  return value\n    .replace(/\\t/g, '\\\\t')\n}\n\nexport function escape(value: string): string {\n  return trim(JSON.stringify(value), 1);\n}\n\nfunction trim(value: string, count: number): string {\n  return value.slice(count, value.length - count);\n}\n\nfunction trimLeadingWhitespace(value: string): string {\n  return value.replace(IS_LEADING_NEW_LINE, '');\n}\n\nfunction escapeNewLines(value: string): string {\n  return value.replace(IS_CRLF, CRLF).replace(IS_LF, LF);\n}\n\nfunction lineEndingBackslash(value: string): string {\n  return value.replace(IS_LINE_ENDING_BACKSLASH, (match, group) => match.replace(group, ''));\n}\n","import {\n  NodeType,\n  KeyValue,\n  Table,\n  TableKey,\n  TableArray,\n  TableArrayKey,\n  Key,\n  Value,\n  String,\n  Integer,\n  Float,\n  Boolean,\n  DateTime,\n  InlineTable,\n  InlineArray,\n  InlineItem,\n  Comment,\n  AST,\n  Block\n} from './ast';\nimport { Token, TokenType, tokenize, DOUBLE_QUOTE, SINGLE_QUOTE } from './tokenizer';\nimport { parseString } from './parse-string';\nimport Cursor from './cursor';\nimport { clonePosition, cloneLocation } from './location';\nimport ParseError from './parse-error';\nimport { merge } from './utils';\n\nconst TRUE = 'true';\nconst FALSE = 'false';\nconst HAS_E = /e/i;\nconst IS_DIVIDER = /\\_/g;\nconst IS_INF = /inf/;\nconst IS_NAN = /nan/;\nconst IS_HEX = /^0x/;\nconst IS_OCTAL = /^0o/;\nconst IS_BINARY = /^0b/;\nexport const IS_FULL_DATE = /(\\d{4})-(\\d{2})-(\\d{2})/;\nexport const IS_FULL_TIME = /(\\d{2}):(\\d{2}):(\\d{2})/;\n\nexport default function* parseTOML(input: string): AST {\n  const tokens = tokenize(input);\n  const cursor = new Cursor(tokens);\n\n  while (!cursor.next().done) {\n    yield* walkBlock(cursor, input);\n  }\n}\n\nfunction* walkBlock(cursor: Cursor<Token>, input: string): IterableIterator<Block> {\n  if (cursor.value!.type === TokenType.Comment) {\n    yield comment(cursor);\n  } else if (cursor.value!.type === TokenType.Bracket) {\n    yield table(cursor, input);\n  } else if (cursor.value!.type === TokenType.Literal) {\n    yield* keyValue(cursor, input);\n  } else {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Unexpected token \"${cursor.value!.type}\". Expected Comment, Bracket, or String`\n    );\n  }\n}\n\nfunction* walkValue(cursor: Cursor<Token>, input: string): IterableIterator<Value | Comment> {\n  if (cursor.value!.type === TokenType.Literal) {\n    if (cursor.value!.raw[0] === DOUBLE_QUOTE || cursor.value!.raw[0] === SINGLE_QUOTE) {\n      yield string(cursor);\n    } else if (cursor.value!.raw === TRUE || cursor.value!.raw === FALSE) {\n      yield boolean(cursor);\n    } else if (IS_FULL_DATE.test(cursor.value!.raw) || IS_FULL_TIME.test(cursor.value!.raw)) {\n      yield datetime(cursor, input);\n    } else if (\n      (!cursor.peek().done && cursor.peek().value!.type === TokenType.Dot) ||\n      IS_INF.test(cursor.value!.raw) ||\n      IS_NAN.test(cursor.value!.raw) ||\n      (HAS_E.test(cursor.value!.raw) && !IS_HEX.test(cursor.value!.raw))\n    ) {\n      yield float(cursor, input);\n    } else {\n      yield integer(cursor);\n    }\n  } else if (cursor.value!.type === TokenType.Curly) {\n    yield inlineTable(cursor, input);\n  } else if (cursor.value!.type === TokenType.Bracket) {\n    const [inline_array, comments] = inlineArray(cursor, input);\n\n    yield inline_array;\n    yield* comments;\n  } else {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Unrecognized token type \"${cursor.value!.type}\". Expected String, Curly, or Bracket`\n    );\n  }\n}\n\nfunction comment(cursor: Cursor<Token>): Comment {\n  // # line comment\n  // ^------------^ Comment\n  return {\n    type: NodeType.Comment,\n    loc: cursor.value!.loc,\n    raw: cursor.value!.raw\n  };\n}\n\nfunction table(cursor: Cursor<Token>, input: string): Table | TableArray {\n  // Table or TableArray\n  //\n  // [ key ]\n  // ^-----^    TableKey\n  //   ^-^      Key\n  //\n  // [[ key ]]\n  // ^ ------^  TableArrayKey\n  //    ^-^     Key\n  //\n  // a = \"b\"  < Items\n  // # c      |\n  // d = \"f\"  <\n  //\n  // ...\n  const type =\n    !cursor.peek().done && cursor.peek().value!.type === TokenType.Bracket\n      ? NodeType.TableArray\n      : NodeType.Table;\n  const is_table = type === NodeType.Table;\n\n  if (is_table && cursor.value!.raw !== '[') {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Expected table opening \"[\", found ${cursor.value!.raw}`\n    );\n  }\n  if (!is_table && (cursor.value!.raw !== '[' || cursor.peek().value!.raw !== '[')) {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Expected array of tables opening \"[[\", found ${cursor.value!.raw + cursor.peek().value!.raw}`\n    );\n  }\n\n  // Set start location from opening tag\n  const key = is_table\n    ? ({\n        type: NodeType.TableKey,\n        loc: cursor.value!.loc\n      } as Partial<TableKey>)\n    : ({\n        type: NodeType.TableArrayKey,\n        loc: cursor.value!.loc\n      } as Partial<TableArrayKey>);\n\n  // Skip to cursor.value for key value\n  cursor.next();\n  if (type === NodeType.TableArray) cursor.next();\n\n  if (cursor.done) {\n    throw new ParseError(input, key.loc!.start, `Expected table key, reached end of file`);\n  }\n\n  key.item = {\n    type: NodeType.Key,\n    loc: cloneLocation(cursor.value!.loc),\n    raw: cursor.value!.raw,\n    value: [parseString(cursor.value!.raw)]\n  };\n\n  while (!cursor.peek().done && cursor.peek().value!.type === TokenType.Dot) {\n    cursor.next();\n    const dot = cursor.value!;\n\n    cursor.next();\n    const before = ' '.repeat(dot.loc.start.column - key.item.loc.end.column);\n    const after = ' '.repeat(cursor.value!.loc.start.column - dot.loc.end.column);\n\n    key.item.loc.end = cursor.value!.loc.end;\n    key.item.raw += `${before}.${after}${cursor.value!.raw}`;\n    key.item.value.push(parseString(cursor.value!.raw));\n  }\n\n  cursor.next();\n\n  if (is_table && (cursor.done || cursor.value!.raw !== ']')) {\n    throw new ParseError(\n      input,\n      cursor.done ? key.item.loc.end : cursor.value!.loc.start,\n      `Expected table closing \"]\", found ${cursor.done ? 'end of file' : cursor.value!.raw}`\n    );\n  }\n  if (\n    !is_table &&\n    (cursor.done ||\n      cursor.peek().done ||\n      cursor.value!.raw !== ']' ||\n      cursor.peek().value!.raw !== ']')\n  ) {\n    throw new ParseError(\n      input,\n      cursor.done || cursor.peek().done ? key.item.loc.end : cursor.value!.loc.start,\n      `Expected array of tables closing \"]]\", found ${\n        cursor.done || cursor.peek().done\n          ? 'end of file'\n          : cursor.value!.raw + cursor.peek().value!.raw\n      }`\n    );\n  }\n\n  // Set end location from closing tag\n  if (!is_table) cursor.next();\n  key.loc!.end = cursor.value!.loc.end;\n\n  // Add child items\n  let items: Array<KeyValue | Comment> = [];\n  while (!cursor.peek().done && cursor.peek().value!.type !== TokenType.Bracket) {\n    cursor.next();\n    merge(items, [...walkBlock(cursor, input)] as Array<KeyValue | Comment>);\n  }\n\n  return {\n    type: is_table ? NodeType.Table : NodeType.TableArray,\n    loc: {\n      start: clonePosition(key.loc!.start),\n      end: items.length\n        ? clonePosition(items[items.length - 1].loc.end)\n        : clonePosition(key.loc!.end)\n    },\n    key: key as TableKey | TableArrayKey,\n    items\n  } as Table | TableArray;\n}\n\nfunction keyValue(cursor: Cursor<Token>, input: string): Array<KeyValue | Comment> {\n  // 3. KeyValue\n  //\n  // key = value\n  // ^-^          key\n  //     ^        equals\n  //       ^---^  value\n  const key: Key = {\n    type: NodeType.Key,\n    loc: cloneLocation(cursor.value!.loc),\n    raw: cursor.value!.raw,\n    value: [parseString(cursor.value!.raw)]\n  };\n\n  while (!cursor.peek().done && cursor.peek().value!.type === TokenType.Dot) {\n    cursor.next();\n    cursor.next();\n\n    key.loc.end = cursor.value!.loc.end;\n    key.raw += `.${cursor.value!.raw}`;\n    key.value.push(parseString(cursor.value!.raw));\n  }\n\n  cursor.next();\n\n  if (cursor.done || cursor.value!.type !== TokenType.Equal) {\n    throw new ParseError(\n      input,\n      cursor.done ? key.loc.end : cursor.value!.loc.start,\n      `Expected \"=\" for key-value, found ${cursor.done ? 'end of file' : cursor.value!.raw}`\n    );\n  }\n\n  const equals = cursor.value!.loc.start.column;\n\n  cursor.next();\n\n  if (cursor.done) {\n    throw new ParseError(input, key.loc.start, `Expected value for key-value, reached end of file`);\n  }\n\n  const [value, ...comments] = walkValue(cursor, input) as Iterable<Value | Comment>;\n\n  return [\n    {\n      type: NodeType.KeyValue,\n      key,\n      value: value as Value,\n      loc: {\n        start: clonePosition(key.loc.start),\n        end: clonePosition(value.loc.end)\n      },\n      equals\n    },\n    ...(comments as Comment[])\n  ];\n}\n\nfunction string(cursor: Cursor<Token>): String {\n  return {\n    type: NodeType.String,\n    loc: cursor.value!.loc,\n    raw: cursor.value!.raw,\n    value: parseString(cursor.value!.raw)\n  };\n}\n\nfunction boolean(cursor: Cursor<Token>): Boolean {\n  return {\n    type: NodeType.Boolean,\n    loc: cursor.value!.loc,\n    value: cursor.value!.raw === TRUE\n  };\n}\n\nfunction datetime(cursor: Cursor<Token>, input: string): DateTime {\n  // Possible values:\n  //\n  // Offset Date-Time\n  // | odt1 = 1979-05-27T07:32:00Z\n  // | odt2 = 1979-05-27T00:32:00-07:00\n  // | odt3 = 1979-05-27T00:32:00.999999-07:00\n  // | odt4 = 1979-05-27 07:32:00Z\n  //\n  // Local Date-Time\n  // | ldt1 = 1979-05-27T07:32:00\n  // | ldt2 = 1979-05-27T00:32:00.999999\n  //\n  // Local Date\n  // | ld1 = 1979-05-27\n  //\n  // Local Time\n  // | lt1 = 07:32:00\n  // | lt2 = 00:32:00.999999\n  let loc = cursor.value!.loc;\n  let raw = cursor.value!.raw;\n  let value: Date;\n\n  // If next token is string,\n  // check if raw is full date and following is full time\n  if (\n    !cursor.peek().done &&\n    cursor.peek().value!.type === TokenType.Literal &&\n    IS_FULL_DATE.test(raw) &&\n    IS_FULL_TIME.test(cursor.peek().value!.raw)\n  ) {\n    const start = loc.start;\n\n    cursor.next();\n    loc = { start, end: cursor.value!.loc.end };\n    raw += ` ${cursor.value!.raw}`;\n  }\n\n  if (!cursor.peek().done && cursor.peek().value!.type === TokenType.Dot) {\n    const start = loc.start;\n\n    cursor.next();\n\n    if (cursor.peek().done || cursor.peek().value!.type !== TokenType.Literal) {\n      throw new ParseError(input, cursor.value!.loc.end, `Expected fractional value for DateTime`);\n    }\n    cursor.next();\n\n    loc = { start, end: cursor.value!.loc.end };\n    raw += `.${cursor.value!.raw}`;\n  }\n\n  if (!IS_FULL_DATE.test(raw)) {\n    // For local time, use local ISO date\n    const [local_date] = new Date().toISOString().split('T');\n    value = new Date(`${local_date}T${raw}`);\n  } else {\n    value = new Date(raw.replace(' ', 'T'));\n  }\n\n  return {\n    type: NodeType.DateTime,\n    loc,\n    raw,\n    value\n  };\n}\n\nfunction float(cursor: Cursor<Token>, input: string): Float {\n  let loc = cursor.value!.loc;\n  let raw = cursor.value!.raw;\n  let value;\n\n  if (IS_INF.test(raw)) {\n    value = raw === '-inf' ? -Infinity : Infinity;\n  } else if (IS_NAN.test(raw)) {\n    value = raw === '-nan' ? -NaN : NaN;\n  } else if (!cursor.peek().done && cursor.peek().value!.type === TokenType.Dot) {\n    const start = loc.start;\n\n    // From spec:\n    // | A fractional part is a decimal point followed by one or more digits.\n    //\n    // -> Don't have to handle \"4.\" (i.e. nothing behind decimal place)\n\n    cursor.next();\n\n    if (cursor.peek().done || cursor.peek().value!.type !== TokenType.Literal) {\n      throw new ParseError(input, cursor.value!.loc.end, `Expected fraction value for Float`);\n    }\n    cursor.next();\n\n    raw += `.${cursor.value!.raw}`;\n    loc = { start, end: cursor.value!.loc.end };\n    value = Number(raw.replace(IS_DIVIDER, ''));\n  } else {\n    value = Number(raw.replace(IS_DIVIDER, ''));\n  }\n\n  return { type: NodeType.Float, loc, raw, value };\n}\n\nfunction integer(cursor: Cursor<Token>): Integer {\n  // > Integer values -0 and +0 are valid and identical to an unprefixed zero\n  if (cursor.value!.raw === '-0' || cursor.value!.raw === '+0') {\n    return {\n      type: NodeType.Integer,\n      loc: cursor.value!.loc,\n      raw: cursor.value!.raw,\n      value: 0\n    };\n  }\n\n  let radix = 10;\n  if (IS_HEX.test(cursor.value!.raw)) {\n    radix = 16;\n  } else if (IS_OCTAL.test(cursor.value!.raw)) {\n    radix = 8;\n  } else if (IS_BINARY.test(cursor.value!.raw)) {\n    radix = 2;\n  }\n\n  const value = parseInt(\n    cursor\n      .value!.raw.replace(IS_DIVIDER, '')\n      .replace(IS_OCTAL, '')\n      .replace(IS_BINARY, ''),\n    radix\n  );\n\n  return {\n    type: NodeType.Integer,\n    loc: cursor.value!.loc,\n    raw: cursor.value!.raw,\n    value\n  };\n}\n\nfunction inlineTable(cursor: Cursor<Token>, input: string): InlineTable {\n  if (cursor.value!.raw !== '{') {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Expected \"{\" for inline table, found ${cursor.value!.raw}`\n    );\n  }\n\n  // 6. InlineTable\n  const value: InlineTable = {\n    type: NodeType.InlineTable,\n    loc: cloneLocation(cursor.value!.loc),\n    items: []\n  };\n\n  cursor.next();\n\n  while (\n    !cursor.done &&\n    !(cursor.value!.type === TokenType.Curly && (cursor.value as Token).raw === '}')\n  ) {\n    if ((cursor.value as Token).type === TokenType.Comma) {\n      const previous = value.items[value.items.length - 1];\n      if (!previous) {\n        throw new ParseError(\n          input,\n          cursor.value!.loc.start,\n          'Found \",\" without previous value in inline table'\n        );\n      }\n\n      previous.comma = true;\n      previous.loc.end = cursor.value!.loc.start;\n\n      cursor.next();\n      continue;\n    }\n\n    const [item] = walkBlock(cursor, input);\n    if (item.type !== NodeType.KeyValue) {\n      throw new ParseError(\n        input,\n        cursor.value!.loc.start,\n        `Only key-values are supported in inline tables, found ${item.type}`\n      );\n    }\n\n    const inline_item: InlineItem<KeyValue> = {\n      type: NodeType.InlineItem,\n      loc: cloneLocation(item.loc),\n      item,\n      comma: false\n    };\n\n    value.items.push(inline_item);\n    cursor.next();\n  }\n\n  if (\n    cursor.done ||\n    cursor.value!.type !== TokenType.Curly ||\n    (cursor.value as Token).raw !== '}'\n  ) {\n    throw new ParseError(\n      input,\n      cursor.done ? value.loc.start : cursor.value!.loc.start,\n      `Expected \"}\", found ${cursor.done ? 'end of file' : cursor.value!.raw}`\n    );\n  }\n\n  value.loc.end = cursor.value!.loc.end;\n\n  return value;\n}\n\nfunction inlineArray(cursor: Cursor<Token>, input: string): [InlineArray, Comment[]] {\n  // 7. InlineArray\n  if (cursor.value!.raw !== '[') {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Expected \"[\" for inline array, found ${cursor.value!.raw}`\n    );\n  }\n\n  const value: InlineArray = {\n    type: NodeType.InlineArray,\n    loc: cloneLocation(cursor.value!.loc),\n    items: []\n  };\n  let comments: Comment[] = [];\n\n  cursor.next();\n\n  while (\n    !cursor.done &&\n    !(cursor.value!.type === TokenType.Bracket && (cursor.value as Token).raw === ']')\n  ) {\n    if ((cursor.value as Token).type === TokenType.Comma) {\n      const previous = value.items[value.items.length - 1];\n      if (!previous) {\n        throw new ParseError(\n          input,\n          cursor.value!.loc.start,\n          'Found \",\" without previous value for inline array'\n        );\n      }\n\n      previous.comma = true;\n      previous.loc.end = cursor.value!.loc.start;\n    } else if ((cursor.value as Token).type === TokenType.Comment) {\n      comments.push(comment(cursor));\n    } else {\n      const [item, ...additional_comments] = walkValue(cursor, input);\n      const inline_item: InlineItem = {\n        type: NodeType.InlineItem,\n        loc: cloneLocation(item.loc),\n        item,\n        comma: false\n      };\n\n      value.items.push(inline_item);\n      merge(comments, additional_comments as Comment[]);\n    }\n\n    cursor.next();\n  }\n\n  if (\n    cursor.done ||\n    cursor.value!.type !== TokenType.Bracket ||\n    (cursor.value as Token).raw !== ']'\n  ) {\n    throw new ParseError(\n      input,\n      cursor.done ? value.loc.start : cursor.value!.loc.start,\n      `Expected \"]\", found ${cursor.done ? 'end of file' : cursor.value!.raw}`\n    );\n  }\n\n  value.loc.end = cursor.value!.loc.end;\n\n  return [value, comments];\n}\n","import {\n  NodeType,\n  AST,\n  TreeNode,\n  Document,\n  Table,\n  TableKey,\n  TableArray,\n  TableArrayKey,\n  KeyValue,\n  Key,\n  String,\n  Integer,\n  Float,\n  Boolean,\n  DateTime,\n  Comment,\n  InlineArray,\n  InlineTable,\n  InlineItem\n} from './ast';\nimport { isIterable } from './utils';\n\nexport type Visit<TNode = TreeNode> = (node: TNode, parent: TNode | null) => void;\nexport type EnterExit<TNode = TreeNode> = { enter?: Visit<TNode>; exit?: Visit<TNode> };\n\nexport type Visitor = {\n  Document?: Visit<Document> | EnterExit<Document>;\n  Table?: Visit<Table> | EnterExit<Table>;\n  TableKey?: Visit<TableKey> | EnterExit<TableKey>;\n  TableArray?: Visit<TableArray> | EnterExit<TableArray>;\n  TableArrayKey?: Visit<TableArrayKey> | EnterExit<TableArrayKey>;\n  KeyValue?: Visit<KeyValue> | EnterExit<KeyValue>;\n  Key?: Visit<Key> | EnterExit<Key>;\n  String?: Visit<String> | EnterExit<String>;\n  Integer?: Visit<Integer> | EnterExit<Integer>;\n  Float?: Visit<Float> | EnterExit<Float>;\n  Boolean?: Visit<Boolean> | EnterExit<Boolean>;\n  DateTime?: Visit<DateTime> | EnterExit<DateTime>;\n  InlineArray?: Visit<InlineArray> | EnterExit<InlineArray>;\n  InlineItem?: Visit<InlineItem> | EnterExit<InlineItem>;\n  InlineTable?: Visit<InlineTable> | EnterExit<InlineTable>;\n  Comment?: Visit<Comment> | EnterExit<Comment>;\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// The traverse function is used to walk the AST and call the visitor functions\n////////////////////////////////////////////////////////////////////////////////\nexport default function traverse(ast: AST | TreeNode, visitor: Visitor) {\n  if (isIterable(ast)) {\n    traverseArray(ast, null);\n  } else {\n    traverseNode(ast, null);\n  }\n\n  function traverseArray(array: Iterable<TreeNode>, parent: TreeNode | null) {\n    for (const node of array) {\n      traverseNode(node, parent);\n    }\n  }\n\n  function traverseNode(node: TreeNode, parent: TreeNode | null) {\n    const visit = visitor[node.type];\n\n    if (visit && typeof visit === 'function') {\n      (visit as Visit)(node, parent);\n    }\n\n    if (visit && (visit as EnterExit).enter) {\n      (visit as EnterExit).enter!(node, parent);\n    }\n\n    switch (node.type) {\n      case NodeType.Document:\n        traverseArray((node as Document).items, node);\n        break;\n\n      case NodeType.Table:\n        traverseNode((node as Table).key, node);\n        traverseArray((node as Table).items, node);\n        break;\n      case NodeType.TableKey:\n        traverseNode((node as TableKey).item, node);\n        break;\n\n      case NodeType.TableArray:\n        traverseNode((node as TableArray).key, node);\n        traverseArray((node as TableArray).items, node);\n        break;\n      case NodeType.TableArrayKey:\n        traverseNode((node as TableArrayKey).item, node);\n        break;\n\n      case NodeType.KeyValue:\n        traverseNode((node as KeyValue).key, node);\n        traverseNode((node as KeyValue).value, node);\n        break;\n\n      case NodeType.InlineArray:\n        traverseArray((node as InlineArray).items, node);\n        break;\n      case NodeType.InlineItem:\n        traverseNode((node as InlineItem).item, node);\n        break;\n\n      case NodeType.InlineTable:\n        traverseArray((node as InlineTable).items, node);\n        break;\n\n      case NodeType.Key:\n      case NodeType.String:\n      case NodeType.Integer:\n      case NodeType.Float:\n      case NodeType.Boolean:\n      case NodeType.DateTime:\n      case NodeType.Comment:\n        break;\n\n      default:\n        throw new Error(`Unrecognized node type \"${node.type}\"`);\n    }\n\n    if (visit && (visit as EnterExit).exit) {\n      (visit as EnterExit).exit!(node, parent);\n    }\n  }\n}\n","import {\n  NodeType,\n  TreeNode,\n  Document,\n  Key,\n  Value,\n  InlineArray,\n  InlineArrayItem,\n  InlineTableItem,\n  isKeyValue,\n  isTable,\n  isTableArray,\n  isInlineTable,\n  isInlineArray,\n  hasItems,\n  hasItem,\n  isComment,\n  isDocument,\n  InlineTable,\n  TableArray,\n  Table,\n  KeyValue,\n  Comment,\n  InlineItem,\n  isInlineItem,\n  Block,\n  isBlock\n} from './ast';\nimport { Span, getSpan, clonePosition } from './location';\nimport { last } from './utils';\nimport traverse from './traverse';\n\n////////////////////////////////////////\n// The purpose of this file is to provide a way to modify the AST\n////////////////////////////////////////\n\n// Root node of the AST\nexport type Root = Document | TreeNode;\n\n// Store line and column offsets per node\n//\n// Some offsets are applied on enter (e.g. shift child items and next items)\n// Others are applied on exit (e.g. shift next items)\ntype Offsets = WeakMap<TreeNode, Span>;\n\nconst enter_offsets: WeakMap<Root, Offsets> = new WeakMap();\nconst getEnterOffsets = (root: Root) => {\n  if (!enter_offsets.has(root)) {\n    enter_offsets.set(root, new WeakMap());\n  }\n  return enter_offsets.get(root)!;\n};\n\nconst exit_offsets: WeakMap<Root, Offsets> = new WeakMap();\nconst getExitOffsets = (root: Root) => {\n  if (!exit_offsets.has(root)) {\n    exit_offsets.set(root, new WeakMap());\n  }\n  return exit_offsets.get(root)!;\n};\n//TODO: Add getOffsets function to get all offsets contained in the tree\nexport function replace(root: Root, parent: TreeNode, existing: TreeNode, replacement: TreeNode) {\n  // First, replace existing node\n  // (by index for items, item, or key/value)\n  if (hasItems(parent)) {\n\n    const index = parent.items.indexOf(existing);\n    if (index < 0) {\n      throw new Error(`Could not find existing item in parent node for replace`);\n    }\n\n    parent.items.splice(index, 1, replacement);\n\n    // This next case is a special case for Inline-Table item\n    // however due to the fact that both replacement of the whole Inline-Table and Inline-Table element will have the same parent,\n    // we need to make sure to make sure it's not an Inline-Table \n  } else if (isKeyValue(parent) && isInlineTable(parent.value) && !isInlineTable(existing)) {\n    \n    const index = parent.value.items.indexOf(existing as InlineTableItem);\n    if (index < 0) {\n      throw new Error(`Could not find existing item in parent node for replace`);\n    } \n    parent.value.items.splice(index, 1, replacement as InlineTableItem);\n\n  } else if (hasItem(parent)) {\n\n    parent.item = replacement;\n\n  } else if (isKeyValue(parent)) {\n\n    if (parent.key === existing) {\n      parent.key = replacement as Key;\n    } else {\n      parent.value = replacement as Value;\n    }\n\n  } else {\n    throw new Error(`Unsupported parent type \"${parent.type}\" for replace`);\n  }\n\n  // Shift the replacement node into the same start position as existing\n  const shift = {\n    lines: existing.loc.start.line - replacement.loc.start.line,\n    columns: existing.loc.start.column - replacement.loc.start.column\n  };\n  shiftNode(replacement, shift);\n\n  // Apply offsets after replacement node\n  const existing_span = getSpan(existing.loc);\n  const replacement_span = getSpan(replacement.loc);\n  const offset = {\n    lines: replacement_span.lines - existing_span.lines,\n    columns: replacement_span.columns - existing_span.columns\n  };\n\n  addOffset(offset, getExitOffsets(root), replacement, existing);\n}\n\nexport function insert(root: Root, parent: TreeNode, child: TreeNode, index?: number) {\n  if (!hasItems(parent)) {\n    throw new Error(`Unsupported parent type \"${(parent as TreeNode).type}\" for insert`);\n  }\n\n  index = (index != null && typeof index === 'number') ? index : parent.items.length; \n\n  let shift: Span;\n  let offset: Span;\n  if (isInlineArray(parent) || isInlineTable(parent)) {\n    ({ shift, offset } = insertInline(parent, child as InlineItem, index));\n  } else {\n    ({ shift, offset } = insertOnNewLine(\n      parent as Document | Table | TableArray,\n      child as KeyValue | Comment,\n      index\n    ));\n  }\n\n  shiftNode(child, shift);\n\n  // The child element is placed relative to the previous element,\n  // if the previous element has an offset, need to position relative to that\n  // -> Move previous offset to child's offset\n  const previous = parent.items[index - 1];\n  const previous_offset = previous && getExitOffsets(root).get(previous);\n  if (previous_offset) {\n    offset.lines += previous_offset.lines;\n    offset.columns += previous_offset.columns;\n\n    getExitOffsets(root).delete(previous!);\n  }\n\n  const offsets = getExitOffsets(root);\n  offsets.set(child, offset);\n}\n\nfunction insertOnNewLine(\n  parent: Document | Table | TableArray,\n  child: Block,\n  index: number\n): { shift: Span; offset: Span } {\n  if (!isBlock(child)) {\n    throw new Error(`Incompatible child type \"${(child as TreeNode).type}\"`);\n  }\n\n  const previous = parent.items[index - 1];\n  const use_first_line = isDocument(parent) && !parent.items.length;\n\n  parent.items.splice(index, 0, child);\n\n  // Set start location from previous item or start of array\n  // (previous is undefined for empty array or inserting at first item)\n  const start = previous\n    ? {\n      line: previous.loc.end.line,\n      column: !isComment(previous) ? previous.loc.start.column : parent.loc.start.column\n    }\n    : clonePosition(parent.loc.start);\n\n  const is_block = isTable(child) || isTableArray(child);\n  let leading_lines = 0;\n  if (use_first_line) {\n    // 0 leading lines\n  } else if (is_block) {\n    leading_lines = 2;\n  } else {\n    leading_lines = 1;\n  }\n  start.line += leading_lines;\n\n  const shift = {\n    lines: start.line - child.loc.start.line,\n    columns: start.column - child.loc.start.column\n  };\n\n  // Apply offsets after child node\n  const child_span = getSpan(child.loc);\n  const offset = {\n    lines: child_span.lines + (leading_lines - 1),\n    columns: child_span.columns\n  };\n\n  return { shift, offset };\n}\n\n/**\n * Inserts an inline element into an inline array or table at the specified index.\n * This function handles positioning, comma management, and offset calculation for the inserted item.\n * \n * @param parent - The inline array or table where the child will be inserted\n * @param child - The inline item to insert\n * @param index - The index position where to insert the child\n * @returns An object containing shift and offset spans:\n *          - shift: Adjustments needed to position the child correctly\n *          - offset: Adjustments needed for elements that follow the insertion\n * @throws Error if the child is not a compatible inline item type\n */\nfunction insertInline(\n  parent: InlineArray | InlineTable,\n  child: InlineItem,\n  index: number\n): { shift: Span; offset: Span } {\n  if (!isInlineItem(child)) {\n    throw new Error(`Incompatible child type \"${(child as TreeNode).type}\"`);\n  }\n\n  // Store preceding node and insert\n  const previous = index != null ? parent.items[index - 1] : last(parent.items);\n  const is_last = index == null || index === parent.items.length;\n\n  parent.items.splice(index, 0, child);\n\n  // Add commas as-needed\n  const has_seperating_comma_before = !!previous;\n  const has_seperating_comma_after = !is_last;\n  const has_trailing_comma = is_last && child.comma === true;\n  if (has_seperating_comma_before) {\n    previous!.comma = true;\n  }\n  if (has_seperating_comma_after) {\n    child.comma = true;\n  }\n\n  // Use a new line for documents, children of Table/TableArray,\n  // and if an inline table is using new lines\n  const use_new_line = isInlineArray(parent) && perLine(parent);\n\n  // Set start location from previous item or start of array\n  // (previous is undefined for empty array or inserting at first item)\n  const start = previous\n    ? {\n      line: previous.loc.end.line,\n      column: use_new_line\n        ? !isComment(previous)\n          ? previous.loc.start.column\n          : parent.loc.start.column\n        : previous.loc.end.column\n    }\n    : clonePosition(parent.loc.start);\n\n  let leading_lines = 0;\n  if (use_new_line) {\n    leading_lines = 1;\n  } else {\n    const skip_comma = 2;\n    const skip_bracket = 1;\n    start.column += has_seperating_comma_before ? skip_comma : skip_bracket;\n  }\n  start.line += leading_lines;\n\n  const shift = {\n    lines: start.line - child.loc.start.line,\n    columns: start.column - child.loc.start.column\n  };\n\n  // Apply offsets after child node\n  const child_span = getSpan(child.loc);\n  const offset = {\n    lines: child_span.lines + (leading_lines - 1),\n    columns: child_span.columns + (has_seperating_comma_before || has_seperating_comma_after ? 2 : 0) + (has_trailing_comma ? 1 : 0)\n  };\n\n  return { shift, offset };\n}\n\nexport function remove(root: Root, parent: TreeNode, node: TreeNode) {\n  // Remove an element from the parent's items\n  // (supports Document, Table, TableArray, InlineTable, and InlineArray\n  //\n  //      X\n  // [ 1, 2, 3 ]\n  //    ^-^\n  // -> Remove element 2 and apply 0,-3 offset to 1\n  //\n  // [table]\n  // a = 1\n  // b = 2 # X\n  // c = 3\n  // -> Remove element 2 and apply -1,0 offset to 1\n  if (!hasItems(parent)) {\n    throw new Error(`Unsupported parent type \"${parent.type}\" for remove`);\n  }\n\n  let index = parent.items.indexOf(node);\n  if (index < 0) {\n    // Try again, looking at child items for nodes like InlineArrayItem\n    index = parent.items.findIndex(item => hasItem(item) && item.item === node);\n\n    if (index < 0) {\n      throw new Error('Could not find node in parent for removal');\n    }\n\n    node = parent.items[index];\n  }\n\n  const previous = parent.items[index - 1];\n  let next = parent.items[index + 1];\n\n  // Remove node\n  parent.items.splice(index, 1);\n  let removed_span = getSpan(node.loc);\n\n  // Remove an associated comment that appears on the same line\n  //\n  // [table]\n  // a = 1\n  // b = 2 # remove this too\n  // c = 3\n  //\n  // TODO InlineTable - this only applies to comments in Table/TableArray\n  if (next && isComment(next) && next.loc.start.line === node.loc.end.line) {\n    // Add comment to removed\n    removed_span = getSpan({ start: node.loc.start, end: next.loc.end });\n\n    // Shift to next item\n    // (use same index since node has already been removed)\n    next = parent.items[index + 1];\n\n    // Remove comment\n    parent.items.splice(index, 1);\n  }\n\n  // For inline tables and arrays, check whether the line should be kept\n  const is_inline = previous && isInlineItem(previous) || next && isInlineItem(next);\n  const previous_on_same_line = previous && previous.loc.end.line === node.loc.start.line;\n  const next_on_sameLine = next && next.loc.start.line === node.loc.end.line;\n  const keep_line = is_inline && (previous_on_same_line || next_on_sameLine);\n\n  const offset = {\n    lines: -(removed_span.lines - (keep_line ? 1 : 0)),\n    columns: -removed_span.columns\n  };\n\n  // Offset for comma and remove comma that appear in front of the element (if-needed)\n  if (is_inline && previous_on_same_line) {\n    offset.columns -= 2;\n  }\n\n  // If first element in array/inline-table, remove space for comma and space after element\n  if (is_inline && !previous && next) {\n    offset.columns -= 2;\n  }\n\n  if (is_inline && previous && !next) {\n    (previous as InlineArrayItem | InlineTableItem).comma = false;\n  }\n\n  // Apply offsets after preceding node or before children of parent node\n  const target = previous || parent;\n  const target_offsets = previous ? getExitOffsets(root) : getEnterOffsets(root);\n  const node_offsets = getExitOffsets(root);\n  const previous_offset = target_offsets.get(target);\n  if (previous_offset) {\n    offset.lines += previous_offset.lines;\n    offset.columns += previous_offset.columns;\n  }\n  const removed_offset = node_offsets.get(node);\n  if (removed_offset) {\n    offset.lines += removed_offset.lines;\n    offset.columns += removed_offset.columns;\n  }\n\n  target_offsets.set(target, offset);\n}\n\nexport function applyBracketSpacing(\n  root: Root,\n  node: InlineArray | InlineTable,\n  bracket_spacing: boolean = true\n) {\n  // Can only add bracket spacing currently\n  if (!bracket_spacing) return;\n  if (!node.items.length) return;\n\n  // Apply enter to node so that items are affected\n  addOffset({ lines: 0, columns: 1 }, getEnterOffsets(root), node);\n\n  // Apply exit to last node in items\n  const last_item = last(node.items as TreeNode[])!;\n  addOffset({ lines: 0, columns: 1 }, getExitOffsets(root), last_item);\n}\n\nexport function applyTrailingComma(\n  root: Root,\n  node: InlineArray | InlineTable,\n  trailing_commas: boolean = false\n) {\n  // Can only add trailing comma currently\n  if (!trailing_commas) return;\n  if (!node.items.length) return;\n\n  const last_item = last(node.items)!;\n  last_item.comma = true;\n\n  addOffset({ lines: 0, columns: 1 }, getExitOffsets(root), last_item);\n}\n\n/**\n * Applies all accumulated write offsets (enter and exit) to the given AST node.\n * This function adjusts the start and end locations of each node in the tree based on\n * the offsets stored in the `enter` and `exit` maps. It ensures that the tree's location\n * data is consistent after modifications.\n *\n * @param root - The root node of the AST tree to which the write offsets will be applied.\n */\nexport function applyWrites(root: TreeNode) {\n  const enter = getEnterOffsets(root);\n  const exit = getExitOffsets(root);\n\n  const offset: { lines: number; columns: { [index: number]: number } } = {\n    lines: 0,\n    columns: {}\n  };\n\n  function shiftStart(node: TreeNode) {\n\n    const lineOffset = offset.lines;\n    node.loc.start.line += lineOffset;\n    \n    const columnOffset = offset.columns[node.loc.start.line] || 0;\n    node.loc.start.column += columnOffset\n\n    const entering = enter.get(node);\n    if (entering) {\n      offset.lines += entering.lines;\n      offset.columns[node.loc.start.line] =\n        (offset.columns[node.loc.start.line] || 0) + entering.columns;\n    }\n  }\n\n  function shiftEnd(node: TreeNode) {\n\n    const lineOffset = offset.lines;\n    node.loc.end.line += lineOffset;\n    \n    const columnOffset = offset.columns[node.loc.end.line] || 0;\n    node.loc.end.column += columnOffset;\n\n    const exiting = exit.get(node);\n    if (exiting) {\n      offset.lines += exiting.lines;\n      offset.columns[node.loc.end.line] =\n        (offset.columns[node.loc.end.line] || 0) + exiting.columns;\n    }\n  }\n\n  const shiftLocation = {\n    enter: shiftStart,\n    exit: shiftEnd\n  };\n\n  traverse(root, {\n    [NodeType.Document]: shiftLocation,\n    [NodeType.Table]: shiftLocation,\n    [NodeType.TableArray]: shiftLocation,\n    [NodeType.InlineTable]: shiftLocation,\n    [NodeType.InlineArray]: shiftLocation,\n\n    [NodeType.InlineItem]: shiftLocation,\n    [NodeType.TableKey]: shiftLocation,\n    [NodeType.TableArrayKey]: shiftLocation,\n\n    [NodeType.KeyValue]: {\n      enter(node) {\n        const start_line = node.loc.start.line + offset.lines;\n        const key_offset = exit.get(node.key);\n        node.equals += (offset.columns[start_line] || 0) + (key_offset ? key_offset.columns : 0);\n\n        shiftStart(node);\n      },\n      exit: shiftEnd\n    },\n\n    [NodeType.Key]: shiftLocation,\n    [NodeType.String]: shiftLocation,\n    [NodeType.Integer]: shiftLocation,\n    [NodeType.Float]: shiftLocation,\n    [NodeType.Boolean]: shiftLocation,\n    [NodeType.DateTime]: shiftLocation,\n    [NodeType.Comment]: shiftLocation\n  });\n\n  enter_offsets.delete(root);\n  exit_offsets.delete(root);\n}\n\nexport function shiftNode(\n  node: TreeNode,\n  span: Span,\n  options: { first_line_only?: boolean } = {}\n): TreeNode {\n  const { first_line_only = false } = options;\n  const start_line = node.loc.start.line;\n  const { lines, columns } = span;\n  const move = (node: TreeNode) => {\n    if (!first_line_only || node.loc.start.line === start_line) {\n      node.loc.start.column += columns;\n      node.loc.end.column += columns;\n    }\n    node.loc.start.line += lines;\n    node.loc.end.line += lines;\n  };\n\n  traverse(node, {\n    [NodeType.Table]: move,\n    [NodeType.TableKey]: move,\n    [NodeType.TableArray]: move,\n    [NodeType.TableArrayKey]: move,\n    [NodeType.KeyValue](node) {\n      move(node);\n      node.equals += columns;\n    },\n    [NodeType.Key]: move,\n    [NodeType.String]: move,\n    [NodeType.Integer]: move,\n    [NodeType.Float]: move,\n    [NodeType.Boolean]: move,\n    [NodeType.DateTime]: move,\n    [NodeType.InlineArray]: move,\n    [NodeType.InlineItem]: move,\n    [NodeType.InlineTable]: move,\n    [NodeType.Comment]: move\n  });\n\n  return node;\n}\n\nfunction perLine(array: InlineArray): boolean {\n  if (!array.items.length) return false;\n\n  const span = getSpan(array.loc);\n  return span.lines > array.items.length;\n}\n\nfunction addOffset(offset: Span, offsets: Offsets, node: TreeNode, from?: TreeNode) {\n  const previous_offset = offsets.get(from || node);\n  if (previous_offset) {\n    offset.lines += previous_offset.lines;\n    offset.columns += previous_offset.columns;\n  }\n\n  offsets.set(node, offset);\n}\n","import {\n  NodeType,\n  Document,\n  Table,\n  TableKey,\n  TableArray,\n  TableArrayKey,\n  Value,\n  KeyValue,\n  Key,\n  String,\n  Integer,\n  Float,\n  Boolean,\n  DateTime,\n  InlineArray,\n  InlineItem,\n  InlineTable,\n  Comment\n} from './ast';\nimport { zero, cloneLocation, clonePosition } from './location';\nimport { shiftNode } from './writer';\n\nexport function generateDocument(): Document {\n  return {\n    type: NodeType.Document,\n    loc: { start: zero(), end: zero() },\n    items: []\n  };\n}\n\nexport function generateTable(key: string[]): Table {\n  const table_key = generateTableKey(key);\n\n  return {\n    type: NodeType.Table,\n    loc: cloneLocation(table_key.loc),\n    key: table_key,\n    items: []\n  };\n}\n\nexport function generateTableKey(key: string[]): TableKey {\n  const raw = keyValueToRaw(key);\n\n  return {\n    type: NodeType.TableKey,\n    loc: {\n      start: zero(),\n      end: { line: 1, column: raw.length + 2 }\n    },\n    item: {\n      type: NodeType.Key,\n      loc: {\n        start: { line: 1, column: 1 },\n        end: { line: 1, column: raw.length + 1 }\n      },\n      value: key,\n      raw\n    }\n  };\n}\n\nexport function generateTableArray(key: string[]): TableArray {\n  const table_array_key = generateTableArrayKey(key);\n\n  return {\n    type: NodeType.TableArray,\n    loc: cloneLocation(table_array_key.loc),\n    key: table_array_key,\n    items: []\n  };\n}\n\nexport function generateTableArrayKey(key: string[]): TableArrayKey {\n  const raw = keyValueToRaw(key);\n\n  return {\n    type: NodeType.TableArrayKey,\n    loc: {\n      start: zero(),\n      end: { line: 1, column: raw.length + 4 }\n    },\n    item: {\n      type: NodeType.Key,\n      loc: {\n        start: { line: 1, column: 2 },\n        end: { line: 1, column: raw.length + 2 }\n      },\n      value: key,\n      raw\n    }\n  };\n}\n\nexport function generateKeyValue(key: string[], value: Value): KeyValue {\n  const key_node = generateKey(key);\n  const { column } = key_node.loc.end;\n\n  const equals = column + 1;\n\n  shiftNode(\n    value,\n    { lines: 0, columns: column + 3 - value.loc.start.column },\n    { first_line_only: true }\n  );\n\n  return {\n    type: NodeType.KeyValue,\n    loc: {\n      start: clonePosition(key_node.loc.start),\n      end: clonePosition(value.loc.end)\n    },\n    key: key_node,\n    equals,\n    value\n  };\n}\n\nconst IS_BARE_KEY = /[\\w,\\d,\\_,\\-]+/;\nfunction keyValueToRaw(value: string[]): string {\n  return value.map(part => (IS_BARE_KEY.test(part) ? part : JSON.stringify(part))).join('.');\n}\n\nexport function generateKey(value: string[]): Key {\n  const raw = keyValueToRaw(value);\n\n  return {\n    type: NodeType.Key,\n    loc: { start: zero(), end: { line: 1, column: raw.length } },\n    raw,\n    value\n  };\n}\n\nexport function generateString(value: string): String {\n  const raw = JSON.stringify(value);\n\n  return {\n    type: NodeType.String,\n    loc: { start: zero(), end: { line: 1, column: raw.length } },\n    raw,\n    value\n  };\n}\n\nexport function generateInteger(value: number): Integer {\n  const raw = value.toString();\n\n  return {\n    type: NodeType.Integer,\n    loc: { start: zero(), end: { line: 1, column: raw.length } },\n    raw,\n    value\n  };\n}\n\nexport function generateFloat(value: number): Float {\n  const raw = value.toString();\n\n  return {\n    type: NodeType.Float,\n    loc: { start: zero(), end: { line: 1, column: raw.length } },\n    raw,\n    value\n  };\n}\n\nexport function generateBoolean(value: boolean): Boolean {\n  return {\n    type: NodeType.Boolean,\n    loc: { start: zero(), end: { line: 1, column: value ? 4 : 5 } },\n    value\n  };\n}\n\nexport function generateDateTime(value: Date): DateTime {\n  const raw = value.toISOString();\n\n  return {\n    type: NodeType.DateTime,\n    loc: { start: zero(), end: { line: 1, column: raw.length } },\n    raw,\n    value\n  };\n}\n\nexport function generateInlineArray(): InlineArray {\n  return {\n    type: NodeType.InlineArray,\n    loc: { start: zero(), end: { line: 1, column: 2 } },\n    items: []\n  };\n}\n\nexport function generateInlineItem(item: KeyValue | Value): InlineItem {\n  return {\n    type: NodeType.InlineItem,\n    loc: cloneLocation(item.loc),\n    item,\n    comma: false\n  };\n}\n\nexport function generateInlineTable(): InlineTable {\n  return {\n    type: NodeType.InlineTable,\n    loc: { start: zero(), end: { line: 1, column: 2 } },\n    items: []\n  };\n}\n\nexport function generateComment(comment: string): Comment {\n  if (!comment.startsWith('#')) comment = `# ${comment}`;\n\n  return {\n    type: NodeType.Comment,\n    loc: { start: zero(), end: { line: 1, column: comment.length } },\n    raw: comment\n  };\n}\n","import {\n  KeyValue,\n  Table,\n  InlineTable,\n  TableArray,\n  InlineArray,\n  isInlineTable,\n  isInlineArray,\n  isKeyValue,\n  Document\n} from './ast';\nimport { generateTable, generateDocument, generateTableArray } from './generate';\nimport { insert, remove, applyWrites, shiftNode } from './writer';\n\nexport interface Format {\n  printWidth?: number;\n  tabWidth?: number;\n  useTabs?: boolean;\n  trailingComma?: boolean;\n  bracketSpacing?: boolean;\n}\n\nexport function formatTopLevel(document: Document): Document {\n  const move_to_top_level = document.items.filter(item => {\n    if (!isKeyValue(item)) return false;\n\n    const is_inline_table = isInlineTable(item.value);\n    const is_inline_array =\n      isInlineArray(item.value) &&\n      item.value.items.length &&\n      isInlineTable(item.value.items[0].item);\n\n    return is_inline_table || is_inline_array;\n  }) as KeyValue[];\n\n  move_to_top_level.forEach(node => {\n    remove(document, document, node);\n\n    if (isInlineTable(node.value)) {\n      insert(document, document, formatTable(node));\n    } else {\n      formatTableArray(node).forEach(table_array => {\n        insert(document, document, table_array);\n      });\n    }\n  });\n\n  applyWrites(document);\n  return document;\n}\n\nfunction formatTable(key_value: KeyValue): Table {\n  const table = generateTable(key_value.key.value);\n\n  for (const item of (key_value.value as InlineTable).items) {\n    insert(table, table, item.item);\n  }\n\n  applyWrites(table);\n  return table;\n}\n\nfunction formatTableArray(key_value: KeyValue): TableArray[] {\n  const root = generateDocument();\n\n  for (const inline_array_item of (key_value.value as InlineArray).items) {\n    const table_array = generateTableArray(key_value.key.value);\n    insert(root, root, table_array);\n\n    for (const inline_table_item of (inline_array_item.item as InlineTable).items) {\n      insert(root, table_array, inline_table_item.item);\n    }\n  }\n\n  applyWrites(root);\n  return root.items as TableArray[];\n}\n\nexport function formatPrintWidth(document: Document, format: Format): Document {\n  // TODO\n  return document;\n}\n\nexport function formatEmptyLines(document: Document): Document {\n  let shift = 0;\n  let previous = 0;\n  for (const item of document.items) {\n    if (previous === 0 && item.loc.start.line > 1) {\n      // Remove leading newlines\n      shift = 1 - item.loc.start.line;\n    } else if (item.loc.start.line + shift > previous + 2) {\n      shift += previous + 2 - (item.loc.start.line + shift);\n    }\n\n    shiftNode(item, {\n      lines: shift,\n      columns: 0\n    });\n    previous = item.loc.end.line;\n  }\n\n  return document;\n}\n","import { Value, KeyValue, Document, InlineArray, InlineTable } from './ast';\nimport {\n  generateDocument,\n  generateKeyValue,\n  generateInlineItem,\n  generateString,\n  generateInteger,\n  generateFloat,\n  generateBoolean,\n  generateDateTime,\n  generateInlineArray,\n  generateInlineTable\n} from './generate';\nimport { Format, formatTopLevel, formatPrintWidth, formatEmptyLines } from './format';\nimport { isObject, isString, isInteger, isFloat, isBoolean, isDate, pipe } from './utils';\nimport { insert, applyWrites, applyBracketSpacing, applyTrailingComma } from './writer';\n\nconst default_format = {\n  printWidth: 80,\n  trailingComma: false,\n  bracketSpacing: true\n};\n\nexport default function parseJS(value: any, format: Format = {}): Document {\n  format = Object.assign({}, default_format, format);\n  value = toJSON(value);\n\n  // Reorder the elements in the object\n  value = reorderElements(value);\n\n  const document = generateDocument();\n  for (const item of walkObject(value, format)) {\n    insert(document, document, item);\n  }\n  applyWrites(document);\n\n  // Heuristics:\n  // 1. Top-level objects/arrays should be tables/table arrays\n  // 2. Convert objects/arrays to tables/table arrays based on print width\n  const formatted = pipe(\n    document,\n    formatTopLevel,\n    document => formatPrintWidth(document, format),\n    formatEmptyLines\n  );\n\n  return formatted;\n}\n\n/** \nThis function makes sure that properties that are simple values (not objects or arrays) are ordered first,\nand that objects and arrays are ordered last. This makes parseJS more reliable and easier to test.\n*/\nfunction reorderElements(value:any) : Object {\n  let result: Record<string, any> = {};\n  \n  // First add all simple values\n  for (const key in value) {\n    if (!isObject(value[key]) && !Array.isArray(value[key])) {\n      result[key] = value[key];\n    }\n  }\n  \n  // Then add all objects and arrays\n  for (const key in value) {\n    if (isObject(value[key]) || Array.isArray(value[key])) {\n      result[key] = value[key];\n    }\n  }\n  \n  return result;\n}\n\nfunction* walkObject(object: any, format: Format): IterableIterator<KeyValue> {\n  for (const key of Object.keys(object)) {\n    yield generateKeyValue([key], walkValue(object[key], format));\n  }\n}\n\nfunction walkValue(value: any, format: Format): Value {\n  if (value == null) {\n    throw new Error('\"null\" and \"undefined\" values are not supported');\n  }\n\n  if (isString(value)) {\n    return generateString(value);\n  } else if (isInteger(value)) {\n    return generateInteger(value);\n  } else if (isFloat(value)) {\n    return generateFloat(value);\n  } else if (isBoolean(value)) {\n    return generateBoolean(value);\n  } else if (isDate(value)) {\n    return generateDateTime(value);\n  } else if (Array.isArray(value)) {\n    return walkInlineArray(value, format);\n  } else {\n    return walkInlineTable(value, format);\n  }\n}\n\nfunction walkInlineArray(value: Array<any>, format: Format): InlineArray {\n  const inline_array = generateInlineArray();\n  for (const element of value) {\n    const item = walkValue(element, format);\n    const inline_array_item = generateInlineItem(item);\n\n    insert(inline_array, inline_array, inline_array_item);\n  }\n  applyBracketSpacing(inline_array, inline_array, format.bracketSpacing);\n  applyTrailingComma(inline_array, inline_array, format.trailingComma);\n  applyWrites(inline_array);\n\n  return inline_array;\n}\n\nfunction walkInlineTable(value: object, format: Format): InlineTable | Value {\n  value = toJSON(value);\n  if (!isObject(value)) return walkValue(value, format);\n\n  const inline_table = generateInlineTable();\n  const items = [...walkObject(value, format)];\n  for (const item of items) {\n    const inline_table_item = generateInlineItem(item);\n\n    insert(inline_table, inline_table, inline_table_item);\n  }\n  applyBracketSpacing(inline_table, inline_table, format.bracketSpacing);\n  applyTrailingComma(inline_table, inline_table, format.trailingComma);\n  applyWrites(inline_table);\n\n  return inline_table;\n}\n\n/**\n * Handles custom object serialization by checking for and using toJSON methods\n * \n * @param value - The value to potentially convert\n * @returns The result of value.toJSON() if available, otherwise the original value\n */\nfunction toJSON(value: any): any {\n  // Skip null/undefined values\n  if (!value) {\n    return value;\n  }\n  \n  // Skip Date objects (they have special handling)\n  if (isDate(value)) {\n    return value;\n  }\n  \n  // Use object's custom toJSON method if available\n  if (typeof value.toJSON === 'function') {\n    return value.toJSON();\n  }\n  \n  // Otherwise return unmodified\n  return value;\n}\n","import { NodeType, AST } from './ast';\nimport traverse from './traverse';\nimport { Location } from './location';\nimport { SPACE } from './tokenizer';\n\nconst BY_NEW_LINE = /(\\r\\n|\\n)/g;\n\nexport default function toTOML(ast: AST, newline: string = '\\n'): string {\n  const lines: string[] = [];\n\n  traverse(ast, {\n    [NodeType.TableKey](node) {\n      const { start, end } = node.loc;\n\n      write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '[');\n      write(lines, { start: { line: end.line, column: end.column - 1 }, end }, ']');\n    },\n    [NodeType.TableArrayKey](node) {\n      const { start, end } = node.loc;\n\n      write(lines, { start, end: { line: start.line, column: start.column + 2 } }, '[[');\n      write(lines, { start: { line: end.line, column: end.column - 2 }, end }, ']]');\n    },\n\n    [NodeType.KeyValue](node) {\n      const {\n        start: { line }\n      } = node.loc;\n      write(\n        lines,\n        { start: { line, column: node.equals }, end: { line, column: node.equals + 1 } },\n        '='\n      );\n    },\n    [NodeType.Key](node) {\n      write(lines, node.loc, node.raw);\n    },\n\n    [NodeType.String](node) {\n      write(lines, node.loc, node.raw);\n    },\n    [NodeType.Integer](node) {\n      write(lines, node.loc, node.raw);\n    },\n    [NodeType.Float](node) {\n      write(lines, node.loc, node.raw);\n    },\n    [NodeType.Boolean](node) {\n      write(lines, node.loc, node.value.toString());\n    },\n    [NodeType.DateTime](node) {\n      write(lines, node.loc, node.raw);\n    },\n\n    [NodeType.InlineArray](node) {\n      const { start, end } = node.loc;\n      write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '[');\n      write(lines, { start: { line: end.line, column: end.column - 1 }, end }, ']');\n    },\n\n    [NodeType.InlineTable](node) {\n      const { start, end } = node.loc;\n      write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '{');\n      write(lines, { start: { line: end.line, column: end.column - 1 }, end }, '}');\n    },\n    [NodeType.InlineItem](node) {\n      if (!node.comma) return;\n\n      const start = node.loc.end;\n      write(lines, { start, end: { line: start.line, column: start.column + 1 } }, ',');\n    },\n\n    [NodeType.Comment](node) {\n      write(lines, node.loc, node.raw);\n    }\n  });\n\n  return lines.join(newline) + newline;\n}\n\nfunction write(lines: string[], loc: Location, raw: string) {\n  const raw_lines = raw.split(BY_NEW_LINE).filter(line => line !== '\\n' && line !== '\\r\\n');\n  const expected_lines = loc.end.line - loc.start.line + 1;\n\n  if (raw_lines.length !== expected_lines) {\n    throw new Error(\n      `Mismatch between location and raw string, expected ${expected_lines} lines for \"${raw}\"`\n    );\n  }\n\n  for (let i = loc.start.line; i <= loc.end.line; i++) {\n    const line = getLine(lines, i);\n    const is_start_line = i === loc.start.line;\n    const is_end_line = i === loc.end.line;\n\n    const before = is_start_line\n      ? line.substr(0, loc.start.column).padEnd(loc.start.column, SPACE)\n      : '';\n    const after = is_end_line ? line.substr(loc.end.column) : '';\n\n    lines[i - 1] = before + raw_lines[i - loc.start.line] + after;\n  }\n}\n\nfunction getLine(lines: string[], index: number): string {\n  if (!lines[index - 1]) {\n    for (let i = 0; i < index; i++) {\n      if (!lines[i]) lines[i] = '';\n    }\n  }\n\n  return lines[index - 1];\n}\n","import { Value, NodeType, TreeNode, AST, isInlineTable } from './ast';\nimport traverse from './traverse';\nimport { last, blank, isDate, has } from './utils';\nimport ParseError from './parse-error';\n\nexport default function toJS(ast: AST, input: string = ''): any {\n  const result = blank();\n  const tables: Set<string> = new Set();\n  const table_arrays: Set<string> = new Set();\n  const defined: Set<string> = new Set();\n  let active: any = result;\n  let previous_active: any;\n  let skip = false;\n\n  traverse(ast, {\n    [NodeType.Table](node) {\n      const key = node.key.item.value;\n      try {\n        validateKey(result, key, node.type, { tables, table_arrays, defined });\n      } catch (err) {\n        const e = err as Error;\n        throw new ParseError(input, node.key.loc.start, e.message);\n      }\n\n      const joined_key = joinKey(key);\n      tables.add(joined_key);\n      defined.add(joined_key);\n\n      active = ensureTable(result, key);\n    },\n\n    [NodeType.TableArray](node) {\n      const key = node.key.item.value;\n\n      try {\n        validateKey(result, key, node.type, { tables, table_arrays, defined });\n      } catch (err) {\n        const e = err as Error;\n        throw new ParseError(input, node.key.loc.start, e.message);\n      }\n\n      const joined_key = joinKey(key);\n      table_arrays.add(joined_key);\n      defined.add(joined_key);\n\n      active = ensureTableArray(result, key);\n    },\n\n    [NodeType.KeyValue]: {\n      enter(node) {\n        if (skip) return;\n\n        const key = node.key.value;\n        try {\n          validateKey(active, key, node.type, { tables, table_arrays, defined });\n        } catch (err) {\n          const e = err as Error;\n          throw new ParseError(input, node.key.loc.start, e.message);\n        }\n\n        const value = toValue(node.value);\n        const target = key.length > 1 ? ensureTable(active, key.slice(0, -1)) : active;\n\n        target[last(key)!] = value;\n        defined.add(joinKey(key));\n\n        if (isInlineTable(node.value)) {\n          previous_active = active;\n          active = value;\n        }\n      },\n      exit(node) {\n        if (isInlineTable(node.value)) {\n          active = previous_active;\n        }\n      }\n    },\n\n    [NodeType.InlineTable]: {\n      enter() {\n        // Handled by toValue\n        skip = true;\n      },\n      exit() {\n        skip = false;\n      }\n    }\n  });\n\n  return result;\n}\n\nexport function toValue(node: Value): any {\n  switch (node.type) {\n    case NodeType.InlineTable:\n      const result = blank();\n\n      node.items.forEach(({ item }) => {\n        const key = item.key.value;\n        const value = toValue(item.value);\n\n        const target = key.length > 1 ? ensureTable(result, key.slice(0, -1)) : result;\n        target[last(key)!] = value;\n      });\n\n      return result;\n\n    case NodeType.InlineArray:\n      return node.items.map(item => toValue(item.item as Value));\n\n    case NodeType.String:\n    case NodeType.Integer:\n    case NodeType.Float:\n    case NodeType.Boolean:\n    case NodeType.DateTime:\n      return node.value;\n\n    default:\n      throw new Error(`Unrecognized value type \"${(node as TreeNode).type}\"`);\n  }\n}\n\nfunction validateKey(\n  object: any,\n  key: string[],\n  type: NodeType.Table | NodeType.TableArray | NodeType.KeyValue,\n  state: { tables: Set<string>; table_arrays: Set<string>; defined: Set<string> }\n) {\n  // 1. Cannot override primitive value\n  let parts: string[] = [];\n  let index = 0;\n  for (const part of key) {\n    parts.push(part);\n\n    if (!has(object, part)) return;\n    if (isPrimitive(object[part])) {\n      throw new Error(`Invalid key, a value has already been defined for ${parts.join('.')}`);\n    }\n\n    const joined_parts = joinKey(parts);\n    if (Array.isArray(object[part]) && !state.table_arrays.has(joined_parts)) {\n      throw new Error(`Invalid key, cannot add to a static array at ${joined_parts}`);\n    }\n\n    const next_is_last = index++ < key.length - 1;\n    object = Array.isArray(object[part]) && next_is_last ? last(object[part]) : object[part];\n  }\n\n  const joined_key = joinKey(key);\n\n  // 2. Cannot override table\n  if (object && type === NodeType.Table && state.defined.has(joined_key)) {\n    throw new Error(`Invalid key, a table has already been defined named ${joined_key}`);\n  }\n\n  // 3. Cannot add table array to static array or table\n  if (object && type === NodeType.TableArray && !state.table_arrays.has(joined_key)) {\n    throw new Error(`Invalid key, cannot add an array of tables to a table at ${joined_key}`);\n  }\n}\n\nfunction ensureTable(object: any, key: string[]): any {\n  const target = ensure(object, key.slice(0, -1));\n  const last_key = last(key)!;\n  if (!target[last_key]) {\n    target[last_key] = blank();\n  }\n\n  return target[last_key];\n}\n\nfunction ensureTableArray(object: any, key: string[]): any {\n  const target = ensure(object, key.slice(0, -1));\n  const last_key = last(key)!;\n  if (!target[last_key]) {\n    target[last_key] = [];\n  }\n\n  const next = blank();\n  target[last(key)!].push(next);\n\n  return next;\n}\n\nfunction ensure(object: any, keys: string[]): any {\n  return keys.reduce((active, subkey) => {\n    if (!active[subkey]) {\n      active[subkey] = blank();\n    }\n    return Array.isArray(active[subkey]) ? last(active[subkey]) : active[subkey];\n  }, object);\n}\n\nfunction isPrimitive(value: any) {\n  return typeof value !== 'object' && !isDate(value);\n}\n\nfunction joinKey(key: string[]): string {\n  return key.join('.');\n}\n","import { isObject, datesEqual, stableStringify, merge } from './utils';\nimport { Path } from './find-by-path';\n\nexport enum ChangeType {\n  Add = 'Add',\n  Edit = 'Edit',\n  Remove = 'Remove',\n  Move = 'Move',\n  Rename = 'Rename'\n}\n\nexport interface Add {\n  type: ChangeType.Add;\n  path: Path;\n}\nexport function isAdd(change: Change): change is Add {\n  return change.type === ChangeType.Add;\n}\n\nexport interface Edit {\n  type: ChangeType.Edit;\n  path: Path;\n}\nexport function isEdit(change: Change): change is Edit {\n  return change.type === ChangeType.Edit;\n}\n\nexport interface Remove {\n  type: ChangeType.Remove;\n  path: Path;\n}\nexport function isRemove(change: Change): change is Remove {\n  return change.type === ChangeType.Remove;\n}\n\nexport interface Move {\n  type: ChangeType.Move;\n  path: Path;\n  from: number;\n  to: number;\n}\nexport function isMove(change: Change): change is Move {\n  return change.type === ChangeType.Move;\n}\n\nexport interface Rename {\n  type: ChangeType.Rename;\n  path: Path;\n  from: string;\n  to: string;\n}\nexport function isRename(change: Change): change is Rename {\n  return change.type === ChangeType.Rename;\n}\n\nexport type Change = Add | Edit | Remove | Move | Rename;\n\nexport default function diff(before: any, after: any, path: Path = []): Change[] {\n  if (before === after || datesEqual(before, after)) {\n    return [];\n  }\n\n  if (Array.isArray(before) && Array.isArray(after)) {\n    return compareArrays(before, after, path);\n  } else if (isObject(before) && isObject(after)) {\n    return compareObjects(before, after, path);\n  } else {\n    return [\n      {\n        type: ChangeType.Edit,\n        path\n      }\n    ];\n  }\n}\n\nfunction compareObjects(before: any, after: any, path: Path = []): Change[] {\n  let changes: Change[] = [];\n\n  // 1. Get keys and stable values\n  const before_keys = Object.keys(before);\n  const before_stable = before_keys.map(key => stableStringify(before[key]));\n  const after_keys = Object.keys(after);\n  const after_stable = after_keys.map(key => stableStringify(after[key]));\n\n  // Check for rename by seeing if object is in both before and after\n  // and that key is no longer used in after\n  const isRename = (stable: string, search: string[]) => {\n    const index = search.indexOf(stable);\n    if (index < 0) return false;\n\n    const before_key = before_keys[before_stable.indexOf(stable)];\n    return !after_keys.includes(before_key);\n  };\n\n  // 2. Check for changes, rename, and removed\n  before_keys.forEach((key, index) => {\n    const sub_path = path.concat(key);\n    if (after_keys.includes(key)) {\n      merge(changes, diff(before[key], after[key], sub_path));\n    } else if (isRename(before_stable[index], after_stable)) {\n      const to = after_keys[after_stable.indexOf(before_stable[index])];\n      changes.push({\n        type: ChangeType.Rename,\n        path,\n        from: key,\n        to\n      });\n    } else {\n      changes.push({\n        type: ChangeType.Remove,\n        path: sub_path\n      });\n    }\n  });\n\n  // 3. Check for additions\n  after_keys.forEach((key, index) => {\n    if (!before_keys.includes(key) && !isRename(after_stable[index], before_stable)) {\n      changes.push({\n        type: ChangeType.Add,\n        path: path.concat(key)\n      });\n    }\n  });\n\n  return changes;\n}\n\nfunction compareArrays(before: any[], after: any[], path: Path = []): Change[] {\n  let changes: Change[] = [];\n\n  // 1. Convert arrays to stable objects\n  const before_stable = before.map(stableStringify);\n  const after_stable = after.map(stableStringify);\n\n  // 2. Step through after array making changes to before array as-needed\n  after_stable.forEach((value, index) => {\n    const overflow = index >= before_stable.length;\n\n    // Check if items are the same\n    if (!overflow && before_stable[index] === value) {\n      return;\n    }\n\n    // Check if item has been moved -> shift into place\n    const from = before_stable.indexOf(value, index + 1);\n    if (!overflow && from > -1) {\n      changes.push({\n        type: ChangeType.Move,\n        path,\n        from,\n        to: index\n      });\n\n      const move = before_stable.splice(from, 1);\n      before_stable.splice(index, 0, ...move);\n\n      return;\n    }\n\n    // Check if item is removed -> assume it's been edited and replace\n    const removed = !after_stable.includes(before_stable[index]);\n    if (!overflow && removed) {\n      merge(changes, diff(before[index], after[index], path.concat(index)));\n      before_stable[index] = value;\n\n      return;\n    }\n\n    // Add as new item and shift existing\n    changes.push({\n      type: ChangeType.Add,\n      path: path.concat(index)\n    });\n    before_stable.splice(index, 0, value);\n  });\n\n  // 3. Remove any remaining overflow items\n  for (let i = after_stable.length; i < before_stable.length; i++) {\n    changes.push({\n      type: ChangeType.Remove,\n      path: path.concat(i)\n    });\n  }\n\n  return changes;\n}\n","import { TreeNode, isKeyValue, isTable, isTableArray, hasItems, isInlineItem, hasItem } from './ast';\nimport { arraysEqual, stableStringify } from './utils';\n\nexport type Path = Array<string | number>;\n\nexport default function findByPath(node: TreeNode, path: Path): TreeNode {\n  if (!path.length) return node;\n\n  if (isKeyValue(node)) {\n    return findByPath(node.value, path);\n  }\n\n  const indexes: { [key: string]: number } = {};\n  let found;\n  if (hasItems(node)) {\n    node.items.some((item, index) => {\n      try {\n        let key: Path = [];\n        if (isKeyValue(item)) {\n          key = item.key.value;\n        } else if (isTable(item)) {\n          key = item.key.item.value;\n        } else if (isTableArray(item)) {\n          key = item.key.item.value;\n\n          const key_string = stableStringify(key);\n          if (!indexes[key_string]) {\n            indexes[key_string] = 0;\n          }\n          const array_index = indexes[key_string]++;\n\n          key = key.concat(array_index);\n        } else if (isInlineItem(item) && isKeyValue(item.item)) {\n          key = item.item.key.value;\n        } else if (isInlineItem(item)) {\n          key = [index];\n        }\n\n        if (key.length && arraysEqual(key, path.slice(0, key.length))) {\n          found = findByPath(item, path.slice(key.length));\n          return true;\n        } else {\n          return false;\n        }\n      } catch (err) {\n        return false;\n      }\n    });\n  }\n\n  if (!found) {\n    throw new Error(`Could not find node at path ${path.join('.')}`);\n  }\n\n  return found;\n}\n\nexport function tryFindByPath(node: TreeNode, path: Path): TreeNode | undefined {\n  try {\n    return findByPath(node, path);\n  } catch (err) {}\n}\n\nexport function findParent(node: TreeNode, path: Path): TreeNode {\n  let parent_path = path;\n  let parent;\n  while (parent_path.length && !parent) {\n    parent_path = parent_path.slice(0, -1);\n    parent = tryFindByPath(node, parent_path);\n  }\n\n  if (!parent) {\n    throw new Error(`Count not find parent node for path ${path.join('.')}`);\n  }\n\n  return parent;\n}\n","import parseTOML from './parse-toml';\nimport parseJS from './parse-js';\nimport toTOML from './to-toml';\nimport toJS from './to-js';\nimport { Format } from './format';\n\nexport function parse(value: string): any {\n  return toJS(parseTOML(value), value);\n}\n\nexport function stringify(value: any, format?: Format): string {\n  const document = parseJS(value, format);\n  return toTOML(document.items);\n}\n\nexport { default as patch } from './patch';\n","import parseTOML from './parse-toml';\nimport parseJS from './parse-js';\nimport toJS from './to-js';\nimport toTOML from './to-toml';\nimport { Format } from './format';\nimport {\n  isKeyValue,\n  WithItems,\n  KeyValue,\n  isTable,\n  TreeNode,\n  Document,\n  isDocument,\n  Block,\n  NodeType,\n  isTableArray,\n  isInlineArray,\n  hasItem,\n  InlineItem,\n  AST\n} from './ast';\nimport diff, { Change, isAdd, isEdit, isRemove, isMove, isRename } from './diff';\nimport findByPath, { tryFindByPath, findParent } from './find-by-path';\nimport { last, isInteger } from './utils';\nimport { insert, replace, remove, applyWrites } from './writer';\nimport { validate } from './validate';\n\nexport function toDocument(ast: AST) : Document  {\n  const items = [...ast];\n  return  {\n    type: NodeType.Document,\n    loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },\n    items\n  };\n}\n\nexport default function patch(existing: string, updated: any, format?: Format): string {\n  const existing_ast = parseTOML(existing);\n  const items = [...existing_ast];\n\n  const existing_js = toJS(items);\n  const existing_document: Document = {\n    type: NodeType.Document,\n    loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },\n    items\n  };\n\n  const updated_document = parseJS(updated, format);\n  const changes = reorder(diff(existing_js, updated));\n\n\n\n  const patched_document = applyChanges(existing_document, updated_document, changes);\n\n  // Validate the patched_document\n  //validate(patched_document);\n\n  return toTOML(patched_document.items);\n}\n\nfunction reorder(changes: Change[]): Change[] {\n  //Reorder deletions among themselves to avoid index issues\n  // We want the path to be looking at the last item in the array first and go down from there\n \n  let sorted = false;\n  for (let i = 0; i < changes.length; i++) {\n    const change = changes[i];\n    if (isRemove(change)) {\n      let j = i + 1;\n      while (j < changes.length) {\n        const next_change = changes[j];\n        if (isRemove(next_change) && next_change.path[0] === change.path[0]  && \n            next_change.path[1] > change.path[1]) {\n          changes.splice(j, 1);\n          changes.splice(i, 0, next_change);\n          // We reset i to the beginning of the loop to avoid skipping any changes\n          i = 0\n          break;\n        }\n        j++;\n      }\n    }\n  }\n  \n  return changes;\n\n}\n\nfunction applyChanges(original: Document, updated: Document, changes: Change[]): Document {\n  // Potential Changes:\n  //\n  // Add: Add key-value to object, add item to array\n  // Edit: Change in value\n  // Remove: Remove key-value from object, remove item from array\n  // Move: Move item in array\n  // Rename: Rename key in key-value\n  //\n  // Special consideration, inline comments need to move as-needed\n\n  changes.forEach(change => {\n    if (isAdd(change)) {\n      const child = findByPath(updated, change.path);\n      const parent_path = change.path.slice(0, -1);\n      let index = last(change.path)! as number;\n\n      let is_table_array = isTableArray(child);\n      if (isInteger(index) && !parent_path.some(isInteger)) {\n        const sibling = tryFindByPath(original, parent_path.concat(0));\n        if (sibling && isTableArray(sibling)) {\n          is_table_array = true;\n        }\n      }\n\n      let parent: TreeNode;\n      if (isTable(child)) {\n        parent = original;\n      } else if (is_table_array) {\n        parent = original;\n\n        // The index needs to be updated to top-level items\n        // to properly account for other items, comments, and nesting\n        const document = original as Document;\n        const before = tryFindByPath(document, parent_path.concat(index - 1)) as Block | undefined;\n        const after = tryFindByPath(document, parent_path.concat(index)) as Block | undefined;\n        if (after) {\n          index = document.items.indexOf(after);\n        } else if (before) {\n          index = document.items.indexOf(before) + 1;\n        } else {\n          index = document.items.length;\n        }\n      } else {\n        parent = findParent(original, change.path);\n        if (isKeyValue(parent)) parent = parent.value;\n      }\n\n      if (isTableArray(parent) || isInlineArray(parent) || isDocument(parent)) {\n        insert(original, parent, child, index);\n      } else {\n        insert(original, parent, child);\n      }\n    } else if (isEdit(change)) {\n      let existing = findByPath(original, change.path);\n      let replacement = findByPath(updated, change.path);\n      let parent;\n\n      if (isKeyValue(existing) && isKeyValue(replacement)) {\n        // Edit for key-value means value changes\n        parent = existing;\n        existing = existing.value;\n        replacement = replacement.value;\n      } else {\n        parent = findParent(original, change.path);\n      }\n\n      replace(original, parent, existing, replacement);\n    } else if (isRemove(change)) {\n      let parent = findParent(original, change.path);\n      if (isKeyValue(parent)) parent = parent.value;\n\n      const node = findByPath(original, change.path);\n\n      remove(original, parent, node);\n    } else if (isMove(change)) {\n      let parent = findByPath(original, change.path);\n      if (hasItem(parent)) parent = parent.item;\n      if (isKeyValue(parent)) parent = parent.value;\n\n      const node = (parent as WithItems).items[change.from];\n\n      remove(original, parent, node);\n      insert(original, parent, node, change.to);\n    } else if (isRename(change)) {\n      let parent = findByPath(original, change.path.concat(change.from)) as\n        | KeyValue\n        | InlineItem<KeyValue>;\n      let replacement = findByPath(updated, change.path.concat(change.to)) as\n        | KeyValue\n        | InlineItem<KeyValue>;\n\n      if (hasItem(parent)) parent = parent.item;\n      if (hasItem(replacement)) replacement = replacement.item;\n\n      replace(original, parent, parent.key, replacement.key);\n    }\n  });\n\n  applyWrites(original);\n  return original;\n}\n"],"names":["NodeType","TokenType","isDocument","node","type","Document","isTable","Table","isTableArray","TableArray","isKeyValue","KeyValue","isInlineArray","InlineArray","isInlineItem","InlineItem","isInlineTable","InlineTable","isComment","Comment","hasItems","hasItem","TableKey","isTableKey","TableArrayKey","isTableArrayKey","Cursor","constructor","iterator","this","index","value","undefined","done","peeked","next","result","_a","peek","Symbol","getSpan","location","lines","end","line","start","columns","column","findPosition","input","Array","isArray","findLines","findIndex","line_index","BY_NEW_LINE","indexes","match","exec","push","length","clonePosition","position","cloneLocation","ParseError","Error","message","error_message","substr","getLine","pointer","count","character","repeat","whitespace","super","IS_WHITESPACE","IS_NEW_LINE","DOUBLE_QUOTE","SINGLE_QUOTE","IS_VALID_LEADING_CHARACTER","tokenize","cursor","locate","createLocate","test","specialCharacter","Bracket","Curly","Equal","Comma","Dot","comment","multiline_char","checkThree","multiline","string","raw","loc","quotes","CheckMoreThanThree","Literal","double_quoted","single_quoted","isFinished","next_item","current","check","backslashes","slice","last","values","blank","Object","create","isInteger","isDate","prototype","toString","call","isObject","has","object","key","hasOwnProperty","pipe","fns","reduce","fn","stableStringify","keys","sort","map","JSON","stringify","join","merge","target","original_length","added_length","i","IS_CRLF","IS_LF","IS_LEADING_NEW_LINE","IS_LINE_ENDING_BACKSLASH","parseString","startsWith","trim","trimLeadingWhitespace","lineEndingBackslash","escapeNewLines","escapeDoubleQuotes","unescapeLargeUnicode","precedingBackslashes","char","escaped","json_escaped","replace","code_point","parseInt","as_string","String","fromCodePoint","fixed_json_escaped","parse","group","TRUE","HAS_E","IS_DIVIDER","IS_INF","IS_NAN","IS_HEX","IS_OCTAL","IS_BINARY","IS_FULL_DATE","IS_FULL_TIME","parseTOML","tokens","walkBlock","is_table","item","Key","dot","before","after","items","table","equals","comments","walkValue","keyValue","Boolean","boolean","Date","local_date","toISOString","split","DateTime","datetime","Infinity","Number","Float","float","Integer","radix","integer","previous","comma","inline_item","inlineTable","inline_array","additional_comments","inlineArray","traverse","ast","visitor","traverseArray","array","parent","traverseNode","visit","enter","exit","enter_offsets","WeakMap","getEnterOffsets","root","set","get","exit_offsets","getExitOffsets","existing","replacement","indexOf","splice","shiftNode","existing_span","replacement_span","addOffset","insert","child","shift","offset","is_last","has_seperating_comma_before","has_seperating_comma_after","has_trailing_comma","use_new_line","perLine","leading_lines","skip_comma","skip_bracket","child_span","insertInline","use_first_line","is_block","insertOnNewLine","previous_offset","delete","remove","removed_span","is_inline","previous_on_same_line","next_on_sameLine","keep_line","target_offsets","node_offsets","removed_offset","applyBracketSpacing","bracket_spacing","last_item","applyTrailingComma","trailing_commas","applyWrites","shiftStart","lineOffset","columnOffset","entering","shiftEnd","exiting","shiftLocation","start_line","key_offset","span","options","first_line_only","move","offsets","from","generateDocument","generateTable","table_key","keyValueToRaw","generateTableKey","generateTableArray","table_array_key","generateTableArrayKey","generateKeyValue","key_node","generateKey","IS_BARE_KEY","part","generateInlineItem","formatTopLevel","document","filter","is_inline_table","is_inline_array","forEach","key_value","formatTable","inline_array_item","table_array","inline_table_item","formatTableArray","formatEmptyLines","default_format","printWidth","trailingComma","bracketSpacing","parseJS","format","assign","reorderElements","toJSON","walkObject","formatted","formatPrintWidth","isString","generateString","generateInteger","isFloat","generateFloat","isBoolean","generateBoolean","generateDateTime","element","walkInlineArray","inline_table","walkInlineTable","toTOML","newline","write","raw_lines","expected_lines","is_start_line","is_end_line","padEnd","toJS","tables","Set","table_arrays","defined","previous_active","active","skip","validateKey","err","e","joined_key","joinKey","add","ensureTable","ensure","last_key","ensureTableArray","toValue","state","parts","joined_parts","next_is_last","subkey","ChangeType","isRemove","change","Remove","diff","path","b","a","changes","before_stable","after_stable","overflow","Move","to","removed","includes","concat","Add","compareArrays","before_keys","after_keys","isRename","stable","search","before_key","sub_path","Rename","compareObjects","Edit","findByPath","found","some","key_string","array_index","arraysEqual","tryFindByPath","findParent","parent_path","updated","existing_js","original","isAdd","is_table_array","sibling","isEdit","isMove","applyChanges","j","next_change","reorder"],"mappings":"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"}
+{"version":3,"file":"toml-patch.umd.min.js","sources":["../src/ast.ts","../src/tokenizer.ts","../src/cursor.ts","../src/location.ts","../src/parse-error.ts","../src/utils.ts","../src/parse-string.ts","../src/parse-toml.ts","../src/traverse.ts","../src/writer.ts","../src/generate.ts","../src/format.ts","../src/parse-js.ts","../src/to-toml.ts","../src/to-js.ts","../src/diff.ts","../src/find-by-path.ts","../src/index.ts","../src/patch.ts"],"sourcesContent":["import { Location } from './location';\n\nexport enum NodeType {\n  Document = 'Document',\n  Table = 'Table',\n  TableKey = 'TableKey',\n  TableArray = 'TableArray',\n  TableArrayKey = 'TableArrayKey',\n  KeyValue = 'KeyValue',\n  Key = 'Key',\n  String = 'String',\n  Integer = 'Integer',\n  Float = 'Float',\n  Boolean = 'Boolean',\n  DateTime = 'DateTime',\n  InlineArray = 'InlineArray',\n  InlineItem = 'InlineItem',\n  InlineTable = 'InlineTable',\n  Comment = 'Comment'\n}\n\n//\n// Abstract Syntax Tree\n//\n// AST nodes are used to represent TOML data\n//\nexport type AST = Iterable<Block>;\n\n//\n// Document\n//\n// Top-level document that stores AST nodes\n//\nexport interface Document extends TreeNode {\n  type: NodeType.Document;\n  items: Array<Block>;\n}\nexport function isDocument(node: TreeNode): node is Document {\n  return node.type === NodeType.Document;\n}\n\n//\n// Table\n//\n// Top-level object\n//\n// v-------|\n// [table] |\n// b = \"c\" |\n//         |\n// # note  |\n//      ^--|\n// [b]\n//\nexport interface Table extends TreeNode {\n  type: NodeType.Table;\n  key: TableKey;\n  items: Array<KeyValue | Comment>;\n}\nexport function isTable(node: TreeNode): node is Table {\n  return node.type === NodeType.Table;\n}\n\n//\n// TableKey\n//\n// Used to store bracket information for Table keys\n//\n// loc includes brackets\n//\n// [  key  ]\n// ^-------^\n//\nexport interface TableKey extends TreeNode {\n  type: NodeType.TableKey;\n  item: Key;\n}\nexport function isTableKey(node: TreeNode): node is TableKey {\n  return node.type === NodeType.TableKey;\n}\n\n//\n// TableArray\n//\n// Top-level array item\n//\n// v---------|\n// [[array]] |\n// a=\"b\"     |\n//           |\n// # details |\n//         ^-|\n// [[array]]\n//\nexport interface TableArray extends TreeNode {\n  type: NodeType.TableArray;\n  key: TableArrayKey;\n  items: Array<KeyValue | Comment>;\n}\nexport function isTableArray(node: TreeNode): node is TableArray {\n  return node.type === NodeType.TableArray;\n}\n\n//\n// TableArrayKey\n//\n// Used to store bracket information for TableArray keys\n// loc includes brackets\n//\n// [[  key  ]]\n// ^---------^\n//\nexport interface TableArrayKey extends TreeNode {\n  type: NodeType.TableArrayKey;\n  item: Key;\n}\nexport function isTableArrayKey(node: TreeNode): node is TableArrayKey {\n  return node.type === NodeType.TableArrayKey;\n}\n\n//\n// KeyValue\n//\n// Key and Value nodes, with position information on equals sign\n//\n// key=\"value\" # note\n// ^---------^\n//\nexport interface KeyValue extends TreeNode {\n  type: NodeType.KeyValue;\n  key: Key;\n  value: Value;\n\n  // Column index (0-based) of the equals sign\n  equals: number;\n}\nexport function isKeyValue(node: TreeNode): node is KeyValue {\n  return node.type === NodeType.KeyValue;\n}\n\n//\n// Key\n//\n// Store raw key and parts (from dots)\n//\nexport interface Key extends TreeNode {\n  type: NodeType.Key;\n  raw: string;\n\n  // Note: Array for keys with dots\n  // e.g. a.b -> raw = 'a.b', value = ['a', 'b']\n  value: string[];\n}\nexport function isKey(node: TreeNode): node is Key {\n  return node.type === NodeType.Key;\n}\n\n//\n// String\n//\n// loc includes quotes\n//\n// a = \"string\"\n//     ^------^\n//\nexport interface String extends TreeNode {\n  type: NodeType.String;\n  raw: string;\n  value: string;\n}\nexport function isString(node: TreeNode): node is String {\n  return node.type === NodeType.String;\n}\n\n//\n// Integer\n//\nexport interface Integer extends TreeNode {\n  type: NodeType.Integer;\n  raw: string;\n  value: number;\n}\nexport function isInteger(node: TreeNode): node is Integer {\n  return node.type === NodeType.Integer;\n}\n\n//\n// Float\n//\nexport interface Float extends TreeNode {\n  type: NodeType.Float;\n  raw: string;\n  value: number;\n}\nexport function isFloat(node: TreeNode): node is Float {\n  return node.type === NodeType.Float;\n}\n\n//\n// Boolean\n//\nexport interface Boolean extends TreeNode {\n  type: NodeType.Boolean;\n\n  // Only `true` and `false` are permitted\n  // -> don't need separate raw and value\n  value: boolean;\n}\nexport function isBoolean(node: TreeNode): node is Boolean {\n  return node.type === NodeType.Boolean;\n}\n\n//\n// DateTime\n//\n// Note: Currently, Offset Date-Time, Local Date-Time, Local Date, and Local Time\n// are handled via raw\n//\nexport interface DateTime extends TreeNode {\n  type: NodeType.DateTime;\n  raw: string;\n  value: Date;\n}\nexport function isDateTime(node: TreeNode): node is DateTime {\n  return node.type === NodeType.DateTime;\n}\n\n//\n// InlineArray\n//\nexport interface InlineArray<TItem = TreeNode> extends TreeNode {\n  type: NodeType.InlineArray;\n  items: InlineArrayItem<TItem>[];\n}\nexport function isInlineArray(node: TreeNode): node is InlineArray {\n  return node.type === NodeType.InlineArray;\n}\n\n//\n// InlineArrayItem\n//\n// loc for InlineArrayItem is from start of value to before comma\n// or end-of-value if no comma\n//\n// [ \"a\"  ,\"b\", \"c\"  ]\n//   ^---^ ^-^  ^-^\n//\nexport interface InlineItem<TItem = TreeNode> extends TreeNode {\n  type: NodeType.InlineItem;\n  item: TItem;\n  comma: boolean;\n}\nexport function isInlineItem(node: TreeNode): node is InlineItem {\n  return node.type === NodeType.InlineItem;\n}\n\nexport interface InlineArrayItem<TItem = TreeNode> extends InlineItem<TItem> {}\n\n//\n// InlineTable\n//\nexport interface InlineTable extends TreeNode {\n  type: NodeType.InlineTable;\n  items: InlineTableItem[];\n}\nexport function isInlineTable(node: TreeNode): node is InlineTable {\n  return node.type === NodeType.InlineTable;\n}\n\n//\n// InlineTableItem\n//\n// loc for InlineTableItem follows InlineArrayItem\n//\n// { a=\"b\"   ,    c =    \"d\"   }\n//   ^------^     ^--------^\n//\nexport interface InlineTableItem extends InlineItem<KeyValue> {}\n\n//\n// Comment\n//\n// loc starts at \"#\" and goes to end of comment (trailing whitespace ignored)\n//\n// # comment here\n// ^------------^\n//\nexport interface Comment extends TreeNode {\n  type: NodeType.Comment;\n  raw: string;\n}\nexport function isComment(node: TreeNode): node is Comment {\n  return node.type === NodeType.Comment;\n}\n\n//\n// Combinations\n//\n\nexport interface WithItems extends TreeNode {\n  items: TreeNode[];\n}\nexport function hasItems(node: TreeNode): node is WithItems {\n  return (\n    isDocument(node) ||\n    isTable(node) ||\n    isTableArray(node) ||\n    isInlineTable(node) ||\n    isInlineArray(node)\n  );\n}\n\nexport interface WithItem extends TreeNode {\n  item: TreeNode;\n}\nexport function hasItem(node: TreeNode): node is WithItem {\n  return isTableKey(node) || isTableArrayKey(node) || isInlineItem(node);\n}\n\nexport type Block = KeyValue | Table | TableArray | Comment;\nexport function isBlock(node: TreeNode): node is Block {\n  return isKeyValue(node) || isTable(node) || isTableArray(node) || isComment(node);\n}\n\nexport type Value<TInlineArrayItem = TreeNode> =\n  | String\n  | Integer\n  | Float\n  | Boolean\n  | DateTime\n  | InlineArray<TInlineArrayItem>\n  | InlineTable;\nexport function isValue(node: TreeNode): node is Value {\n  return (\n    isString(node) ||\n    isInteger(node) ||\n    isFloat(node) ||\n    isBoolean(node) ||\n    isDateTime(node) ||\n    isInlineArray(node) ||\n    isInlineTable(node)\n  );\n}\n\nexport interface TreeNode {\n  type: NodeType;\n  loc: Location;\n}\n","import Cursor, { iterator } from './cursor';\nimport { Location, Locator, createLocate, findPosition } from './location';\nimport ParseError from './parse-error';\n\nexport enum TokenType {\n  Bracket = 'Bracket',\n  Curly = 'Curly',\n  Equal = 'Equal',\n  Comma = 'Comma',\n  Dot = 'Dot',\n  Comment = 'Comment',\n  Literal = 'Literal'\n}\n\nexport interface Token {\n  type: TokenType;\n  raw: string;\n  loc: Location;\n}\n\nexport const IS_WHITESPACE = /\\s/;\nexport const IS_NEW_LINE = /(\\r\\n|\\n)/;\nexport const DOUBLE_QUOTE = `\"`;\nexport const SINGLE_QUOTE = `'`;\nexport const SPACE = ' ';\nexport const ESCAPE = '\\\\';\n\nconst IS_VALID_LEADING_CHARACTER = /[\\w,\\d,\\\",\\',\\+,\\-,\\_]/;\n\nexport function* tokenize(input: string): IterableIterator<Token> {\n  const cursor = new Cursor(iterator(input));\n  cursor.next();\n\n  const locate = createLocate(input);\n\n  while (!cursor.done) {\n    if (IS_WHITESPACE.test(cursor.value!)) {\n      // (skip whitespace)\n    } else if (cursor.value === '[' || cursor.value === ']') {\n      // Handle special characters: [, ], {, }, =, comma\n      yield specialCharacter(cursor, locate, TokenType.Bracket);\n    } else if (cursor.value === '{' || cursor.value === '}') {\n      yield specialCharacter(cursor, locate, TokenType.Curly);\n    } else if (cursor.value === '=') {\n      yield specialCharacter(cursor, locate, TokenType.Equal);\n    } else if (cursor.value === ',') {\n      yield specialCharacter(cursor, locate, TokenType.Comma);\n    } else if (cursor.value === '.') {\n      yield specialCharacter(cursor, locate, TokenType.Dot);\n    } else if (cursor.value === '#') {\n      // Handle comments = # -> EOL\n      yield comment(cursor, locate);\n    } else {\n      const multiline_char =\n        checkThree(input, cursor.index, SINGLE_QUOTE) ||\n        checkThree(input, cursor.index, DOUBLE_QUOTE);\n\n      if (multiline_char) {\n        // Multi-line literals or strings = no escaping\n        yield multiline(cursor, locate, multiline_char, input);\n      } else {\n        yield string(cursor, locate, input);\n      }\n    }\n\n    cursor.next();\n  }\n}\n\nfunction specialCharacter(cursor: Cursor<string>, locate: Locator, type: TokenType): Token {\n  return { type, raw: cursor.value!, loc: locate(cursor.index, cursor.index + 1) };\n}\n\nfunction comment(cursor: Cursor<string>, locate: Locator): Token {\n  const start = cursor.index;\n  let raw = cursor.value!;\n  while (!cursor.peek().done && !IS_NEW_LINE.test(cursor.peek().value!)) {\n    cursor.next();\n    raw += cursor.value!;\n  }\n\n  // Early exit is ok for comment, no closing conditions\n\n  return {\n    type: TokenType.Comment,\n    raw,\n    loc: locate(start, cursor.index + 1)\n  };\n}\n\nfunction multiline(\n  cursor: Cursor<string>,\n  locate: Locator,\n  multiline_char: string,\n  input: string\n): Token {\n  const start = cursor.index;\n  let quotes = multiline_char + multiline_char + multiline_char;\n  let raw = quotes;\n\n  // Skip over quotes\n  cursor.next();\n  cursor.next();\n  cursor.next();\n\n  // 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\n  // See spec-string-basic-multiline-9.toml\n  while (!cursor.done && (!checkThree(input, cursor.index, multiline_char) || CheckMoreThanThree(input, cursor.index, multiline_char))) {\n    raw += cursor.value;\n    cursor.next();\n  }\n\n  if (cursor.done) {\n    throw new ParseError(\n      input,\n      findPosition(input, cursor.index),\n      `Expected close of multiline string with ${quotes}, reached end of file`\n    );\n  }\n\n  raw += quotes;\n\n  cursor.next();\n  cursor.next();\n\n  return {\n    type: TokenType.Literal,\n    raw,\n    loc: locate(start, cursor.index + 1)\n  };\n}\n\nfunction string(cursor: Cursor<string>, locate: Locator, input: string): Token {\n  // Remaining possibilities: keys, strings, literals, integer, float, boolean\n  //\n  // Special cases:\n  // \"...\" -> quoted\n  // '...' -> quoted\n  // \"...\".'...' -> bare\n  // 0000-00-00 00:00:00 -> bare\n  //\n  // See https://github.com/toml-lang/toml#offset-date-time\n  //\n  // | 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).\n  // | `odt4 = 1979-05-27 07:32:00Z`\n  //\n  // From RFC 3339:\n  //\n  // | NOTE: ISO 8601 defines date and time separated by \"T\".\n  // | Applications using this syntax may choose, for the sake of\n  // | readability, to specify a full-date and full-time separated by\n  // | (say) a space character.\n\n  // First, check for invalid characters\n  if (!IS_VALID_LEADING_CHARACTER.test(cursor.value!)) {\n    throw new ParseError(\n      input,\n      findPosition(input, cursor.index),\n      `Unsupported character \"${cursor.value}\". Expected ALPHANUMERIC, \", ', +, -, or _`\n    );\n  }\n\n  const start = cursor.index;\n  let raw = cursor.value!;\n  let double_quoted = cursor.value === DOUBLE_QUOTE;\n  let single_quoted = cursor.value === SINGLE_QUOTE;\n\n  const isFinished = (cursor: Cursor<string>) => {\n    if (cursor.peek().done) return true;\n    const next_item = cursor.peek().value!;\n\n    return (\n      !(double_quoted || single_quoted) &&\n      (IS_WHITESPACE.test(next_item) ||\n        next_item === ',' ||\n        next_item === '.' ||\n        next_item === ']' ||\n        next_item === '}' ||\n        next_item === '=' ||\n        next_item === '#'\n      )\n    );\n  };\n\n  while (!cursor.done && !isFinished(cursor)) {\n    cursor.next();\n\n    if (cursor.value === DOUBLE_QUOTE) double_quoted = !double_quoted;\n    if (cursor.value === SINGLE_QUOTE && !double_quoted) single_quoted = !single_quoted;\n\n    raw += cursor.value!;\n\n    if (cursor.peek().done) break;\n    let next_item = cursor.peek().value!;\n\n    // If next character is escape and currently double-quoted,\n    // check for escaped quote\n    if (double_quoted && cursor.value === ESCAPE) {\n      if (next_item === DOUBLE_QUOTE) {\n        raw += DOUBLE_QUOTE;\n        cursor.next();\n      } else if (next_item === ESCAPE) {\n        raw += ESCAPE;\n        cursor.next();\n      }\n    }\n  }\n\n  if (double_quoted || single_quoted) {\n    throw new ParseError(\n      input,\n      findPosition(input, start),\n      `Expected close of string with ${double_quoted ? DOUBLE_QUOTE : SINGLE_QUOTE}`\n    );\n  }\n\n  return {\n    type: TokenType.Literal,\n    raw,\n    loc: locate(start, cursor.index + 1)\n  };\n}\n\n/**\n * Check if the current character and the next two characters are the same\n * and not escaped.\n *\n * @param input - The input string.\n * @param current - The current index in the input string.\n * @param check - The character to check for.\n * @returns ⚠️The character if found, otherwise false.\n */\nfunction checkThree(input: string, current: number, check: string): false | string {\n  if (!check) {\n    return false;\n  }\n\n  const has3 =\n    input[current] === check &&\n    input[current + 1] === check &&\n    input[current + 2] === check;\n\n  if (!has3) {\n    return false;\n  }\n\n  // Check if the sequence is escaped\n  const precedingText = input.slice(0, current); // Get the text before the current position\n  const backslashes  = precedingText.match(/\\\\+$/); // Match trailing backslashes\n\n  if (!backslashes) {\n    return check; // No backslashes means not escaped\n  }\n \n  const isEscaped = backslashes[0].length % 2 !== 0; // Odd number of backslashes means escaped\n\n  return isEscaped ? false : check; // Return `check` if not escaped, otherwise `false`\n}\n\nexport function CheckMoreThanThree(input: string, current: number, check: string): boolean {\n  \n  if (!check) {\n    return false;\n  }\n\n  return (\n    input[current] === check &&\n    input[current + 1] === check &&\n    input[current + 2] === check &&\n    input[current + 3] === check\n  )\n\n}\n","export function iterator<T>(value: Iterable<T>): Iterator<T> {\n  return value[Symbol.iterator]();\n}\n\n/**\n * Cursor<T>\n * \n * A utility class that wraps an iterator and provides additional functionality\n * such as peeking at the next value without advancing the iterator, tracking\n * the current index, and iterating over the values.\n * \n * @template T - The type of elements in the iterator.\n * \n * Properties:\n * - `iterator`: The underlying iterator being wrapped.\n * - `index`: The current index of the iterator (starts at -1).\n * - `value`: The current value of the iterator.\n * - `done`: A boolean indicating whether the iterator is complete.\n * - `peeked`: The result of peeking at the next value without advancing.\n * \n * Methods:\n * - `next()`: Advances the iterator and returns the next value.\n * - `peek()`: Returns the next value without advancing the iterator.\n * - `[Symbol.iterator]`: Makes the Cursor itself iterable.\n */\nexport default class Cursor<T> implements Iterator<T | undefined> {\n  iterator: Iterator<T>;\n  index: number;\n  value?: T;\n  done: boolean;\n  peeked: IteratorResult<T | undefined> | null;\n\n  constructor(iterator: Iterator<T>) {\n    this.iterator = iterator;\n    this.index = -1;\n    this.value = undefined;\n    this.done = false;\n    this.peeked = null;\n  }\n\n  next(): IteratorResult<T | undefined> {\n    if (this.done) return done();\n\n    const result = this.peeked || this.iterator.next();\n\n    this.index += 1;\n    this.value = result.value;\n    this.done = result.done ?? false;\n    this.peeked = null;\n\n    return result;\n  }\n\n  peek(): IteratorResult<T | undefined> {\n    if (this.done) return done();\n    if (this.peeked) return this.peeked;\n\n    this.peeked = this.iterator.next();\n    return this.peeked;\n  }\n\n  [Symbol.iterator]() {\n    return this;\n  }\n}\n\nfunction done(): IteratorResult<undefined> {\n  return { value: undefined, done: true };\n}\n","export interface Location {\n  start: Position;\n  end: Position;\n}\n\nexport interface Position {\n  // Note: line is 1-indexed while column is 0-indexed\n  line: number;\n  column: number;\n}\n\nexport interface Span {\n  lines: number;\n  columns: number;\n}\n\nexport function getSpan(location: Location): Span {\n  return {\n    lines: location.end.line - location.start.line + 1,\n    columns: location.end.column - location.start.column\n  };\n}\n\nexport type Locator = (start: number, end: number) => Location;\nexport function createLocate(input: string): Locator {\n  const lines = findLines(input);\n\n  return (start: number, end: number) => {\n    return {\n      start: findPosition(lines, start),\n      end: findPosition(lines, end)\n    };\n  };\n}\n\nexport function findPosition(input: string | number[], index: number): Position {\n  // abc\\ndef\\ng\n  // 0123 4567 8\n  //      012\n  //           0\n  //\n  // lines = [3, 7, 9]\n  //\n  // c = 2: 0 -> 1, 2 - (undefined + 1 || 0) = 2\n  //     3: 0 -> 1, 3 - (undefined + 1 || 0) = 3\n  // e = 5: 1 -> 2, 5 - (3 + 1 || 0) = 1\n  // g = 8: 2 -> 3, 8 - (7 + 1 || 0) = 0\n\n  const lines = Array.isArray(input) ? input : findLines(input);\n  const line = lines.findIndex(line_index => line_index >= index) + 1;\n  const column = index - (lines[line - 2] + 1 || 0);\n\n  return { line, column };\n}\n\nexport function getLine(input: string, position: Position): string {\n  const lines = findLines(input);\n  const start = lines[position.line - 2] || 0;\n  const end = lines[position.line - 1] || input.length;\n\n  return input.substr(start, end - start);\n}\n\nexport function findLines(input: string): number[] {\n  // exec is stateful, so create new regexp each time\n  const BY_NEW_LINE = /[\\r\\n|\\n]/g;\n  const indexes: number[] = [];\n\n  let match;\n  while ((match = BY_NEW_LINE.exec(input)) != null) {\n    indexes.push(match.index);\n  }\n  indexes.push(input.length + 1);\n\n  return indexes;\n}\n\nexport function clonePosition(position: Position): Position {\n  return { line: position.line, column: position.column };\n}\n\nexport function cloneLocation(location: Location): Location {\n  return { start: clonePosition(location.start), end: clonePosition(location.end) };\n}\n\nexport function zero(): Position {\n  return { line: 1, column: 0 };\n}\n","import { Position, getLine } from './location';\n\nexport default class ParseError extends Error {\n  line: number;\n  column: number;\n\n  constructor(input: string, position: Position, message: string) {\n    let error_message = `Error parsing TOML (${position.line}, ${position.column + 1}):\\n`;\n\n    if (input) {\n      const line = getLine(input, position);\n      const pointer = `${whitespace(position.column)}^`;\n\n      if (line) error_message += `${line}\\n${pointer}\\n`;\n    }\n    error_message += message;\n\n    super(error_message);\n\n    this.line = position.line;\n    this.column = position.column;\n  }\n}\n\nexport function isParseError(error: Error): error is ParseError {\n  return error && Object.prototype.hasOwnProperty.call(error, 'line');\n}\n\nfunction whitespace(count: number, character: string = ' '): string {\n  return character.repeat(count);\n}\n","export function last<TValue>(values: TValue[]): TValue | undefined {\n  return values[values.length - 1];\n}\n\nexport type BlankObject = { [key: string]: any };\n\nexport function blank(): BlankObject {\n  return Object.create(null);\n}\n\nexport function isString(value: any): value is string {\n  return typeof value === 'string';\n}\n\nexport function isInteger(value: any): value is number {\n  return typeof value === 'number' && value % 1 === 0;\n}\n\nexport function isFloat(value: any): value is number {\n  return typeof value === 'number' && !isInteger(value);\n}\n\nexport function isBoolean(value: any): value is boolean {\n  return typeof value === 'boolean';\n}\n\nexport function isDate(value: any): value is Date {\n  return Object.prototype.toString.call(value) === '[object Date]';\n}\n\nexport function isObject(value: any): boolean {\n  return value && typeof value === 'object' && !isDate(value) && !Array.isArray(value);\n}\n\nexport function isIterable<T>(value: any): value is Iterable<T> {\n  return value != null && typeof value[Symbol.iterator] === 'function';\n}\n\nexport function has(object: any, key: string): boolean {\n  return Object.prototype.hasOwnProperty.call(object, key);\n}\n\nexport function arraysEqual<TItem>(a: TItem[], b: TItem[]): boolean {\n  if (a.length !== b.length) return false;\n\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n\n  return true;\n}\n\nexport function datesEqual(a: any, b: any): boolean {\n  return isDate(a) && isDate(b) && a.toISOString() === b.toISOString();\n}\n\nexport function pipe<TValue>(value: TValue, ...fns: Array<(value: TValue) => TValue>): TValue {\n  return fns.reduce((value, fn) => fn(value), value);\n}\n\nexport function stableStringify(object: any): string {\n  if (isObject(object)) {\n    const key_values = Object.keys(object)\n      .sort()\n      .map(key => `${JSON.stringify(key)}:${stableStringify(object[key])}`);\n\n    return `{${key_values.join(',')}}`;\n  } else if (Array.isArray(object)) {\n    return `[${object.map(stableStringify).join(',')}]`;\n  } else {\n    return JSON.stringify(object);\n  }\n}\n\nexport function merge<TValue>(target: TValue[], values: TValue[]) {\n  // __mutating__: merge values into target\n  // Reference: https://dev.to/uilicious/javascript-array-push-is-945x-faster-than-array-concat-1oki\n  const original_length = target.length;\n  const added_length = values.length;\n  target.length = original_length + added_length;\n\n  for (let i = 0; i < added_length; i++) {\n    target[original_length + i] = values[i];\n  }\n}\n","import { SINGLE_QUOTE, DOUBLE_QUOTE } from './tokenizer';\nimport { pipe } from './utils';\n\nconst TRIPLE_DOUBLE_QUOTE = `\"\"\"`;\nconst TRIPLE_SINGLE_QUOTE = `'''`;\nconst LF = '\\\\n';\nconst CRLF = '\\\\r\\\\n';\nconst IS_CRLF = /\\r\\n/g;\nconst IS_LF = /\\n/g;\nconst IS_LEADING_NEW_LINE = /^(\\r\\n|\\n)/;\n// This regex is used to match an odd number of backslashes followed by a line ending\n// It uses a negative lookbehind to ensure that the backslash is not preceded by another backslash.\n// We need an odd number of backslashes so that the last one is not escaped.\nconst IS_LINE_ENDING_BACKSLASH = /(?<!\\\\)(?:\\\\\\\\)*(\\\\\\s*[\\n\\r\\n]\\s*)/g;\n\nexport function parseString(raw: string): string {\n  if (raw.startsWith(TRIPLE_SINGLE_QUOTE)) {\n    return pipe(\n      trim(raw, 3),\n      trimLeadingWhitespace\n    );\n  } else if (raw.startsWith(SINGLE_QUOTE)) {\n    return trim(raw, 1);\n  } else if (raw.startsWith(TRIPLE_DOUBLE_QUOTE)) {\n    return pipe(\n      trim(raw, 3),\n      trimLeadingWhitespace,\n      lineEndingBackslash,\n      escapeNewLines,\n      escapeDoubleQuotes,\n      unescapeLargeUnicode\n    );\n  } else if (raw.startsWith(DOUBLE_QUOTE)) {\n    return pipe(\n      trim(raw, 1),\n      unescapeLargeUnicode\n    );\n  } else {\n    return raw;\n  }\n}\n\nexport function escapeDoubleQuotes(value: string): string {\n  let result = '';\n  let precedingBackslashes = 0;\n\n  for (let i = 0; i < value.length; i++) {\n    const char = value[i];\n\n    if (char === '\"' && precedingBackslashes % 2 === 0) {\n      // If the current character is a quote and it is not escaped, escape it\n      result += '\\\\\"';\n    } else {\n      // Otherwise, add the character as is\n      result += char;\n    }\n\n    // Update the count of consecutive backslashes\n    if (char === '\\\\') {\n      precedingBackslashes++;\n    } else {\n      precedingBackslashes = 0; // Reset if the character is not a backslash\n    }\n  }\n\n  return result;\n}\n\nexport function unescapeLargeUnicode(escaped: string): string {\n  // JSON.parse handles everything except \\UXXXXXXXX\n  // replace those instances with code point, escape that, and then parse\n  const LARGE_UNICODE = /\\\\U[a-fA-F0-9]{8}/g;\n  const json_escaped = escaped.replace(LARGE_UNICODE, value => {\n    const code_point = parseInt(value.replace('\\\\U', ''), 16);\n    const as_string = String.fromCodePoint(code_point);\n\n    return trim(JSON.stringify(as_string), 1);\n  });\n\n  const fixed_json_escaped = escapeTabsForJSON(json_escaped);\n\n  // Parse the properly escaped JSON string\n  const parsed = JSON.parse(`\"${fixed_json_escaped}\"`);\n  return parsed;\n}\n\nfunction escapeTabsForJSON(value: string): string {\n  return value\n    .replace(/\\t/g, '\\\\t')\n}\n\nexport function escape(value: string): string {\n  return trim(JSON.stringify(value), 1);\n}\n\nfunction trim(value: string, count: number): string {\n  return value.slice(count, value.length - count);\n}\n\nfunction trimLeadingWhitespace(value: string): string {\n  return value.replace(IS_LEADING_NEW_LINE, '');\n}\n\nfunction escapeNewLines(value: string): string {\n  return value.replace(IS_CRLF, CRLF).replace(IS_LF, LF);\n}\n\nfunction lineEndingBackslash(value: string): string {\n  return value.replace(IS_LINE_ENDING_BACKSLASH, (match, group) => match.replace(group, ''));\n}\n","import {\n  NodeType,\n  KeyValue,\n  Table,\n  TableKey,\n  TableArray,\n  TableArrayKey,\n  Key,\n  Value,\n  String,\n  Integer,\n  Float,\n  Boolean,\n  DateTime,\n  InlineTable,\n  InlineArray,\n  InlineItem,\n  Comment,\n  AST,\n  Block\n} from './ast';\nimport { Token, TokenType, tokenize, DOUBLE_QUOTE, SINGLE_QUOTE } from './tokenizer';\nimport { parseString } from './parse-string';\nimport Cursor from './cursor';\nimport { clonePosition, cloneLocation } from './location';\nimport ParseError from './parse-error';\nimport { merge } from './utils';\n\nconst TRUE = 'true';\nconst FALSE = 'false';\nconst HAS_E = /e/i;\nconst IS_DIVIDER = /\\_/g;\nconst IS_INF = /inf/;\nconst IS_NAN = /nan/;\nconst IS_HEX = /^0x/;\nconst IS_OCTAL = /^0o/;\nconst IS_BINARY = /^0b/;\nexport const IS_FULL_DATE = /(\\d{4})-(\\d{2})-(\\d{2})/;\nexport const IS_FULL_TIME = /(\\d{2}):(\\d{2}):(\\d{2})/;\n\nexport default function* parseTOML(input: string): AST {\n  const tokens = tokenize(input);\n  const cursor = new Cursor(tokens);\n\n  while (!cursor.next().done) {\n    yield* walkBlock(cursor, input);\n  }\n}\n\nfunction* walkBlock(cursor: Cursor<Token>, input: string): IterableIterator<Block> {\n  if (cursor.value!.type === TokenType.Comment) {\n    yield comment(cursor);\n  } else if (cursor.value!.type === TokenType.Bracket) {\n    yield table(cursor, input);\n  } else if (cursor.value!.type === TokenType.Literal) {\n    yield* keyValue(cursor, input);\n  } else {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Unexpected token \"${cursor.value!.type}\". Expected Comment, Bracket, or String`\n    );\n  }\n}\n\nfunction* walkValue(cursor: Cursor<Token>, input: string): IterableIterator<Value | Comment> {\n  if (cursor.value!.type === TokenType.Literal) {\n    if (cursor.value!.raw[0] === DOUBLE_QUOTE || cursor.value!.raw[0] === SINGLE_QUOTE) {\n      yield string(cursor);\n    } else if (cursor.value!.raw === TRUE || cursor.value!.raw === FALSE) {\n      yield boolean(cursor);\n    } else if (IS_FULL_DATE.test(cursor.value!.raw) || IS_FULL_TIME.test(cursor.value!.raw)) {\n      yield datetime(cursor, input);\n    } else if (\n      (!cursor.peek().done && cursor.peek().value!.type === TokenType.Dot) ||\n      IS_INF.test(cursor.value!.raw) ||\n      IS_NAN.test(cursor.value!.raw) ||\n      (HAS_E.test(cursor.value!.raw) && !IS_HEX.test(cursor.value!.raw))\n    ) {\n      yield float(cursor, input);\n    } else {\n      yield integer(cursor);\n    }\n  } else if (cursor.value!.type === TokenType.Curly) {\n    yield inlineTable(cursor, input);\n  } else if (cursor.value!.type === TokenType.Bracket) {\n    const [inline_array, comments] = inlineArray(cursor, input);\n\n    yield inline_array;\n    yield* comments;\n  } else {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Unrecognized token type \"${cursor.value!.type}\". Expected String, Curly, or Bracket`\n    );\n  }\n}\n\nfunction comment(cursor: Cursor<Token>): Comment {\n  // # line comment\n  // ^------------^ Comment\n  return {\n    type: NodeType.Comment,\n    loc: cursor.value!.loc,\n    raw: cursor.value!.raw\n  };\n}\n\nfunction table(cursor: Cursor<Token>, input: string): Table | TableArray {\n  // Table or TableArray\n  //\n  // [ key ]\n  // ^-----^    TableKey\n  //   ^-^      Key\n  //\n  // [[ key ]]\n  // ^ ------^  TableArrayKey\n  //    ^-^     Key\n  //\n  // a = \"b\"  < Items\n  // # c      |\n  // d = \"f\"  <\n  //\n  // ...\n  const type =\n    !cursor.peek().done && cursor.peek().value!.type === TokenType.Bracket\n      ? NodeType.TableArray\n      : NodeType.Table;\n  const is_table = type === NodeType.Table;\n\n  if (is_table && cursor.value!.raw !== '[') {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Expected table opening \"[\", found ${cursor.value!.raw}`\n    );\n  }\n  if (!is_table && (cursor.value!.raw !== '[' || cursor.peek().value!.raw !== '[')) {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Expected array of tables opening \"[[\", found ${cursor.value!.raw + cursor.peek().value!.raw}`\n    );\n  }\n\n  // Set start location from opening tag\n  const key = is_table\n    ? ({\n        type: NodeType.TableKey,\n        loc: cursor.value!.loc\n      } as Partial<TableKey>)\n    : ({\n        type: NodeType.TableArrayKey,\n        loc: cursor.value!.loc\n      } as Partial<TableArrayKey>);\n\n  // Skip to cursor.value for key value\n  cursor.next();\n  if (type === NodeType.TableArray) cursor.next();\n\n  if (cursor.done) {\n    throw new ParseError(input, key.loc!.start, `Expected table key, reached end of file`);\n  }\n\n  key.item = {\n    type: NodeType.Key,\n    loc: cloneLocation(cursor.value!.loc),\n    raw: cursor.value!.raw,\n    value: [parseString(cursor.value!.raw)]\n  };\n\n  while (!cursor.peek().done && cursor.peek().value!.type === TokenType.Dot) {\n    cursor.next();\n    const dot = cursor.value!;\n\n    cursor.next();\n    const before = ' '.repeat(dot.loc.start.column - key.item.loc.end.column);\n    const after = ' '.repeat(cursor.value!.loc.start.column - dot.loc.end.column);\n\n    key.item.loc.end = cursor.value!.loc.end;\n    key.item.raw += `${before}.${after}${cursor.value!.raw}`;\n    key.item.value.push(parseString(cursor.value!.raw));\n  }\n\n  cursor.next();\n\n  if (is_table && (cursor.done || cursor.value!.raw !== ']')) {\n    throw new ParseError(\n      input,\n      cursor.done ? key.item.loc.end : cursor.value!.loc.start,\n      `Expected table closing \"]\", found ${cursor.done ? 'end of file' : cursor.value!.raw}`\n    );\n  }\n  if (\n    !is_table &&\n    (cursor.done ||\n      cursor.peek().done ||\n      cursor.value!.raw !== ']' ||\n      cursor.peek().value!.raw !== ']')\n  ) {\n    throw new ParseError(\n      input,\n      cursor.done || cursor.peek().done ? key.item.loc.end : cursor.value!.loc.start,\n      `Expected array of tables closing \"]]\", found ${\n        cursor.done || cursor.peek().done\n          ? 'end of file'\n          : cursor.value!.raw + cursor.peek().value!.raw\n      }`\n    );\n  }\n\n  // Set end location from closing tag\n  if (!is_table) cursor.next();\n  key.loc!.end = cursor.value!.loc.end;\n\n  // Add child items\n  let items: Array<KeyValue | Comment> = [];\n  while (!cursor.peek().done && cursor.peek().value!.type !== TokenType.Bracket) {\n    cursor.next();\n    merge(items, [...walkBlock(cursor, input)] as Array<KeyValue | Comment>);\n  }\n\n  return {\n    type: is_table ? NodeType.Table : NodeType.TableArray,\n    loc: {\n      start: clonePosition(key.loc!.start),\n      end: items.length\n        ? clonePosition(items[items.length - 1].loc.end)\n        : clonePosition(key.loc!.end)\n    },\n    key: key as TableKey | TableArrayKey,\n    items\n  } as Table | TableArray;\n}\n\nfunction keyValue(cursor: Cursor<Token>, input: string): Array<KeyValue | Comment> {\n  // 3. KeyValue\n  //\n  // key = value\n  // ^-^          key\n  //     ^        equals\n  //       ^---^  value\n  const key: Key = {\n    type: NodeType.Key,\n    loc: cloneLocation(cursor.value!.loc),\n    raw: cursor.value!.raw,\n    value: [parseString(cursor.value!.raw)]\n  };\n\n  while (!cursor.peek().done && cursor.peek().value!.type === TokenType.Dot) {\n    cursor.next();\n    cursor.next();\n\n    key.loc.end = cursor.value!.loc.end;\n    key.raw += `.${cursor.value!.raw}`;\n    key.value.push(parseString(cursor.value!.raw));\n  }\n\n  cursor.next();\n\n  if (cursor.done || cursor.value!.type !== TokenType.Equal) {\n    throw new ParseError(\n      input,\n      cursor.done ? key.loc.end : cursor.value!.loc.start,\n      `Expected \"=\" for key-value, found ${cursor.done ? 'end of file' : cursor.value!.raw}`\n    );\n  }\n\n  const equals = cursor.value!.loc.start.column;\n\n  cursor.next();\n\n  if (cursor.done) {\n    throw new ParseError(input, key.loc.start, `Expected value for key-value, reached end of file`);\n  }\n\n  const [value, ...comments] = walkValue(cursor, input) as Iterable<Value | Comment>;\n\n  return [\n    {\n      type: NodeType.KeyValue,\n      key,\n      value: value as Value,\n      loc: {\n        start: clonePosition(key.loc.start),\n        end: clonePosition(value.loc.end)\n      },\n      equals\n    },\n    ...(comments as Comment[])\n  ];\n}\n\nfunction string(cursor: Cursor<Token>): String {\n  return {\n    type: NodeType.String,\n    loc: cursor.value!.loc,\n    raw: cursor.value!.raw,\n    value: parseString(cursor.value!.raw)\n  };\n}\n\nfunction boolean(cursor: Cursor<Token>): Boolean {\n  return {\n    type: NodeType.Boolean,\n    loc: cursor.value!.loc,\n    value: cursor.value!.raw === TRUE\n  };\n}\n\nfunction datetime(cursor: Cursor<Token>, input: string): DateTime {\n  // Possible values:\n  //\n  // Offset Date-Time\n  // | odt1 = 1979-05-27T07:32:00Z\n  // | odt2 = 1979-05-27T00:32:00-07:00\n  // | odt3 = 1979-05-27T00:32:00.999999-07:00\n  // | odt4 = 1979-05-27 07:32:00Z\n  //\n  // Local Date-Time\n  // | ldt1 = 1979-05-27T07:32:00\n  // | ldt2 = 1979-05-27T00:32:00.999999\n  //\n  // Local Date\n  // | ld1 = 1979-05-27\n  //\n  // Local Time\n  // | lt1 = 07:32:00\n  // | lt2 = 00:32:00.999999\n  let loc = cursor.value!.loc;\n  let raw = cursor.value!.raw;\n  let value: Date;\n\n  // If next token is string,\n  // check if raw is full date and following is full time\n  if (\n    !cursor.peek().done &&\n    cursor.peek().value!.type === TokenType.Literal &&\n    IS_FULL_DATE.test(raw) &&\n    IS_FULL_TIME.test(cursor.peek().value!.raw)\n  ) {\n    const start = loc.start;\n\n    cursor.next();\n    loc = { start, end: cursor.value!.loc.end };\n    raw += ` ${cursor.value!.raw}`;\n  }\n\n  if (!cursor.peek().done && cursor.peek().value!.type === TokenType.Dot) {\n    const start = loc.start;\n\n    cursor.next();\n\n    if (cursor.peek().done || cursor.peek().value!.type !== TokenType.Literal) {\n      throw new ParseError(input, cursor.value!.loc.end, `Expected fractional value for DateTime`);\n    }\n    cursor.next();\n\n    loc = { start, end: cursor.value!.loc.end };\n    raw += `.${cursor.value!.raw}`;\n  }\n\n  if (!IS_FULL_DATE.test(raw)) {\n    // For local time, use local ISO date\n    const [local_date] = new Date().toISOString().split('T');\n    value = new Date(`${local_date}T${raw}`);\n  } else {\n    value = new Date(raw.replace(' ', 'T'));\n  }\n\n  return {\n    type: NodeType.DateTime,\n    loc,\n    raw,\n    value\n  };\n}\n\nfunction float(cursor: Cursor<Token>, input: string): Float {\n  let loc = cursor.value!.loc;\n  let raw = cursor.value!.raw;\n  let value;\n\n  if (IS_INF.test(raw)) {\n    value = raw === '-inf' ? -Infinity : Infinity;\n  } else if (IS_NAN.test(raw)) {\n    value = raw === '-nan' ? -NaN : NaN;\n  } else if (!cursor.peek().done && cursor.peek().value!.type === TokenType.Dot) {\n    const start = loc.start;\n\n    // From spec:\n    // | A fractional part is a decimal point followed by one or more digits.\n    //\n    // -> Don't have to handle \"4.\" (i.e. nothing behind decimal place)\n\n    cursor.next();\n\n    if (cursor.peek().done || cursor.peek().value!.type !== TokenType.Literal) {\n      throw new ParseError(input, cursor.value!.loc.end, `Expected fraction value for Float`);\n    }\n    cursor.next();\n\n    raw += `.${cursor.value!.raw}`;\n    loc = { start, end: cursor.value!.loc.end };\n    value = Number(raw.replace(IS_DIVIDER, ''));\n  } else {\n    value = Number(raw.replace(IS_DIVIDER, ''));\n  }\n\n  return { type: NodeType.Float, loc, raw, value };\n}\n\nfunction integer(cursor: Cursor<Token>): Integer {\n  // > Integer values -0 and +0 are valid and identical to an unprefixed zero\n  if (cursor.value!.raw === '-0' || cursor.value!.raw === '+0') {\n    return {\n      type: NodeType.Integer,\n      loc: cursor.value!.loc,\n      raw: cursor.value!.raw,\n      value: 0\n    };\n  }\n\n  let radix = 10;\n  if (IS_HEX.test(cursor.value!.raw)) {\n    radix = 16;\n  } else if (IS_OCTAL.test(cursor.value!.raw)) {\n    radix = 8;\n  } else if (IS_BINARY.test(cursor.value!.raw)) {\n    radix = 2;\n  }\n\n  const value = parseInt(\n    cursor\n      .value!.raw.replace(IS_DIVIDER, '')\n      .replace(IS_OCTAL, '')\n      .replace(IS_BINARY, ''),\n    radix\n  );\n\n  return {\n    type: NodeType.Integer,\n    loc: cursor.value!.loc,\n    raw: cursor.value!.raw,\n    value\n  };\n}\n\nfunction inlineTable(cursor: Cursor<Token>, input: string): InlineTable {\n  if (cursor.value!.raw !== '{') {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Expected \"{\" for inline table, found ${cursor.value!.raw}`\n    );\n  }\n\n  // 6. InlineTable\n  const value: InlineTable = {\n    type: NodeType.InlineTable,\n    loc: cloneLocation(cursor.value!.loc),\n    items: []\n  };\n\n  cursor.next();\n\n  while (\n    !cursor.done &&\n    !(cursor.value!.type === TokenType.Curly && (cursor.value as Token).raw === '}')\n  ) {\n    if ((cursor.value as Token).type === TokenType.Comma) {\n      const previous = value.items[value.items.length - 1];\n      if (!previous) {\n        throw new ParseError(\n          input,\n          cursor.value!.loc.start,\n          'Found \",\" without previous value in inline table'\n        );\n      }\n\n      previous.comma = true;\n      previous.loc.end = cursor.value!.loc.start;\n\n      cursor.next();\n      continue;\n    }\n\n    const [item] = walkBlock(cursor, input);\n    if (item.type !== NodeType.KeyValue) {\n      throw new ParseError(\n        input,\n        cursor.value!.loc.start,\n        `Only key-values are supported in inline tables, found ${item.type}`\n      );\n    }\n\n    const inline_item: InlineItem<KeyValue> = {\n      type: NodeType.InlineItem,\n      loc: cloneLocation(item.loc),\n      item,\n      comma: false\n    };\n\n    value.items.push(inline_item);\n    cursor.next();\n  }\n\n  if (\n    cursor.done ||\n    cursor.value!.type !== TokenType.Curly ||\n    (cursor.value as Token).raw !== '}'\n  ) {\n    throw new ParseError(\n      input,\n      cursor.done ? value.loc.start : cursor.value!.loc.start,\n      `Expected \"}\", found ${cursor.done ? 'end of file' : cursor.value!.raw}`\n    );\n  }\n\n  value.loc.end = cursor.value!.loc.end;\n\n  return value;\n}\n\nfunction inlineArray(cursor: Cursor<Token>, input: string): [InlineArray, Comment[]] {\n  // 7. InlineArray\n  if (cursor.value!.raw !== '[') {\n    throw new ParseError(\n      input,\n      cursor.value!.loc.start,\n      `Expected \"[\" for inline array, found ${cursor.value!.raw}`\n    );\n  }\n\n  const value: InlineArray = {\n    type: NodeType.InlineArray,\n    loc: cloneLocation(cursor.value!.loc),\n    items: []\n  };\n  let comments: Comment[] = [];\n\n  cursor.next();\n\n  while (\n    !cursor.done &&\n    !(cursor.value!.type === TokenType.Bracket && (cursor.value as Token).raw === ']')\n  ) {\n    if ((cursor.value as Token).type === TokenType.Comma) {\n      const previous = value.items[value.items.length - 1];\n      if (!previous) {\n        throw new ParseError(\n          input,\n          cursor.value!.loc.start,\n          'Found \",\" without previous value for inline array'\n        );\n      }\n\n      previous.comma = true;\n      previous.loc.end = cursor.value!.loc.start;\n    } else if ((cursor.value as Token).type === TokenType.Comment) {\n      comments.push(comment(cursor));\n    } else {\n      const [item, ...additional_comments] = walkValue(cursor, input);\n      const inline_item: InlineItem = {\n        type: NodeType.InlineItem,\n        loc: cloneLocation(item.loc),\n        item,\n        comma: false\n      };\n\n      value.items.push(inline_item);\n      merge(comments, additional_comments as Comment[]);\n    }\n\n    cursor.next();\n  }\n\n  if (\n    cursor.done ||\n    cursor.value!.type !== TokenType.Bracket ||\n    (cursor.value as Token).raw !== ']'\n  ) {\n    throw new ParseError(\n      input,\n      cursor.done ? value.loc.start : cursor.value!.loc.start,\n      `Expected \"]\", found ${cursor.done ? 'end of file' : cursor.value!.raw}`\n    );\n  }\n\n  value.loc.end = cursor.value!.loc.end;\n\n  return [value, comments];\n}\n","import {\n  NodeType,\n  AST,\n  TreeNode,\n  Document,\n  Table,\n  TableKey,\n  TableArray,\n  TableArrayKey,\n  KeyValue,\n  Key,\n  String,\n  Integer,\n  Float,\n  Boolean,\n  DateTime,\n  Comment,\n  InlineArray,\n  InlineTable,\n  InlineItem\n} from './ast';\nimport { isIterable } from './utils';\n\nexport type Visit<TNode = TreeNode> = (node: TNode, parent: TNode | null) => void;\nexport type EnterExit<TNode = TreeNode> = { enter?: Visit<TNode>; exit?: Visit<TNode> };\n\nexport type Visitor = {\n  Document?: Visit<Document> | EnterExit<Document>;\n  Table?: Visit<Table> | EnterExit<Table>;\n  TableKey?: Visit<TableKey> | EnterExit<TableKey>;\n  TableArray?: Visit<TableArray> | EnterExit<TableArray>;\n  TableArrayKey?: Visit<TableArrayKey> | EnterExit<TableArrayKey>;\n  KeyValue?: Visit<KeyValue> | EnterExit<KeyValue>;\n  Key?: Visit<Key> | EnterExit<Key>;\n  String?: Visit<String> | EnterExit<String>;\n  Integer?: Visit<Integer> | EnterExit<Integer>;\n  Float?: Visit<Float> | EnterExit<Float>;\n  Boolean?: Visit<Boolean> | EnterExit<Boolean>;\n  DateTime?: Visit<DateTime> | EnterExit<DateTime>;\n  InlineArray?: Visit<InlineArray> | EnterExit<InlineArray>;\n  InlineItem?: Visit<InlineItem> | EnterExit<InlineItem>;\n  InlineTable?: Visit<InlineTable> | EnterExit<InlineTable>;\n  Comment?: Visit<Comment> | EnterExit<Comment>;\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// The traverse function is used to walk the AST and call the visitor functions\n////////////////////////////////////////////////////////////////////////////////\nexport default function traverse(ast: AST | TreeNode, visitor: Visitor) {\n  if (isIterable(ast)) {\n    traverseArray(ast, null);\n  } else {\n    traverseNode(ast, null);\n  }\n\n  function traverseArray(array: Iterable<TreeNode>, parent: TreeNode | null) {\n    for (const node of array) {\n      traverseNode(node, parent);\n    }\n  }\n\n  function traverseNode(node: TreeNode, parent: TreeNode | null) {\n    const visit = visitor[node.type];\n\n    if (visit && typeof visit === 'function') {\n      (visit as Visit)(node, parent);\n    }\n\n    if (visit && (visit as EnterExit).enter) {\n      (visit as EnterExit).enter!(node, parent);\n    }\n\n    switch (node.type) {\n      case NodeType.Document:\n        traverseArray((node as Document).items, node);\n        break;\n\n      case NodeType.Table:\n        traverseNode((node as Table).key, node);\n        traverseArray((node as Table).items, node);\n        break;\n      case NodeType.TableKey:\n        traverseNode((node as TableKey).item, node);\n        break;\n\n      case NodeType.TableArray:\n        traverseNode((node as TableArray).key, node);\n        traverseArray((node as TableArray).items, node);\n        break;\n      case NodeType.TableArrayKey:\n        traverseNode((node as TableArrayKey).item, node);\n        break;\n\n      case NodeType.KeyValue:\n        traverseNode((node as KeyValue).key, node);\n        traverseNode((node as KeyValue).value, node);\n        break;\n\n      case NodeType.InlineArray:\n        traverseArray((node as InlineArray).items, node);\n        break;\n      case NodeType.InlineItem:\n        traverseNode((node as InlineItem).item, node);\n        break;\n\n      case NodeType.InlineTable:\n        traverseArray((node as InlineTable).items, node);\n        break;\n\n      case NodeType.Key:\n      case NodeType.String:\n      case NodeType.Integer:\n      case NodeType.Float:\n      case NodeType.Boolean:\n      case NodeType.DateTime:\n      case NodeType.Comment:\n        break;\n\n      default:\n        throw new Error(`Unrecognized node type \"${node.type}\"`);\n    }\n\n    if (visit && (visit as EnterExit).exit) {\n      (visit as EnterExit).exit!(node, parent);\n    }\n  }\n}\n","import {\n  NodeType,\n  TreeNode,\n  Document,\n  Key,\n  Value,\n  InlineArray,\n  InlineArrayItem,\n  InlineTableItem,\n  isKeyValue,\n  isTable,\n  isTableArray,\n  isInlineTable,\n  isInlineArray,\n  hasItems,\n  hasItem,\n  isComment,\n  isDocument,\n  InlineTable,\n  TableArray,\n  Table,\n  KeyValue,\n  Comment,\n  InlineItem,\n  isInlineItem,\n  Block,\n  isBlock\n} from './ast';\nimport { Span, getSpan, clonePosition } from './location';\nimport { last } from './utils';\nimport traverse from './traverse';\n\n////////////////////////////////////////\n// The purpose of this file is to provide a way to modify the AST\n////////////////////////////////////////\n\n// Root node of the AST\nexport type Root = Document | TreeNode;\n\n// Store line and column offsets per node\n//\n// Some offsets are applied on enter (e.g. shift child items and next items)\n// Others are applied on exit (e.g. shift next items)\ntype Offsets = WeakMap<TreeNode, Span>;\n\nconst enter_offsets: WeakMap<Root, Offsets> = new WeakMap();\nconst getEnterOffsets = (root: Root) => {\n  if (!enter_offsets.has(root)) {\n    enter_offsets.set(root, new WeakMap());\n  }\n  return enter_offsets.get(root)!;\n};\n\nconst exit_offsets: WeakMap<Root, Offsets> = new WeakMap();\nconst getExitOffsets = (root: Root) => {\n  if (!exit_offsets.has(root)) {\n    exit_offsets.set(root, new WeakMap());\n  }\n  return exit_offsets.get(root)!;\n};\n//TODO: Add getOffsets function to get all offsets contained in the tree\nexport function replace(root: Root, parent: TreeNode, existing: TreeNode, replacement: TreeNode) {\n  // First, replace existing node\n  // (by index for items, item, or key/value)\n  if (hasItems(parent)) {\n\n    const index = parent.items.indexOf(existing);\n    if (index < 0) {\n      throw new Error(`Could not find existing item in parent node for replace`);\n    }\n\n    parent.items.splice(index, 1, replacement);\n\n    // This next case is a special case for Inline-Table item\n    // however due to the fact that both replacement of the whole Inline-Table and Inline-Table element will have the same parent,\n    // we need to make sure it's not an Inline-Table \n  } else if (isKeyValue(parent) && isInlineTable(parent.value) && !isInlineTable(existing)) {\n    \n    const index = parent.value.items.indexOf(existing as InlineTableItem);\n    if (index < 0) {\n      throw new Error(`Could not find existing item in parent node for replace`);\n    } \n    parent.value.items.splice(index, 1, replacement as InlineTableItem);\n\n  } else if (hasItem(parent)) {\n\n    parent.item = replacement;\n\n  } else if (isKeyValue(parent)) {\n\n    if (parent.key === existing) {\n      parent.key = replacement as Key;\n    } else {\n      parent.value = replacement as Value;\n    }\n\n  } else {\n    throw new Error(`Unsupported parent type \"${parent.type}\" for replace`);\n  }\n\n  // Shift the replacement node into the same start position as existing\n  const shift = {\n    lines: existing.loc.start.line - replacement.loc.start.line,\n    columns: existing.loc.start.column - replacement.loc.start.column\n  };\n  shiftNode(replacement, shift);\n\n  // Apply offsets after replacement node\n  const existing_span = getSpan(existing.loc);\n  const replacement_span = getSpan(replacement.loc);\n  const offset = {\n    lines: replacement_span.lines - existing_span.lines,\n    columns: replacement_span.columns - existing_span.columns\n  };\n\n  addOffset(offset, getExitOffsets(root), replacement, existing);\n}\n\nexport function insert(root: Root, parent: TreeNode, child: TreeNode, index?: number) {\n  if (!hasItems(parent)) {\n    throw new Error(`Unsupported parent type \"${(parent as TreeNode).type}\" for insert`);\n  }\n\n  index = (index != null && typeof index === 'number') ? index : parent.items.length; \n\n  let shift: Span;\n  let offset: Span;\n  if (isInlineArray(parent) || isInlineTable(parent)) {\n    ({ shift, offset } = insertInline(parent, child as InlineItem, index));\n  } else {\n    ({ shift, offset } = insertOnNewLine(\n      parent as Document | Table | TableArray,\n      child as KeyValue | Comment,\n      index\n    ));\n  }\n\n  shiftNode(child, shift);\n\n  // The child element is placed relative to the previous element,\n  // if the previous element has an offset, need to position relative to that\n  // -> Move previous offset to child's offset\n  const previous = parent.items[index - 1];\n  const previous_offset = previous && getExitOffsets(root).get(previous);\n  if (previous_offset) {\n    offset.lines += previous_offset.lines;\n    offset.columns += previous_offset.columns;\n\n    getExitOffsets(root).delete(previous!);\n  }\n\n  const offsets = getExitOffsets(root);\n  offsets.set(child, offset);\n}\n\nfunction insertOnNewLine(\n  parent: Document | Table | TableArray,\n  child: Block,\n  index: number\n): { shift: Span; offset: Span } {\n  if (!isBlock(child)) {\n    throw new Error(`Incompatible child type \"${(child as TreeNode).type}\"`);\n  }\n\n  const previous = parent.items[index - 1];\n  const use_first_line = isDocument(parent) && !parent.items.length;\n\n  parent.items.splice(index, 0, child);\n\n  // Set start location from previous item or start of array\n  // (previous is undefined for empty array or inserting at first item)\n  const start = previous\n    ? {\n      line: previous.loc.end.line,\n      column: !isComment(previous) ? previous.loc.start.column : parent.loc.start.column\n    }\n    : clonePosition(parent.loc.start);\n\n  const is_block = isTable(child) || isTableArray(child);\n  let leading_lines = 0;\n  if (use_first_line) {\n    // 0 leading lines\n  } else if (is_block) {\n    leading_lines = 2;\n  } else {\n    leading_lines = 1;\n  }\n  start.line += leading_lines;\n\n  const shift = {\n    lines: start.line - child.loc.start.line,\n    columns: start.column - child.loc.start.column\n  };\n\n  // Apply offsets after child node\n  const child_span = getSpan(child.loc);\n  const offset = {\n    lines: child_span.lines + (leading_lines - 1),\n    columns: child_span.columns\n  };\n\n  return { shift, offset };\n}\n\n/**\n * Inserts an inline element into an inline array or table at the specified index.\n * This function handles positioning, comma management, and offset calculation for the inserted item.\n * \n * @param parent - The inline array or table where the child will be inserted\n * @param child - The inline item to insert\n * @param index - The index position where to insert the child\n * @returns An object containing shift and offset spans:\n *          - shift: Adjustments needed to position the child correctly\n *          - offset: Adjustments needed for elements that follow the insertion\n * @throws Error if the child is not a compatible inline item type\n */\nfunction insertInline(\n  parent: InlineArray | InlineTable,\n  child: InlineItem,\n  index: number\n): { shift: Span; offset: Span } {\n  if (!isInlineItem(child)) {\n    throw new Error(`Incompatible child type \"${(child as TreeNode).type}\"`);\n  }\n\n  // Store preceding node and insert\n  const previous = index != null ? parent.items[index - 1] : last(parent.items);\n  const is_last = index == null || index === parent.items.length;\n\n  parent.items.splice(index, 0, child);\n\n  // Add commas as-needed\n  const has_seperating_comma_before = !!previous;\n  const has_seperating_comma_after = !is_last;\n  const has_trailing_comma = is_last && child.comma === true;\n  if (has_seperating_comma_before) {\n    previous!.comma = true;\n  }\n  if (has_seperating_comma_after) {\n    child.comma = true;\n  }\n\n  // Use a new line for documents, children of Table/TableArray,\n  // and if an inline table is using new lines\n  const use_new_line = isInlineArray(parent) && perLine(parent);\n\n  // Set start location from previous item or start of array\n  // (previous is undefined for empty array or inserting at first item)\n  const start = previous\n    ? {\n      line: previous.loc.end.line,\n      column: use_new_line\n        ? !isComment(previous)\n          ? previous.loc.start.column\n          : parent.loc.start.column\n        : previous.loc.end.column\n    }\n    : clonePosition(parent.loc.start);\n\n  let leading_lines = 0;\n  if (use_new_line) {\n    leading_lines = 1;\n  } else {\n    const skip_comma = 2;\n    const skip_bracket = 1;\n    start.column += has_seperating_comma_before ? skip_comma : skip_bracket;\n  }\n  start.line += leading_lines;\n\n  const shift = {\n    lines: start.line - child.loc.start.line,\n    columns: start.column - child.loc.start.column\n  };\n\n  // Apply offsets after child node\n  const child_span = getSpan(child.loc);\n  const offset = {\n    lines: child_span.lines + (leading_lines - 1),\n    columns: child_span.columns + (has_seperating_comma_before || has_seperating_comma_after ? 2 : 0) + (has_trailing_comma ? 1 : 0)\n  };\n\n  return { shift, offset };\n}\n\nexport function remove(root: Root, parent: TreeNode, node: TreeNode) {\n  // Remove an element from the parent's items\n  // (supports Document, Table, TableArray, InlineTable, and InlineArray\n  //\n  //      X\n  // [ 1, 2, 3 ]\n  //    ^-^\n  // -> Remove element 2 and apply 0,-3 offset to 1\n  //\n  // [table]\n  // a = 1\n  // b = 2 # X\n  // c = 3\n  // -> Remove element 2 and apply -1,0 offset to 1\n  if (!hasItems(parent)) {\n    throw new Error(`Unsupported parent type \"${parent.type}\" for remove`);\n  }\n\n  let index = parent.items.indexOf(node);\n  if (index < 0) {\n    // Try again, looking at child items for nodes like InlineArrayItem\n    index = parent.items.findIndex(item => hasItem(item) && item.item === node);\n\n    if (index < 0) {\n      throw new Error('Could not find node in parent for removal');\n    }\n\n    node = parent.items[index];\n  }\n\n  const previous = parent.items[index - 1];\n  let next = parent.items[index + 1];\n\n  // Remove node\n  parent.items.splice(index, 1);\n  let removed_span = getSpan(node.loc);\n\n  // Remove an associated comment that appears on the same line\n  //\n  // [table]\n  // a = 1\n  // b = 2 # remove this too\n  // c = 3\n  //\n  // TODO InlineTable - this only applies to comments in Table/TableArray\n  if (next && isComment(next) && next.loc.start.line === node.loc.end.line) {\n    // Add comment to removed\n    removed_span = getSpan({ start: node.loc.start, end: next.loc.end });\n\n    // Shift to next item\n    // (use same index since node has already been removed)\n    next = parent.items[index + 1];\n\n    // Remove comment\n    parent.items.splice(index, 1);\n  }\n\n  // For inline tables and arrays, check whether the line should be kept\n  const is_inline = previous && isInlineItem(previous) || next && isInlineItem(next);\n  const previous_on_same_line = previous && previous.loc.end.line === node.loc.start.line;\n  const next_on_sameLine = next && next.loc.start.line === node.loc.end.line;\n  const keep_line = is_inline && (previous_on_same_line || next_on_sameLine);\n\n  const offset = {\n    lines: -(removed_span.lines - (keep_line ? 1 : 0)),\n    columns: -removed_span.columns\n  };\n\n  // Offset for comma and remove comma that appear in front of the element (if-needed)\n  if (is_inline && previous_on_same_line) {\n    offset.columns -= 2;\n  }\n\n  // If first element in array/inline-table, remove space for comma and space after element\n  if (is_inline && !previous && next) {\n    offset.columns -= 2;\n  }\n\n  if (is_inline && previous && !next) {\n    (previous as InlineArrayItem | InlineTableItem).comma = false;\n  }\n\n  // Apply offsets after preceding node or before children of parent node\n  const target = previous || parent;\n  const target_offsets = previous ? getExitOffsets(root) : getEnterOffsets(root);\n  const node_offsets = getExitOffsets(root);\n  const previous_offset = target_offsets.get(target);\n  if (previous_offset) {\n    offset.lines += previous_offset.lines;\n    offset.columns += previous_offset.columns;\n  }\n  const removed_offset = node_offsets.get(node);\n  if (removed_offset) {\n    offset.lines += removed_offset.lines;\n    offset.columns += removed_offset.columns;\n  }\n\n  target_offsets.set(target, offset);\n}\n\nexport function applyBracketSpacing(\n  root: Root,\n  node: InlineArray | InlineTable,\n  bracket_spacing: boolean = true\n) {\n  // Can only add bracket spacing currently\n  if (!bracket_spacing) return;\n  if (!node.items.length) return;\n\n  // Apply enter to node so that items are affected\n  addOffset({ lines: 0, columns: 1 }, getEnterOffsets(root), node);\n\n  // Apply exit to last node in items\n  const last_item = last(node.items as TreeNode[])!;\n  addOffset({ lines: 0, columns: 1 }, getExitOffsets(root), last_item);\n}\n\nexport function applyTrailingComma(\n  root: Root,\n  node: InlineArray | InlineTable,\n  trailing_commas: boolean = false\n) {\n  // Can only add trailing comma currently\n  if (!trailing_commas) return;\n  if (!node.items.length) return;\n\n  const last_item = last(node.items)!;\n  last_item.comma = true;\n\n  addOffset({ lines: 0, columns: 1 }, getExitOffsets(root), last_item);\n}\n\n/**\n * Applies all accumulated write offsets (enter and exit) to the given AST node.\n * This function adjusts the start and end locations of each node in the tree based on\n * the offsets stored in the `enter` and `exit` maps. It ensures that the tree's location\n * data is consistent after modifications.\n *\n * @param root - The root node of the AST tree to which the write offsets will be applied.\n */\nexport function applyWrites(root: TreeNode) {\n  const enter = getEnterOffsets(root);\n  const exit = getExitOffsets(root);\n\n  const offset: { lines: number; columns: { [index: number]: number } } = {\n    lines: 0,\n    columns: {}\n  };\n\n  function shiftStart(node: TreeNode) {\n\n    const lineOffset = offset.lines;\n    node.loc.start.line += lineOffset;\n    \n    const columnOffset = offset.columns[node.loc.start.line] || 0;\n    node.loc.start.column += columnOffset\n\n    const entering = enter.get(node);\n    if (entering) {\n      offset.lines += entering.lines;\n      offset.columns[node.loc.start.line] =\n        (offset.columns[node.loc.start.line] || 0) + entering.columns;\n    }\n  }\n\n  function shiftEnd(node: TreeNode) {\n\n    const lineOffset = offset.lines;\n    node.loc.end.line += lineOffset;\n    \n    const columnOffset = offset.columns[node.loc.end.line] || 0;\n    node.loc.end.column += columnOffset;\n\n    const exiting = exit.get(node);\n    if (exiting) {\n      offset.lines += exiting.lines;\n      offset.columns[node.loc.end.line] =\n        (offset.columns[node.loc.end.line] || 0) + exiting.columns;\n    }\n  }\n\n  const shiftLocation = {\n    enter: shiftStart,\n    exit: shiftEnd\n  };\n\n  traverse(root, {\n    [NodeType.Document]: shiftLocation,\n    [NodeType.Table]: shiftLocation,\n    [NodeType.TableArray]: shiftLocation,\n    [NodeType.InlineTable]: shiftLocation,\n    [NodeType.InlineArray]: shiftLocation,\n\n    [NodeType.InlineItem]: shiftLocation,\n    [NodeType.TableKey]: shiftLocation,\n    [NodeType.TableArrayKey]: shiftLocation,\n\n    [NodeType.KeyValue]: {\n      enter(node) {\n        const start_line = node.loc.start.line + offset.lines;\n        const key_offset = exit.get(node.key);\n        node.equals += (offset.columns[start_line] || 0) + (key_offset ? key_offset.columns : 0);\n\n        shiftStart(node);\n      },\n      exit: shiftEnd\n    },\n\n    [NodeType.Key]: shiftLocation,\n    [NodeType.String]: shiftLocation,\n    [NodeType.Integer]: shiftLocation,\n    [NodeType.Float]: shiftLocation,\n    [NodeType.Boolean]: shiftLocation,\n    [NodeType.DateTime]: shiftLocation,\n    [NodeType.Comment]: shiftLocation\n  });\n\n  enter_offsets.delete(root);\n  exit_offsets.delete(root);\n}\n\nexport function shiftNode(\n  node: TreeNode,\n  span: Span,\n  options: { first_line_only?: boolean } = {}\n): TreeNode {\n  const { first_line_only = false } = options;\n  const start_line = node.loc.start.line;\n  const { lines, columns } = span;\n  const move = (node: TreeNode) => {\n    if (!first_line_only || node.loc.start.line === start_line) {\n      node.loc.start.column += columns;\n      node.loc.end.column += columns;\n    }\n    node.loc.start.line += lines;\n    node.loc.end.line += lines;\n  };\n\n  traverse(node, {\n    [NodeType.Table]: move,\n    [NodeType.TableKey]: move,\n    [NodeType.TableArray]: move,\n    [NodeType.TableArrayKey]: move,\n    [NodeType.KeyValue](node) {\n      move(node);\n      node.equals += columns;\n    },\n    [NodeType.Key]: move,\n    [NodeType.String]: move,\n    [NodeType.Integer]: move,\n    [NodeType.Float]: move,\n    [NodeType.Boolean]: move,\n    [NodeType.DateTime]: move,\n    [NodeType.InlineArray]: move,\n    [NodeType.InlineItem]: move,\n    [NodeType.InlineTable]: move,\n    [NodeType.Comment]: move\n  });\n\n  return node;\n}\n\nfunction perLine(array: InlineArray): boolean {\n  if (!array.items.length) return false;\n\n  const span = getSpan(array.loc);\n  return span.lines > array.items.length;\n}\n\nfunction addOffset(offset: Span, offsets: Offsets, node: TreeNode, from?: TreeNode) {\n  const previous_offset = offsets.get(from || node);\n  if (previous_offset) {\n    offset.lines += previous_offset.lines;\n    offset.columns += previous_offset.columns;\n  }\n\n  offsets.set(node, offset);\n}\n","import {\n  NodeType,\n  Document,\n  Table,\n  TableKey,\n  TableArray,\n  TableArrayKey,\n  Value,\n  KeyValue,\n  Key,\n  String,\n  Integer,\n  Float,\n  Boolean,\n  DateTime,\n  InlineArray,\n  InlineItem,\n  InlineTable,\n  Comment\n} from './ast';\nimport { zero, cloneLocation, clonePosition } from './location';\nimport { shiftNode } from './writer';\n\nexport function generateDocument(): Document {\n  return {\n    type: NodeType.Document,\n    loc: { start: zero(), end: zero() },\n    items: []\n  };\n}\n\nexport function generateTable(key: string[]): Table {\n  const table_key = generateTableKey(key);\n\n  return {\n    type: NodeType.Table,\n    loc: cloneLocation(table_key.loc),\n    key: table_key,\n    items: []\n  };\n}\n\nexport function generateTableKey(key: string[]): TableKey {\n  const raw = keyValueToRaw(key);\n\n  return {\n    type: NodeType.TableKey,\n    loc: {\n      start: zero(),\n      end: { line: 1, column: raw.length + 2 }\n    },\n    item: {\n      type: NodeType.Key,\n      loc: {\n        start: { line: 1, column: 1 },\n        end: { line: 1, column: raw.length + 1 }\n      },\n      value: key,\n      raw\n    }\n  };\n}\n\nexport function generateTableArray(key: string[]): TableArray {\n  const table_array_key = generateTableArrayKey(key);\n\n  return {\n    type: NodeType.TableArray,\n    loc: cloneLocation(table_array_key.loc),\n    key: table_array_key,\n    items: []\n  };\n}\n\nexport function generateTableArrayKey(key: string[]): TableArrayKey {\n  const raw = keyValueToRaw(key);\n\n  return {\n    type: NodeType.TableArrayKey,\n    loc: {\n      start: zero(),\n      end: { line: 1, column: raw.length + 4 }\n    },\n    item: {\n      type: NodeType.Key,\n      loc: {\n        start: { line: 1, column: 2 },\n        end: { line: 1, column: raw.length + 2 }\n      },\n      value: key,\n      raw\n    }\n  };\n}\n\nexport function generateKeyValue(key: string[], value: Value): KeyValue {\n  const key_node = generateKey(key);\n  const { column } = key_node.loc.end;\n\n  const equals = column + 1;\n\n  shiftNode(\n    value,\n    { lines: 0, columns: column + 3 - value.loc.start.column },\n    { first_line_only: true }\n  );\n\n  return {\n    type: NodeType.KeyValue,\n    loc: {\n      start: clonePosition(key_node.loc.start),\n      end: clonePosition(value.loc.end)\n    },\n    key: key_node,\n    equals,\n    value\n  };\n}\n\nconst IS_BARE_KEY = /[\\w,\\d,\\_,\\-]+/;\nfunction keyValueToRaw(value: string[]): string {\n  return value.map(part => (IS_BARE_KEY.test(part) ? part : JSON.stringify(part))).join('.');\n}\n\nexport function generateKey(value: string[]): Key {\n  const raw = keyValueToRaw(value);\n\n  return {\n    type: NodeType.Key,\n    loc: { start: zero(), end: { line: 1, column: raw.length } },\n    raw,\n    value\n  };\n}\n\nexport function generateString(value: string): String {\n  const raw = JSON.stringify(value);\n\n  return {\n    type: NodeType.String,\n    loc: { start: zero(), end: { line: 1, column: raw.length } },\n    raw,\n    value\n  };\n}\n\nexport function generateInteger(value: number): Integer {\n  const raw = value.toString();\n\n  return {\n    type: NodeType.Integer,\n    loc: { start: zero(), end: { line: 1, column: raw.length } },\n    raw,\n    value\n  };\n}\n\nexport function generateFloat(value: number): Float {\n  const raw = value.toString();\n\n  return {\n    type: NodeType.Float,\n    loc: { start: zero(), end: { line: 1, column: raw.length } },\n    raw,\n    value\n  };\n}\n\nexport function generateBoolean(value: boolean): Boolean {\n  return {\n    type: NodeType.Boolean,\n    loc: { start: zero(), end: { line: 1, column: value ? 4 : 5 } },\n    value\n  };\n}\n\nexport function generateDateTime(value: Date): DateTime {\n  const raw = value.toISOString();\n\n  return {\n    type: NodeType.DateTime,\n    loc: { start: zero(), end: { line: 1, column: raw.length } },\n    raw,\n    value\n  };\n}\n\nexport function generateInlineArray(): InlineArray {\n  return {\n    type: NodeType.InlineArray,\n    loc: { start: zero(), end: { line: 1, column: 2 } },\n    items: []\n  };\n}\n\nexport function generateInlineItem(item: KeyValue | Value): InlineItem {\n  return {\n    type: NodeType.InlineItem,\n    loc: cloneLocation(item.loc),\n    item,\n    comma: false\n  };\n}\n\nexport function generateInlineTable(): InlineTable {\n  return {\n    type: NodeType.InlineTable,\n    loc: { start: zero(), end: { line: 1, column: 2 } },\n    items: []\n  };\n}\n\nexport function generateComment(comment: string): Comment {\n  if (!comment.startsWith('#')) comment = `# ${comment}`;\n\n  return {\n    type: NodeType.Comment,\n    loc: { start: zero(), end: { line: 1, column: comment.length } },\n    raw: comment\n  };\n}\n","import {\n  KeyValue,\n  Table,\n  InlineTable,\n  TableArray,\n  InlineArray,\n  isInlineTable,\n  isInlineArray,\n  isKeyValue,\n  Document\n} from './ast';\nimport { generateTable, generateDocument, generateTableArray } from './generate';\nimport { insert, remove, applyWrites, shiftNode } from './writer';\n\nexport interface Format {\n  printWidth?: number;\n  tabWidth?: number;\n  useTabs?: boolean;\n  trailingComma?: boolean;\n  bracketSpacing?: boolean;\n}\n\nexport function formatTopLevel(document: Document): Document {\n  const move_to_top_level = document.items.filter(item => {\n    if (!isKeyValue(item)) return false;\n\n    const is_inline_table = isInlineTable(item.value);\n    const is_inline_array =\n      isInlineArray(item.value) &&\n      item.value.items.length &&\n      isInlineTable(item.value.items[0].item);\n\n    return is_inline_table || is_inline_array;\n  }) as KeyValue[];\n\n  move_to_top_level.forEach(node => {\n    remove(document, document, node);\n\n    if (isInlineTable(node.value)) {\n      insert(document, document, formatTable(node));\n    } else {\n      formatTableArray(node).forEach(table_array => {\n        insert(document, document, table_array);\n      });\n    }\n  });\n\n  applyWrites(document);\n  return document;\n}\n\nfunction formatTable(key_value: KeyValue): Table {\n  const table = generateTable(key_value.key.value);\n\n  for (const item of (key_value.value as InlineTable).items) {\n    insert(table, table, item.item);\n  }\n\n  applyWrites(table);\n  return table;\n}\n\nfunction formatTableArray(key_value: KeyValue): TableArray[] {\n  const root = generateDocument();\n\n  for (const inline_array_item of (key_value.value as InlineArray).items) {\n    const table_array = generateTableArray(key_value.key.value);\n    insert(root, root, table_array);\n\n    for (const inline_table_item of (inline_array_item.item as InlineTable).items) {\n      insert(root, table_array, inline_table_item.item);\n    }\n  }\n\n  applyWrites(root);\n  return root.items as TableArray[];\n}\n\nexport function formatPrintWidth(document: Document, format: Format): Document {\n  // TODO\n  return document;\n}\n\nexport function formatEmptyLines(document: Document): Document {\n  let shift = 0;\n  let previous = 0;\n  for (const item of document.items) {\n    if (previous === 0 && item.loc.start.line > 1) {\n      // Remove leading newlines\n      shift = 1 - item.loc.start.line;\n    } else if (item.loc.start.line + shift > previous + 2) {\n      shift += previous + 2 - (item.loc.start.line + shift);\n    }\n\n    shiftNode(item, {\n      lines: shift,\n      columns: 0\n    });\n    previous = item.loc.end.line;\n  }\n\n  return document;\n}\n","import { Value, KeyValue, Document, InlineArray, InlineTable } from './ast';\nimport {\n  generateDocument,\n  generateKeyValue,\n  generateInlineItem,\n  generateString,\n  generateInteger,\n  generateFloat,\n  generateBoolean,\n  generateDateTime,\n  generateInlineArray,\n  generateInlineTable\n} from './generate';\nimport { Format, formatTopLevel, formatPrintWidth, formatEmptyLines } from './format';\nimport { isObject, isString, isInteger, isFloat, isBoolean, isDate, pipe } from './utils';\nimport { insert, applyWrites, applyBracketSpacing, applyTrailingComma } from './writer';\n\nconst default_format = {\n  printWidth: 80,\n  trailingComma: false,\n  bracketSpacing: true\n};\n\nexport default function parseJS(value: any, format: Format = {}): Document {\n  format = Object.assign({}, default_format, format);\n  value = toJSON(value);\n\n  // Reorder the elements in the object\n  value = reorderElements(value);\n\n  const document = generateDocument();\n  for (const item of walkObject(value, format)) {\n    insert(document, document, item);\n  }\n  applyWrites(document);\n\n  // Heuristics:\n  // 1. Top-level objects/arrays should be tables/table arrays\n  // 2. Convert objects/arrays to tables/table arrays based on print width\n  const formatted = pipe(\n    document,\n    formatTopLevel,\n    document => formatPrintWidth(document, format),\n    formatEmptyLines\n  );\n\n  return formatted;\n}\n\n/** \nThis function makes sure that properties that are simple values (not objects or arrays) are ordered first,\nand that objects and arrays are ordered last. This makes parseJS more reliable and easier to test.\n*/\nfunction reorderElements(value:any) : Object {\n  let result: Record<string, any> = {};\n  \n  // First add all simple values\n  for (const key in value) {\n    if (!isObject(value[key]) && !Array.isArray(value[key])) {\n      result[key] = value[key];\n    }\n  }\n  \n  // Then add all objects and arrays\n  for (const key in value) {\n    if (isObject(value[key]) || Array.isArray(value[key])) {\n      result[key] = value[key];\n    }\n  }\n  \n  return result;\n}\n\nfunction* walkObject(object: any, format: Format): IterableIterator<KeyValue> {\n  for (const key of Object.keys(object)) {\n    yield generateKeyValue([key], walkValue(object[key], format));\n  }\n}\n\nfunction walkValue(value: any, format: Format): Value {\n  if (value == null) {\n    throw new Error('\"null\" and \"undefined\" values are not supported');\n  }\n\n  if (isString(value)) {\n    return generateString(value);\n  } else if (isInteger(value)) {\n    return generateInteger(value);\n  } else if (isFloat(value)) {\n    return generateFloat(value);\n  } else if (isBoolean(value)) {\n    return generateBoolean(value);\n  } else if (isDate(value)) {\n    return generateDateTime(value);\n  } else if (Array.isArray(value)) {\n    return walkInlineArray(value, format);\n  } else {\n    return walkInlineTable(value, format);\n  }\n}\n\nfunction walkInlineArray(value: Array<any>, format: Format): InlineArray {\n  const inline_array = generateInlineArray();\n  for (const element of value) {\n    const item = walkValue(element, format);\n    const inline_array_item = generateInlineItem(item);\n\n    insert(inline_array, inline_array, inline_array_item);\n  }\n  applyBracketSpacing(inline_array, inline_array, format.bracketSpacing);\n  applyTrailingComma(inline_array, inline_array, format.trailingComma);\n  applyWrites(inline_array);\n\n  return inline_array;\n}\n\nfunction walkInlineTable(value: object, format: Format): InlineTable | Value {\n  value = toJSON(value);\n  if (!isObject(value)) return walkValue(value, format);\n\n  const inline_table = generateInlineTable();\n  const items = [...walkObject(value, format)];\n  for (const item of items) {\n    const inline_table_item = generateInlineItem(item);\n\n    insert(inline_table, inline_table, inline_table_item);\n  }\n  applyBracketSpacing(inline_table, inline_table, format.bracketSpacing);\n  applyTrailingComma(inline_table, inline_table, format.trailingComma);\n  applyWrites(inline_table);\n\n  return inline_table;\n}\n\n/**\n * Handles custom object serialization by checking for and using toJSON methods\n * \n * @param value - The value to potentially convert\n * @returns The result of value.toJSON() if available, otherwise the original value\n */\nfunction toJSON(value: any): any {\n  // Skip null/undefined values\n  if (!value) {\n    return value;\n  }\n  \n  // Skip Date objects (they have special handling)\n  if (isDate(value)) {\n    return value;\n  }\n  \n  // Use object's custom toJSON method if available\n  if (typeof value.toJSON === 'function') {\n    return value.toJSON();\n  }\n  \n  // Otherwise return unmodified\n  return value;\n}\n","import { NodeType, AST } from './ast';\nimport traverse from './traverse';\nimport { Location } from './location';\nimport { SPACE } from './tokenizer';\n\nconst BY_NEW_LINE = /(\\r\\n|\\n)/g;\n\nexport default function toTOML(ast: AST, newline: string = '\\n'): string {\n  const lines: string[] = [];\n\n  traverse(ast, {\n    [NodeType.TableKey](node) {\n      const { start, end } = node.loc;\n\n      write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '[');\n      write(lines, { start: { line: end.line, column: end.column - 1 }, end }, ']');\n    },\n    [NodeType.TableArrayKey](node) {\n      const { start, end } = node.loc;\n\n      write(lines, { start, end: { line: start.line, column: start.column + 2 } }, '[[');\n      write(lines, { start: { line: end.line, column: end.column - 2 }, end }, ']]');\n    },\n\n    [NodeType.KeyValue](node) {\n      const {\n        start: { line }\n      } = node.loc;\n      write(\n        lines,\n        { start: { line, column: node.equals }, end: { line, column: node.equals + 1 } },\n        '='\n      );\n    },\n    [NodeType.Key](node) {\n      write(lines, node.loc, node.raw);\n    },\n\n    [NodeType.String](node) {\n      write(lines, node.loc, node.raw);\n    },\n    [NodeType.Integer](node) {\n      write(lines, node.loc, node.raw);\n    },\n    [NodeType.Float](node) {\n      write(lines, node.loc, node.raw);\n    },\n    [NodeType.Boolean](node) {\n      write(lines, node.loc, node.value.toString());\n    },\n    [NodeType.DateTime](node) {\n      write(lines, node.loc, node.raw);\n    },\n\n    [NodeType.InlineArray](node) {\n      const { start, end } = node.loc;\n      write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '[');\n      write(lines, { start: { line: end.line, column: end.column - 1 }, end }, ']');\n    },\n\n    [NodeType.InlineTable](node) {\n      const { start, end } = node.loc;\n      write(lines, { start, end: { line: start.line, column: start.column + 1 } }, '{');\n      write(lines, { start: { line: end.line, column: end.column - 1 }, end }, '}');\n    },\n    [NodeType.InlineItem](node) {\n      if (!node.comma) return;\n\n      const start = node.loc.end;\n      write(lines, { start, end: { line: start.line, column: start.column + 1 } }, ',');\n    },\n\n    [NodeType.Comment](node) {\n      write(lines, node.loc, node.raw);\n    }\n  });\n\n  return lines.join(newline) + newline;\n}\n\nfunction write(lines: string[], loc: Location, raw: string) {\n  const raw_lines = raw.split(BY_NEW_LINE).filter(line => line !== '\\n' && line !== '\\r\\n');\n  const expected_lines = loc.end.line - loc.start.line + 1;\n\n  if (raw_lines.length !== expected_lines) {\n    throw new Error(\n      `Mismatch between location and raw string, expected ${expected_lines} lines for \"${raw}\"`\n    );\n  }\n\n  for (let i = loc.start.line; i <= loc.end.line; i++) {\n    const line = getLine(lines, i);\n    const is_start_line = i === loc.start.line;\n    const is_end_line = i === loc.end.line;\n\n    const before = is_start_line\n      ? line.substr(0, loc.start.column).padEnd(loc.start.column, SPACE)\n      : '';\n    const after = is_end_line ? line.substr(loc.end.column) : '';\n\n    lines[i - 1] = before + raw_lines[i - loc.start.line] + after;\n  }\n}\n\nfunction getLine(lines: string[], index: number): string {\n  if (!lines[index - 1]) {\n    for (let i = 0; i < index; i++) {\n      if (!lines[i]) lines[i] = '';\n    }\n  }\n\n  return lines[index - 1];\n}\n","import { Value, NodeType, TreeNode, AST, isInlineTable } from './ast';\nimport traverse from './traverse';\nimport { last, blank, isDate, has } from './utils';\nimport ParseError from './parse-error';\n\nexport default function toJS(ast: AST, input: string = ''): any {\n  const result = blank();\n  const tables: Set<string> = new Set();\n  const table_arrays: Set<string> = new Set();\n  const defined: Set<string> = new Set();\n  let active: any = result;\n  let previous_active: any;\n  let skip = false;\n\n  traverse(ast, {\n    [NodeType.Table](node) {\n      const key = node.key.item.value;\n      try {\n        validateKey(result, key, node.type, { tables, table_arrays, defined });\n      } catch (err) {\n        const e = err as Error;\n        throw new ParseError(input, node.key.loc.start, e.message);\n      }\n\n      const joined_key = joinKey(key);\n      tables.add(joined_key);\n      defined.add(joined_key);\n\n      active = ensureTable(result, key);\n    },\n\n    [NodeType.TableArray](node) {\n      const key = node.key.item.value;\n\n      try {\n        validateKey(result, key, node.type, { tables, table_arrays, defined });\n      } catch (err) {\n        const e = err as Error;\n        throw new ParseError(input, node.key.loc.start, e.message);\n      }\n\n      const joined_key = joinKey(key);\n      table_arrays.add(joined_key);\n      defined.add(joined_key);\n\n      active = ensureTableArray(result, key);\n    },\n\n    [NodeType.KeyValue]: {\n      enter(node) {\n        if (skip) return;\n\n        const key = node.key.value;\n        try {\n          validateKey(active, key, node.type, { tables, table_arrays, defined });\n        } catch (err) {\n          const e = err as Error;\n          throw new ParseError(input, node.key.loc.start, e.message);\n        }\n\n        const value = toValue(node.value);\n        const target = key.length > 1 ? ensureTable(active, key.slice(0, -1)) : active;\n\n        target[last(key)!] = value;\n        defined.add(joinKey(key));\n\n        if (isInlineTable(node.value)) {\n          previous_active = active;\n          active = value;\n        }\n      },\n      exit(node) {\n        if (isInlineTable(node.value)) {\n          active = previous_active;\n        }\n      }\n    },\n\n    [NodeType.InlineTable]: {\n      enter() {\n        // Handled by toValue\n        skip = true;\n      },\n      exit() {\n        skip = false;\n      }\n    }\n  });\n\n  return result;\n}\n\nexport function toValue(node: Value): any {\n  switch (node.type) {\n    case NodeType.InlineTable:\n      const result = blank();\n\n      node.items.forEach(({ item }) => {\n        const key = item.key.value;\n        const value = toValue(item.value);\n\n        const target = key.length > 1 ? ensureTable(result, key.slice(0, -1)) : result;\n        target[last(key)!] = value;\n      });\n\n      return result;\n\n    case NodeType.InlineArray:\n      return node.items.map(item => toValue(item.item as Value));\n\n    case NodeType.String:\n    case NodeType.Integer:\n    case NodeType.Float:\n    case NodeType.Boolean:\n    case NodeType.DateTime:\n      return node.value;\n\n    default:\n      throw new Error(`Unrecognized value type \"${(node as TreeNode).type}\"`);\n  }\n}\n\nfunction validateKey(\n  object: any,\n  key: string[],\n  type: NodeType.Table | NodeType.TableArray | NodeType.KeyValue,\n  state: { tables: Set<string>; table_arrays: Set<string>; defined: Set<string> }\n) {\n  // 1. Cannot override primitive value\n  let parts: string[] = [];\n  let index = 0;\n  for (const part of key) {\n    parts.push(part);\n\n    if (!has(object, part)) return;\n    if (isPrimitive(object[part])) {\n      throw new Error(`Invalid key, a value has already been defined for ${parts.join('.')}`);\n    }\n\n    const joined_parts = joinKey(parts);\n    if (Array.isArray(object[part]) && !state.table_arrays.has(joined_parts)) {\n      throw new Error(`Invalid key, cannot add to a static array at ${joined_parts}`);\n    }\n\n    const next_is_last = index++ < key.length - 1;\n    object = Array.isArray(object[part]) && next_is_last ? last(object[part]) : object[part];\n  }\n\n  const joined_key = joinKey(key);\n\n  // 2. Cannot override table\n  if (object && type === NodeType.Table && state.defined.has(joined_key)) {\n    throw new Error(`Invalid key, a table has already been defined named ${joined_key}`);\n  }\n\n  // 3. Cannot add table array to static array or table\n  if (object && type === NodeType.TableArray && !state.table_arrays.has(joined_key)) {\n    throw new Error(`Invalid key, cannot add an array of tables to a table at ${joined_key}`);\n  }\n}\n\nfunction ensureTable(object: any, key: string[]): any {\n  const target = ensure(object, key.slice(0, -1));\n  const last_key = last(key)!;\n  if (!target[last_key]) {\n    target[last_key] = blank();\n  }\n\n  return target[last_key];\n}\n\nfunction ensureTableArray(object: any, key: string[]): any {\n  const target = ensure(object, key.slice(0, -1));\n  const last_key = last(key)!;\n  if (!target[last_key]) {\n    target[last_key] = [];\n  }\n\n  const next = blank();\n  target[last(key)!].push(next);\n\n  return next;\n}\n\nfunction ensure(object: any, keys: string[]): any {\n  return keys.reduce((active, subkey) => {\n    if (!active[subkey]) {\n      active[subkey] = blank();\n    }\n    return Array.isArray(active[subkey]) ? last(active[subkey]) : active[subkey];\n  }, object);\n}\n\nfunction isPrimitive(value: any) {\n  return typeof value !== 'object' && !isDate(value);\n}\n\nfunction joinKey(key: string[]): string {\n  return key.join('.');\n}\n","import { isObject, datesEqual, stableStringify, merge } from './utils';\nimport { Path } from './find-by-path';\n\nexport enum ChangeType {\n  Add = 'Add',\n  Edit = 'Edit',\n  Remove = 'Remove',\n  Move = 'Move',\n  Rename = 'Rename'\n}\n\nexport interface Add {\n  type: ChangeType.Add;\n  path: Path;\n}\nexport function isAdd(change: Change): change is Add {\n  return change.type === ChangeType.Add;\n}\n\nexport interface Edit {\n  type: ChangeType.Edit;\n  path: Path;\n}\nexport function isEdit(change: Change): change is Edit {\n  return change.type === ChangeType.Edit;\n}\n\nexport interface Remove {\n  type: ChangeType.Remove;\n  path: Path;\n}\nexport function isRemove(change: Change): change is Remove {\n  return change.type === ChangeType.Remove;\n}\n\nexport interface Move {\n  type: ChangeType.Move;\n  path: Path;\n  from: number;\n  to: number;\n}\nexport function isMove(change: Change): change is Move {\n  return change.type === ChangeType.Move;\n}\n\nexport interface Rename {\n  type: ChangeType.Rename;\n  path: Path;\n  from: string;\n  to: string;\n}\nexport function isRename(change: Change): change is Rename {\n  return change.type === ChangeType.Rename;\n}\n\nexport type Change = Add | Edit | Remove | Move | Rename;\n\nexport default function diff(before: any, after: any, path: Path = []): Change[] {\n  if (before === after || datesEqual(before, after)) {\n    return [];\n  }\n\n  if (Array.isArray(before) && Array.isArray(after)) {\n    return compareArrays(before, after, path);\n  } else if (isObject(before) && isObject(after)) {\n    return compareObjects(before, after, path);\n  } else {\n    return [\n      {\n        type: ChangeType.Edit,\n        path\n      }\n    ];\n  }\n}\n\nfunction compareObjects(before: any, after: any, path: Path = []): Change[] {\n  let changes: Change[] = [];\n\n  // 1. Get keys and stable values\n  const before_keys = Object.keys(before);\n  const before_stable = before_keys.map(key => stableStringify(before[key]));\n  const after_keys = Object.keys(after);\n  const after_stable = after_keys.map(key => stableStringify(after[key]));\n\n  // Check for rename by seeing if object is in both before and after\n  // and that key is no longer used in after\n  const isRename = (stable: string, search: string[]) => {\n    const index = search.indexOf(stable);\n    if (index < 0) return false;\n\n    const before_key = before_keys[before_stable.indexOf(stable)];\n    return !after_keys.includes(before_key);\n  };\n\n  // 2. Check for changes, rename, and removed\n  before_keys.forEach((key, index) => {\n    const sub_path = path.concat(key);\n    if (after_keys.includes(key)) {\n      merge(changes, diff(before[key], after[key], sub_path));\n    } else if (isRename(before_stable[index], after_stable)) {\n      const to = after_keys[after_stable.indexOf(before_stable[index])];\n      changes.push({\n        type: ChangeType.Rename,\n        path,\n        from: key,\n        to\n      });\n    } else {\n      changes.push({\n        type: ChangeType.Remove,\n        path: sub_path\n      });\n    }\n  });\n\n  // 3. Check for additions\n  after_keys.forEach((key, index) => {\n    if (!before_keys.includes(key) && !isRename(after_stable[index], before_stable)) {\n      changes.push({\n        type: ChangeType.Add,\n        path: path.concat(key)\n      });\n    }\n  });\n\n  return changes;\n}\n\nfunction compareArrays(before: any[], after: any[], path: Path = []): Change[] {\n  let changes: Change[] = [];\n\n  // 1. Convert arrays to stable objects\n  const before_stable = before.map(stableStringify);\n  const after_stable = after.map(stableStringify);\n\n  // 2. Step through after array making changes to before array as-needed\n  after_stable.forEach((value, index) => {\n    const overflow = index >= before_stable.length;\n\n    // Check if items are the same\n    if (!overflow && before_stable[index] === value) {\n      return;\n    }\n\n    // Check if item has been moved -> shift into place\n    const from = before_stable.indexOf(value, index + 1);\n    if (!overflow && from > -1) {\n      changes.push({\n        type: ChangeType.Move,\n        path,\n        from,\n        to: index\n      });\n\n      const move = before_stable.splice(from, 1);\n      before_stable.splice(index, 0, ...move);\n\n      return;\n    }\n\n    // Check if item is removed -> assume it's been edited and replace\n    const removed = !after_stable.includes(before_stable[index]);\n    if (!overflow && removed) {\n      merge(changes, diff(before[index], after[index], path.concat(index)));\n      before_stable[index] = value;\n\n      return;\n    }\n\n    // Add as new item and shift existing\n    changes.push({\n      type: ChangeType.Add,\n      path: path.concat(index)\n    });\n    before_stable.splice(index, 0, value);\n  });\n\n  // 3. Remove any remaining overflow items\n  for (let i = after_stable.length; i < before_stable.length; i++) {\n    changes.push({\n      type: ChangeType.Remove,\n      path: path.concat(i)\n    });\n  }\n\n  return changes;\n}\n","import { TreeNode, isKeyValue, isTable, isTableArray, hasItems, isInlineItem, hasItem } from './ast';\nimport { arraysEqual, stableStringify } from './utils';\n\nexport type Path = Array<string | number>;\n\nexport default function findByPath(node: TreeNode, path: Path): TreeNode {\n  if (!path.length) return node;\n\n  if (isKeyValue(node)) {\n    return findByPath(node.value, path);\n  }\n\n  const indexes: { [key: string]: number } = {};\n  let found;\n  if (hasItems(node)) {\n    node.items.some((item, index) => {\n      try {\n        let key: Path = [];\n        if (isKeyValue(item)) {\n          key = item.key.value;\n        } else if (isTable(item)) {\n          key = item.key.item.value;\n        } else if (isTableArray(item)) {\n          key = item.key.item.value;\n\n          const key_string = stableStringify(key);\n          if (!indexes[key_string]) {\n            indexes[key_string] = 0;\n          }\n          const array_index = indexes[key_string]++;\n\n          key = key.concat(array_index);\n        } else if (isInlineItem(item) && isKeyValue(item.item)) {\n          key = item.item.key.value;\n        } else if (isInlineItem(item)) {\n          key = [index];\n        }\n\n        if (key.length && arraysEqual(key, path.slice(0, key.length))) {\n          found = findByPath(item, path.slice(key.length));\n          return true;\n        } else {\n          return false;\n        }\n      } catch (err) {\n        return false;\n      }\n    });\n  }\n\n  if (!found) {\n    throw new Error(`Could not find node at path ${path.join('.')}`);\n  }\n\n  return found;\n}\n\nexport function tryFindByPath(node: TreeNode, path: Path): TreeNode | undefined {\n  try {\n    return findByPath(node, path);\n  } catch (err) {}\n}\n\nexport function findParent(node: TreeNode, path: Path): TreeNode {\n  let parent_path = path;\n  let parent;\n  while (parent_path.length && !parent) {\n    parent_path = parent_path.slice(0, -1);\n    parent = tryFindByPath(node, parent_path);\n  }\n\n  if (!parent) {\n    throw new Error(`Count not find parent node for path ${path.join('.')}`);\n  }\n\n  return parent;\n}\n","import parseTOML from './parse-toml';\nimport parseJS from './parse-js';\nimport toTOML from './to-toml';\nimport toJS from './to-js';\nimport { Format } from './format';\n\n/**\n * Parses a TOML string into a JavaScript object.\n * The function converts TOML syntax to its JavaScript equivalent.\n * \n * @param value - The TOML string to parse\n * @returns The parsed JavaScript object\n */\nexport function parse(value: string): any {\n  return toJS(parseTOML(value), value);\n}\n\n/**\n * Converts a JavaScript object to a TOML string.\n * \n * @param value - The JavaScript object to stringify\n * @param format - Optional formatting options for the resulting TOML\n * @returns The stringified TOML representation\n */\nexport function stringify(value: any, format?: Format): string {\n  const document = parseJS(value, format);\n  return toTOML(document.items);\n}\n\nexport { default as patch } from './patch';\n","import parseTOML from './parse-toml';\nimport parseJS from './parse-js';\nimport toJS from './to-js';\nimport toTOML from './to-toml';\nimport { Format } from './format';\nimport {\n  isKeyValue,\n  WithItems,\n  KeyValue,\n  isTable,\n  TreeNode,\n  Document,\n  isDocument,\n  Block,\n  NodeType,\n  isTableArray,\n  isInlineArray,\n  isInlineItem,\n  hasItem,\n  InlineItem,\n  AST\n} from './ast';\nimport diff, { Change, isAdd, isEdit, isRemove, isMove, isRename } from './diff';\nimport findByPath, { tryFindByPath, findParent } from './find-by-path';\nimport { last, isInteger } from './utils';\nimport { insert, replace, remove, applyWrites } from './writer';\nimport { validate } from './validate';\n\nexport function toDocument(ast: AST) : Document  {\n  const items = [...ast];\n  return  {\n    type: NodeType.Document,\n    loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },\n    items\n  };\n}\n\n/**\n * Applies modifications to a TOML document by comparing an existing TOML string with updated JavaScript data.\n * \n * This function preserves formatting and comments from the existing TOML document while\n * applying changes from the updated data structure. It performs a diff between the existing\n * and updated data, then strategically applies only the necessary changes to maintain the\n * original document structure as much as possible.\n * \n * @param existing - The original TOML document as a string\n * @param updated - The updated JavaScript object with desired changes\n * @param format - Optional formatting options to apply to new or modified sections\n * @returns A new TOML string with the changes applied\n */\nexport default function patch(existing: string, updated: any, format?: Format): string {\n  const existing_ast = parseTOML(existing);\n  const items = [...existing_ast];\n\n  const existing_js = toJS(items);\n  const existing_document: Document = {\n    type: NodeType.Document,\n    loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },\n    items\n  };\n\n  const updated_document = parseJS(updated, format);\n  const changes = reorder(diff(existing_js, updated));\n\n\n\n  const patched_document = applyChanges(existing_document, updated_document, changes);\n\n  // Validate the patched_document\n  //validate(patched_document);\n\n  return toTOML(patched_document.items);\n}\n\nfunction reorder(changes: Change[]): Change[] {\n  //Reorder deletions among themselves to avoid index issues\n  // We want the path to be looking at the last item in the array first and go down from there\n \n  let sorted = false;\n  for (let i = 0; i < changes.length; i++) {\n    const change = changes[i];\n    if (isRemove(change)) {\n      let j = i + 1;\n      while (j < changes.length) {\n        const next_change = changes[j];\n        if (isRemove(next_change) && next_change.path[0] === change.path[0]  && \n            next_change.path[1] > change.path[1]) {\n          changes.splice(j, 1);\n          changes.splice(i, 0, next_change);\n          // We reset i to the beginning of the loop to avoid skipping any changes\n          i = 0\n          break;\n        }\n        j++;\n      }\n    }\n  }\n  \n  return changes;\n\n}\n\nfunction applyChanges(original: Document, updated: Document, changes: Change[]): Document {\n  // Potential Changes:\n  //\n  // Add: Add key-value to object, add item to array\n  // Edit: Change in value\n  // Remove: Remove key-value from object, remove item from array\n  // Move: Move item in array\n  // Rename: Rename key in key-value\n  //\n  // Special consideration, inline comments need to move as-needed\n\n  changes.forEach(change => {\n    if (isAdd(change)) {\n      const child = findByPath(updated, change.path);\n      const parent_path = change.path.slice(0, -1);\n      let index = last(change.path)! as number;\n\n      let is_table_array = isTableArray(child);\n      if (isInteger(index) && !parent_path.some(isInteger)) {\n        const sibling = tryFindByPath(original, parent_path.concat(0));\n        if (sibling && isTableArray(sibling)) {\n          is_table_array = true;\n        }\n      }\n\n      let parent: TreeNode;\n      if (isTable(child)) {\n        parent = original;\n      } else if (is_table_array) {\n        parent = original;\n\n        // The index needs to be updated to top-level items\n        // to properly account for other items, comments, and nesting\n        const document = original as Document;\n        const before = tryFindByPath(document, parent_path.concat(index - 1)) as Block | undefined;\n        const after = tryFindByPath(document, parent_path.concat(index)) as Block | undefined;\n        if (after) {\n          index = document.items.indexOf(after);\n        } else if (before) {\n          index = document.items.indexOf(before) + 1;\n        } else {\n          index = document.items.length;\n        }\n      } else {\n        parent = findParent(original, change.path);\n        if (isKeyValue(parent)) parent = parent.value;\n      }\n\n      if (isTableArray(parent) || isInlineArray(parent) || isDocument(parent)) {\n        insert(original, parent, child, index);\n      } else {\n        insert(original, parent, child);\n      }\n    } else if (isEdit(change)) {\n      let existing = findByPath(original, change.path);\n      let replacement = findByPath(updated, change.path);\n      let parent;\n\n      if (isKeyValue(existing) && isKeyValue(replacement)) {\n        // Edit for key-value means value changes\n        parent = existing;\n        existing = existing.value;\n        replacement = replacement.value;\n      } else if (isKeyValue(existing) && isInlineItem(replacement) && isKeyValue(replacement.item)) {\n        // Sometimes, the replacement looks like it could be an inline item, but the original is a key-value\n        // In this case, we convert the replacement to a key-value to match the original\n        parent = existing;\n        existing = existing.value;\n        replacement = replacement.item.value;\n      } else {\n        parent = findParent(original, change.path);\n      }\n\n      replace(original, parent, existing, replacement);\n    } else if (isRemove(change)) {\n      let parent = findParent(original, change.path);\n      if (isKeyValue(parent)) parent = parent.value;\n\n      const node = findByPath(original, change.path);\n\n      remove(original, parent, node);\n    } else if (isMove(change)) {\n      let parent = findByPath(original, change.path);\n      if (hasItem(parent)) parent = parent.item;\n      if (isKeyValue(parent)) parent = parent.value;\n\n      const node = (parent as WithItems).items[change.from];\n\n      remove(original, parent, node);\n      insert(original, parent, node, change.to);\n    } else if (isRename(change)) {\n      let parent = findByPath(original, change.path.concat(change.from)) as\n        | KeyValue\n        | InlineItem<KeyValue>;\n      let replacement = findByPath(updated, change.path.concat(change.to)) as\n        | KeyValue\n        | InlineItem<KeyValue>;\n\n      if (hasItem(parent)) parent = parent.item;\n      if (hasItem(replacement)) replacement = replacement.item;\n\n      replace(original, parent, parent.key, replacement.key);\n    }\n  });\n\n  applyWrites(original);\n  return original;\n}\n"],"names":["NodeType","TokenType","isDocument","node","type","Document","isTable","Table","isTableArray","TableArray","isKeyValue","KeyValue","isInlineArray","InlineArray","isInlineItem","InlineItem","isInlineTable","InlineTable","isComment","Comment","hasItems","hasItem","TableKey","isTableKey","TableArrayKey","isTableArrayKey","Cursor","constructor","iterator","this","index","value","undefined","done","peeked","next","result","_a","peek","Symbol","getSpan","location","lines","end","line","start","columns","column","findPosition","input","Array","isArray","findLines","findIndex","line_index","BY_NEW_LINE","indexes","match","exec","push","length","clonePosition","position","cloneLocation","ParseError","Error","message","error_message","substr","getLine","pointer","count","character","repeat","whitespace","super","IS_WHITESPACE","IS_NEW_LINE","DOUBLE_QUOTE","SINGLE_QUOTE","IS_VALID_LEADING_CHARACTER","tokenize","cursor","locate","createLocate","test","specialCharacter","Bracket","Curly","Equal","Comma","Dot","comment","multiline_char","checkThree","multiline","string","raw","loc","quotes","CheckMoreThanThree","Literal","double_quoted","single_quoted","isFinished","next_item","current","check","backslashes","slice","last","values","blank","Object","create","isInteger","isDate","prototype","toString","call","isObject","has","object","key","hasOwnProperty","pipe","fns","reduce","fn","stableStringify","keys","sort","map","JSON","stringify","join","merge","target","original_length","added_length","i","IS_CRLF","IS_LF","IS_LEADING_NEW_LINE","IS_LINE_ENDING_BACKSLASH","parseString","startsWith","trim","trimLeadingWhitespace","lineEndingBackslash","escapeNewLines","escapeDoubleQuotes","unescapeLargeUnicode","precedingBackslashes","char","escaped","json_escaped","replace","code_point","parseInt","as_string","String","fromCodePoint","fixed_json_escaped","parse","group","TRUE","HAS_E","IS_DIVIDER","IS_INF","IS_NAN","IS_HEX","IS_OCTAL","IS_BINARY","IS_FULL_DATE","IS_FULL_TIME","parseTOML","tokens","walkBlock","is_table","item","Key","dot","before","after","items","table","equals","comments","walkValue","keyValue","Boolean","boolean","Date","local_date","toISOString","split","DateTime","datetime","Infinity","Number","Float","float","Integer","radix","integer","previous","comma","inline_item","inlineTable","inline_array","additional_comments","inlineArray","traverse","ast","visitor","traverseArray","array","parent","traverseNode","visit","enter","exit","enter_offsets","WeakMap","getEnterOffsets","root","set","get","exit_offsets","getExitOffsets","existing","replacement","indexOf","splice","shiftNode","existing_span","replacement_span","addOffset","insert","child","shift","offset","is_last","has_seperating_comma_before","has_seperating_comma_after","has_trailing_comma","use_new_line","perLine","leading_lines","skip_comma","skip_bracket","child_span","insertInline","use_first_line","is_block","insertOnNewLine","previous_offset","delete","remove","removed_span","is_inline","previous_on_same_line","next_on_sameLine","keep_line","target_offsets","node_offsets","removed_offset","applyBracketSpacing","bracket_spacing","last_item","applyTrailingComma","trailing_commas","applyWrites","shiftStart","lineOffset","columnOffset","entering","shiftEnd","exiting","shiftLocation","start_line","key_offset","span","options","first_line_only","move","offsets","from","generateDocument","generateTable","table_key","keyValueToRaw","generateTableKey","generateTableArray","table_array_key","generateTableArrayKey","generateKeyValue","key_node","generateKey","IS_BARE_KEY","part","generateInlineItem","formatTopLevel","document","filter","is_inline_table","is_inline_array","forEach","key_value","formatTable","inline_array_item","table_array","inline_table_item","formatTableArray","formatEmptyLines","default_format","printWidth","trailingComma","bracketSpacing","parseJS","format","assign","reorderElements","toJSON","walkObject","formatted","formatPrintWidth","isString","generateString","generateInteger","isFloat","generateFloat","isBoolean","generateBoolean","generateDateTime","element","walkInlineArray","inline_table","walkInlineTable","toTOML","newline","write","raw_lines","expected_lines","is_start_line","is_end_line","padEnd","toJS","tables","Set","table_arrays","defined","previous_active","active","skip","validateKey","err","e","joined_key","joinKey","add","ensureTable","ensure","last_key","ensureTableArray","toValue","state","parts","joined_parts","next_is_last","subkey","ChangeType","isRemove","change","Remove","diff","path","b","a","changes","before_stable","after_stable","overflow","Move","to","removed","includes","concat","Add","compareArrays","before_keys","after_keys","isRename","stable","search","before_key","sub_path","Rename","compareObjects","Edit","findByPath","found","some","key_string","array_index","arraysEqual","tryFindByPath","findParent","parent_path","updated","existing_js","original","isAdd","is_table_array","sibling","isEdit","isMove","applyChanges","j","next_change","reorder"],"mappings":";4OAEA,IAAYA,ECEAC,EDiCN,SAAUC,EAAWC,GACzB,OAAOA,EAAKC,OAASJ,EAASK,QAChC,CAoBM,SAAUC,EAAQH,GACtB,OAAOA,EAAKC,OAASJ,EAASO,KAChC,CAsCM,SAAUC,EAAaL,GAC3B,OAAOA,EAAKC,OAASJ,EAASS,UAChC,CAmCM,SAAUC,EAAWP,GACzB,OAAOA,EAAKC,OAASJ,EAASW,QAChC,CAgGM,SAAUC,EAAcT,GAC5B,OAAOA,EAAKC,OAASJ,EAASa,WAChC,CAgBM,SAAUC,EAAaX,GAC3B,OAAOA,EAAKC,OAASJ,EAASe,UAChC,CAWM,SAAUC,EAAcb,GAC5B,OAAOA,EAAKC,OAASJ,EAASiB,WAChC,CAwBM,SAAUC,EAAUf,GACxB,OAAOA,EAAKC,OAASJ,EAASmB,OAChC,CASM,SAAUC,EAASjB,GACvB,OACED,EAAWC,IACXG,EAAQH,IACRK,EAAaL,IACba,EAAcb,IACdS,EAAcT,EAElB,CAKM,SAAUkB,EAAQlB,GACtB,OA/OI,SAAqBA,GACzB,OAAOA,EAAKC,OAASJ,EAASsB,QAChC,CA6OSC,CAAWpB,IAxMd,SAA0BA,GAC9B,OAAOA,EAAKC,OAASJ,EAASwB,aAChC,CAsM6BC,CAAgBtB,IAASW,EAAaX,EACnE,EA3TA,SAAYH,GACVA,EAAA,SAAA,WACAA,EAAA,MAAA,QACAA,EAAA,SAAA,WACAA,EAAA,WAAA,aACAA,EAAA,cAAA,gBACAA,EAAA,SAAA,WACAA,EAAA,IAAA,MACAA,EAAA,OAAA,SACAA,EAAA,QAAA,UACAA,EAAA,MAAA,QACAA,EAAA,QAAA,UACAA,EAAA,SAAA,WACAA,EAAA,YAAA,cACAA,EAAA,WAAA,aACAA,EAAA,YAAA,cACAA,EAAA,QAAA,SACD,CAjBD,CAAYA,IAAAA,EAAQ,CAAA,IEuBN,MAAO0B,EAOnB,WAAAC,CAAYC,GACVC,KAAKD,SAAWA,EAChBC,KAAKC,OAAQ,EACbD,KAAKE,WAAQC,EACbH,KAAKI,MAAO,EACZJ,KAAKK,OAAS,IAChB,CAEA,IAAAC,SACE,GAAIN,KAAKI,KAAM,OAAOA,IAEtB,MAAMG,EAASP,KAAKK,QAAUL,KAAKD,SAASO,OAO5C,OALAN,KAAKC,OAAS,EACdD,KAAKE,MAAQK,EAAOL,MACpBF,KAAKI,KAAkB,QAAXI,EAAAD,EAAOH,YAAI,IAAAI,GAAAA,EACvBR,KAAKK,OAAS,KAEPE,CACT,CAEA,IAAAE,GACE,OAAIT,KAAKI,KAAaA,KAClBJ,KAAKK,SAETL,KAAKK,OAASL,KAAKD,SAASO,QAFJN,KAAKK,OAI/B,CAEA,CAACK,OAAOX,YACN,OAAOC,IACT,EAGF,SAASI,IACP,MAAO,CAAEF,WAAOC,EAAWC,MAAM,EACnC,CCpDM,SAAUO,EAAQC,GACtB,MAAO,CACLC,MAAOD,EAASE,IAAIC,KAAOH,EAASI,MAAMD,KAAO,EACjDE,QAASL,EAASE,IAAII,OAASN,EAASI,MAAME,OAElD,CAcM,SAAUC,EAAaC,EAA0BnB,GAarD,MAAMY,EAAQQ,MAAMC,QAAQF,GAASA,EAAQG,EAAUH,GACjDL,EAAOF,EAAMW,WAAUC,GAAcA,GAAcxB,IAAS,EAGlE,MAAO,CAAEc,OAAMG,OAFAjB,GAASY,EAAME,EAAO,GAAK,GAAK,GAGjD,CAUM,SAAUQ,EAAUH,GAExB,MAAMM,EAAc,aACdC,EAAoB,GAE1B,IAAIC,EACJ,KAA4C,OAApCA,EAAQF,EAAYG,KAAKT,KAC/BO,EAAQG,KAAKF,EAAM3B,OAIrB,OAFA0B,EAAQG,KAAKV,EAAMW,OAAS,GAErBJ,CACT,CAEM,SAAUK,EAAcC,GAC5B,MAAO,CAAElB,KAAMkB,EAASlB,KAAMG,OAAQe,EAASf,OACjD,CAEM,SAAUgB,EAActB,GAC5B,MAAO,CAAEI,MAAOgB,EAAcpB,EAASI,OAAQF,IAAKkB,EAAcpB,EAASE,KAC7E,CCjFc,MAAOqB,UAAmBC,MAItC,WAAAtC,CAAYsB,EAAea,EAAoBI,GAC7C,IAAIC,EAAgB,uBAAuBL,EAASlB,SAASkB,EAASf,OAAS,QAE/E,GAAIE,EAAO,CACT,MAAML,ED6CN,SAAkBK,EAAea,GACrC,MAAMpB,EAAQU,EAAUH,GAClBJ,EAAQH,EAAMoB,EAASlB,KAAO,IAAM,EACpCD,EAAMD,EAAMoB,EAASlB,KAAO,IAAMK,EAAMW,OAE9C,OAAOX,EAAMmB,OAAOvB,EAAOF,EAAME,EACnC,CCnDmBwB,CAAQpB,EAAOa,GACtBQ,EAAU,GAiBtB,SAAoBC,EAAeC,EAAoB,KACrD,OAAOA,EAAUC,OAAOF,EAC1B,CAnByBG,CAAWZ,EAASf,WAEnCH,IAAMuB,GAAiB,GAAGvB,MAAS0B,MACzC,CACAH,GAAiBD,EAEjBS,MAAMR,GAENtC,KAAKe,KAAOkB,EAASlB,KACrBf,KAAKkB,OAASe,EAASf,MACzB,GHjBF,SAAY9C,GACVA,EAAA,QAAA,UACAA,EAAA,MAAA,QACAA,EAAA,MAAA,QACAA,EAAA,MAAA,QACAA,EAAA,IAAA,MACAA,EAAA,QAAA,UACAA,EAAA,QAAA,SACD,CARD,CAAYA,IAAAA,EAAS,CAAA,IAgBd,MAAM2E,EAAgB,KAChBC,EAAc,YACdC,EAAe,IACfC,EAAe,IAItBC,EAA6B,yBAE7B,SAAWC,EAAShC,GACxB,MAAMiC,EAAS,IAAIxD,EAAgBuB,EC7BtBV,OAAOX,aD8BpBsD,EAAO/C,OAEP,MAAMgD,EETF,SAAuBlC,GAC3B,MAAMP,EAAQU,EAAUH,GAExB,MAAO,CAACJ,EAAeF,KACd,CACLE,MAAOG,EAAaN,EAAOG,GAC3BF,IAAKK,EAAaN,EAAOC,IAG/B,CFAiByC,CAAanC,GAE5B,MAAQiC,EAAOjD,MAAM,CACnB,GAAI2C,EAAcS,KAAKH,EAAOnD,aAEvB,GAAqB,MAAjBmD,EAAOnD,OAAkC,MAAjBmD,EAAOnD,YAElCuD,EAAiBJ,EAAQC,EAAQlF,EAAUsF,cAC5C,GAAqB,MAAjBL,EAAOnD,OAAkC,MAAjBmD,EAAOnD,YAClCuD,EAAiBJ,EAAQC,EAAQlF,EAAUuF,YAC5C,GAAqB,MAAjBN,EAAOnD,YACVuD,EAAiBJ,EAAQC,EAAQlF,EAAUwF,YAC5C,GAAqB,MAAjBP,EAAOnD,YACVuD,EAAiBJ,EAAQC,EAAQlF,EAAUyF,YAC5C,GAAqB,MAAjBR,EAAOnD,YACVuD,EAAiBJ,EAAQC,EAAQlF,EAAU0F,UAC5C,GAAqB,MAAjBT,EAAOnD,YAEV6D,EAAQV,EAAQC,OACjB,CACL,MAAMU,EACJC,EAAW7C,EAAOiC,EAAOpD,MAAOiD,IAChCe,EAAW7C,EAAOiC,EAAOpD,MAAOgD,GAE9Be,QAEIE,EAAUb,EAAQC,EAAQU,EAAgB5C,SAE1C+C,EAAOd,EAAQC,EAAQlC,EAEjC,CAEAiC,EAAO/C,MACT,CACF,CAEA,SAASmD,EAAiBJ,EAAwBC,EAAiB/E,GACjE,MAAO,CAAEA,OAAM6F,IAAKf,EAAOnD,MAAQmE,IAAKf,EAAOD,EAAOpD,MAAOoD,EAAOpD,MAAQ,GAC9E,CAEA,SAAS8D,EAAQV,EAAwBC,GACvC,MAAMtC,EAAQqC,EAAOpD,MACrB,IAAImE,EAAMf,EAAOnD,MACjB,MAAQmD,EAAO5C,OAAOL,OAAS4C,EAAYQ,KAAKH,EAAO5C,OAAOP,QAC5DmD,EAAO/C,OACP8D,GAAOf,EAAOnD,MAKhB,MAAO,CACL3B,KAAMH,EAAUkB,QAChB8E,MACAC,IAAKf,EAAOtC,EAAOqC,EAAOpD,MAAQ,GAEtC,CAEA,SAASiE,EACPb,EACAC,EACAU,EACA5C,GAEA,MAAMJ,EAAQqC,EAAOpD,MACrB,IAAIqE,EAASN,EAAiBA,EAAiBA,EAC3CI,EAAME,EASV,IANAjB,EAAO/C,OACP+C,EAAO/C,OACP+C,EAAO/C,QAIC+C,EAAOjD,QAAU6D,EAAW7C,EAAOiC,EAAOpD,MAAO+D,IAAmBO,EAAmBnD,EAAOiC,EAAOpD,MAAO+D,KAClHI,GAAOf,EAAOnD,MACdmD,EAAO/C,OAGT,GAAI+C,EAAOjD,KACT,MAAM,IAAI+B,EACRf,EACAD,EAAaC,EAAOiC,EAAOpD,OAC3B,2CAA2CqE,0BAS/C,OALAF,GAAOE,EAEPjB,EAAO/C,OACP+C,EAAO/C,OAEA,CACL/B,KAAMH,EAAUoG,QAChBJ,MACAC,IAAKf,EAAOtC,EAAOqC,EAAOpD,MAAQ,GAEtC,CAEA,SAASkE,EAAOd,EAAwBC,EAAiBlC,GAsBvD,IAAK+B,EAA2BK,KAAKH,EAAOnD,OAC1C,MAAM,IAAIiC,EACRf,EACAD,EAAaC,EAAOiC,EAAOpD,OAC3B,0BAA0BoD,EAAOnD,mDAIrC,MAAMc,EAAQqC,EAAOpD,MACrB,IAAImE,EAAMf,EAAOnD,MACbuE,EAAgBpB,EAAOnD,QAAU+C,EACjCyB,EAAgBrB,EAAOnD,QAAUgD,EAErC,MAAMyB,EAActB,IAClB,GAAIA,EAAO5C,OAAOL,KAAM,OAAO,EAC/B,MAAMwE,EAAYvB,EAAO5C,OAAOP,MAEhC,QACIuE,GAAiBC,KAClB3B,EAAcS,KAAKoB,IACJ,MAAdA,GACc,MAAdA,GACc,MAAdA,GACc,MAAdA,GACc,MAAdA,GACc,MAAdA,EACD,EAIL,MAAQvB,EAAOjD,OAASuE,EAAWtB,KACjCA,EAAO/C,OAEH+C,EAAOnD,QAAU+C,IAAcwB,GAAiBA,GAChDpB,EAAOnD,QAAUgD,GAAiBuB,IAAeC,GAAiBA,GAEtEN,GAAOf,EAAOnD,OAEVmD,EAAO5C,OAAOL,OARwB,CAS1C,IAAIwE,EAAYvB,EAAO5C,OAAOP,MAI1BuE,GA5Kc,OA4KGpB,EAAOnD,QACtB0E,IAAc3B,GAChBmB,GAAOnB,EACPI,EAAO/C,QA/KO,OAgLLsE,IACTR,GAjLc,KAkLdf,EAAO/C,QAGb,CAEA,GAAImE,GAAiBC,EACnB,MAAM,IAAIvC,EACRf,EACAD,EAAaC,EAAOJ,GACpB,iCAAiCyD,EAAgBxB,EAAeC,KAIpE,MAAO,CACL3E,KAAMH,EAAUoG,QAChBJ,MACAC,IAAKf,EAAOtC,EAAOqC,EAAOpD,MAAQ,GAEtC,CAWA,SAASgE,EAAW7C,EAAeyD,EAAiBC,GAClD,IAAKA,EACH,OAAO,EAQT,KAJE1D,EAAMyD,KAAaC,GACnB1D,EAAMyD,EAAU,KAAOC,GACvB1D,EAAMyD,EAAU,KAAOC,GAGvB,OAAO,EAIT,MACMC,EADgB3D,EAAM4D,MAAM,EAAGH,GACFjD,MAAM,QAEzC,IAAKmD,EACH,OAAOD,EAKT,QAFkBC,EAAY,GAAGhD,OAAS,GAAM,IAErB+C,CAC7B,UAEgBP,EAAmBnD,EAAeyD,EAAiBC,GAEjE,QAAKA,IAKH1D,EAAMyD,KAAaC,GACnB1D,EAAMyD,EAAU,KAAOC,GACvB1D,EAAMyD,EAAU,KAAOC,GACvB1D,EAAMyD,EAAU,KAAOC,EAG3B,CIhRM,SAAUG,EAAaC,GAC3B,OAAOA,EAAOA,EAAOnD,OAAS,EAChC,UAIgBoD,IACd,OAAOC,OAAOC,OAAO,KACvB,CAMM,SAAUC,EAAUpF,GACxB,MAAwB,iBAAVA,GAAsBA,EAAQ,GAAM,CACpD,CAUM,SAAUqF,EAAOrF,GACrB,MAAiD,kBAA1CkF,OAAOI,UAAUC,SAASC,KAAKxF,EACxC,CAEM,SAAUyF,EAASzF,GACvB,OAAOA,GAA0B,iBAAVA,IAAuBqF,EAAOrF,KAAWmB,MAAMC,QAAQpB,EAChF,CAMM,SAAU0F,EAAIC,EAAaC,GAC/B,OAAOV,OAAOI,UAAUO,eAAeL,KAAKG,EAAQC,EACtD,UAgBgBE,EAAa9F,KAAkB+F,GAC7C,OAAOA,EAAIC,QAAO,CAAChG,EAAOiG,IAAOA,EAAGjG,IAAQA,EAC9C,CAEM,SAAUkG,EAAgBP,GAC9B,GAAIF,EAASE,GAAS,CAKpB,MAAO,IAJYT,OAAOiB,KAAKR,GAC5BS,OACAC,KAAIT,GAAO,GAAGU,KAAKC,UAAUX,MAAQM,EAAgBP,EAAOC,QAEzCY,KAAK,OAC7B,CAAO,OAAIrF,MAAMC,QAAQuE,GAChB,IAAIA,EAAOU,IAAIH,GAAiBM,KAAK,QAErCF,KAAKC,UAAUZ,EAE1B,CAEM,SAAUc,EAAcC,EAAkB1B,GAG9C,MAAM2B,EAAkBD,EAAO7E,OACzB+E,EAAe5B,EAAOnD,OAC5B6E,EAAO7E,OAAS8E,EAAkBC,EAElC,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAcC,IAChCH,EAAOC,EAAkBE,GAAK7B,EAAO6B,EAEzC,CCjFA,MAIMC,EAAU,QACVC,EAAQ,MACRC,EAAsB,aAItBC,EAA2B,sCAE3B,SAAUC,EAAYhD,GAC1B,OAAIA,EAAIiD,WAZkB,OAajBrB,EACLsB,EAAKlD,EAAK,GACVmD,GAEOnD,EAAIiD,WAAWnE,GACjBoE,EAAKlD,EAAK,GACRA,EAAIiD,WApBW,OAqBjBrB,EACLsB,EAAKlD,EAAK,GACVmD,EACAC,EACAC,EACAC,EACAC,GAEOvD,EAAIiD,WAAWpE,GACjB+C,EACLsB,EAAKlD,EAAK,GACVuD,GAGKvD,CAEX,CAEM,SAAUsD,EAAmBxH,GACjC,IAAIK,EAAS,GACTqH,EAAuB,EAE3B,IAAK,IAAIb,EAAI,EAAGA,EAAI7G,EAAM6B,OAAQgF,IAAK,CACrC,MAAMc,EAAO3H,EAAM6G,GAIjBxG,GAFW,MAATsH,GAAgBD,EAAuB,GAAM,EAErC,MAGAC,EAIC,OAATA,EACFD,IAEAA,EAAuB,CAE3B,CAEA,OAAOrH,CACT,CAEM,SAAUoH,EAAqBG,GAGnC,MACMC,EAAeD,EAAQE,QADP,sBAC8B9H,IAClD,MAAM+H,EAAaC,SAAShI,EAAM8H,QAAQ,MAAO,IAAK,IAChDG,EAAYC,OAAOC,cAAcJ,GAEvC,OAAOX,EAAKd,KAAKC,UAAU0B,GAAY,EAAE,IAGrCG,EAAuCP,EAS1CC,QAAQ,MAAO,OALlB,OADexB,KAAK+B,MAAM,IAAID,KAEhC,CAWA,SAAShB,EAAKpH,EAAewC,GAC3B,OAAOxC,EAAM8E,MAAMtC,EAAOxC,EAAM6B,OAASW,EAC3C,CAEA,SAAS6E,EAAsBrH,GAC7B,OAAOA,EAAM8H,QAAQd,EAAqB,GAC5C,CAEA,SAASO,EAAevH,GACtB,OAAOA,EAAM8H,QAAQhB,EAlGV,UAkGyBgB,QAAQf,EAnGnC,MAoGX,CAEA,SAASO,EAAoBtH,GAC3B,OAAOA,EAAM8H,QAAQb,GAA0B,CAACvF,EAAO4G,IAAU5G,EAAMoG,QAAQQ,EAAO,KACxF,CCjFA,MAAMC,EAAO,OAEPC,GAAQ,KACRC,GAAa,MACbC,GAAS,MACTC,GAAS,MACTC,GAAS,MACTC,GAAW,MACXC,GAAY,MACLC,GAAe,0BACfC,GAAe,0BAEd,SAAWC,GAAU/H,GACjC,MAAMgI,EAAShG,EAAShC,GAClBiC,EAAS,IAAIxD,EAAOuJ,GAE1B,MAAQ/F,EAAO/C,OAAOF,YACbiJ,GAAUhG,EAAQjC,EAE7B,CAEA,SAAUiI,GAAUhG,EAAuBjC,GACzC,GAAIiC,EAAOnD,MAAO3B,OAASH,EAAUkB,cAC7ByE,GAAQV,QACT,GAAIA,EAAOnD,MAAO3B,OAASH,EAAUsF,cAyD9C,SAAeL,EAAuBjC,GAgBpC,MAAM7C,EACH8E,EAAO5C,OAAOL,MAAQiD,EAAO5C,OAAOP,MAAO3B,OAASH,EAAUsF,QAE3DvF,EAASO,MADTP,EAASS,WAET0K,EAAW/K,IAASJ,EAASO,MAEnC,GAAI4K,GAAkC,MAAtBjG,EAAOnD,MAAOkE,IAC5B,MAAM,IAAIjC,EACRf,EACAiC,EAAOnD,MAAOmE,IAAIrD,MAClB,qCAAqCqC,EAAOnD,MAAOkE,OAGvD,IAAKkF,IAAmC,MAAtBjG,EAAOnD,MAAOkE,KAA4C,MAA7Bf,EAAO5C,OAAOP,MAAOkE,KAClE,MAAM,IAAIjC,EACRf,EACAiC,EAAOnD,MAAOmE,IAAIrD,MAClB,gDAAgDqC,EAAOnD,MAAOkE,IAAMf,EAAO5C,OAAOP,MAAOkE,OAK7F,MAAM0B,EAAMwD,EACP,CACC/K,KAAMJ,EAASsB,SACf4E,IAAKhB,EAAOnD,MAAOmE,KAEpB,CACC9F,KAAMJ,EAASwB,cACf0E,IAAKhB,EAAOnD,MAAOmE,KAIzBhB,EAAO/C,OACH/B,IAASJ,EAASS,YAAYyE,EAAO/C,OAEzC,GAAI+C,EAAOjD,KACT,MAAM,IAAI+B,EAAWf,EAAO0E,EAAIzB,IAAKrD,MAAO,2CAG9C8E,EAAIyD,KAAO,CACThL,KAAMJ,EAASqL,IACfnF,IAAKnC,EAAcmB,EAAOnD,MAAOmE,KACjCD,IAAKf,EAAOnD,MAAOkE,IACnBlE,MAAO,CAACkH,EAAY/D,EAAOnD,MAAOkE,OAGpC,MAAQf,EAAO5C,OAAOL,MAAQiD,EAAO5C,OAAOP,MAAO3B,OAASH,EAAU0F,KAAK,CACzET,EAAO/C,OACP,MAAMmJ,EAAMpG,EAAOnD,MAEnBmD,EAAO/C,OACP,MAAMoJ,EAAS,IAAI9G,OAAO6G,EAAIpF,IAAIrD,MAAME,OAAS4E,EAAIyD,KAAKlF,IAAIvD,IAAII,QAC5DyI,EAAQ,IAAI/G,OAAOS,EAAOnD,MAAOmE,IAAIrD,MAAME,OAASuI,EAAIpF,IAAIvD,IAAII,QAEtE4E,EAAIyD,KAAKlF,IAAIvD,IAAMuC,EAAOnD,MAAOmE,IAAIvD,IACrCgF,EAAIyD,KAAKnF,KAAO,GAAGsF,KAAUC,IAAQtG,EAAOnD,MAAOkE,MACnD0B,EAAIyD,KAAKrJ,MAAM4B,KAAKsF,EAAY/D,EAAOnD,MAAOkE,KAChD,CAIA,GAFAf,EAAO/C,OAEHgJ,IAAajG,EAAOjD,MAA8B,MAAtBiD,EAAOnD,MAAOkE,KAC5C,MAAM,IAAIjC,EACRf,EACAiC,EAAOjD,KAAO0F,EAAIyD,KAAKlF,IAAIvD,IAAMuC,EAAOnD,MAAOmE,IAAIrD,MACnD,qCAAqCqC,EAAOjD,KAAO,cAAgBiD,EAAOnD,MAAOkE,OAGrF,IACGkF,IACAjG,EAAOjD,MACNiD,EAAO5C,OAAOL,MACQ,MAAtBiD,EAAOnD,MAAOkE,KACe,MAA7Bf,EAAO5C,OAAOP,MAAOkE,KAEvB,MAAM,IAAIjC,EACRf,EACAiC,EAAOjD,MAAQiD,EAAO5C,OAAOL,KAAO0F,EAAIyD,KAAKlF,IAAIvD,IAAMuC,EAAOnD,MAAOmE,IAAIrD,MACzE,gDACEqC,EAAOjD,MAAQiD,EAAO5C,OAAOL,KACzB,cACAiD,EAAOnD,MAAOkE,IAAMf,EAAO5C,OAAOP,MAAOkE,OAM9CkF,GAAUjG,EAAO/C,OACtBwF,EAAIzB,IAAKvD,IAAMuC,EAAOnD,MAAOmE,IAAIvD,IAGjC,IAAI8I,EAAmC,GACvC,MAAQvG,EAAO5C,OAAOL,MAAQiD,EAAO5C,OAAOP,MAAO3B,OAASH,EAAUsF,SACpEL,EAAO/C,OACPqG,EAAMiD,EAAO,IAAIP,GAAUhG,EAAQjC,KAGrC,MAAO,CACL7C,KAAM+K,EAAWnL,EAASO,MAAQP,EAASS,WAC3CyF,IAAK,CACHrD,MAAOgB,EAAc8D,EAAIzB,IAAKrD,OAC9BF,IAAK8I,EAAM7H,OACPC,EAAc4H,EAAMA,EAAM7H,OAAS,GAAGsC,IAAIvD,KAC1CkB,EAAc8D,EAAIzB,IAAKvD,MAE7BgF,IAAKA,EACL8D,QAEJ,CArLUC,CAAMxG,EAAQjC,OACf,IAAIiC,EAAOnD,MAAO3B,OAASH,EAAUoG,QAG1C,MAAM,IAAIrC,EACRf,EACAiC,EAAOnD,MAAOmE,IAAIrD,MAClB,qBAAqBqC,EAAOnD,MAAO3B,qDAgLzC,SAAkB8E,EAAuBjC,GAOvC,MAAM0E,EAAW,CACfvH,KAAMJ,EAASqL,IACfnF,IAAKnC,EAAcmB,EAAOnD,MAAOmE,KACjCD,IAAKf,EAAOnD,MAAOkE,IACnBlE,MAAO,CAACkH,EAAY/D,EAAOnD,MAAOkE,OAGpC,MAAQf,EAAO5C,OAAOL,MAAQiD,EAAO5C,OAAOP,MAAO3B,OAASH,EAAU0F,KACpET,EAAO/C,OACP+C,EAAO/C,OAEPwF,EAAIzB,IAAIvD,IAAMuC,EAAOnD,MAAOmE,IAAIvD,IAChCgF,EAAI1B,KAAO,IAAIf,EAAOnD,MAAOkE,MAC7B0B,EAAI5F,MAAM4B,KAAKsF,EAAY/D,EAAOnD,MAAOkE,MAK3C,GAFAf,EAAO/C,OAEH+C,EAAOjD,MAAQiD,EAAOnD,MAAO3B,OAASH,EAAUwF,MAClD,MAAM,IAAIzB,EACRf,EACAiC,EAAOjD,KAAO0F,EAAIzB,IAAIvD,IAAMuC,EAAOnD,MAAOmE,IAAIrD,MAC9C,qCAAqCqC,EAAOjD,KAAO,cAAgBiD,EAAOnD,MAAOkE,OAIrF,MAAM0F,EAASzG,EAAOnD,MAAOmE,IAAIrD,MAAME,OAIvC,GAFAmC,EAAO/C,OAEH+C,EAAOjD,KACT,MAAM,IAAI+B,EAAWf,EAAO0E,EAAIzB,IAAIrD,MAAO,qDAG7C,MAAOd,KAAU6J,GAAYC,GAAU3G,EAAQjC,GAE/C,MAAO,CACL,CACE7C,KAAMJ,EAASW,SACfgH,MACA5F,MAAOA,EACPmE,IAAK,CACHrD,MAAOgB,EAAc8D,EAAIzB,IAAIrD,OAC7BF,IAAKkB,EAAc9B,EAAMmE,IAAIvD,MAE/BgJ,aAEEC,EAER,CA7OWE,CAAS5G,EAAQjC,EAO1B,CACF,CAEA,SAAU4I,GAAU3G,EAAuBjC,GACzC,GAAIiC,EAAOnD,MAAO3B,OAASH,EAAUoG,QAC/BnB,EAAOnD,MAAOkE,IAAI,KAAOnB,GAAgBI,EAAOnD,MAAOkE,IAAI,KAAOlB,QAmO1E,SAAgBG,GACd,MAAO,CACL9E,KAAMJ,EAASiK,OACf/D,IAAKhB,EAAOnD,MAAOmE,IACnBD,IAAKf,EAAOnD,MAAOkE,IACnBlE,MAAOkH,EAAY/D,EAAOnD,MAAOkE,KAErC,CAzOYD,CAAOd,GACJA,EAAOnD,MAAOkE,MAAQqE,GAxCvB,UAwC+BpF,EAAOnD,MAAOkE,UA0O3D,SAAiBf,GACf,MAAO,CACL9E,KAAMJ,EAAS+L,QACf7F,IAAKhB,EAAOnD,MAAOmE,IACnBnE,MAAOmD,EAAOnD,MAAOkE,MAAQqE,EAEjC,CA/OY0B,CAAQ9G,GACL4F,GAAazF,KAAKH,EAAOnD,MAAOkE,MAAQ8E,GAAa1F,KAAKH,EAAOnD,MAAOkE,WAgPvF,SAAkBf,EAAuBjC,GAmBvC,IAEIlB,EAFAmE,EAAMhB,EAAOnD,MAAOmE,IACpBD,EAAMf,EAAOnD,MAAOkE,IAKxB,IACGf,EAAO5C,OAAOL,MACfiD,EAAO5C,OAAOP,MAAO3B,OAASH,EAAUoG,SACxCyE,GAAazF,KAAKY,IAClB8E,GAAa1F,KAAKH,EAAO5C,OAAOP,MAAOkE,KACvC,CACA,MAAMpD,EAAQqD,EAAIrD,MAElBqC,EAAO/C,OACP+D,EAAM,CAAErD,QAAOF,IAAKuC,EAAOnD,MAAOmE,IAAIvD,KACtCsD,GAAO,IAAIf,EAAOnD,MAAOkE,KAC3B,CAEA,IAAKf,EAAO5C,OAAOL,MAAQiD,EAAO5C,OAAOP,MAAO3B,OAASH,EAAU0F,IAAK,CACtE,MAAM9C,EAAQqD,EAAIrD,MAIlB,GAFAqC,EAAO/C,OAEH+C,EAAO5C,OAAOL,MAAQiD,EAAO5C,OAAOP,MAAO3B,OAASH,EAAUoG,QAChE,MAAM,IAAIrC,EAAWf,EAAOiC,EAAOnD,MAAOmE,IAAIvD,IAAK,0CAErDuC,EAAO/C,OAEP+D,EAAM,CAAErD,QAAOF,IAAKuC,EAAOnD,MAAOmE,IAAIvD,KACtCsD,GAAO,IAAIf,EAAOnD,MAAOkE,KAC3B,CAEA,GAAK6E,GAAazF,KAAKY,GAKrBlE,EAAQ,IAAIkK,KAAKhG,EAAI4D,QAAQ,IAAK,UALP,CAE3B,MAAOqC,IAAc,IAAID,MAAOE,cAAcC,MAAM,KACpDrK,EAAQ,IAAIkK,KAAK,GAAGC,KAAcjG,IACpC,CAIA,MAAO,CACL7F,KAAMJ,EAASqM,SACfnG,MACAD,MACAlE,QAEJ,CAjTYuK,CAASpH,EAAQjC,IAErBiC,EAAO5C,OAAOL,MAAQiD,EAAO5C,OAAOP,MAAO3B,OAASH,EAAU0F,KAChE8E,GAAOpF,KAAKH,EAAOnD,MAAOkE,MAC1ByE,GAAOrF,KAAKH,EAAOnD,MAAOkE,MACzBsE,GAAMlF,KAAKH,EAAOnD,MAAOkE,OAAS0E,GAAOtF,KAAKH,EAAOnD,MAAOkE,WA8SnE,SAAef,EAAuBjC,GACpC,IAEIlB,EAFAmE,EAAMhB,EAAOnD,MAAOmE,IACpBD,EAAMf,EAAOnD,MAAOkE,IAGxB,GAAIwE,GAAOpF,KAAKY,GACdlE,EAAgB,SAARkE,GAAkBsG,IAAWA,SAChC,GAAI7B,GAAOrF,KAAKY,GACrBlE,EAAyB,SACpB,GAAKmD,EAAO5C,OAAOL,MAAQiD,EAAO5C,OAAOP,MAAO3B,OAASH,EAAU0F,IAmBxE5D,EAAQyK,OAAOvG,EAAI4D,QAAQW,GAAY,SAnBsC,CAC7E,MAAM3H,EAAQqD,EAAIrD,MASlB,GAFAqC,EAAO/C,OAEH+C,EAAO5C,OAAOL,MAAQiD,EAAO5C,OAAOP,MAAO3B,OAASH,EAAUoG,QAChE,MAAM,IAAIrC,EAAWf,EAAOiC,EAAOnD,MAAOmE,IAAIvD,IAAK,qCAErDuC,EAAO/C,OAEP8D,GAAO,IAAIf,EAAOnD,MAAOkE,MACzBC,EAAM,CAAErD,QAAOF,IAAKuC,EAAOnD,MAAOmE,IAAIvD,KACtCZ,EAAQyK,OAAOvG,EAAI4D,QAAQW,GAAY,IACzC,CAIA,MAAO,CAAEpK,KAAMJ,EAASyM,MAAOvG,MAAKD,MAAKlE,QAC3C,CA5UY2K,CAAMxH,EAAQjC,SA8U1B,SAAiBiC,GAEf,GAA0B,OAAtBA,EAAOnD,MAAOkE,KAAsC,OAAtBf,EAAOnD,MAAOkE,IAC9C,MAAO,CACL7F,KAAMJ,EAAS2M,QACfzG,IAAKhB,EAAOnD,MAAOmE,IACnBD,IAAKf,EAAOnD,MAAOkE,IACnBlE,MAAO,GAIX,IAAI6K,EAAQ,GACRjC,GAAOtF,KAAKH,EAAOnD,MAAOkE,KAC5B2G,EAAQ,GACChC,GAASvF,KAAKH,EAAOnD,MAAOkE,KACrC2G,EAAQ,EACC/B,GAAUxF,KAAKH,EAAOnD,MAAOkE,OACtC2G,EAAQ,GAGV,MAAM7K,EAAQgI,SACZ7E,EACGnD,MAAOkE,IAAI4D,QAAQW,GAAY,IAC/BX,QAAQe,GAAU,IAClBf,QAAQgB,GAAW,IACtB+B,GAGF,MAAO,CACLxM,KAAMJ,EAAS2M,QACfzG,IAAKhB,EAAOnD,MAAOmE,IACnBD,IAAKf,EAAOnD,MAAOkE,IACnBlE,QAEJ,CA9WY8K,CAAQ3H,QAEX,GAAIA,EAAOnD,MAAO3B,OAASH,EAAUuF,YA8W9C,SAAqBN,EAAuBjC,GAC1C,GAA0B,MAAtBiC,EAAOnD,MAAOkE,IAChB,MAAM,IAAIjC,EACRf,EACAiC,EAAOnD,MAAOmE,IAAIrD,MAClB,wCAAwCqC,EAAOnD,MAAOkE,OAK1D,MAAMlE,EAAqB,CACzB3B,KAAMJ,EAASiB,YACfiF,IAAKnC,EAAcmB,EAAOnD,MAAOmE,KACjCuF,MAAO,IAGTvG,EAAO/C,OAEP,MACG+C,EAAOjD,OACNiD,EAAOnD,MAAO3B,OAASH,EAAUuF,OAAyC,MAA/BN,EAAOnD,MAAgBkE,MACpE,CACA,GAAKf,EAAOnD,MAAgB3B,OAASH,EAAUyF,MAAO,CACpD,MAAMoH,EAAW/K,EAAM0J,MAAM1J,EAAM0J,MAAM7H,OAAS,GAClD,IAAKkJ,EACH,MAAM,IAAI9I,EACRf,EACAiC,EAAOnD,MAAOmE,IAAIrD,MAClB,oDAIJiK,EAASC,OAAQ,EACjBD,EAAS5G,IAAIvD,IAAMuC,EAAOnD,MAAOmE,IAAIrD,MAErCqC,EAAO/C,OACP,QACF,CAEA,MAAOiJ,GAAQF,GAAUhG,EAAQjC,GACjC,GAAImI,EAAKhL,OAASJ,EAASW,SACzB,MAAM,IAAIqD,EACRf,EACAiC,EAAOnD,MAAOmE,IAAIrD,MAClB,yDAAyDuI,EAAKhL,QAIlE,MAAM4M,EAAoC,CACxC5M,KAAMJ,EAASe,WACfmF,IAAKnC,EAAcqH,EAAKlF,KACxBkF,OACA2B,OAAO,GAGThL,EAAM0J,MAAM9H,KAAKqJ,GACjB9H,EAAO/C,MACT,CAEA,GACE+C,EAAOjD,MACPiD,EAAOnD,MAAO3B,OAASH,EAAUuF,OACD,MAA/BN,EAAOnD,MAAgBkE,IAExB,MAAM,IAAIjC,EACRf,EACAiC,EAAOjD,KAAOF,EAAMmE,IAAIrD,MAAQqC,EAAOnD,MAAOmE,IAAIrD,MAClD,uBAAuBqC,EAAOjD,KAAO,cAAgBiD,EAAOnD,MAAOkE,OAMvE,OAFAlE,EAAMmE,IAAIvD,IAAMuC,EAAOnD,MAAOmE,IAAIvD,IAE3BZ,CACT,CAvbUkL,CAAY/H,EAAQjC,OACrB,IAAIiC,EAAOnD,MAAO3B,OAASH,EAAUsF,QAM1C,MAAM,IAAIvB,EACRf,EACAiC,EAAOnD,MAAOmE,IAAIrD,MAClB,4BAA4BqC,EAAOnD,MAAO3B,6CATO,CACnD,MAAO8M,EAActB,GAubzB,SAAqB1G,EAAuBjC,GAE1C,GAA0B,MAAtBiC,EAAOnD,MAAOkE,IAChB,MAAM,IAAIjC,EACRf,EACAiC,EAAOnD,MAAOmE,IAAIrD,MAClB,wCAAwCqC,EAAOnD,MAAOkE,OAI1D,MAAMlE,EAAqB,CACzB3B,KAAMJ,EAASa,YACfqF,IAAKnC,EAAcmB,EAAOnD,MAAOmE,KACjCuF,MAAO,IAET,IAAIG,EAAsB,GAE1B1G,EAAO/C,OAEP,MACG+C,EAAOjD,OACNiD,EAAOnD,MAAO3B,OAASH,EAAUsF,SAA2C,MAA/BL,EAAOnD,MAAgBkE,MACtE,CACA,GAAKf,EAAOnD,MAAgB3B,OAASH,EAAUyF,MAAO,CACpD,MAAMoH,EAAW/K,EAAM0J,MAAM1J,EAAM0J,MAAM7H,OAAS,GAClD,IAAKkJ,EACH,MAAM,IAAI9I,EACRf,EACAiC,EAAOnD,MAAOmE,IAAIrD,MAClB,qDAIJiK,EAASC,OAAQ,EACjBD,EAAS5G,IAAIvD,IAAMuC,EAAOnD,MAAOmE,IAAIrD,KACvC,MAAO,GAAKqC,EAAOnD,MAAgB3B,OAASH,EAAUkB,QACpDyK,EAASjI,KAAKiC,GAAQV,QACjB,CACL,MAAOkG,KAAS+B,GAAuBtB,GAAU3G,EAAQjC,GACnD+J,EAA0B,CAC9B5M,KAAMJ,EAASe,WACfmF,IAAKnC,EAAcqH,EAAKlF,KACxBkF,OACA2B,OAAO,GAGThL,EAAM0J,MAAM9H,KAAKqJ,GACjBxE,EAAMoD,EAAUuB,EAClB,CAEAjI,EAAO/C,MACT,CAEA,GACE+C,EAAOjD,MACPiD,EAAOnD,MAAO3B,OAASH,EAAUsF,SACD,MAA/BL,EAAOnD,MAAgBkE,IAExB,MAAM,IAAIjC,EACRf,EACAiC,EAAOjD,KAAOF,EAAMmE,IAAIrD,MAAQqC,EAAOnD,MAAOmE,IAAIrD,MAClD,uBAAuBqC,EAAOjD,KAAO,cAAgBiD,EAAOnD,MAAOkE,OAMvE,OAFAlE,EAAMmE,IAAIvD,IAAMuC,EAAOnD,MAAOmE,IAAIvD,IAE3B,CAACZ,EAAO6J,EACjB,CA3fqCwB,CAAYlI,EAAQjC,SAE/CiK,QACCtB,CACT,CAMA,CACF,CAEA,SAAShG,GAAQV,GAGf,MAAO,CACL9E,KAAMJ,EAASmB,QACf+E,IAAKhB,EAAOnD,MAAOmE,IACnBD,IAAKf,EAAOnD,MAAOkE,IAEvB,CC3Dc,SAAUoH,GAASC,EAAqBC,GHdhD,IAAwBxL,EGqB5B,SAASyL,EAAcC,EAA2BC,GAChD,IAAK,MAAMvN,KAAQsN,EACjBE,EAAaxN,EAAMuN,EAEvB,CAEA,SAASC,EAAaxN,EAAgBuN,GACpC,MAAME,EAAQL,EAAQpN,EAAKC,MAU3B,OARIwN,GAA0B,mBAAVA,GACjBA,EAAgBzN,EAAMuN,GAGrBE,GAAUA,EAAoBC,OAC/BD,EAAoBC,MAAO1N,EAAMuN,GAG5BvN,EAAKC,MACX,KAAKJ,EAASK,SACZmN,EAAerN,EAAkBsL,MAAOtL,GACxC,MAEF,KAAKH,EAASO,MACZoN,EAAcxN,EAAewH,IAAKxH,GAClCqN,EAAerN,EAAesL,MAAOtL,GACrC,MACF,KAAKH,EAASsB,SACZqM,EAAcxN,EAAkBiL,KAAMjL,GACtC,MAEF,KAAKH,EAASS,WACZkN,EAAcxN,EAAoBwH,IAAKxH,GACvCqN,EAAerN,EAAoBsL,MAAOtL,GAC1C,MACF,KAAKH,EAASwB,cACZmM,EAAcxN,EAAuBiL,KAAMjL,GAC3C,MAEF,KAAKH,EAASW,SACZgN,EAAcxN,EAAkBwH,IAAKxH,GACrCwN,EAAcxN,EAAkB4B,MAAO5B,GACvC,MAEF,KAAKH,EAASa,YACZ2M,EAAerN,EAAqBsL,MAAOtL,GAC3C,MACF,KAAKH,EAASe,WACZ4M,EAAcxN,EAAoBiL,KAAMjL,GACxC,MAEF,KAAKH,EAASiB,YACZuM,EAAerN,EAAqBsL,MAAOtL,GAC3C,MAEF,KAAKH,EAASqL,IACd,KAAKrL,EAASiK,OACd,KAAKjK,EAAS2M,QACd,KAAK3M,EAASyM,MACd,KAAKzM,EAAS+L,QACd,KAAK/L,EAASqM,SACd,KAAKrM,EAASmB,QACZ,MAEF,QACE,MAAM,IAAI8C,MAAM,2BAA2B9D,EAAKC,SAGhDwN,GAAUA,EAAoBE,MAC/BF,EAAoBE,KAAM3N,EAAMuN,EAErC,CH1FgB,OADY3L,EGebuL,IHd2C,mBAA3BvL,EAAMQ,OAAOX,UGe1C4L,EAAcF,EAAK,MAEnBK,EAAaL,EAAK,KA0EtB,CCjFA,MAAMS,GAAwC,IAAIC,QAC5CC,GAAmBC,IAClBH,GAActG,IAAIyG,IACrBH,GAAcI,IAAID,EAAM,IAAIF,SAEvBD,GAAcK,IAAIF,IAGrBG,GAAuC,IAAIL,QAC3CM,GAAkBJ,IACjBG,GAAa5G,IAAIyG,IACpBG,GAAaF,IAAID,EAAM,IAAIF,SAEtBK,GAAaD,IAAIF,IAGpB,SAAUrE,GAAQqE,EAAYR,EAAkBa,EAAoBC,GAGxE,GAAIpN,EAASsM,GAAS,CAEpB,MAAM5L,EAAQ4L,EAAOjC,MAAMgD,QAAQF,GACnC,GAAIzM,EAAQ,EACV,MAAM,IAAImC,MAAM,2DAGlByJ,EAAOjC,MAAMiD,OAAO5M,EAAO,EAAG0M,EAKhC,MAAO,GAAI9N,EAAWgN,IAAW1M,EAAc0M,EAAO3L,SAAWf,EAAcuN,GAAW,CAExF,MAAMzM,EAAQ4L,EAAO3L,MAAM0J,MAAMgD,QAAQF,GACzC,GAAIzM,EAAQ,EACV,MAAM,IAAImC,MAAM,2DAElByJ,EAAO3L,MAAM0J,MAAMiD,OAAO5M,EAAO,EAAG0M,EAEtC,MAAO,GAAInN,EAAQqM,GAEjBA,EAAOtC,KAAOoD,MAET,KAAI9N,EAAWgN,GASpB,MAAM,IAAIzJ,MAAM,4BAA4ByJ,EAAOtN,qBAP/CsN,EAAO/F,MAAQ4G,EACjBb,EAAO/F,IAAM6G,EAEbd,EAAO3L,MAAQyM,CAKnB,CAOAG,GAAUH,EAJI,CACZ9L,MAAO6L,EAASrI,IAAIrD,MAAMD,KAAO4L,EAAYtI,IAAIrD,MAAMD,KACvDE,QAASyL,EAASrI,IAAIrD,MAAME,OAASyL,EAAYtI,IAAIrD,MAAME,SAK7D,MAAM6L,EAAgBpM,EAAQ+L,EAASrI,KACjC2I,EAAmBrM,EAAQgM,EAAYtI,KAM7C4I,GALe,CACbpM,MAAOmM,EAAiBnM,MAAQkM,EAAclM,MAC9CI,QAAS+L,EAAiB/L,QAAU8L,EAAc9L,SAGlCwL,GAAeJ,GAAOM,EAAaD,EACvD,CAEM,SAAUQ,GAAOb,EAAYR,EAAkBsB,EAAiBlN,GACpE,IAAKV,EAASsM,GACZ,MAAM,IAAIzJ,MAAM,4BAA6ByJ,EAAoBtN,oBAKnE,IAAI6O,EACAC,EAHJpN,EAAkB,MAATA,GAAkC,iBAAVA,EAAsBA,EAAQ4L,EAAOjC,MAAM7H,OAIxEhD,EAAc8M,IAAW1M,EAAc0M,KACtCuB,QAAOC,UAwFd,SACExB,EACAsB,EACAlN,GAEA,IAAKhB,EAAakO,GAChB,MAAM,IAAI/K,MAAM,4BAA6B+K,EAAmB5O,SAIlE,MAAM0M,EAAoB,MAAThL,EAAgB4L,EAAOjC,MAAM3J,EAAQ,GAAKgF,EAAK4G,EAAOjC,OACjE0D,EAAmB,MAATrN,GAAiBA,IAAU4L,EAAOjC,MAAM7H,OAExD8J,EAAOjC,MAAMiD,OAAO5M,EAAO,EAAGkN,GAG9B,MAAMI,IAAgCtC,EAChCuC,GAA8BF,EAC9BG,EAAqBH,IAA2B,IAAhBH,EAAMjC,MACxCqC,IACFtC,EAAUC,OAAQ,GAEhBsC,IACFL,EAAMjC,OAAQ,GAKhB,MAAMwC,EAAe3O,EAAc8M,IA8SrC,SAAiBD,GACf,IAAKA,EAAMhC,MAAM7H,OAAQ,OAAO,EAGhC,OADapB,EAAQiL,EAAMvH,KACfxD,MAAQ+K,EAAMhC,MAAM7H,MAClC,CAnTgD4L,CAAQ9B,GAIhD7K,EAAQiK,EACV,CACAlK,KAAMkK,EAAS5G,IAAIvD,IAAIC,KACvBG,OAAQwM,EACHrO,EAAU4L,GAETY,EAAOxH,IAAIrD,MAAME,OADjB+J,EAAS5G,IAAIrD,MAAME,OAErB+J,EAAS5G,IAAIvD,IAAII,QAErBc,EAAc6J,EAAOxH,IAAIrD,OAE7B,IAAI4M,EAAgB,EACpB,GAAIF,EACFE,EAAgB,MACX,CACL,MAAMC,EAAa,EACbC,EAAe,EACrB9M,EAAME,QAAUqM,EAA8BM,EAAaC,CAC7D,CACA9M,EAAMD,MAAQ6M,EAEd,MAAMR,EAAQ,CACZvM,MAAOG,EAAMD,KAAOoM,EAAM9I,IAAIrD,MAAMD,KACpCE,QAASD,EAAME,OAASiM,EAAM9I,IAAIrD,MAAME,QAIpC6M,EAAapN,EAAQwM,EAAM9I,KAC3BgJ,EAAS,CACbxM,MAAOkN,EAAWlN,OAAS+M,EAAgB,GAC3C3M,QAAS8M,EAAW9M,SAAWsM,GAA+BC,EAA6B,EAAI,IAAMC,EAAqB,EAAI,IAGhI,MAAO,CAAEL,QAAOC,SAClB,CA1JyBW,CAAanC,EAAQsB,EAAqBlN,MAE5DmN,QAAOC,UAyBd,SACExB,EACAsB,EACAlN,GAEA,GTgKsB3B,EShKT6O,ITiKNtO,EAAWP,IAASG,EAAQH,IAASK,EAAaL,IAASe,EAAUf,IShK1E,MAAM,IAAI8D,MAAM,4BAA6B+K,EAAmB5O,ST+J9D,IAAkBD,ES5JtB,MAAM2M,EAAWY,EAAOjC,MAAM3J,EAAQ,GAChCgO,EAAiB5P,EAAWwN,KAAYA,EAAOjC,MAAM7H,OAE3D8J,EAAOjC,MAAMiD,OAAO5M,EAAO,EAAGkN,GAI9B,MAAMnM,EAAQiK,EACV,CACAlK,KAAMkK,EAAS5G,IAAIvD,IAAIC,KACvBG,OAAS7B,EAAU4L,GAAwCY,EAAOxH,IAAIrD,MAAME,OAA7C+J,EAAS5G,IAAIrD,MAAME,QAElDc,EAAc6J,EAAOxH,IAAIrD,OAEvBkN,EAAWzP,EAAQ0O,IAAUxO,EAAawO,GAChD,IAAIS,EAAgB,EAChBK,IAGFL,EADSM,EACO,EAEA,GAElBlN,EAAMD,MAAQ6M,EAEd,MAAMR,EAAQ,CACZvM,MAAOG,EAAMD,KAAOoM,EAAM9I,IAAIrD,MAAMD,KACpCE,QAASD,EAAME,OAASiM,EAAM9I,IAAIrD,MAAME,QAIpC6M,EAAapN,EAAQwM,EAAM9I,KAC3BgJ,EAAS,CACbxM,MAAOkN,EAAWlN,OAAS+M,EAAgB,GAC3C3M,QAAS8M,EAAW9M,SAGtB,MAAO,CAAEmM,QAAOC,SAClB,CAxEyBc,CACnBtC,EACAsB,EACAlN,IAIJ6M,GAAUK,EAAOC,GAKjB,MAAMnC,EAAWY,EAAOjC,MAAM3J,EAAQ,GAChCmO,EAAkBnD,GAAYwB,GAAeJ,GAAME,IAAItB,GACzDmD,IACFf,EAAOxM,OAASuN,EAAgBvN,MAChCwM,EAAOpM,SAAWmN,EAAgBnN,QAElCwL,GAAeJ,GAAMgC,OAAOpD,IAGdwB,GAAeJ,GACvBC,IAAIa,EAAOE,EACrB,UAmIgBiB,GAAOjC,EAAYR,EAAkBvN,GAcnD,IAAKiB,EAASsM,GACZ,MAAM,IAAIzJ,MAAM,4BAA4ByJ,EAAOtN,oBAGrD,IAAI0B,EAAQ4L,EAAOjC,MAAMgD,QAAQtO,GACjC,GAAI2B,EAAQ,EAAG,CAIb,GAFAA,EAAQ4L,EAAOjC,MAAMpI,WAAU+H,GAAQ/J,EAAQ+J,IAASA,EAAKA,OAASjL,IAElE2B,EAAQ,EACV,MAAM,IAAImC,MAAM,6CAGlB9D,EAAOuN,EAAOjC,MAAM3J,EACtB,CAEA,MAAMgL,EAAWY,EAAOjC,MAAM3J,EAAQ,GACtC,IAAIK,EAAOuL,EAAOjC,MAAM3J,EAAQ,GAGhC4L,EAAOjC,MAAMiD,OAAO5M,EAAO,GAC3B,IAAIsO,EAAe5N,EAAQrC,EAAK+F,KAU5B/D,GAAQjB,EAAUiB,IAASA,EAAK+D,IAAIrD,MAAMD,OAASzC,EAAK+F,IAAIvD,IAAIC,OAElEwN,EAAe5N,EAAQ,CAAEK,MAAO1C,EAAK+F,IAAIrD,MAAOF,IAAKR,EAAK+D,IAAIvD,MAI9DR,EAAOuL,EAAOjC,MAAM3J,EAAQ,GAG5B4L,EAAOjC,MAAMiD,OAAO5M,EAAO,IAI7B,MAAMuO,EAAYvD,GAAYhM,EAAagM,IAAa3K,GAAQrB,EAAaqB,GACvEmO,EAAwBxD,GAAYA,EAAS5G,IAAIvD,IAAIC,OAASzC,EAAK+F,IAAIrD,MAAMD,KAC7E2N,EAAmBpO,GAAQA,EAAK+D,IAAIrD,MAAMD,OAASzC,EAAK+F,IAAIvD,IAAIC,KAChE4N,EAAYH,IAAcC,GAAyBC,GAEnDrB,EAAS,CACbxM,QAAS0N,EAAa1N,OAAS8N,EAAY,EAAI,IAC/C1N,SAAUsN,EAAatN,SAIrBuN,GAAaC,IACfpB,EAAOpM,SAAW,GAIhBuN,IAAcvD,GAAY3K,IAC5B+M,EAAOpM,SAAW,GAGhBuN,GAAavD,IAAa3K,IAC3B2K,EAA+CC,OAAQ,GAI1D,MAAMtE,EAASqE,GAAYY,EACrB+C,EAAiB3D,EAAWwB,GAAeJ,GAAQD,GAAgBC,GACnEwC,EAAepC,GAAeJ,GAC9B+B,EAAkBQ,EAAerC,IAAI3F,GACvCwH,IACFf,EAAOxM,OAASuN,EAAgBvN,MAChCwM,EAAOpM,SAAWmN,EAAgBnN,SAEpC,MAAM6N,EAAiBD,EAAatC,IAAIjO,GACpCwQ,IACFzB,EAAOxM,OAASiO,EAAejO,MAC/BwM,EAAOpM,SAAW6N,EAAe7N,SAGnC2N,EAAetC,IAAI1F,EAAQyG,EAC7B,CAEM,SAAU0B,GACd1C,EACA/N,EACA0Q,GAA2B,GAG3B,IAAKA,EAAiB,OACtB,IAAK1Q,EAAKsL,MAAM7H,OAAQ,OAGxBkL,GAAU,CAAEpM,MAAO,EAAGI,QAAS,GAAKmL,GAAgBC,GAAO/N,GAG3D,MAAM2Q,EAAYhK,EAAK3G,EAAKsL,OAC5BqD,GAAU,CAAEpM,MAAO,EAAGI,QAAS,GAAKwL,GAAeJ,GAAO4C,EAC5D,CAEM,SAAUC,GACd7C,EACA/N,EACA6Q,GAA2B,GAG3B,IAAKA,EAAiB,OACtB,IAAK7Q,EAAKsL,MAAM7H,OAAQ,OAExB,MAAMkN,EAAYhK,EAAK3G,EAAKsL,OAC5BqF,EAAU/D,OAAQ,EAElB+B,GAAU,CAAEpM,MAAO,EAAGI,QAAS,GAAKwL,GAAeJ,GAAO4C,EAC5D,CAUM,SAAUG,GAAY/C,GAC1B,MAAML,EAAQI,GAAgBC,GACxBJ,EAAOQ,GAAeJ,GAEtBgB,EAAkE,CACtExM,MAAO,EACPI,QAAS,CAAA,GAGX,SAASoO,EAAW/Q,GAElB,MAAMgR,EAAajC,EAAOxM,MAC1BvC,EAAK+F,IAAIrD,MAAMD,MAAQuO,EAEvB,MAAMC,EAAelC,EAAOpM,QAAQ3C,EAAK+F,IAAIrD,MAAMD,OAAS,EAC5DzC,EAAK+F,IAAIrD,MAAME,QAAUqO,EAEzB,MAAMC,EAAWxD,EAAMO,IAAIjO,GACvBkR,IACFnC,EAAOxM,OAAS2O,EAAS3O,MACzBwM,EAAOpM,QAAQ3C,EAAK+F,IAAIrD,MAAMD,OAC3BsM,EAAOpM,QAAQ3C,EAAK+F,IAAIrD,MAAMD,OAAS,GAAKyO,EAASvO,QAE5D,CAEA,SAASwO,EAASnR,GAEhB,MAAMgR,EAAajC,EAAOxM,MAC1BvC,EAAK+F,IAAIvD,IAAIC,MAAQuO,EAErB,MAAMC,EAAelC,EAAOpM,QAAQ3C,EAAK+F,IAAIvD,IAAIC,OAAS,EAC1DzC,EAAK+F,IAAIvD,IAAII,QAAUqO,EAEvB,MAAMG,EAAUzD,EAAKM,IAAIjO,GACrBoR,IACFrC,EAAOxM,OAAS6O,EAAQ7O,MACxBwM,EAAOpM,QAAQ3C,EAAK+F,IAAIvD,IAAIC,OACzBsM,EAAOpM,QAAQ3C,EAAK+F,IAAIvD,IAAIC,OAAS,GAAK2O,EAAQzO,QAEzD,CAEA,MAAM0O,EAAgB,CACpB3D,MAAOqD,EACPpD,KAAMwD,GAGRjE,GAASa,EAAM,CACb,CAAClO,EAASK,UAAWmR,EACrB,CAACxR,EAASO,OAAQiR,EAClB,CAACxR,EAASS,YAAa+Q,EACvB,CAACxR,EAASiB,aAAcuQ,EACxB,CAACxR,EAASa,aAAc2Q,EAExB,CAACxR,EAASe,YAAayQ,EACvB,CAACxR,EAASsB,UAAWkQ,EACrB,CAACxR,EAASwB,eAAgBgQ,EAE1B,CAACxR,EAASW,UAAW,CACnB,KAAAkN,CAAM1N,GACJ,MAAMsR,EAAatR,EAAK+F,IAAIrD,MAAMD,KAAOsM,EAAOxM,MAC1CgP,EAAa5D,EAAKM,IAAIjO,EAAKwH,KACjCxH,EAAKwL,SAAWuD,EAAOpM,QAAQ2O,IAAe,IAAMC,EAAaA,EAAW5O,QAAU,GAEtFoO,EAAW/Q,EACb,EACA2N,KAAMwD,GAGR,CAACtR,EAASqL,KAAMmG,EAChB,CAACxR,EAASiK,QAASuH,EACnB,CAACxR,EAAS2M,SAAU6E,EACpB,CAACxR,EAASyM,OAAQ+E,EAClB,CAACxR,EAAS+L,SAAUyF,EACpB,CAACxR,EAASqM,UAAWmF,EACrB,CAACxR,EAASmB,SAAUqQ,IAGtBzD,GAAcmC,OAAOhC,GACrBG,GAAa6B,OAAOhC,EACtB,CAEM,SAAUS,GACdxO,EACAwR,EACAC,EAAyC,CAAA,GAEzC,MAAMC,gBAAEA,GAAkB,GAAUD,EAC9BH,EAAatR,EAAK+F,IAAIrD,MAAMD,MAC5BF,MAAEA,EAAKI,QAAEA,GAAY6O,EACrBG,EAAQ3R,IACP0R,GAAmB1R,EAAK+F,IAAIrD,MAAMD,OAAS6O,IAC9CtR,EAAK+F,IAAIrD,MAAME,QAAUD,EACzB3C,EAAK+F,IAAIvD,IAAII,QAAUD,GAEzB3C,EAAK+F,IAAIrD,MAAMD,MAAQF,EACvBvC,EAAK+F,IAAIvD,IAAIC,MAAQF,CAAK,EAwB5B,OArBA2K,GAASlN,EAAM,CACb,CAACH,EAASO,OAAQuR,EAClB,CAAC9R,EAASsB,UAAWwQ,EACrB,CAAC9R,EAASS,YAAaqR,EACvB,CAAC9R,EAASwB,eAAgBsQ,EAC1B,CAAC9R,EAASW,UAAUR,GAClB2R,EAAK3R,GACLA,EAAKwL,QAAU7I,CACjB,EACA,CAAC9C,EAASqL,KAAMyG,EAChB,CAAC9R,EAASiK,QAAS6H,EACnB,CAAC9R,EAAS2M,SAAUmF,EACpB,CAAC9R,EAASyM,OAAQqF,EAClB,CAAC9R,EAAS+L,SAAU+F,EACpB,CAAC9R,EAASqM,UAAWyF,EACrB,CAAC9R,EAASa,aAAciR,EACxB,CAAC9R,EAASe,YAAa+Q,EACvB,CAAC9R,EAASiB,aAAc6Q,EACxB,CAAC9R,EAASmB,SAAU2Q,IAGf3R,CACT,CASA,SAAS2O,GAAUI,EAAc6C,EAAkB5R,EAAgB6R,GACjE,MAAM/B,EAAkB8B,EAAQ3D,IAAI4D,GAAQ7R,GACxC8P,IACFf,EAAOxM,OAASuN,EAAgBvN,MAChCwM,EAAOpM,SAAWmN,EAAgBnN,SAGpCiP,EAAQ5D,IAAIhO,EAAM+O,EACpB,UC1hBgB+C,KACd,MAAO,CACL7R,KAAMJ,EAASK,SACf6F,IAAK,CAAErD,MP4DF,CAAED,KAAM,EAAGG,OAAQ,GO5DFJ,IP4DjB,CAAEC,KAAM,EAAGG,OAAQ,IO3DxB0I,MAAO,GAEX,CAEM,SAAUyG,GAAcvK,GAC5B,MAAMwK,EAUF,SAA2BxK,GAC/B,MAAM1B,EAAMmM,GAAczK,GAE1B,MAAO,CACLvH,KAAMJ,EAASsB,SACf4E,IAAK,CACHrD,MPsCG,CAAED,KAAM,EAAGG,OAAQ,GOrCtBJ,IAAK,CAAEC,KAAM,EAAGG,OAAQkD,EAAIrC,OAAS,IAEvCwH,KAAM,CACJhL,KAAMJ,EAASqL,IACfnF,IAAK,CACHrD,MAAO,CAAED,KAAM,EAAGG,OAAQ,GAC1BJ,IAAK,CAAEC,KAAM,EAAGG,OAAQkD,EAAIrC,OAAS,IAEvC7B,MAAO4F,EACP1B,OAGN,CA7BoBoM,CAAiB1K,GAEnC,MAAO,CACLvH,KAAMJ,EAASO,MACf2F,IAAKnC,EAAcoO,EAAUjM,KAC7ByB,IAAKwK,EACL1G,MAAO,GAEX,CAuBM,SAAU6G,GAAmB3K,GACjC,MAAM4K,EAUF,SAAgC5K,GACpC,MAAM1B,EAAMmM,GAAczK,GAE1B,MAAO,CACLvH,KAAMJ,EAASwB,cACf0E,IAAK,CACHrD,MPMG,CAAED,KAAM,EAAGG,OAAQ,GOLtBJ,IAAK,CAAEC,KAAM,EAAGG,OAAQkD,EAAIrC,OAAS,IAEvCwH,KAAM,CACJhL,KAAMJ,EAASqL,IACfnF,IAAK,CACHrD,MAAO,CAAED,KAAM,EAAGG,OAAQ,GAC1BJ,IAAK,CAAEC,KAAM,EAAGG,OAAQkD,EAAIrC,OAAS,IAEvC7B,MAAO4F,EACP1B,OAGN,CA7B0BuM,CAAsB7K,GAE9C,MAAO,CACLvH,KAAMJ,EAASS,WACfyF,IAAKnC,EAAcwO,EAAgBrM,KACnCyB,IAAK4K,EACL9G,MAAO,GAEX,CAuBM,SAAUgH,GAAiB9K,EAAe5F,GAC9C,MAAM2Q,EA4BF,SAAsB3Q,GAC1B,MAAMkE,EAAMmM,GAAcrQ,GAE1B,MAAO,CACL3B,KAAMJ,EAASqL,IACfnF,IAAK,CAAErD,MP3CF,CAAED,KAAM,EAAGG,OAAQ,GO2CFJ,IAAK,CAAEC,KAAM,EAAGG,OAAQkD,EAAIrC,SAClDqC,MACAlE,QAEJ,CArCmB4Q,CAAYhL,IACvB5E,OAAEA,GAAW2P,EAASxM,IAAIvD,IAE1BgJ,EAAS5I,EAAS,EAQxB,OANA4L,GACE5M,EACA,CAAEW,MAAO,EAAGI,QAASC,EAAS,EAAIhB,EAAMmE,IAAIrD,MAAME,QAClD,CAAE8O,iBAAiB,IAGd,CACLzR,KAAMJ,EAASW,SACfuF,IAAK,CACHrD,MAAOgB,EAAc6O,EAASxM,IAAIrD,OAClCF,IAAKkB,EAAc9B,EAAMmE,IAAIvD,MAE/BgF,IAAK+K,EACL/G,SACA5J,QAEJ,CAEA,MAAM6Q,GAAc,iBACpB,SAASR,GAAcrQ,GACrB,OAAOA,EAAMqG,KAAIyK,GAASD,GAAYvN,KAAKwN,GAAQA,EAAOxK,KAAKC,UAAUuK,KAAQtK,KAAK,IACxF,CAyEM,SAAUuK,GAAmB1H,GACjC,MAAO,CACLhL,KAAMJ,EAASe,WACfmF,IAAKnC,EAAcqH,EAAKlF,KACxBkF,OACA2B,OAAO,EAEX,CCpLM,SAAUgG,GAAeC,GA0B7B,OAzB0BA,EAASvH,MAAMwH,QAAO7H,IAC9C,IAAK1K,EAAW0K,GAAO,OAAO,EAE9B,MAAM8H,EAAkBlS,EAAcoK,EAAKrJ,OACrCoR,EACJvS,EAAcwK,EAAKrJ,QACnBqJ,EAAKrJ,MAAM0J,MAAM7H,QACjB5C,EAAcoK,EAAKrJ,MAAM0J,MAAM,GAAGL,MAEpC,OAAO8H,GAAmBC,CAAe,IAGzBC,SAAQjT,IACxBgQ,GAAO6C,EAAUA,EAAU7S,GAEvBa,EAAcb,EAAK4B,OACrBgN,GAAOiE,EAAUA,EAYvB,SAAqBK,GACnB,MAAM3H,EAAQwG,GAAcmB,EAAU1L,IAAI5F,OAE1C,IAAK,MAAMqJ,KAASiI,EAAUtR,MAAsB0J,MAClDsD,GAAOrD,EAAOA,EAAON,EAAKA,MAI5B,OADA6F,GAAYvF,GACLA,CACT,CArBiC4H,CAAYnT,IAuB7C,SAA0BkT,GACxB,MAAMnF,EAAO+D,KAEb,IAAK,MAAMsB,KAAsBF,EAAUtR,MAAsB0J,MAAO,CACtE,MAAM+H,EAAclB,GAAmBe,EAAU1L,IAAI5F,OACrDgN,GAAOb,EAAMA,EAAMsF,GAEnB,IAAK,MAAMC,KAAsBF,EAAkBnI,KAAqBK,MACtEsD,GAAOb,EAAMsF,EAAaC,EAAkBrI,KAEhD,CAGA,OADA6F,GAAY/C,GACLA,EAAKzC,KACd,CAnCMiI,CAAiBvT,GAAMiT,SAAQI,IAC7BzE,GAAOiE,EAAUA,EAAUQ,EAAY,GAE3C,IAGFvC,GAAY+B,GACLA,CACT,CAkCM,SAAUW,GAAiBX,GAC/B,IAAI/D,EAAQ,EACRnC,EAAW,EACf,IAAK,MAAM1B,KAAQ4H,EAASvH,MACT,IAAbqB,GAAkB1B,EAAKlF,IAAIrD,MAAMD,KAAO,EAE1CqM,EAAQ,EAAI7D,EAAKlF,IAAIrD,MAAMD,KAClBwI,EAAKlF,IAAIrD,MAAMD,KAAOqM,EAAQnC,EAAW,IAClDmC,GAASnC,EAAW,GAAK1B,EAAKlF,IAAIrD,MAAMD,KAAOqM,IAGjDN,GAAUvD,EAAM,CACd1I,MAAOuM,EACPnM,QAAS,IAEXgK,EAAW1B,EAAKlF,IAAIvD,IAAIC,KAG1B,OAAOoQ,CACT,CCrFA,MAAMY,GAAiB,CACrBC,WAAY,GACZC,eAAe,EACfC,gBAAgB,GAGJ,SAAUC,GAAQjS,EAAYkS,EAAiB,IAC3DA,EAAShN,OAAOiN,OAAO,CAAA,EAAIN,GAAgBK,GAI3ClS,EAyBF,SAAyBA,GACvB,IAAIK,EAA8B,CAAA,EAGlC,IAAK,MAAMuF,KAAO5F,EACXyF,EAASzF,EAAM4F,KAAUzE,MAAMC,QAAQpB,EAAM4F,MAChDvF,EAAOuF,GAAO5F,EAAM4F,IAKxB,IAAK,MAAMA,KAAO5F,GACZyF,EAASzF,EAAM4F,KAASzE,MAAMC,QAAQpB,EAAM4F,OAC9CvF,EAAOuF,GAAO5F,EAAM4F,IAIxB,OAAOvF,CACT,CA3CU+R,CAHRpS,EAAQqS,GAAOrS,IAKf,MAAMiR,EAAWf,KACjB,IAAK,MAAM7G,KAAQiJ,GAAWtS,EAAOkS,GACnClF,GAAOiE,EAAUA,EAAU5H,GAE7B6F,GAAY+B,GAKZ,MAAMsB,EAAYzM,EAChBmL,EACAD,IACAC,GDoCE,SAA2BA,GAE/B,OAAOA,CACT,CCvCgBuB,CAAiBvB,IAC7BW,IAGF,OAAOW,CACT,CA0BA,SAAUD,GAAW3M,EAAauM,GAChC,IAAK,MAAMtM,KAAOV,OAAOiB,KAAKR,SACtB+K,GAAiB,CAAC9K,GAAMkE,GAAUnE,EAAOC,GAAMsM,GAEzD,CAEA,SAASpI,GAAU9J,EAAYkS,GAC7B,GAAa,MAATlS,EACF,MAAM,IAAIkC,MAAM,mDAGlB,OP1EI,SAAmBlC,GACvB,MAAwB,iBAAVA,CAChB,COwEMyS,CAASzS,GFmDT,SAAyBA,GAC7B,MAAMkE,EAAMoC,KAAKC,UAAUvG,GAE3B,MAAO,CACL3B,KAAMJ,EAASiK,OACf/D,IAAK,CAAErD,MPtDF,CAAED,KAAM,EAAGG,OAAQ,GOsDFJ,IAAK,CAAEC,KAAM,EAAGG,OAAQkD,EAAIrC,SAClDqC,MACAlE,QAEJ,CE3DW0S,CAAe1S,GACboF,EAAUpF,GF4DjB,SAA0BA,GAC9B,MAAMkE,EAAMlE,EAAMuF,WAElB,MAAO,CACLlH,KAAMJ,EAAS2M,QACfzG,IAAK,CAAErD,MPjEF,CAAED,KAAM,EAAGG,OAAQ,GOiEFJ,IAAK,CAAEC,KAAM,EAAGG,OAAQkD,EAAIrC,SAClDqC,MACAlE,QAEJ,CEpEW2S,CAAgB3S,GPrErB,SAAkBA,GACtB,MAAwB,iBAAVA,IAAuBoF,EAAUpF,EACjD,COoEa4S,CAAQ5S,GFqEf,SAAwBA,GAC5B,MAAMkE,EAAMlE,EAAMuF,WAElB,MAAO,CACLlH,KAAMJ,EAASyM,MACfvG,IAAK,CAAErD,MP5EF,CAAED,KAAM,EAAGG,OAAQ,GO4EFJ,IAAK,CAAEC,KAAM,EAAGG,OAAQkD,EAAIrC,SAClDqC,MACAlE,QAEJ,CE7EW6S,CAAc7S,GPnEnB,SAAoBA,GACxB,MAAwB,kBAAVA,CAChB,COkEa8S,CAAU9S,GF8EjB,SAA0BA,GAC9B,MAAO,CACL3B,KAAMJ,EAAS+L,QACf7F,IAAK,CAAErD,MPrFF,CAAED,KAAM,EAAGG,OAAQ,GOqFFJ,IAAK,CAAEC,KAAM,EAAGG,OAAQhB,EAAQ,EAAI,IAC1DA,QAEJ,CEnFW+S,CAAgB/S,GACdqF,EAAOrF,GFoFd,SAA2BA,GAC/B,MAAMkE,EAAMlE,EAAMoK,cAElB,MAAO,CACL/L,KAAMJ,EAASqM,SACfnG,IAAK,CAAErD,MP/FF,CAAED,KAAM,EAAGG,OAAQ,GO+FFJ,IAAK,CAAEC,KAAM,EAAGG,OAAQkD,EAAIrC,SAClDqC,MACAlE,QAEJ,CE5FWgT,CAAiBhT,GACfmB,MAAMC,QAAQpB,GAO3B,SAAyBA,EAAmBkS,GAC1C,MAAM/G,EFsFC,CACL9M,KAAMJ,EAASa,YACfqF,IAAK,CAAErD,MPxGF,CAAED,KAAM,EAAGG,OAAQ,GOwGFJ,IAAK,CAAEC,KAAM,EAAGG,OAAQ,IAC9C0I,MAAO,IExFT,IAAK,MAAMuJ,KAAWjT,EAAO,CAI3BgN,GAAO7B,EAAcA,EAFK4F,GADbjH,GAAUmJ,EAASf,IAIlC,CAKA,OAJArD,GAAoB1D,EAAcA,EAAc+G,EAAOF,gBACvDhD,GAAmB7D,EAAcA,EAAc+G,EAAOH,eACtD7C,GAAY/D,GAELA,CACT,CAnBW+H,CAAgBlT,EAAOkS,GAqBlC,SAAyBlS,EAAekS,GAEtC,GADAlS,EAAQqS,GAAOrS,IACVyF,EAASzF,GAAQ,OAAO8J,GAAU9J,EAAOkS,GAE9C,MAAMiB,EFqFC,CACL9U,KAAMJ,EAASiB,YACfiF,IAAK,CAAErD,MPzHF,CAAED,KAAM,EAAGG,OAAQ,GOyHFJ,IAAK,CAAEC,KAAM,EAAGG,OAAQ,IAC9C0I,MAAO,IEvFHA,EAAQ,IAAI4I,GAAWtS,EAAOkS,IACpC,IAAK,MAAM7I,KAAQK,EAAO,CAGxBsD,GAAOmG,EAAcA,EAFKpC,GAAmB1H,GAG/C,CAKA,OAJAwF,GAAoBsE,EAAcA,EAAcjB,EAAOF,gBACvDhD,GAAmBmE,EAAcA,EAAcjB,EAAOH,eACtD7C,GAAYiE,GAELA,CACT,CAnCWC,CAAgBpT,EAAOkS,EAElC,CAyCA,SAASG,GAAOrS,GAEd,OAAKA,EAKDqF,EAAOrF,GACFA,EAImB,mBAAjBA,EAAMqS,OACRrS,EAAMqS,SAIRrS,EAdEA,CAeX,CCzJA,MAAMwB,GAAc,aAEN,SAAU6R,GAAO9H,EAAU+H,EAAkB,MACzD,MAAM3S,EAAkB,GAqExB,OAnEA2K,GAASC,EAAK,CACZ,CAACtN,EAASsB,UAAUnB,GAClB,MAAM0C,MAAEA,EAAKF,IAAEA,GAAQxC,EAAK+F,IAE5BoP,GAAM5S,EAAO,CAAEG,QAAOF,IAAK,CAAEC,KAAMC,EAAMD,KAAMG,OAAQF,EAAME,OAAS,IAAO,KAC7EuS,GAAM5S,EAAO,CAAEG,MAAO,CAAED,KAAMD,EAAIC,KAAMG,OAAQJ,EAAII,OAAS,GAAKJ,OAAO,IAC3E,EACA,CAAC3C,EAASwB,eAAerB,GACvB,MAAM0C,MAAEA,EAAKF,IAAEA,GAAQxC,EAAK+F,IAE5BoP,GAAM5S,EAAO,CAAEG,QAAOF,IAAK,CAAEC,KAAMC,EAAMD,KAAMG,OAAQF,EAAME,OAAS,IAAO,MAC7EuS,GAAM5S,EAAO,CAAEG,MAAO,CAAED,KAAMD,EAAIC,KAAMG,OAAQJ,EAAII,OAAS,GAAKJ,OAAO,KAC3E,EAEA,CAAC3C,EAASW,UAAUR,GAClB,MACE0C,OAAOD,KAAEA,IACPzC,EAAK+F,IACToP,GACE5S,EACA,CAAEG,MAAO,CAAED,OAAMG,OAAQ5C,EAAKwL,QAAUhJ,IAAK,CAAEC,OAAMG,OAAQ5C,EAAKwL,OAAS,IAC3E,IAEJ,EACA,CAAC3L,EAASqL,KAAKlL,GACbmV,GAAM5S,EAAOvC,EAAK+F,IAAK/F,EAAK8F,IAC9B,EAEA,CAACjG,EAASiK,QAAQ9J,GAChBmV,GAAM5S,EAAOvC,EAAK+F,IAAK/F,EAAK8F,IAC9B,EACA,CAACjG,EAAS2M,SAASxM,GACjBmV,GAAM5S,EAAOvC,EAAK+F,IAAK/F,EAAK8F,IAC9B,EACA,CAACjG,EAASyM,OAAOtM,GACfmV,GAAM5S,EAAOvC,EAAK+F,IAAK/F,EAAK8F,IAC9B,EACA,CAACjG,EAAS+L,SAAS5L,GACjBmV,GAAM5S,EAAOvC,EAAK+F,IAAK/F,EAAK4B,MAAMuF,WACpC,EACA,CAACtH,EAASqM,UAAUlM,GAClBmV,GAAM5S,EAAOvC,EAAK+F,IAAK/F,EAAK8F,IAC9B,EAEA,CAACjG,EAASa,aAAaV,GACrB,MAAM0C,MAAEA,EAAKF,IAAEA,GAAQxC,EAAK+F,IAC5BoP,GAAM5S,EAAO,CAAEG,QAAOF,IAAK,CAAEC,KAAMC,EAAMD,KAAMG,OAAQF,EAAME,OAAS,IAAO,KAC7EuS,GAAM5S,EAAO,CAAEG,MAAO,CAAED,KAAMD,EAAIC,KAAMG,OAAQJ,EAAII,OAAS,GAAKJ,OAAO,IAC3E,EAEA,CAAC3C,EAASiB,aAAad,GACrB,MAAM0C,MAAEA,EAAKF,IAAEA,GAAQxC,EAAK+F,IAC5BoP,GAAM5S,EAAO,CAAEG,QAAOF,IAAK,CAAEC,KAAMC,EAAMD,KAAMG,OAAQF,EAAME,OAAS,IAAO,KAC7EuS,GAAM5S,EAAO,CAAEG,MAAO,CAAED,KAAMD,EAAIC,KAAMG,OAAQJ,EAAII,OAAS,GAAKJ,OAAO,IAC3E,EACA,CAAC3C,EAASe,YAAYZ,GACpB,IAAKA,EAAK4M,MAAO,OAEjB,MAAMlK,EAAQ1C,EAAK+F,IAAIvD,IACvB2S,GAAM5S,EAAO,CAAEG,QAAOF,IAAK,CAAEC,KAAMC,EAAMD,KAAMG,OAAQF,EAAME,OAAS,IAAO,IAC/E,EAEA,CAAC/C,EAASmB,SAAShB,GACjBmV,GAAM5S,EAAOvC,EAAK+F,IAAK/F,EAAK8F,IAC9B,IAGKvD,EAAM6F,KAAK8M,GAAWA,CAC/B,CAEA,SAASC,GAAM5S,EAAiBwD,EAAeD,GAC7C,MAAMsP,EAAYtP,EAAImG,MAAM7I,IAAa0P,QAAOrQ,GAAiB,OAATA,GAA0B,SAATA,IACnE4S,EAAiBtP,EAAIvD,IAAIC,KAAOsD,EAAIrD,MAAMD,KAAO,EAEvD,GAAI2S,EAAU3R,SAAW4R,EACvB,MAAM,IAAIvR,MACR,sDAAsDuR,gBAA6BvP,MAIvF,IAAK,IAAI2C,EAAI1C,EAAIrD,MAAMD,KAAMgG,GAAK1C,EAAIvD,IAAIC,KAAMgG,IAAK,CACnD,MAAMhG,EAAOyB,GAAQ3B,EAAOkG,GACtB6M,EAAgB7M,IAAM1C,EAAIrD,MAAMD,KAChC8S,EAAc9M,IAAM1C,EAAIvD,IAAIC,KAE5B2I,EAASkK,EACX7S,EAAKwB,OAAO,EAAG8B,EAAIrD,MAAME,QAAQ4S,OAAOzP,EAAIrD,MAAME,OZxErC,KYyEb,GACEyI,EAAQkK,EAAc9S,EAAKwB,OAAO8B,EAAIvD,IAAII,QAAU,GAE1DL,EAAMkG,EAAI,GAAK2C,EAASgK,EAAU3M,EAAI1C,EAAIrD,MAAMD,MAAQ4I,CAC1D,CACF,CAEA,SAASnH,GAAQ3B,EAAiBZ,GAChC,IAAKY,EAAMZ,EAAQ,GACjB,IAAK,IAAI8G,EAAI,EAAGA,EAAI9G,EAAO8G,IACpBlG,EAAMkG,KAAIlG,EAAMkG,GAAK,IAI9B,OAAOlG,EAAMZ,EAAQ,EACvB,CC3Gc,SAAU8T,GAAKtI,EAAUrK,EAAgB,IACrD,MAAMb,EAAS4E,IACT6O,EAAsB,IAAIC,IAC1BC,EAA4B,IAAID,IAChCE,EAAuB,IAAIF,IACjC,IACIG,EADAC,EAAc9T,EAEd+T,GAAO,EA6EX,OA3EA9I,GAASC,EAAK,CACZ,CAACtN,EAASO,OAAOJ,GACf,MAAMwH,EAAMxH,EAAKwH,IAAIyD,KAAKrJ,MAC1B,IACEqU,GAAYhU,EAAQuF,EAAKxH,EAAKC,KAAM,CAAEyV,SAAQE,eAAcC,WAC9D,CAAE,MAAOK,GACP,MAAMC,EAAID,EACV,MAAM,IAAIrS,EAAWf,EAAO9C,EAAKwH,IAAIzB,IAAIrD,MAAOyT,EAAEpS,QACpD,CAEA,MAAMqS,EAAaC,GAAQ7O,GAC3BkO,EAAOY,IAAIF,GACXP,EAAQS,IAAIF,GAEZL,EAASQ,GAAYtU,EAAQuF,EAC/B,EAEA,CAAC3H,EAASS,YAAYN,GACpB,MAAMwH,EAAMxH,EAAKwH,IAAIyD,KAAKrJ,MAE1B,IACEqU,GAAYhU,EAAQuF,EAAKxH,EAAKC,KAAM,CAAEyV,SAAQE,eAAcC,WAC9D,CAAE,MAAOK,GACP,MAAMC,EAAID,EACV,MAAM,IAAIrS,EAAWf,EAAO9C,EAAKwH,IAAIzB,IAAIrD,MAAOyT,EAAEpS,QACpD,CAEA,MAAMqS,EAAaC,GAAQ7O,GAC3BoO,EAAaU,IAAIF,GACjBP,EAAQS,IAAIF,GAEZL,EA8HN,SAA0BxO,EAAaC,GACrC,MAAMc,EAASkO,GAAOjP,EAAQC,EAAId,MAAM,GAAG,IACrC+P,EAAW9P,EAAKa,GACjBc,EAAOmO,KACVnO,EAAOmO,GAAY,IAGrB,MAAMzU,EAAO6E,IAGb,OAFAyB,EAAO3B,EAAKa,IAAOhE,KAAKxB,GAEjBA,CACT,CAzIe0U,CAAiBzU,EAAQuF,EACpC,EAEA,CAAC3H,EAASW,UAAW,CACnB,KAAAkN,CAAM1N,GACJ,GAAIgW,EAAM,OAEV,MAAMxO,EAAMxH,EAAKwH,IAAI5F,MACrB,IACEqU,GAAYF,EAAQvO,EAAKxH,EAAKC,KAAM,CAAEyV,SAAQE,eAAcC,WAC9D,CAAE,MAAOK,GACP,MAAMC,EAAID,EACV,MAAM,IAAIrS,EAAWf,EAAO9C,EAAKwH,IAAIzB,IAAIrD,MAAOyT,EAAEpS,QACpD,CAEA,MAAMnC,EAAQ+U,GAAQ3W,EAAK4B,QACZ4F,EAAI/D,OAAS,EAAI8S,GAAYR,EAAQvO,EAAId,MAAM,GAAG,IAAOqP,GAEjEpP,EAAKa,IAAS5F,EACrBiU,EAAQS,IAAID,GAAQ7O,IAEhB3G,EAAcb,EAAK4B,SACrBkU,EAAkBC,EAClBA,EAASnU,EAEb,EACA,IAAA+L,CAAK3N,GACCa,EAAcb,EAAK4B,SACrBmU,EAASD,EAEb,GAGF,CAACjW,EAASiB,aAAc,CACtB,KAAA4M,GAEEsI,GAAO,CACT,EACA,IAAArI,GACEqI,GAAO,CACT,KAIG/T,CACT,CAEM,SAAU0U,GAAQ3W,GACtB,OAAQA,EAAKC,MACX,KAAKJ,EAASiB,YACZ,MAAMmB,EAAS4E,IAUf,OARA7G,EAAKsL,MAAM2H,SAAQ,EAAGhI,WACpB,MAAMzD,EAAMyD,EAAKzD,IAAI5F,MACfA,EAAQ+U,GAAQ1L,EAAKrJ,QAEZ4F,EAAI/D,OAAS,EAAI8S,GAAYtU,EAAQuF,EAAId,MAAM,GAAG,IAAOzE,GACjE0E,EAAKa,IAAS5F,CAAK,IAGrBK,EAET,KAAKpC,EAASa,YACZ,OAAOV,EAAKsL,MAAMrD,KAAIgD,GAAQ0L,GAAQ1L,EAAKA,QAE7C,KAAKpL,EAASiK,OACd,KAAKjK,EAAS2M,QACd,KAAK3M,EAASyM,MACd,KAAKzM,EAAS+L,QACd,KAAK/L,EAASqM,SACZ,OAAOlM,EAAK4B,MAEd,QACE,MAAM,IAAIkC,MAAM,4BAA6B9D,EAAkBC,SAErE,CAEA,SAASgW,GACP1O,EACAC,EACAvH,EACA2W,GAGA,IAAIC,EAAkB,GAClBlV,EAAQ,EACZ,IAAK,MAAM+Q,KAAQlL,EAAK,CAGtB,GAFAqP,EAAMrT,KAAKkP,IAENpL,EAAIC,EAAQmL,GAAO,OACxB,GA2DsB,iBADL9Q,EA1DD2F,EAAOmL,MA2DYzL,EAAOrF,GA1DxC,MAAM,IAAIkC,MAAM,qDAAqD+S,EAAMzO,KAAK,QAGlF,MAAM0O,EAAeT,GAAQQ,GAC7B,GAAI9T,MAAMC,QAAQuE,EAAOmL,MAAWkE,EAAMhB,aAAatO,IAAIwP,GACzD,MAAM,IAAIhT,MAAM,gDAAgDgT,KAGlE,MAAMC,EAAepV,IAAU6F,EAAI/D,OAAS,EAC5C8D,EAASxE,MAAMC,QAAQuE,EAAOmL,KAAUqE,EAAepQ,EAAKY,EAAOmL,IAASnL,EAAOmL,EACrF,CA+CF,IAAqB9Q,EA7CnB,MAAMwU,EAAaC,GAAQ7O,GAG3B,GAAID,GAAUtH,IAASJ,EAASO,OAASwW,EAAMf,QAAQvO,IAAI8O,GACzD,MAAM,IAAItS,MAAM,uDAAuDsS,KAIzE,GAAI7O,GAAUtH,IAASJ,EAASS,aAAesW,EAAMhB,aAAatO,IAAI8O,GACpE,MAAM,IAAItS,MAAM,4DAA4DsS,IAEhF,CAEA,SAASG,GAAYhP,EAAaC,GAChC,MAAMc,EAASkO,GAAOjP,EAAQC,EAAId,MAAM,GAAG,IACrC+P,EAAW9P,EAAKa,GAKtB,OAJKc,EAAOmO,KACVnO,EAAOmO,GAAY5P,KAGdyB,EAAOmO,EAChB,CAeA,SAASD,GAAOjP,EAAaQ,GAC3B,OAAOA,EAAKH,QAAO,CAACmO,EAAQiB,KACrBjB,EAAOiB,KACVjB,EAAOiB,GAAUnQ,KAEZ9D,MAAMC,QAAQ+S,EAAOiB,IAAWrQ,EAAKoP,EAAOiB,IAAWjB,EAAOiB,KACpEzP,EACL,CAMA,SAAS8O,GAAQ7O,GACf,OAAOA,EAAIY,KAAK,IAClB,CCpMA,IAAY6O,GA4BN,SAAUC,GAASC,GACvB,OAAOA,EAAOlX,OAASgX,GAAWG,MACpC,CAwBc,SAAUC,GAAKjM,EAAaC,EAAYiM,EAAa,IACjE,OAAIlM,IAAWC,IVNkBkM,EUMUlM,EVLpCpE,EADkBuQ,EUMUpM,IVLfnE,EAAOsQ,IAAMC,EAAExL,gBAAkBuL,EAAEvL,eUM9C,GAGLjJ,MAAMC,QAAQoI,IAAWrI,MAAMC,QAAQqI,GAmE7C,SAAuBD,EAAeC,EAAciM,EAAa,IAC/D,IAAIG,EAAoB,GAGxB,MAAMC,EAAgBtM,EAAOnD,IAAIH,GAC3B6P,EAAetM,EAAMpD,IAAIH,GAG/B6P,EAAa1E,SAAQ,CAACrR,EAAOD,KAC3B,MAAMiW,EAAWjW,GAAS+V,EAAcjU,OAGxC,IAAKmU,GAAYF,EAAc/V,KAAWC,EACxC,OAIF,MAAMiQ,EAAO6F,EAAcpJ,QAAQ1M,EAAOD,EAAQ,GAClD,IAAKiW,GAAY/F,KAAW,CAC1B4F,EAAQjU,KAAK,CACXvD,KAAMgX,GAAWY,KACjBP,OACAzF,OACAiG,GAAInW,IAGN,MAAMgQ,EAAO+F,EAAcnJ,OAAOsD,EAAM,GAGxC,YAFA6F,EAAcnJ,OAAO5M,EAAO,KAAMgQ,EAGpC,CAGA,MAAMoG,GAAWJ,EAAaK,SAASN,EAAc/V,IACrD,IAAKiW,GAAYG,EAIf,OAHA1P,EAAMoP,EAASJ,GAAKjM,EAAOzJ,GAAQ0J,EAAM1J,GAAQ2V,EAAKW,OAAOtW,UAC7D+V,EAAc/V,GAASC,GAMzB6V,EAAQjU,KAAK,CACXvD,KAAMgX,GAAWiB,IACjBZ,KAAMA,EAAKW,OAAOtW,KAEpB+V,EAAcnJ,OAAO5M,EAAO,EAAGC,EAAM,IAIvC,IAAK,IAAI6G,EAAIkP,EAAalU,OAAQgF,EAAIiP,EAAcjU,OAAQgF,IAC1DgP,EAAQjU,KAAK,CACXvD,KAAMgX,GAAWG,OACjBE,KAAMA,EAAKW,OAAOxP,KAItB,OAAOgP,CACT,CA5HWU,CAAc/M,EAAQC,EAAOiM,GAC3BjQ,EAAS+D,IAAW/D,EAASgE,GAY1C,SAAwBD,EAAaC,EAAYiM,EAAa,IAC5D,IAAIG,EAAoB,GAGxB,MAAMW,EAActR,OAAOiB,KAAKqD,GAC1BsM,EAAgBU,EAAYnQ,KAAIT,GAAOM,EAAgBsD,EAAO5D,MAC9D6Q,EAAavR,OAAOiB,KAAKsD,GACzBsM,EAAeU,EAAWpQ,KAAIT,GAAOM,EAAgBuD,EAAM7D,MAI3D8Q,EAAW,CAACC,EAAgBC,KAEhC,GADcA,EAAOlK,QAAQiK,GACjB,EAAG,OAAO,EAEtB,MAAME,EAAaL,EAAYV,EAAcpJ,QAAQiK,IACrD,OAAQF,EAAWL,SAASS,EAAW,EAkCzC,OA9BAL,EAAYnF,SAAQ,CAACzL,EAAK7F,KACxB,MAAM+W,EAAWpB,EAAKW,OAAOzQ,GAC7B,GAAI6Q,EAAWL,SAASxQ,GACtBa,EAAMoP,EAASJ,GAAKjM,EAAO5D,GAAM6D,EAAM7D,GAAMkR,SACxC,GAAIJ,EAASZ,EAAc/V,GAAQgW,GAAe,CACvD,MAAMG,EAAKO,EAAWV,EAAarJ,QAAQoJ,EAAc/V,KACzD8V,EAAQjU,KAAK,CACXvD,KAAMgX,GAAW0B,OACjBrB,OACAzF,KAAMrK,EACNsQ,MAEJ,MACEL,EAAQjU,KAAK,CACXvD,KAAMgX,GAAWG,OACjBE,KAAMoB,GAEV,IAIFL,EAAWpF,SAAQ,CAACzL,EAAK7F,KAClByW,EAAYJ,SAASxQ,IAAS8Q,EAASX,EAAahW,GAAQ+V,IAC/DD,EAAQjU,KAAK,CACXvD,KAAMgX,GAAWiB,IACjBZ,KAAMA,EAAKW,OAAOzQ,IAEtB,IAGKiQ,CACT,CA9DWmB,CAAexN,EAAQC,EAAOiM,GAE9B,CACL,CACErX,KAAMgX,GAAW4B,KACjBvB,SVlBF,IAAqBE,EAAQD,CUsBnC,CCrEc,SAAUuB,GAAW9Y,EAAgBsX,GACjD,IAAKA,EAAK7T,OAAQ,OAAOzD,EAEzB,GAAIO,EAAWP,GACb,OAAO8Y,GAAW9Y,EAAK4B,MAAO0V,GAGhC,MAAMjU,EAAqC,CAAA,EAC3C,IAAI0V,EAqCJ,GApCI9X,EAASjB,IACXA,EAAKsL,MAAM0N,MAAK,CAAC/N,EAAMtJ,KACrB,IACE,IAAI6F,EAAY,GAChB,GAAIjH,EAAW0K,GACbzD,EAAMyD,EAAKzD,IAAI5F,WACV,GAAIzB,EAAQ8K,GACjBzD,EAAMyD,EAAKzD,IAAIyD,KAAKrJ,WACf,GAAIvB,EAAa4K,GAAO,CAC7BzD,EAAMyD,EAAKzD,IAAIyD,KAAKrJ,MAEpB,MAAMqX,EAAanR,EAAgBN,GAC9BnE,EAAQ4V,KACX5V,EAAQ4V,GAAc,GAExB,MAAMC,EAAc7V,EAAQ4V,KAE5BzR,EAAMA,EAAIyQ,OAAOiB,EACnB,MAAWvY,EAAasK,IAAS1K,EAAW0K,EAAKA,MAC/CzD,EAAMyD,EAAKA,KAAKzD,IAAI5F,MACXjB,EAAasK,KACtBzD,EAAM,CAAC7F,IAGT,SAAI6F,EAAI/D,SXIV,SAA6B+T,EAAYD,GAC7C,GAAIC,EAAE/T,SAAW8T,EAAE9T,OAAQ,OAAO,EAElC,IAAK,IAAIgF,EAAI,EAAGA,EAAI+O,EAAE/T,OAAQgF,IAC5B,GAAI+O,EAAE/O,KAAO8O,EAAE9O,GAAI,OAAO,EAG5B,OAAO,CACT,CWZ0B0Q,CAAY3R,EAAK8P,EAAK5Q,MAAM,EAAGc,EAAI/D,YACnDsV,EAAQD,GAAW7N,EAAMqM,EAAK5Q,MAAMc,EAAI/D,UACjC,EAIX,CAAE,MAAOyS,GACP,OAAO,CACT,MAIC6C,EACH,MAAM,IAAIjV,MAAM,+BAA+BwT,EAAKlP,KAAK,QAG3D,OAAO2Q,CACT,CAEM,SAAUK,GAAcpZ,EAAgBsX,GAC5C,IACE,OAAOwB,GAAW9Y,EAAMsX,EAC1B,CAAE,MAAOpB,GAAM,CACjB,CAEM,SAAUmD,GAAWrZ,EAAgBsX,GACzC,IACI/J,EADA+L,EAAchC,EAElB,KAAOgC,EAAY7V,SAAW8J,GAC5B+L,EAAcA,EAAY5S,MAAM,GAAG,GACnC6G,EAAS6L,GAAcpZ,EAAMsZ,GAG/B,IAAK/L,EACH,MAAM,IAAIzJ,MAAM,uCAAuCwT,EAAKlP,KAAK,QAGnE,OAAOmF,CACT,EDzEA,SAAY0J,GACVA,EAAA,IAAA,MACAA,EAAA,KAAA,OACAA,EAAA,OAAA,SACAA,EAAA,KAAA,OACAA,EAAA,OAAA,QACD,CAND,CAAYA,KAAAA,GAAU,CAAA,YEUhB,SAAgBrV,GACpB,OAAO6T,GAAK5K,GAAUjJ,GAAQA,EAChC,UCmCc,SAAgBwM,EAAkBmL,EAAczF,GAC5D,MACMxI,EAAQ,IADOT,GAAUuD,IAGzBoL,EAAc/D,GAAKnK,GAiBzB,OAAO2J,GA+BT,SAAsBwE,EAAoBF,EAAmB9B,GA0G3D,OA/FAA,EAAQxE,SAAQkE,IACd,GHnGE,SAAgBA,GACpB,OAAOA,EAAOlX,OAASgX,GAAWiB,GACpC,CGiGQwB,CAAMvC,GAAS,CACjB,MAAMtI,EAAQiK,GAAWS,EAASpC,EAAOG,MACnCgC,EAAcnC,EAAOG,KAAK5Q,MAAM,GAAG,GACzC,IAUI6G,EAVA5L,EAAQgF,EAAKwQ,EAAOG,MAEpBqC,EAAiBtZ,EAAawO,GAClC,GAAI7H,EAAUrF,KAAW2X,EAAYN,KAAKhS,GAAY,CACpD,MAAM4S,EAAUR,GAAcK,EAAUH,EAAYrB,OAAO,IACvD2B,GAAWvZ,EAAauZ,KAC1BD,GAAiB,EAErB,CAGA,GAAIxZ,EAAQ0O,GACVtB,EAASkM,OACJ,GAAIE,EAAgB,CACzBpM,EAASkM,EAIT,MAAM5G,EAAW4G,EACXrO,EAASgO,GAAcvG,EAAUyG,EAAYrB,OAAOtW,EAAQ,IAC5D0J,EAAQ+N,GAAcvG,EAAUyG,EAAYrB,OAAOtW,IAEvDA,EADE0J,EACMwH,EAASvH,MAAMgD,QAAQjD,GACtBD,EACDyH,EAASvH,MAAMgD,QAAQlD,GAAU,EAEjCyH,EAASvH,MAAM7H,MAE3B,MACE8J,EAAS8L,GAAWI,EAAUtC,EAAOG,MACjC/W,EAAWgN,KAASA,EAASA,EAAO3L,OAGtCvB,EAAakN,IAAW9M,EAAc8M,IAAWxN,EAAWwN,GAC9DqB,GAAO6K,EAAUlM,EAAQsB,EAAOlN,GAEhCiN,GAAO6K,EAAUlM,EAAQsB,EAE7B,MAAO,GHpIL,SAAiBsI,GACrB,OAAOA,EAAOlX,OAASgX,GAAW4B,IACpC,CGkIegB,CAAO1C,GAAS,CACzB,IAEI5J,EAFAa,EAAW0K,GAAWW,EAAUtC,EAAOG,MACvCjJ,EAAcyK,GAAWS,EAASpC,EAAOG,MAGzC/W,EAAW6N,IAAa7N,EAAW8N,IAErCd,EAASa,EACTA,EAAWA,EAASxM,MACpByM,EAAcA,EAAYzM,OACjBrB,EAAW6N,IAAazN,EAAa0N,IAAgB9N,EAAW8N,EAAYpD,OAGrFsC,EAASa,EACTA,EAAWA,EAASxM,MACpByM,EAAcA,EAAYpD,KAAKrJ,OAE/B2L,EAAS8L,GAAWI,EAAUtC,EAAOG,MAGvC5N,GAAQ+P,EAAUlM,EAAQa,EAAUC,EACtC,MAAO,GAAI6I,GAASC,GAAS,CAC3B,IAAI5J,EAAS8L,GAAWI,EAAUtC,EAAOG,MACrC/W,EAAWgN,KAASA,EAASA,EAAO3L,OAExC,MAAM5B,EAAO8Y,GAAWW,EAAUtC,EAAOG,MAEzCtH,GAAOyJ,EAAUlM,EAAQvN,EAC3B,MAAO,GH9IL,SAAiBmX,GACrB,OAAOA,EAAOlX,OAASgX,GAAWY,IACpC,CG4IeiC,CAAO3C,GAAS,CACzB,IAAI5J,EAASuL,GAAWW,EAAUtC,EAAOG,MACrCpW,EAAQqM,KAASA,EAASA,EAAOtC,MACjC1K,EAAWgN,KAASA,EAASA,EAAO3L,OAExC,MAAM5B,EAAQuN,EAAqBjC,MAAM6L,EAAOtF,MAEhD7B,GAAOyJ,EAAUlM,EAAQvN,GACzB4O,GAAO6K,EAAUlM,EAAQvN,EAAMmX,EAAOW,GACxC,MAAO,GH7IL,SAAmBX,GACvB,OAAOA,EAAOlX,OAASgX,GAAW0B,MACpC,CG2IeL,CAASnB,GAAS,CAC3B,IAAI5J,EAASuL,GAAWW,EAAUtC,EAAOG,KAAKW,OAAOd,EAAOtF,OAGxDxD,EAAcyK,GAAWS,EAASpC,EAAOG,KAAKW,OAAOd,EAAOW,KAI5D5W,EAAQqM,KAASA,EAASA,EAAOtC,MACjC/J,EAAQmN,KAAcA,EAAcA,EAAYpD,MAEpDvB,GAAQ+P,EAAUlM,EAAQA,EAAO/F,IAAK6G,EAAY7G,IACpD,KAGFsJ,GAAY2I,GACLA,CACT,CA/I2BM,CAXW,CAClC9Z,KAAMJ,EAASK,SACf6F,IAAK,CAAErD,MAAO,CAAED,KAAM,EAAGG,OAAQ,GAAKJ,IAAK,CAAEC,KAAM,EAAGG,OAAQ,IAC9D0I,SAGuBuI,GAAQ0F,EAASzF,GAa5C,SAAiB2D,GAKf,IAAK,IAAIhP,EAAI,EAAGA,EAAIgP,EAAQhU,OAAQgF,IAAK,CACvC,MAAM0O,EAASM,EAAQhP,GACvB,GAAIyO,GAASC,GAAS,CACpB,IAAI6C,EAAIvR,EAAI,EACZ,KAAOuR,EAAIvC,EAAQhU,QAAQ,CACzB,MAAMwW,EAAcxC,EAAQuC,GAC5B,GAAI9C,GAAS+C,IAAgBA,EAAY3C,KAAK,KAAOH,EAAOG,KAAK,IAC7D2C,EAAY3C,KAAK,GAAKH,EAAOG,KAAK,GAAI,CACxCG,EAAQlJ,OAAOyL,EAAG,GAClBvC,EAAQlJ,OAAO9F,EAAG,EAAGwR,GAErBxR,EAAI,EACJ,KACF,CACAuR,GACF,CACF,CACF,CAEA,OAAOvC,CAET,CAtCkByC,CAAQ7C,GAAKmC,EAAaD,KASXjO,MACjC,cDhDM,SAAoB1J,EAAYkS,GAEpC,OAAOmB,GADUpB,GAAQjS,EAAOkS,GACTxI,MACzB"}