@kamilio/wire 0.1.9 → 0.1.11

package/node_modules/toolcraft/node_modules/smol-toml/src/primitive.ts

@@ -0,0 +1,247 @@
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import { TomlDate } from './date.js'
+import { TomlError } from './error.js'
+
+// let CTRL_REGEX = /[\x00-\x08\x0f-\x1f\x7f]/
+let INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/
+let FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/
+let LEADING_ZERO = /^[+-]?0[0-9_]/
+
+export function parseString(str: string, ptr: number): [string, number] {
+	let c = str[ptr++]!
+	let first = c
+	let isLiteral = c === "'"
+	let isMultiline = c === str[ptr] && c === str[ptr + 1]
+	if (isMultiline) {
+		// Trim initial newline
+		if (str[ptr += 2] === '\n') ptr++
+		else if (str[ptr] === '\r' && str[ptr + 1] === '\n') ptr += 2
+	}
+
+	/*
+	The fast path does not seem to bring significant performance gains, so it's commented out.
+	Kept for reference and/or future fafoing.
+
+	Without: spec  5.08 µs/iter    3.88 ipc (99.44% cache)   23.90 branch misses   28.61k cycles    111.01k instructions
+	         5MB   115.73 ms/iter  2.51 ipc (98.36% cache)   3.12M branch misses   619.30M cycles   1.56G instructions
+
+	With:    spec  5.09 µs/iter    3.90 ipc (99.46% cache)   24.42 branch misses   28.57k cycles    111.49k instructions
+	         5MB   113.89 ms/iter  2.47 ipc (98.38% cache)   3.12M branch misses   611.94M cycles   1.51G instructions
+
+	if (c === "'") {
+		// Literal strings fast path - no transform needs to occur; just grab the str and that's it
+		let endPtr = str.indexOf(isMultiline ? "'''" : "'", ptr)
+		if (endPtr < 0) {
+			throw new TomlError("unfinished string literal", { toml: str, ptr })
+		}
+
+		if (isMultiline) {
+			// If the string ends with 4-5 quotes, then the first 1-2 are part of the string
+			if (str[endPtr + 3] === "'") endPtr++
+			if (str[endPtr + 3] === "'") endPtr++
+		}
+
+		let string = str.slice(ptr, endPtr)
+		if (CTRL_REGEX.test(string)) {
+			let match = string.match(CTRL_REGEX)!
+			throw new TomlError('control characters are not allowed in strings', { toml: str, ptr: ptr + (match.index ?? 0) })
+		}
+		return [string, endPtr + (isMultiline ? 3 : 1)]
+	}
+	*/
+
+	let parsed = ''
+	let sliceStart = ptr
+
+	// states:
+	//   0 - decoding
+	//   1 - decoding escape
+	//   2 - whitespace escape (no newline encountered yet, must fail on non-whitespace)
+	//   3 - whitespace escape (newline encountered, allowed to transition back to normal decode)
+	let state = 0
+	for (let i = ptr; i < str.length; i++) {
+		c = str[i]!
+
+		// Deal with newlines first, since that simplifies control character checking and handling across all states
+		if (isMultiline && (c === '\n' || (c === '\r' && str[i + 1] === '\n'))) {
+			state = state && 3
+		}
+
+		// Control characters are banned in TOML, so we throw an error if we encounter them
+		else if ((c < '\x20' && c !== '\t') || c === '\x7f') {
+			throw new TomlError('control characters are not allowed in strings', {
+				toml: str,
+				ptr: i,
+			})
+		}
+
+		// The string might terminate while we're parsing through a newline escape.
+		// It must have encountered a newline; otherwise, it'll simply fail in another branch.
+		else if ((!state || state === 3) && c === first && (!isMultiline || (str[i + 1] === first && str[i + 2] === first))) {
+			if (isMultiline) {
+				// If the string ends with 4-5 quotes, then the first 1-2 are part of the string
+				if (str[i + 3] === first) i++
+				if (str[i + 3] === first) i++
+			}
+
+			return [
+				// If we're in a newline escape still, then there's nothing to add.
+				// Also try to avoid concat if there's nothing to add to parsed, or nothing has been added to parsed.
+				state ? parsed : parsed + str.slice(sliceStart, i),
+				i + (isMultiline ? 3 : 1),
+			]
+		}
+
+		else if (!state) {
+			if (!isLiteral && c === '\\') {
+				parsed += str.slice(sliceStart, (sliceStart = i))
+				state = 1
+			}
+		}
+
+		else if (state === 1) {
+			if (c === 'x' || c === 'u' || c === 'U') { // Unicode escape
+				let value = 0
+				let len = c === 'x' ? 2 : c === 'u' ? 4 : 8
+				for (let j = 0; j < len; j++, i++) {
+					let hex = str.charCodeAt(i + 1)
+					let digit =
+						/* 0-9 */ hex >= 0x30 && hex <= 0x39 ? hex - 0x30 :
+						/* A-F */ hex >= 0x41 && hex <= 0x46 ? hex - 0x41 + 10 :
+						/* a-f */ hex >= 0x61 && hex <= 0x66 ? hex - 0x61 + 10 : -1
+
+					if (digit < 0) throw new TomlError('invalid non-hex character in unicode escape', { toml: str, ptr: i + 1 })
+					value = (value << 4) | digit
+				}
+
+				// Because JS does bitwise on signed 32bit integers, all 0xfzzzzzzz values are actually seen as negative
+				if (value < 0 || value > 0x10ffff || (value >= 0xd800 && value <= 0xdfff)) {
+					throw new TomlError('invalid unicode escape', { toml: str, ptr: i })
+				}
+
+				parsed += String.fromCodePoint(value)
+				sliceStart = i + 1
+				state = 0
+			}
+
+			else if (c === ' ' || c === '\t') { // If it was a newline, it'd have been handled earlier
+				state = 2
+			}
+
+			else {
+				if (c === 'b') parsed += '\b'
+				else if (c === 't') parsed += '\t'
+				else if (c === 'n') parsed += '\n'
+				else if (c === 'f') parsed += '\f'
+				else if (c === 'r') parsed += '\r'
+				else if (c === 'e') parsed += '\x1b'
+				else if (c === '"') parsed += '"'
+				else if (c === '\\') parsed += '\\'
+				else throw new TomlError('unrecognized escape sequence', { toml: str, ptr: i })
+				sliceStart = i + 1
+				state = 0
+			}
+		}
+
+		else if (c !== ' ' && c !== '\t') {
+			if (state === 2) {
+				throw new TomlError('invalid escape: only line-ending whitespace may be escaped', {
+					toml: str,
+					ptr: sliceStart,
+				})
+			}
+
+			// State cannot be zero, or we'd have branched earlier already.
+			// If it's a backslash, immediately transition to the escape state so it can be processed.
+			state = !isLiteral && c === '\\' ? 1 : 0
+			sliceStart = i
+		}
+	}
+
+	throw new TomlError('unfinished string', { toml: str, ptr })
+}
+
+export type IntegersAsBigInt = undefined | boolean | 'asNeeded'
+
+export function parseValue(value: string, toml: string, ptr: number, integersAsBigInt: IntegersAsBigInt): boolean | number | bigint | TomlDate {
+	// Constant values
+	if (value === 'true') return true
+	if (value === 'false') return false
+	if (value === '-inf') return -Infinity
+	if (value === 'inf' || value === '+inf') return Infinity
+	if (value === 'nan' || value === '+nan' || value === '-nan') return NaN
+
+	// Avoid FP representation of -0
+	if (value === '-0') return integersAsBigInt ? 0n : 0
+
+	// Numbers
+	let isInt = INT_REGEX.test(value)
+	if (isInt || FLOAT_REGEX.test(value)) {
+		if (LEADING_ZERO.test(value)) {
+			throw new TomlError('leading zeroes are not allowed', {
+				toml: toml,
+				ptr: ptr,
+			})
+		}
+
+		value = value.replace(/_/g, '')
+		let numeric: number | bigint = +value
+
+		if (isNaN(numeric)) {
+			throw new TomlError('invalid number', {
+				toml: toml,
+				ptr: ptr,
+			})
+		}
+
+		if (isInt) {
+			if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+				throw new TomlError('integer value cannot be represented losslessly', {
+					toml: toml,
+					ptr: ptr,
+				})
+			}
+
+			if (isInt || integersAsBigInt === true) numeric = BigInt(value)
+		}
+
+		return numeric
+	}
+
+	const date = new TomlDate(value)
+	if (!date.isValid()) {
+		throw new TomlError('invalid value', {
+			toml: toml,
+			ptr: ptr,
+		})
+	}
+
+	return date
+}

