smol-toml 1.0.0 → 1.1.0

package/README.md

@@ -1,8 +1,9 @@
 # smol-toml
+[![TOML 1.0.0](https://img.shields.io/badge/TOML-1.0.0-9c4221?style=flat-square)](https://toml.io/en/v1.0.0)
 [![License](https://img.shields.io/github/license/squirrelchat/smol-toml.svg?style=flat-square)](https://github.com/squirrelchat/smol-toml/blob/mistress/LICENSE)
 [![npm](https://img.shields.io/npm/v/smol-toml?style=flat-square)](https://npm.im/smol-toml)
 
-A small, fast, and correct TOML parser. smol-toml is fully spec-compliant with TOML v1.0.0.
+A small, fast, and correct TOML parser and serializer. smol-toml is fully(ish) spec-compliant with TOML v1.0.0.
 
 Why yet another TOML parser? Well, the ecosystem of TOML parsers in JavaScript is quite underwhelming, most likely due
 to a lack of interest. With most parsers being outdated, unmaintained, non-compliant, or a combination of these, a new
@@ -10,7 +11,32 @@ parser didn't feel too out of place.
 
 *[insert xkcd 927]*
 
-smol-toml produces valid results (or errors) for all the test TOML files in https://github.com/iarna/toml-spec-tests.
+smol-toml passes most of the tests from [BurntSushi's `toml-test` suite](https://github.com/BurntSushi/toml-test).
+However, due to the nature of JavaScript and the limits of the language, it doesn't pass certain tests, namely:
+- Invalid UTF-8 strings are not rejected
+- Certain invalid UTF-8 codepoints are not rejected
+- smol-toml doesn't preserve type information between integers and floats (in JS, everything is a float)
+- smol-toml doesn't support the whole 64-bit range for integers (but does throw an appropriate error)
+  - As all numbers are floats in JS, the safe range is `2**53 - 1` <=> `-(2**53 - 1)`.
+
+smol-toml also passes all of the tests in https://github.com/iarna/toml-spec-tests.
+
+<details>
+<summary>List of failed `toml-test` cases</summary>
+
+These tests were done by modifying `primitive.ts` and make the implementation return bigints for integers. This allows
+verifying the parser correctly intents a number to be an integer or a float.
+
+*Ideally, this becomes an option of the library, but for now...*
+
+The following parse tests are failing:
+- invalid/encoding/bad-utf8-in-comment
+- invalid/encoding/bad-utf8-in-multiline-literal
+- invalid/encoding/bad-utf8-in-multiline
+- invalid/encoding/bad-utf8-in-string-literal
+- invalid/encoding/bad-utf8-in-string
+- invalid/string/bad-codepoint
+</details>
 
 ## Installation
 ```
@@ -19,11 +45,65 @@ smol-toml produces valid results (or errors) for all the test TOML files in http
 
 ## Usage
 ```js
-import { parse } from 'smol-toml'
+import { parse, stringify } from 'smol-toml'
 
 const doc = '...'
 const parsed = parse(doc)
 console.log(parsed)
+
+const toml = stringify(parsed)
+console.log(toml)
+```
+
+A few notes on the `stringify` function:
+- `undefined` and `null` values on objects are ignored (does not produce a key/value).
+- `undefined` and `null` values in arrays are **rejected**.
+- Functions, classes and symbols are **rejected**.
+- floats will be serialized as integers if they don't have a decimal part.
+  - `stringify(parse('a = 1.0')) === 'a = 1'`
+- JS `Date` will be serialized as Offset Date Time
+  - Use the [`TomlDate` object](#dates) for representing other types.
+
+### Dates
+`smol-toml` uses an extended `Date` object to represent all types of TOML Dates. In the future, `smol-toml` will use
+objects from the Temporal proposal, but for now we're stuck with the legacy Date object.
+
+```js
+import { TomlDate } from 'smol-toml'
+
+// Offset Date Time
+const date = new TomlDate('1979-05-27T07:32:00.000-08:00')
+console.log(date.isDateTime(), date.isDate(), date.isTime(), date.isLocal()) // ~> true, false, false, false
+console.log(date.toISOString()) // ~> 1979-05-27T07:32:00.000-08:00
+
+// Local Date Time
+const date = new TomlDate('1979-05-27T07:32:00.000')
+console.log(date.isDateTime(), date.isDate(), date.isTime(), date.isLocal()) // ~> true, false, false, true
+console.log(date.toISOString()) // ~> 1979-05-27T07:32:00.000
+
+// Local Date
+const date = new TomlDate('1979-05-27')
+console.log(date.isDateTime(), date.isDate(), date.isTime(), date.isLocal()) // ~> false, true, false, true
+console.log(date.toISOString()) // ~> 1979-05-27
+
+// Local Time
+const date = new TomlDate('07:32:00')
+console.log(date.isDateTime(), date.isDate(), date.isTime(), date.isLocal()) // ~> false, false, true, true
+console.log(date.toISOString()) // ~> 07:32:00.000
+```
+
+You can also wrap a native `Date` object and specify using different methods depending on the type of date you wish
+to represent:
+
+```js
+import { TomlDate } from 'smol-toml'
+
+const jsDate = new Date()
+
+const offsetDateTime = TomlDate.wrapAsOffsetDateTime(jsDate)
+const localDateTime = TomlDate.wrapAsLocalDateTime(jsDate)
+const localDate = TomlDate.wrapAsLocalDate(jsDate)
+const localTime = TomlDate.wrapAsLocalTime(jsDate)
 ```
 
 ## Performance
@@ -36,43 +116,80 @@ idea is to have a file relatively close to a real-world application.
 
 The large TOML generator can be found [here](https://gist.github.com/cyyynthia/e77c744cb6494dabe37d0182506526b9)
 
-|                | smol-toml           | @iarna/toml@3.0.0 | @ltd/j-toml    | fast-toml      |
-|----------------|---------------------|-------------------|----------------|----------------|
-| Spec example   | **60,733.91 op/s**  | 32,565.20 op/s    | 16,781.03 op/s | 31,336.67 op/s |
-| ~5MB test file | **4.2567 op/s**     | *DNF*             | 2.4873 op/s    | 2.5790 op/s    |
+| **Parse**      | smol-toml           | @iarna/toml@3.0.0 | @ltd/j-toml     | fast-toml       |
+|----------------|---------------------|-------------------|-----------------|-----------------|
+| Spec example   | **71,356.51 op/s**  | 33,629.31 op/s    | 16,433.86 op/s  | 29,421.60 op/s  |
+| ~5MB test file | **3.8091 op/s**     | *DNF*             | 2.4369 op/s     | 2.6078 op/s     |
+
+| **Stringify**  | smol-toml            | @iarna/toml@3.0.0 | @ltd/j-toml    |
+|----------------|----------------------|-------------------|----------------|
+| Spec example   | **195,191.99 op/s**  | 46,583.07 op/s    | 5,670.12 op/s  |
+| ~5MB test file | **14.6709 op/s**     | 3.5941 op/s       | 0.7856 op/s    |
 
 <details>
 <summary>Detailed benchmark data</summary>
 
-Tests ran using Vitest v0.31.0 on commit 361089f3dbc30d994494bf6ec1e8e2f135531247
+Tests ran using Vitest v0.31.0 on commit f58cb6152e667e9cea09f31c93d90652e3b82bf5
 
 CPU: Intel Core i7 7700K (4.2GHz)
 
 ```
  RUN  v0.31.0
 
- ✓ bench/parseSpecExample.bench.ts (4) 2466ms
+ ✓ bench/parseSpecExample.bench.ts (4) 2462ms
      name                hz     min     max    mean     p75     p99    p995    p999     rme  samples
-   · smol-toml    60,733.91  0.0145  0.2580  0.0165  0.0152  0.0319  0.0345  0.1383  ±0.46%    30367   fastest
-   · @iarna/toml  32,565.20  0.0268  0.3208  0.0307  0.0284  0.0580  0.0619  0.1699  ±0.54%    16283
-   · @ltd/j-toml  16,781.03  0.0505  1.0392  0.0596  0.0540  0.1147  0.1360  0.7657  ±1.52%     8391   slowest
-   · fast-toml    31,336.67  0.0298  0.3357  0.0319  0.0305  0.0578  0.0622  0.1580  ±0.41%    15669
- ✓ bench/parseLargeMixed.bench.ts (3) 15752ms
+   · smol-toml    71,356.51  0.0132  0.2633  0.0140  0.0137  0.0219  0.0266  0.1135  ±0.37%    35679   fastest
+   · @iarna/toml  33,629.31  0.0272  0.2629  0.0297  0.0287  0.0571  0.0650  0.1593  ±0.45%    16815
+   · @ltd/j-toml  16,433.86  0.0523  1.3088  0.0608  0.0550  0.1140  0.1525  0.7348  ±1.47%     8217   slowest
+   · fast-toml    29,421.60  0.0305  0.2995  0.0340  0.0312  0.0618  0.0640  0.1553  ±0.47%    14711
+ ✓ bench/parseLargeMixed.bench.ts (3) 16062ms
      name             hz     min     max    mean     p75     p99    p995    p999     rme  samples
-   · smol-toml    4.2567  225.85  257.42  234.92  242.74  257.42  257.42  257.42  ±3.35%       10   fastest
-   · @ltd/j-toml  2.4873  382.66  441.12  402.05  416.25  441.12  441.12  441.12  ±3.40%       10   slowest
-   · fast-toml    2.5790  377.86  409.32  387.75  392.90  409.32  409.32  409.32  ±2.07%       10
+   · smol-toml    3.8091  239.60  287.30  262.53  274.17  287.30  287.30  287.30  ±3.66%       10   fastest
+   · @ltd/j-toml  2.4369  376.73  493.49  410.35  442.58  493.49  493.49  493.49  ±7.08%       10   slowest
+   · fast-toml    2.6078  373.88  412.79  383.47  388.62  412.79  412.79  412.79  ±2.72%       10
+ ✓ bench/stringifySpecExample.bench.ts (3) 1886ms
+     name                 hz     min     max    mean     p75     p99    p995    p999     rme  samples
+   · smol-toml    195,191.99  0.0047  0.2704  0.0051  0.0050  0.0099  0.0110  0.0152  ±0.41%    97596   fastest
+   · @iarna/toml   46,583.07  0.0197  0.2808  0.0215  0.0208  0.0448  0.0470  0.1704  ±0.47%    23292
+   · @ltd/j-toml    5,670.12  0.1613  0.5768  0.1764  0.1726  0.3036  0.3129  0.4324  ±0.56%     2836   slowest
+ ✓ bench/stringifyLargeMixed.bench.ts (3) 24057ms
+     name              hz       min       max      mean       p75       p99      p995      p999     rme  samples
+   · smol-toml    14.6709   65.1071   79.2199   68.1623   67.1088   79.2199   79.2199   79.2199  ±5.25%       10   fastest
+   · @iarna/toml   3.5941    266.48    295.24    278.24    290.10    295.24    295.24    295.24  ±2.83%       10
+   · @ltd/j-toml   0.7856  1,254.33  1,322.05  1,272.87  1,286.82  1,322.05  1,322.05  1,322.05  ±1.37%       10   slowest
 
 
  BENCH  Summary
 
   smol-toml - bench/parseLargeMixed.bench.ts >
-    1.65x faster than fast-toml
-    1.71x faster than @ltd/j-toml
+    1.46x faster than fast-toml
+    1.56x faster than @ltd/j-toml
 
   smol-toml - bench/parseSpecExample.bench.ts >
-    1.86x faster than @iarna/toml
-    1.94x faster than fast-toml
-    3.62x faster than @ltd/j-toml
+    2.12x faster than @iarna/toml
+    2.43x faster than fast-toml
+    4.34x faster than @ltd/j-toml
+
+  smol-toml - bench/stringifyLargeMixed.bench.ts >
+    4.00x faster than @iarna/toml
+    18.33x faster than @ltd/j-toml
+
+  smol-toml - bench/stringifySpecExample.bench.ts >
+    4.19x faster than @iarna/toml
+    34.42x faster than @ltd/j-toml
 ```
+
+---
+Additional notes:
+
+I initially tried to benchmark `toml-nodejs`, but the 0.3.0 package is broken.
+I initially reported this to the library author, but the author decided to
+- a) advise to use a custom loader (via *experimental* flag) to circumvent the invalid imports.
+  - Said flag, `--experimental-specifier-resolution`, has been removed in Node v20.
+- b) [delete the issue](https://github.com/huan231/toml-nodejs/issues/12) when pointed out links to the NodeJS
+documentation about the flag removal and standard resolution algorithm.
+
+For the reference anyways, `toml-nodejs` (with proper imports) is ~8x slower on both parse benchmark with:
+- spec example: 7,543.47 op/s
+- 5mb mixed: 0.7006 op/s
 </details>

package/dist/date.d.ts

@@ -25,7 +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 let DATE_TIME_RE: RegExp;
 export default class TomlDate extends Date {
     #private;
     constructor(date: string | Date);
@@ -33,6 +32,7 @@ export default class TomlDate extends Date {
     isLocal(): boolean;
     isDate(): boolean;
     isTime(): boolean;
+    isValid(): boolean;
     toISOString(): string;
     static wrapAsOffsetDateTime(jsDate: Date, offset?: string): TomlDate;
     static wrapAsLocalDateTime(jsDate: Date): TomlDate;

package/dist/date.js

@@ -25,11 +25,11 @@
  * 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 let DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(\d{2}:\d{2}:\d{2}(?:\.\d{3,})?)?(Z|[-+]\d{2}:\d{2})?$/;
+let DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}:\d{2}(?:\.\d+)?)?(Z|[-+]\d{2}:\d{2})?$/i;
 export default class TomlDate extends Date {
-    #hasDate;
-    #hasTime;
-    #offset;
+    #hasDate = false;
+    #hasTime = false;
+    #offset = null;
     constructor(date) {
         let hasDate = true;
         let hasTime = true;
@@ -42,16 +42,23 @@ export default class TomlDate extends Date {
                     date = `0000-01-01T${date}`;
                 }
                 hasTime = !!match[2];
-                offset = match[3] || null;
+                // Do not allow rollover hours
+                if (match[2] && +match[2] > 23) {
+                    date = '';
+                }
+                else {
+                    offset = match[3] || null;
+                    date = date.toUpperCase();
+                    if (!offset)
+                        date += 'Z';
+                }
+            }
+            else {
+                date = '';
             }
         }
         super(date);
-        if (isNaN(this.getTime())) {
-            this.#hasDate = false;
-            this.#hasTime = false;
-            this.#offset = null;
-        }
-        else {
+        if (!isNaN(this.getTime())) {
             this.#hasDate = hasDate;
             this.#hasTime = hasTime;
             this.#offset = offset;
@@ -61,7 +68,7 @@ export default class TomlDate extends Date {
         return this.#hasDate && this.#hasTime;
     }
     isLocal() {
-        return !this.#hasTime || !this.#hasTime || !this.#offset;
+        return !this.#hasDate || !this.#hasTime || !this.#offset;
     }
     isDate() {
         return this.#hasDate && !this.#hasTime;
@@ -69,6 +76,9 @@ export default class TomlDate extends Date {
     isTime() {
         return this.#hasTime && !this.#hasDate;
     }
+    isValid() {
+        return this.#hasDate || this.#hasTime;
+    }
     toISOString() {
         let iso = super.toISOString();
         // Local Date

package/dist/extract.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * 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 TomlPrimitive } from './util.js';
+export declare function extractValue(str: string, ptr: number, end?: string): [TomlPrimitive, number];

package/dist/extract.js

@@ -0,0 +1,92 @@
+/*!
+ * 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 { parseString, parseValue } from './primitive.js';
+import { parseArray, parseInlineTable } from './struct.js';
+import { indexOfNewline, skipVoid, skipUntil, skipComment, getStringEnd } from './util.js';
+import TomlError from './error.js';
+function sliceAndTrimEndOf(str, startPtr, endPtr, allowNewLines) {
+    let value = str.slice(startPtr, endPtr);
+    let commentIdx = value.indexOf('#');
+    if (commentIdx > -1) {
+        // The call to skipComment allows to "validate" the comment
+        // (absence of control characters)
+        skipComment(str, commentIdx);
+        value = value.slice(0, commentIdx);
+    }
+    let trimmed = value.trimEnd();
+    if (!allowNewLines) {
+        let newlineIdx = value.indexOf('\n', trimmed.length);
+        if (newlineIdx > -1) {
+            throw new TomlError('newlines are not allowed in inline tables', {
+                toml: str,
+                ptr: startPtr + newlineIdx
+            });
+        }
+    }
+    return [trimmed, commentIdx];
+}
+export function extractValue(str, ptr, end) {
+    let c = str[ptr];
+    if (c === '[' || c === '{') {
+        let [value, endPtr] = c === '['
+            ? parseArray(str, ptr)
+            : parseInlineTable(str, ptr);
+        let newPtr = skipUntil(str, endPtr, ',', end);
+        if (end === '}') {
+            let nextNewLine = indexOfNewline(str, endPtr, newPtr);
+            if (nextNewLine > -1) {
+                throw new TomlError('newlines are not allowed in inline tables', {
+                    toml: str,
+                    ptr: nextNewLine
+                });
+            }
+        }
+        return [value, newPtr];
+    }
+    let endPtr;
+    if (c === '"' || c === "'") {
+        endPtr = getStringEnd(str, ptr);
+        return [parseString(str, ptr, endPtr), endPtr + +(!!end && str[endPtr] === ',')];
+    }
+    endPtr = skipUntil(str, ptr, ',', end);
+    let slice = sliceAndTrimEndOf(str, ptr, endPtr - (+(str[endPtr - 1] === ',')), end === ']');
+    if (!slice[0]) {
+        throw new TomlError('incomplete key-value declaration: no value specified', {
+            toml: str,
+            ptr: ptr
+        });
+    }
+    if (end && slice[1] > -1) {
+        endPtr = skipVoid(str, ptr + slice[1]);
+        endPtr += +(str[endPtr] === ',');
+    }
+    return [
+        parseValue(slice[0], str, ptr),
+        endPtr,
+    ];
+}

package/dist/index.d.ts

@@ -25,6 +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.
  */
-import { type TomlPrimitive } from './util.js';
+export { default as TomlError } from './error.js';
 export { default as TomlDate } from './date.js';
-export declare function parse(toml: string): Record<string, TomlPrimitive>;
+export { parse } from './parse.js';
+export { stringify } from './stringify.js';

package/dist/index.js

@@ -25,66 +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.
  */
-import { parseKey } from './struct.js';
-import { extractKeyValue } from './parse.js';
-import { skipVoid, peekTable } from './util.js';
-import TomlError from './error.js';
+export { default as TomlError } from './error.js';
 export { default as TomlDate } from './date.js';
-export function parse(toml) {
-    let res = {};
-    let tbl = res;
-    let seenTables = new Set();
-    let seenValues = new Set();
-    for (let ptr = skipVoid(toml, 0); ptr < toml.length;) {
-        if (toml[ptr] === '[') {
-            let isTableArray = toml[ptr + 1] === '[';
-            let end = toml.indexOf(']', ptr);
-            if (end === -1)
-                throw new TomlError('unfinished table encountered', {
-                    toml: toml,
-                    ptr: ptr
-                });
-            let k = parseKey(toml, ptr += +isTableArray + 1, end++);
-            let strKey = k.join('"."');
-            if (!isTableArray && seenTables.has(strKey))
-                throw new TomlError('trying to redefine an already defined table', {
-                    toml: toml,
-                    ptr: ptr - 1
-                });
-            seenTables.add(strKey);
-            let r = peekTable(res, k, seenValues, true);
-            if (!r) {
-                throw new TomlError('trying to redefine an already defined value', {
-                    toml: toml,
-                    ptr: ptr - 1
-                });
-            }
-            let v = r[1][r[0]];
-            if (!v) {
-                r[1][r[0]] = (v = isTableArray ? [] : {});
-            }
-            else if (isTableArray && !Array.isArray(v)) {
-                throw new TomlError('trying to define an array of tables, but a table already exists for this identifier', {
-                    toml: toml,
-                    ptr: ptr - 2
-                });
-            }
-            tbl = v;
-            if (isTableArray)
-                v.push(tbl = {});
-            ptr = end + +isTableArray;
-        }
-        else {
-            ptr = extractKeyValue(toml, ptr, tbl, seenValues);
-        }
-        ptr = skipVoid(toml, ptr, true);
-        if (toml[ptr] && toml[ptr] !== '\n' && toml[ptr] !== '\r') {
-            throw new TomlError('each key-value declaration must be followed by an end-of-line', {
-                toml: toml,
-                ptr: ptr
-            });
-        }
-        ptr = skipVoid(toml, ptr);
-    }
-    return res;
-}
+export { parse } from './parse.js';
+export { stringify } from './stringify.js';

package/dist/parse.d.ts

@@ -26,5 +26,4 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import { type TomlPrimitive } from './util.js';
-export declare function extractValue(str: string, ptr: number, end?: string): [TomlPrimitive, number];
-export declare function extractKeyValue(str: string, ptr: number, table: Record<string, TomlPrimitive>, seen: Set<any>, isInline?: boolean): number;
+export declare function parse(toml: string): Record<string, TomlPrimitive>;