smol-toml 1.2.2 → 1.3.1

package/dist/index.d.ts

@@ -25,8 +25,16 @@
  * 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.
  */
-export { TomlError } from './error.js';
-export { TomlDate } from './date.js';
-export { parse } from './parse.js';
-export { stringify } from './stringify.js';
+import { parse } from './parse.js';
+import { stringify } from './stringify.js';
+import { TomlDate } from './date.js';
+import { TomlError } from './error.js';
 export type { TomlPrimitive } from './util.js';
+declare const _default: {
+    parse: typeof parse;
+    stringify: typeof stringify;
+    TomlDate: typeof TomlDate;
+    TomlError: typeof TomlError;
+};
+export default _default;
+export { parse, stringify, TomlDate, TomlError };

package/dist/index.js

@@ -1,4 +1,3 @@
-"use strict";
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -26,13 +25,9 @@
  * 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.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringify = exports.parse = exports.TomlDate = exports.TomlError = void 0;
-var error_js_1 = require("./error.js");
-Object.defineProperty(exports, "TomlError", { enumerable: true, get: function () { return error_js_1.TomlError; } });
-var date_js_1 = require("./date.js");
-Object.defineProperty(exports, "TomlDate", { enumerable: true, get: function () { return date_js_1.TomlDate; } });
-var parse_js_1 = require("./parse.js");
-Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parse_js_1.parse; } });
-var stringify_js_1 = require("./stringify.js");
-Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return stringify_js_1.stringify; } });
+import { parse } from './parse.js';
+import { stringify } from './stringify.js';
+import { TomlDate } from './date.js';
+import { TomlError } from './error.js';
+export default { parse, stringify, TomlDate, TomlError };
+export { parse, stringify, TomlDate, TomlError };

package/dist/parse.d.ts

@@ -26,4 +26,6 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import { type TomlPrimitive } from './util.js';
-export declare function parse(toml: string): Record<string, TomlPrimitive>;
+export declare function parse(toml: string, opts?: {
+    maxDepth: number;
+}): Record<string, TomlPrimitive>;

package/dist/parse.js

@@ -1,4 +1,3 @@
-"use strict";
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -26,12 +25,10 @@
  * 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.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = void 0;
-const struct_js_1 = require("./struct.js");
-const extract_js_1 = require("./extract.js");
-const util_js_1 = require("./util.js");
-const error_js_1 = require("./error.js");
+import { parseKey } from './struct.js';
+import { extractValue } from './extract.js';
+import { skipVoid } from './util.js';
+import { TomlError } from './error.js';
 function peekTable(key, table, meta, type) {
     let t = table;
     let m = meta;
@@ -96,18 +93,19 @@ function peekTable(key, table, meta, type) {
     }
     return [k, t, state.c];
 }