package/node_modules/toolcraft/node_modules/smol-toml/src/stringify.ts

@@ -0,0 +1,191 @@
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+let BARE_KEY = /^[a-z0-9-_]+$/i
+
+type ExtendedType = ReturnType<typeof extendedTypeOf>
+function extendedTypeOf(obj: any) {
+	let type = typeof obj
+	if (type === 'object') {
+		if (Array.isArray(obj)) return 'array'
+		if (obj instanceof Date) return 'date'
+	}
+
+	return type
+}
+
+function isArrayOfTables(obj: any[]) {
+	for (let i = 0; i < obj.length; i++) {
+		if (extendedTypeOf(obj[i]) !== 'object') return false
+	}
+
+	return obj.length != 0
+}
+
+function formatString(s: string) {
+	return JSON.stringify(s).replace(/\x7f/g, '\\u007f')
+}
+
+function stringifyValue(val: any, type: ExtendedType, depth: number, numberAsFloat: boolean) {
+	if (depth === 0) {
+		throw new Error('Could not stringify the object: maximum object depth exceeded')
+	}
+
+	if (type === 'number') {
+		if (isNaN(val)) return 'nan'
+		if (val === Infinity) return 'inf'
+		if (val === -Infinity) return '-inf'
+		if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val))) return val.toFixed(1)
+		return val.toString()
+	}
+
+	if (type === 'bigint' || type === 'boolean') {
+		return val.toString()
+	}
+
+	if (type === 'string') {
+		return formatString(val)
+	}
+
+	if (type === 'date') {
+		if (isNaN(val.getTime())) {
+			throw new TypeError('cannot serialize invalid date')
+		}
+
+		return val.toISOString()
+	}
+
+	if (type === 'object') {
+		return stringifyInlineTable(val, depth, numberAsFloat)
+	}
+
+	if (type === 'array') {
+		return stringifyArray(val, depth, numberAsFloat)
+	}
+}
+
+function stringifyInlineTable(obj: any, depth: number, numberAsFloat: boolean) {
+	let keys = Object.keys(obj)
+	if (keys.length === 0) return '{}'
+
+	let res = '{ '
+	for (let i = 0; i < keys.length; i++) {
+		let k = keys[i]!
+		if (i) res += ', '
+
+		res += BARE_KEY.test(k) ? k : formatString(k)
+		res += ' = '
+		res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat)
+	}
+
+	return res + ' }'
+}
+
+function stringifyArray(array: any[], depth: number, numberAsFloat: boolean) {
+	if (array.length === 0) return '[]'
+
+	let res = '[ '
+	for (let i = 0; i < array.length; i++) {
+		if (i) res += ', '
+		if (array[i] === null || array[i] === void 0) {
+			throw new TypeError('arrays cannot contain null or undefined values')
+		}
+
+		res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat)
+	}
+
+	return res + ' ]'
+}
+
+function stringifyArrayTable(array: any[], key: string, depth: number, numberAsFloat: boolean) {
+	if (depth === 0) {
+		throw new Error('Could not stringify the object: maximum object depth exceeded')
+	}
+
+	let res = ''
+	for (let i = 0; i < array.length; i++) {
+		res += `${res && '\n'}[[${key}]]\n`
+		res += stringifyTable(0, array[i], key, depth, numberAsFloat)
+	}
+
+	return res
+}
+
+function stringifyTable(tableKey: string | 0, obj: any, prefix: string, depth: number, numberAsFloat: boolean) {
+	if (depth === 0) {
+		throw new Error('Could not stringify the object: maximum object depth exceeded')
+	}
+
+	let preamble = ''
+	let tables = ''
+
+	let keys = Object.keys(obj)
+	for (let i = 0; i < keys.length; i++) {
+		let k = keys[i]!
+		if (obj[k] !== null && obj[k] !== void 0) {
+			let type: ExtendedType = extendedTypeOf(obj[k])
+			if (type === 'symbol' || type === 'function') {
+				throw new TypeError(`cannot serialize values of type '${type}'`)
+			}
+
+			let key = BARE_KEY.test(k) ? k : formatString(k)
+
+			if (type === 'array' && isArrayOfTables(obj[k])) {
+				tables += (tables && '\n') + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat)
+			} else if (type === 'object') {
+				let tblKey = prefix ? `${prefix}.${key}` : key
+				tables += (tables && '\n') + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat)
+			} else {
+				preamble += key
+				preamble += ' = '
+				preamble += stringifyValue(obj[k], type, depth, numberAsFloat)
+				preamble += '\n'
+			}
+		}
+	}
+
+	if (tableKey && (preamble || !tables)) // Create table only if necessary
+		preamble = preamble ? `[${tableKey}]\n${preamble}` : `[${tableKey}]`
+
+	return preamble && tables
+		? `${preamble}\n${tables}`
+		: preamble || tables
+}
+
+export function stringify (
+	obj: any,
+	{ maxDepth = 1000, numbersAsFloat = false }: { maxDepth?: number, numbersAsFloat?: boolean } = {},
+) {
+	if (extendedTypeOf(obj) !== 'object') {
+		throw new TypeError('stringify can only be called with an object')
+	}
+
+	let str = stringifyTable(0, obj, '', maxDepth, numbersAsFloat)
+	if (str[str.length - 1] !== '\n') return str + '\n'
+	return str
+}

package/node_modules/toolcraft/node_modules/smol-toml/src/struct.ts

@@ -0,0 +1,199 @@
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import { type IntegersAsBigInt, parseString } from './primitive.js'
+import { extractValue } from './extract.js'
+import { indexOfNewline, skipComment, skipVoid, type TomlTable, type TomlValue } from './util.js'
+import { TomlError } from './error.js'
+
+let KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/
+
+export function parseKey(str: string, ptr: number, end = '='): [string[], number] {
+	let dot = ptr - 1
+	let parsed = []
+
+	let endPtr = str.indexOf(end, ptr)
+	if (endPtr < 0) {
+		throw new TomlError('incomplete key-value: cannot find end of key', {
+			toml: str,
+			ptr: ptr,
+		})
+	}
+
+	do {
+		let c = str[(ptr = ++dot)]
+
+		// If it's whitespace, ignore
+		if (c !== ' ' && c !== '\t') {
+			// If it's a string
+			if (c === '"' || c === "'") {
+				if (c === str[ptr + 1] && c === str[ptr + 2]) {
+					throw new TomlError('multiline strings are not allowed in keys', {
+						toml: str,
+						ptr: ptr,
+					})
+				}
+
+				let [part, eos] = parseString(str, ptr)
+				dot = str.indexOf('.', eos)
+
+				let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot)
+				let newLine = indexOfNewline(strEnd)
+				if (newLine > -1) {
+					throw new TomlError('newlines are not allowed in keys', {
+						toml: str,
+						ptr: ptr + dot + newLine,
+					})
+				}
+
+				if (strEnd.trimStart()) {
+					throw new TomlError('found extra tokens after the string part', {
+						toml: str,
+						ptr: eos,
+					})
+				}
+
+				if (endPtr < eos) {
+					endPtr = str.indexOf(end, eos)
+					if (endPtr < 0) {
+						throw new TomlError('incomplete key-value: cannot find end of key', {
+							toml: str,
+							ptr: ptr,
+						})
+					}
+				}
+
+				parsed.push(part)
+			} else {
+				// Normal raw key part consumption and validation
+				dot = str.indexOf('.', ptr)
+				let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot)
+				if (!KEY_PART_RE.test(part)) {
+					throw new TomlError('only letter, numbers, dashes and underscores are allowed in keys', {
+						toml: str,
+						ptr: ptr,
+					})
+				}
+
+				parsed.push(part.trimEnd())
+			}
+		}
+		// Until there's no more dot
+	} while (dot + 1 && dot < endPtr)
+
+	return [parsed, skipVoid(str, endPtr + 1, true, true)]
+}
+
+export function parseInlineTable(str: string, ptr: number, depth: number, integersAsBigInt: IntegersAsBigInt): [TomlTable, number] {
+	let res: TomlTable = {}
+	let seen = new Set()
+	let c: string
+
+	ptr++
+	while ((c = str[ptr++]!) !== '}' && c) {
+		if (c === ',') {
+			throw new TomlError('expected value, found comma', {
+				toml: str,
+				ptr: ptr - 1,
+			})
+		} else if (c === '#') ptr = skipComment(str, ptr)
+		else if (c !== ' ' && c !== '\t' && c !== '\n' && c !== '\r') {
+			let k: string
+			let t: any = res
+			let hasOwn = false
+
+			let [key, keyEndPtr] = parseKey(str, ptr - 1)
+			for (let i = 0; i < key.length; i++) {
+				if (i) t = hasOwn! ? t[k!] : (t[k!] = {})
+
+				k = key[i]!
+				if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== 'object' || seen.has(t[k]))) {
+					throw new TomlError('trying to redefine an already defined value', {
+						toml: str,
+						ptr: ptr,
+					})
+				}
+
+				if (!hasOwn && k === '__proto__') {
+					Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true })
+				}
+			}
+
+			if (hasOwn) {
+				throw new TomlError('trying to redefine an already defined value', {
+					toml: str,
+					ptr: ptr,
+				})
+			}
+
+			let [value, valueEndPtr] = extractValue(str, keyEndPtr, '}', depth - 1, integersAsBigInt)
+			seen.add(value)
+
+			t[k!] = value
+			ptr = valueEndPtr
+		}
+	}
+
+	if (!c) {
+		throw new TomlError('unfinished table encountered', {
+			toml: str,
+			ptr: ptr,
+		})
+	}
+
+	return [res, ptr]
+}
+
+export function parseArray(str: string, ptr: number, depth: number, integersAsBigInt: IntegersAsBigInt): [TomlValue[], number] {
+	let res: TomlValue[] = []
+	let c
+
+	ptr++
+	while ((c = str[ptr++]) !== ']' && c) {
+		if (c === ',') {
+			throw new TomlError('expected value, found comma', {
+				toml: str,
+				ptr: ptr - 1,
+			})
+		} else if (c === '#') ptr = skipComment(str, ptr)
+		else if (c !== ' ' && c !== '\t' && c !== '\n' && c !== '\r') {
+			let e = extractValue(str, ptr - 1, ']', depth - 1, integersAsBigInt)
+			res.push(e[0])
+			ptr = e[1]
+		}
+	}
+
+	if (!c) {
+		throw new TomlError('unfinished array encountered', {
+			toml: str,
+			ptr: ptr,
+		})
+	}
+
+	return [res, ptr]
+}