-function parse(toml) {
+export function parse(toml, opts) {
+    let maxDepth = opts?.maxDepth ?? 1000;
     let res = {};
     let meta = {};
     let tbl = res;
     let m = meta;
-    for (let ptr = (0, util_js_1.skipVoid)(toml, 0); ptr < toml.length;) {
+    for (let ptr = skipVoid(toml, 0); ptr < toml.length;) {
         if (toml[ptr] === '[') {
             let isTableArray = toml[++ptr] === '[';
-            let k = (0, struct_js_1.parseKey)(toml, ptr += +isTableArray, ']');
+            let k = parseKey(toml, ptr += +isTableArray, ']');
             if (isTableArray) {
                 if (toml[k[1] - 1] !== ']') {
-                    throw new error_js_1.TomlError('expected end of table declaration', {
+                    throw new TomlError('expected end of table declaration', {
                         toml: toml,
                         ptr: k[1] - 1,
                     });
@@ -116,7 +114,7 @@ function parse(toml) {
             }
             let p = peekTable(k[0], res, meta, isTableArray ? 2 /* Type.ARRAY */ : 1 /* Type.EXPLICIT */);
             if (!p) {
-                throw new error_js_1.TomlError('trying to redefine an already defined table or value', {
+                throw new TomlError('trying to redefine an already defined table or value', {
                     toml: toml,
                     ptr: ptr,
                 });
@@ -126,27 +124,26 @@ function parse(toml) {
             ptr = k[1];
         }
         else {
-            let k = (0, struct_js_1.parseKey)(toml, ptr);
+            let k = parseKey(toml, ptr);
             let p = peekTable(k[0], tbl, m, 0 /* Type.DOTTED */);
             if (!p) {
-                throw new error_js_1.TomlError('trying to redefine an already defined table or value', {
+                throw new TomlError('trying to redefine an already defined table or value', {
                     toml: toml,
                     ptr: ptr,
                 });
             }
-            let v = (0, extract_js_1.extractValue)(toml, k[1]);
+            let v = extractValue(toml, k[1], void 0, maxDepth);
             p[1][p[0]] = v[0];
             ptr = v[1];
         }
-        ptr = (0, util_js_1.skipVoid)(toml, ptr, true);
+        ptr = skipVoid(toml, ptr, true);
         if (toml[ptr] && toml[ptr] !== '\n' && toml[ptr] !== '\r') {
-            throw new error_js_1.TomlError('each key-value declaration must be followed by an end-of-line', {
+            throw new TomlError('each key-value declaration must be followed by an end-of-line', {
                 toml: toml,
                 ptr: ptr
             });
         }
-        ptr = (0, util_js_1.skipVoid)(toml, ptr);
+        ptr = skipVoid(toml, ptr);
     }
     return res;
 }
-exports.parse = parse;

package/dist/primitive.js

@@ -1,4 +1,3 @@
-"use strict";
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -26,11 +25,9 @@
  * 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.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseValue = exports.parseString = void 0;
-const util_js_1 = require("./util.js");
-const date_js_1 = require("./date.js");
-const error_js_1 = require("./error.js");
+import { skipVoid } from './util.js';
+import { TomlDate } from './date.js';
+import { TomlError } from './error.js';
 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_]/;
@@ -44,7 +41,7 @@ let ESC_MAP = {
     '"': '"',
     '\\': '\\',
 };
-function parseString(str, ptr = 0, endPtr = str.length) {
+export function parseString(str, ptr = 0, endPtr = str.length) {
     let isLiteral = str[ptr] === "'";
     let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
     if (isMultiline) {
@@ -62,14 +59,14 @@ function parseString(str, ptr = 0, endPtr = str.length) {
         let c = str[ptr++];
         if (c === '\n' || (c === '\r' && str[ptr] === '\n')) {
             if (!isMultiline) {
-                throw new error_js_1.TomlError('newlines are not allowed in strings', {
+                throw new TomlError('newlines are not allowed in strings', {
                     toml: str,
                     ptr: ptr - 1
                 });
             }
         }
         else if ((c < '\x20' && c !== '\t') || c === '\x7f') {
-            throw new error_js_1.TomlError('control characters are not allowed in strings', {
+            throw new TomlError('control characters are not allowed in strings', {
                 toml: str,
                 ptr: ptr - 1
             });
@@ -80,7 +77,7 @@ function parseString(str, ptr = 0, endPtr = str.length) {
                 // Unicode escape
                 let code = str.slice(ptr, (ptr += (c === 'u' ? 4 : 8)));
                 if (!ESCAPE_REGEX.test(code)) {
-                    throw new error_js_1.TomlError('invalid unicode escape', {
+                    throw new TomlError('invalid unicode escape', {
                         toml: str,
                         ptr: tmp
                     });
@@ -89,7 +86,7 @@ function parseString(str, ptr = 0, endPtr = str.length) {
                     parsed += String.fromCodePoint(parseInt(code, 16));
                 }
                 catch {
-                    throw new error_js_1.TomlError('invalid unicode escape', {
+                    throw new TomlError('invalid unicode escape', {
                         toml: str,
                         ptr: tmp
                     });
@@ -97,21 +94,21 @@ function parseString(str, ptr = 0, endPtr = str.length) {
             }
             else if (isMultiline && (c === '\n' || c === ' ' || c === '\t' || c === '\r')) {
                 // Multiline escape
-                ptr = (0, util_js_1.skipVoid)(str, ptr - 1, true);
+                ptr = skipVoid(str, ptr - 1, true);
                 if (str[ptr] !== '\n' && str[ptr] !== '\r') {
-                    throw new error_js_1.TomlError('invalid escape: only line-ending whitespace may be escaped', {
+                    throw new TomlError('invalid escape: only line-ending whitespace may be escaped', {
                         toml: str,
                         ptr: tmp
                     });
                 }
-                ptr = (0, util_js_1.skipVoid)(str, ptr);
+                ptr = skipVoid(str, ptr);
             }
             else if (c in ESC_MAP) {
                 // Classic escape
                 parsed += ESC_MAP[c];
             }
             else {
-                throw new error_js_1.TomlError('unrecognized escape sequence', {
+                throw new TomlError('unrecognized escape sequence', {
                     toml: str,
                     ptr: tmp
                 });
@@ -126,8 +123,7 @@ function parseString(str, ptr = 0, endPtr = str.length) {
     }
     return parsed + str.slice(sliceStart, endPtr - 1);
 }
-exports.parseString = parseString;
-function parseValue(value, toml, ptr) {
+export function parseValue(value, toml, ptr) {
     // Constant values
     if (value === 'true')
         return true;
@@ -145,33 +141,32 @@ function parseValue(value, toml, ptr) {
     let isInt;
     if ((isInt = INT_REGEX.test(value)) || FLOAT_REGEX.test(value)) {
         if (LEADING_ZERO.test(value)) {
-            throw new error_js_1.TomlError('leading zeroes are not allowed', {
+            throw new TomlError('leading zeroes are not allowed', {
                 toml: toml,
                 ptr: ptr
             });
         }
         let numeric = +(value.replace(/_/g, ''));
         if (isNaN(numeric)) {
-            throw new error_js_1.TomlError('invalid number', {
+            throw new TomlError('invalid number', {
                 toml: toml,
                 ptr: ptr
             });
         }
         if (isInt && !Number.isSafeInteger(numeric)) {
-            throw new error_js_1.TomlError('integer value cannot be represented losslessly', {
+            throw new TomlError('integer value cannot be represented losslessly', {
                 toml: toml,
                 ptr: ptr
             });
         }
         return numeric;
     }
-    let date = new date_js_1.TomlDate(value);
+    let date = new TomlDate(value);
     if (!date.isValid()) {
-        throw new error_js_1.TomlError('invalid value', {
+        throw new TomlError('invalid value', {
             toml: toml,
             ptr: ptr
         });
     }
     return date;
 }
-exports.parseValue = parseValue;

package/dist/stringify.d.ts

@@ -25,4 +25,6 @@
  * 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.
  */
-export declare function stringify(obj: any): string;
+export declare function stringify(obj: any, opts?: {
+    maxDepth?: number;
+}): string;

package/dist/stringify.js

@@ -1,4 +1,3 @@
-"use strict";
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -26,9 +25,7 @@
  * 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.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringify = void 0;
-const BARE_KEY = /^[a-z0-9-_]+$/i;
+let BARE_KEY = /^[a-z0-9-_]+$/i;
 function extendedTypeOf(obj) {
     let type = typeof obj;
     if (type === 'object') {
@@ -49,7 +46,10 @@ function isArrayOfTables(obj) {
 function formatString(s) {
     return JSON.stringify(s).replace(/\x7f/g, '\\u007f');
 }
-function stringifyValue(val, type = extendedTypeOf(val)) {
+function stringifyValue(val, type, depth) {
+    if (depth === 0) {
+        throw new Error("Could not stringify the object: maximum object depth exceeded");
+    }
     if (type === 'number') {
         if (isNaN(val))
             return 'nan';
@@ -72,13 +72,13 @@ function stringifyValue(val, type = extendedTypeOf(val)) {
         return val.toISOString();
     }
     if (type === 'object') {
-        return stringifyInlineTable(val);
+        return stringifyInlineTable(val, depth);
     }
     if (type === 'array') {
-        return stringifyArray(val);
+        return stringifyArray(val, depth);
     }
 }
-function stringifyInlineTable(obj) {
+function stringifyInlineTable(obj, depth) {
     let keys = Object.keys(obj);
     if (keys.length === 0)
         return '{}';
@@ -89,11 +89,11 @@ function stringifyInlineTable(obj) {
             res += ', ';
         res += BARE_KEY.test(k) ? k : formatString(k);
         res += ' = ';
-        res += stringifyValue(obj[k]);
+        res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1);
     }
     return res + ' }';
 }
-function stringifyArray(array) {
+function stringifyArray(array, depth) {
     if (array.length === 0)
         return '[]';
     let res = '[ ';
@@ -103,20 +103,26 @@ function stringifyArray(array) {
         if (array[i] === null || array[i] === void 0) {
             throw new TypeError('arrays cannot contain null or undefined values');
         }
-        res += stringifyValue(array[i]);
+        res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1);
     }
     return res + ' ]';
 }
-function stringifyArrayTable(array, key) {
+function stringifyArrayTable(array, key, depth) {
+    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 += `[[${key}]]\n`;
-        res += stringifyTable(array[i], key);
+        res += stringifyTable(array[i], key, depth);
         res += '\n\n';
     }
     return res;
 }
-function stringifyTable(obj, prefix = '') {
+function stringifyTable(obj, prefix, depth) {
+    if (depth === 0) {
+        throw new Error("Could not stringify the object: maximum object depth exceeded");
+    }
     let preamble = '';
     let tables = '';
     let keys = Object.keys(obj);
@@ -129,28 +135,28 @@ function stringifyTable(obj, prefix = '') {
             }
             let key = BARE_KEY.test(k) ? k : formatString(k);
             if (type === 'array' && isArrayOfTables(obj[k])) {
-                tables += stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key);
+                tables += stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1);
             }
             else if (type === 'object') {
                 let tblKey = prefix ? `${prefix}.${key}` : key;
                 tables += `[${tblKey}]\n`;
-                tables += stringifyTable(obj[k], tblKey);
+                tables += stringifyTable(obj[k], tblKey, depth - 1);
                 tables += '\n\n';
             }
             else {
                 preamble += key;
                 preamble += ' = ';
-                preamble += stringifyValue(obj[k], type);
+                preamble += stringifyValue(obj[k], type, depth);
                 preamble += '\n';
             }
         }
     }
     return `${preamble}\n${tables}`.trim();
 }
-function stringify(obj) {
+export function stringify(obj, opts) {
     if (extendedTypeOf(obj) !== 'object') {
         throw new TypeError('stringify can only be called with an object');
     }
-    return stringifyTable(obj);
+    let maxDepth = opts?.maxDepth ?? 1000;
+    return stringifyTable(obj, '', maxDepth);
 }
-exports.stringify = stringify;

package/dist/struct.d.ts

@@ -27,5 +27,5 @@
  */
 import { type TomlPrimitive } from './util.js';
 export declare function parseKey(str: string, ptr: number, end?: string): [string[], number];
-export declare function parseInlineTable(str: string, ptr: number): [Record<string, TomlPrimitive>, number];
-export declare function parseArray(str: string, ptr: number): [TomlPrimitive[], number];
+export declare function parseInlineTable(str: string, ptr: number, depth: number): [Record<string, TomlPrimitive>, number];
+export declare function parseArray(str: string, ptr: number, depth: number): [TomlPrimitive[], number];

package/dist/struct.js

@@ -1,4 +1,3 @@
-"use strict";
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -26,19 +25,17 @@
  * 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.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseArray = exports.parseInlineTable = exports.parseKey = void 0;
-const primitive_js_1 = require("./primitive.js");
-const extract_js_1 = require("./extract.js");
-const util_js_1 = require("./util.js");
-const error_js_1 = require("./error.js");
+import { parseString } from './primitive.js';
+import { extractValue } from './extract.js';
+import { skipComment, indexOfNewline, getStringEnd, skipVoid } from './util.js';
+import { TomlError } from './error.js';
 let KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
-function parseKey(str, ptr, end = '=') {
+export function parseKey(str, ptr, end = '=') {
     let dot = ptr - 1;
     let parsed = [];
     let endPtr = str.indexOf(end, ptr);
     if (endPtr < 0) {
-        throw new error_js_1.TomlError('incomplete key-value: cannot find end of key', {
+        throw new TomlError('incomplete key-value: cannot find end of key', {
             toml: str,
             ptr: ptr
         });
@@ -50,29 +47,29 @@ function parseKey(str, ptr, end = '=') {
             // If it's a string
             if (c === '"' || c === "'") {
                 if (c === str[ptr + 1] && c === str[ptr + 2]) {
-                    throw new error_js_1.TomlError('multiline strings are not allowed in keys', {
+                    throw new TomlError('multiline strings are not allowed in keys', {
                         toml: str,
                         ptr: ptr,
                     });
                 }
-                let eos = (0, util_js_1.getStringEnd)(str, ptr);
+                let eos = getStringEnd(str, ptr);
                 if (eos < 0) {
-                    throw new error_js_1.TomlError('unfinished string encountered', {
+                    throw new TomlError('unfinished string encountered', {
                         toml: str,
                         ptr: ptr,
                     });
                 }
                 dot = str.indexOf('.', eos);
                 let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
-                let newLine = (0, util_js_1.indexOfNewline)(strEnd);
+                let newLine = indexOfNewline(strEnd);
                 if (newLine > -1) {
-                    throw new error_js_1.TomlError('newlines are not allowed in keys', {
+                    throw new TomlError('newlines are not allowed in keys', {
                         toml: str,
                         ptr: ptr + dot + newLine,
                     });
                 }
                 if (strEnd.trimStart()) {
-                    throw new error_js_1.TomlError('found extra tokens after the string part', {
+                    throw new TomlError('found extra tokens after the string part', {
                         toml: str,
                         ptr: eos,
                     });
@@ -80,20 +77,20 @@ function parseKey(str, ptr, end = '=') {
                 if (endPtr < eos) {
                     endPtr = str.indexOf(end, eos);
                     if (endPtr < 0) {
-                        throw new error_js_1.TomlError('incomplete key-value: cannot find end of key', {
+                        throw new TomlError('incomplete key-value: cannot find end of key', {
                             toml: str,
                             ptr: ptr,
                         });
                     }
                 }
-                parsed.push((0, primitive_js_1.parseString)(str, ptr, eos));
+                parsed.push(parseString(str, ptr, eos));
             }
             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 error_js_1.TomlError('only letter, numbers, dashes and underscores are allowed in keys', {
+                    throw new TomlError('only letter, numbers, dashes and underscores are allowed in keys', {
                         toml: str,
                         ptr: ptr,
                     });
@@ -103,10 +100,9 @@ function parseKey(str, ptr, end = '=') {
         }
         // Until there's no more dot
     } while (dot + 1 && dot < endPtr);
-    return [parsed, (0, util_js_1.skipVoid)(str, endPtr + 1, true, true)];
+    return [parsed, skipVoid(str, endPtr + 1, true, true)];
 }
-exports.parseKey = parseKey;
-function parseInlineTable(str, ptr) {
+export function parseInlineTable(str, ptr, depth) {
     let res = {};
     let seen = new Set();
     let c;
@@ -114,19 +110,19 @@ function parseInlineTable(str, ptr) {
     ptr++;
     while ((c = str[ptr++]) !== '}' && c) {
         if (c === '\n') {
-            throw new error_js_1.TomlError('newlines are not allowed in inline tables', {
+            throw new TomlError('newlines are not allowed in inline tables', {
                 toml: str,
                 ptr: ptr - 1
             });
         }
         else if (c === '#') {
-            throw new error_js_1.TomlError('inline tables cannot contain comments', {
+            throw new TomlError('inline tables cannot contain comments', {
                 toml: str,
                 ptr: ptr - 1
             });
         }
         else if (c === ',') {
-            throw new error_js_1.TomlError('expected key-value, found comma', {
+            throw new TomlError('expected key-value, found comma', {
                 toml: str,
                 ptr: ptr - 1
             });
@@ -141,7 +137,7 @@ function parseInlineTable(str, ptr) {
                     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 error_js_1.TomlError('trying to redefine an already defined value', {
+                    throw new TomlError('trying to redefine an already defined value', {
                         toml: str,
                         ptr: ptr
                     });
@@ -151,12 +147,12 @@ function parseInlineTable(str, ptr) {
                 }
             }
             if (hasOwn) {
-                throw new error_js_1.TomlError('trying to redefine an already defined value', {
+                throw new TomlError('trying to redefine an already defined value', {
                     toml: str,
                     ptr: ptr
                 });
             }
-            let [value, valueEndPtr] = (0, extract_js_1.extractValue)(str, keyEndPtr, '}');
+            let [value, valueEndPtr] = extractValue(str, keyEndPtr, '}', depth - 1);
             seen.add(value);
             t[k] = value;
             ptr = valueEndPtr;
@@ -164,45 +160,43 @@ function parseInlineTable(str, ptr) {
         }
     }
     if (comma) {
-        throw new error_js_1.TomlError('trailing commas are not allowed in inline tables', {
+        throw new TomlError('trailing commas are not allowed in inline tables', {
             toml: str,
             ptr: comma
         });
     }
     if (!c) {
-        throw new error_js_1.TomlError('unfinished table encountered', {
+        throw new TomlError('unfinished table encountered', {
             toml: str,
             ptr: ptr
         });
     }
     return [res, ptr];
 }
-exports.parseInlineTable = parseInlineTable;
-function parseArray(str, ptr) {
+export function parseArray(str, ptr, depth) {
     let res = [];
     let c;
     ptr++;
     while ((c = str[ptr++]) !== ']' && c) {
         if (c === ',') {
-            throw new error_js_1.TomlError('expected value, found comma', {
+            throw new TomlError('expected value, found comma', {
                 toml: str,
                 ptr: ptr - 1
             });
         }
         else if (c === '#')
-            ptr = (0, util_js_1.skipComment)(str, ptr);
+            ptr = skipComment(str, ptr);
         else if (c !== ' ' && c !== '\t' && c !== '\n' && c !== '\r') {
-            let e = (0, extract_js_1.extractValue)(str, ptr - 1, ']');
+            let e = extractValue(str, ptr - 1, ']', depth - 1);
             res.push(e[0]);
             ptr = e[1];
         }
     }
     if (!c) {
-        throw new error_js_1.TomlError('unfinished array encountered', {
+        throw new TomlError('unfinished array encountered', {
             toml: str,
             ptr: ptr
         });
     }
     return [res, ptr];
 }
-exports.parseArray = parseArray;