smol-toml 0.1.0 → 1.0.1

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 (almost) fully spec-compliant with TOML v1.0.0.
+A small, fast, and correct TOML parser. 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,12 +11,31 @@ parser didn't feel too out of place.
 
 *[insert xkcd 927]*
 
-smol-toml only fails to comply with the spec in 2 (minor) ways:
-- comments are not validated (absence of control characters)
-- integers can only be between -9_007_199_254_740_991 and 9_007_199_254_740_991 instead of the recommended full 64-bit range
-	- integers outside of this range do raise an error, complying with the specification on this regard
+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)`.
 
-Otherwise, smol-toml produces valid results (or errors) for all the test TOML files in https://github.com/iarna/toml-spec-tests
+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 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
 ```
@@ -43,28 +63,55 @@ The large TOML generator can be found [here](https://gist.github.com/cyyynthia/e
 
 |                | smol-toml           | @iarna/toml@3.0.0 | @ltd/j-toml    | fast-toml      |
 |----------------|---------------------|-------------------|----------------|----------------|
-| Spec example   | **37,009.05 op/s**  | 29,203.53 op/s    | 16,225.50 op/s | 23,886.25 op/s |
-| ~5MB test file | **4.6007 op/s**     | *DNF*             | 2.4919 op/s    | 2.5952 op/s    |
+| 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    |
 
 <details>
 <summary>Detailed benchmark data</summary>
 
-Tests ran using Vitest v0.31.0 on commit bd69ffb52920ee6f2843356dff3325fc2e868821
+Tests ran using Vitest v0.31.0 on commit 04d233e351f9ae719222154ee2217aea8b95dbab
 
 CPU: Intel Core i7 7700K (4.2GHz)
 
 ```
-✓ bench/parse.bench.ts (7) 17780ms
-   ✓ TOML spec example (4) 17778ms
+ RUN  v0.31.0
+
+ ✓ bench/parseSpecExample.bench.ts (4) 2462ms
      name                hz     min     max    mean     p75     p99    p995    p999     rme  samples
-   · smol-toml    37,009.05  0.0231  4.1194  0.0270  0.0260  0.0445  0.0500  0.0622  ±2.88%    18505   fastest
-   · @iarna/toml  29,203.53  0.0308  2.1478  0.0342  0.0325  0.0687  0.0714  0.2747  ±1.08%    14602
-   · @ltd/j-toml  16,225.50  0.0519  2.8481  0.0616  0.0545  0.1015  0.1193  1.9987  ±3.20%     8113   slowest
-   · fast-toml    23,886.25  0.0366  1.7331  0.0419  0.0391  0.0758  0.0818  1.1500  ±1.84%    11944
-   ✓ 5MB of TOML (all structures) (3) 17268ms
+   · 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.6007  208.19  238.94  217.36  229.56  238.94  238.94  238.94  ±4.10%       10   fastest
-   · @ltd/j-toml  2.4919  379.85  428.13  401.31  416.64  428.13  428.13  428.13  ±2.82%       10   slowest
-   · fast-toml    2.5952  375.28  416.15  385.33  393.15  416.15  416.15  416.15  ±2.60%       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  Summary
+
+  smol-toml - bench/parseLargeMixed.bench.ts >
+    1.46x faster than fast-toml
+    1.56x faster than @ltd/j-toml
+
+  smol-toml - bench/parseSpecExample.bench.ts >
+    2.12x faster than @iarna/toml
+    2.43x faster than fast-toml
+    4.34x 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 benchmark with:
+- spec example: 7,543.47 op/s
+- 5mb mixed: 0.7006 op/s
 </details>

package/dist/date.d.ts

@@ -0,0 +1,41 @@
+/*!
+ * 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.
+ */
+export default class TomlDate extends Date {
+    #private;
+    constructor(date: string | Date);
+    isDateTime(): boolean;
+    isLocal(): boolean;
+    isDate(): boolean;
+    isTime(): boolean;
+    isValid(): boolean;
+    toISOString(): string;
+    static wrapAsOffsetDateTime(jsDate: Date, offset?: string): TomlDate;
+    static wrapAsLocalDateTime(jsDate: Date): TomlDate;
+    static wrapAsLocalDate(jsDate: Date): TomlDate;
+    static wrapAsLocalTime(jsDate: Date): TomlDate;
+}

package/dist/date.js

@@ -0,0 +1,123 @@
+/*!
+ * 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 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 = false;
+    #hasTime = false;
+    #offset = null;
+    constructor(date) {
+        let hasDate = true;
+        let hasTime = true;
+        let offset = 'Z';
+        if (typeof date === 'string') {
+            let match = date.match(DATE_TIME_RE);
+            if (match) {
+                if (!match[1]) {
+                    hasDate = false;
+                    date = `0000-01-01T${date}`;
+                }
+                hasTime = !!match[2];
+                // Do not allow rollover hours
+                if (match[2] && +match[2] > 23) {
+                    date = '';
+                }
+                else {
+                    offset = match[3] || null;
+                    date = date.toUpperCase();
+                }
+            }
+            else {
+                date = '';
+            }
+        }
+        super(date);
+        if (!isNaN(this.getTime())) {
+            this.#hasDate = hasDate;
+            this.#hasTime = hasTime;
+            this.#offset = offset;
+        }
+    }
+    isDateTime() {
+        return this.#hasDate && this.#hasTime;
+    }
+    isLocal() {
+        return !this.#hasDate || !this.#hasTime || !this.#offset;
+    }
+    isDate() {
+        return this.#hasDate && !this.#hasTime;
+    }
+    isTime() {
+        return this.#hasTime && !this.#hasDate;
+    }
+    isValid() {
+        return this.#hasDate || this.#hasTime;
+    }
+    toISOString() {
+        let iso = super.toISOString();
+        // Local Date
+        if (this.isDate())
+            return iso.slice(0, 10);
+        // Local Time
+        if (this.isTime())
+            return iso.slice(11, 23);
+        // Local DateTime
+        if (this.#offset === null)
+            return iso.slice(0, -1);
+        // Offset DateTime
+        if (this.#offset === 'Z')
+            return iso;
+        // This part is quite annoying: JS strips the original timezone from the ISO string representation
+        // Instead of using a "modified" date and "Z", we restore the representation "as authored"
+        let offset = (+(this.#offset.slice(1, 3)) * 60) + +(this.#offset.slice(4, 6));
+        offset = this.#offset[0] === '-' ? offset : -offset;
+        let offsetDate = new Date(this.getTime() - (offset * 60e3));
+        return offsetDate.toISOString().slice(0, -1) + this.#offset;
+    }
+    static wrapAsOffsetDateTime(jsDate, offset = 'Z') {
+        let date = new TomlDate(jsDate);
+        date.#offset = offset;
+        return date;
+    }
+    static wrapAsLocalDateTime(jsDate) {
+        let date = new TomlDate(jsDate);
+        date.#offset = null;
+        return date;
+    }
+    static wrapAsLocalDate(jsDate) {
+        let date = new TomlDate(jsDate);
+        date.#hasTime = false;
+        date.#offset = null;
+        return date;
+    }
+    static wrapAsLocalTime(jsDate) {
+        let date = new TomlDate(jsDate);
+        date.#hasDate = false;
+        date.#offset = null;
+        return date;
+    }
+}

package/dist/index.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 parse(toml: string): {};
+import { type TomlPrimitive } from './util.js';
+export { default as TomlDate } from './date.js';
+export declare function parse(toml: string): Record<string, TomlPrimitive>;

package/dist/index.js

@@ -26,56 +26,115 @@
  * 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 { extractValue } from './parse.js';
+import { skipVoid } from './util.js';
 import TomlError from './error.js';
+export { default as TomlDate } from './date.js';
+function peekTable(key, table, meta, type) {
+    let t = table;
+    let m = meta;
+    let k;
+    let hasOwn = false;
+    let state;
+    for (let i = 0; i < key.length; i++) {
+        if (i) {
+            t = hasOwn ? t[k] : (t[k] = {});
+            m = (state = m[k]).c;
+            if (type === 0 /* Type.DOTTED */ && state.t === 1 /* Type.EXPLICIT */) {
+                return null;
+            }
+            if (state.t === 2 /* Type.ARRAY */) {
+                let l = t.length - 1;
+                t = t[l];
+                m = m[l].c;
+            }
+        }
+        k = key[i];
+        if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 /* Type.DOTTED */ && m[k]?.d) {
+            return null;
+        }
+        if (!hasOwn) {
+            if (k === '__proto__') {
+                Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+                Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+            }
+            m[k] = {
+                t: i < key.length - 1 && type === 2 /* Type.ARRAY */
+                    ? 0 /* Type.DOTTED */
+                    : type,
+                d: false,
+                i: 0,
+                c: {},
+            };
+        }
+    }
+    state = m[k];
+    if (state.t !== type) {
+        // Bad key type!
+        return null;
+    }
+    if (type === 2 /* Type.ARRAY */) {
+        if (!state.d) {
+            state.d = true;
+            t[k] = [];
+        }
+        t[k].push(t = {});
+        state.c[state.i++] = (state = { t: 1 /* Type.EXPLICIT */, d: false, i: 0, c: {} });
+    }
+    if (state.d) {
+        // Redefining a table!
+        return null;
+    }
+    state.d = true;
+    if (type === 1 /* Type.EXPLICIT */) {
+        t = hasOwn ? t[k] : (t[k] = {});
+    }
+    else if (type === 0 /* Type.DOTTED */ && hasOwn) {
+        return null;
+    }
+    return [k, t, state.c];
+}
 export function parse(toml) {
     let res = {};
+    let meta = {};
     let tbl = res;
-    let seenTables = new Set();
-    let seenValues = new Set();
-    toml = toml.trim();
+    let m = meta;
     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 ? [] : {});
+            let isTableArray = toml[++ptr] === '[';
+            let k = parseKey(toml, ptr += +isTableArray, ']');
+            if (isTableArray) {
+                if (toml[k[1] - 1] !== ']') {
+                    throw new TomlError('expected end of table declaration', {
+                        toml: toml,
+                        ptr: k[1] - 1,
+                    });
+                }
+                k[1]++;
             }
-            else if (isTableArray && !Array.isArray(v)) {
-                throw new TomlError('trying to define an array of tables, but a table already exists for this identifier', {
+            let p = peekTable(k[0], res, meta, isTableArray ? 2 /* Type.ARRAY */ : 1 /* Type.EXPLICIT */);
+            if (!p) {
+                throw new TomlError('trying to redefine an already defined table or value', {
                     toml: toml,
-                    ptr: ptr - 2
+                    ptr: ptr,
                 });
             }
-            tbl = v;
-            if (isTableArray)
-                v.push(tbl = {});
-            ptr = end + +isTableArray;
+            m = p[2];
+            tbl = p[1];
+            ptr = k[1];
         }
         else {
-            ptr = extractKeyValue(toml, ptr, tbl, seenValues);
+            let k = parseKey(toml, ptr);
+            let p = peekTable(k[0], tbl, m, 0 /* Type.DOTTED */);
+            if (!p) {
+                throw new TomlError('trying to redefine an already defined table or value', {
+                    toml: toml,
+                    ptr: ptr,
+                });
+            }
+            let v = extractValue(toml, k[1]);
+            p[1][p[0]] = v[0];
+            ptr = v[1];
         }
         ptr = skipVoid(toml, ptr, true);
         if (toml[ptr] && toml[ptr] !== '\n' && toml[ptr] !== '\r') {

package/dist/parse.d.ts

@@ -25,5 +25,5 @@
  * 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 extractValue(str: string, ptr: number, end?: string): [any, number];
-export declare function extractKeyValue(str: string, ptr: number, table: Record<string, any>, seen: Set<any>, isInline?: boolean): number;
+import { type TomlPrimitive } from './util.js';
+export declare function extractValue(str: string, ptr: number, end?: string): [TomlPrimitive, number];

package/dist/parse.js

@@ -26,56 +26,37 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import { parseString, parseValue } from './primitive.js';
-import { parseKey, parseArray, parseInlineTable } from './struct.js';
-import { peekTable, indexOfNewline, skipUntil, skipVoid } from './util.js';
+import { parseArray, parseInlineTable } from './struct.js';
+import { indexOfNewline, skipVoid, skipUntil, skipComment, getStringEnd } from './util.js';
 import TomlError from './error.js';
-function getStringEnd(str, seek) {
-    let first = str[seek];
-    let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2]
-        ? str.slice(seek, seek + 3)
-        : first;
-    seek += target.length - 1;
-    do
-        seek = str.indexOf(target, ++seek);
-    while (seek > -1 && first !== "'" && str[seek - 1] === '\\' && str[seek - 2] !== '\\');
-    seek += target.length;
-    if (target.length > 1) {
-        if (str[seek] === first)
-            seek++;
-        if (str[seek] === first)
-            seek++;
-    }
-    return seek;
-}
 function sliceAndTrimEndOf(str, startPtr, endPtr, allowNewLines) {
     let value = str.slice(startPtr, endPtr);
-    let newlineIdx;
     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 s = '\n';
-        newlineIdx = value.lastIndexOf('\n');
-        if (newlineIdx < 0)
-            newlineIdx = value.lastIndexOf(s = '\r');
-        if (trimmed.lastIndexOf(s) !== newlineIdx) {
+        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;
+    return [trimmed, commentIdx];
 }
 export function extractValue(str, ptr, end) {
-    let c = str[ptr], offset;
+    let c = str[ptr];
     if (c === '[' || c === '{') {
         let [value, endPtr] = c === '['
             ? parseArray(str, ptr)
             : parseInlineTable(str, ptr);
-        let newPtr = skipUntil(str, endPtr, end);
+        let newPtr = skipUntil(str, endPtr, ',', end);
         if (end === '}') {
             let nextNewLine = indexOfNewline(str, endPtr, newPtr);
             if (nextNewLine > -1) {
@@ -90,48 +71,22 @@ export function extractValue(str, ptr, end) {
     let endPtr;
     if (c === '"' || c === "'") {
         endPtr = getStringEnd(str, ptr);
-        offset = !!end && str[endPtr] === ',';
-        return [parseString(str, ptr, endPtr), endPtr + +offset];
+        return [parseString(str, ptr, endPtr), endPtr + +(!!end && str[endPtr] === ',')];
     }
-    endPtr = skipUntil(str, ptr, end);
-    let valStr = sliceAndTrimEndOf(str, ptr, endPtr - (+(str[endPtr - 1] === ',')), end === ']');
-    if (!valStr) {
+    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(valStr, str, ptr),
-        endPtr
+        parseValue(slice[0], str, ptr),
+        endPtr,
     ];
 }
-export function extractKeyValue(str, ptr, table, seen, isInline) {
-    let equalIdx = str.indexOf('=', ptr);
-    if (equalIdx < 0) {
-        throw new TomlError('incomplete key-value declaration: no equals sign after the key', {
-            toml: str,
-            ptr: ptr
-        });
-    }
-    // KEY
-    let t = peekTable(table, parseKey(str, ptr, equalIdx), seen);
-    if (!t) {
-        throw new TomlError('trying to redefine an already defined value', {
-            toml: str,
-            ptr: ptr
-        });
-    }
-    // VALUE
-    ptr = skipVoid(str, equalIdx + 1, true, true);
-    if (str[ptr] === '\n' || str[ptr] === '\r') {
-        throw new TomlError('newlines are not allowed in key-value declarations', {
-            toml: str,
-            ptr: ptr
-        });
-    }
-    let e = extractValue(str, ptr, isInline ? '}' : void 0);
-    t[1][t[0]] = e[0];
-    seen.add(e[0]);
-    return e[1];
-}

package/dist/primitive.d.ts

@@ -25,5 +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.
  */
+import TomlDate from './date.js';
 export declare function parseString(str: string, ptr?: number, endPtr?: number): string;
-export declare function parseValue(value: string, toml: string, ptr: number): boolean | number | Date;
+export declare function parseValue(value: string, toml: string, ptr: number): boolean | number | TomlDate;

package/dist/primitive.js

@@ -26,10 +26,11 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import { skipVoid } from './util.js';
+import TomlDate from './date.js';
 import TomlError from './error.js';
-let NUM_REGEX = /^(0x|0b|0o|[+-])?[0-9a-f_]+(\.[0-9a-f_]+)?([e][+-]?[0-9a-f_]+)?$/i;
-let INT_REGEX = /^(0x|0b|0o|[+-])?[0-9a-f]+$/;
-let LEADING_ZERO = /^[+-]?0\d+/;
+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_]/;
 let ESCAPE_REGEX = /^[0-9a-f]{4,8}$/i;
 let ESC_MAP = {
     b: '\b',
@@ -40,17 +41,6 @@ let ESC_MAP = {
     '"': '"',
     '\\': '\\',
 };
-let VALUES_MAP = {
-    true: true,
-    false: false,
-    inf: Infinity,
-    '+inf': Infinity,
-    '-inf': -Infinity,
-    nan: NaN,
-    '+nan': NaN,
-    '-nan': NaN,
-    '-0': 0,
-};
 export function parseString(str, ptr = 0, endPtr = str.length) {
     let isLiteral = str[ptr] === "'";
     let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
@@ -67,13 +57,15 @@ export function parseString(str, ptr = 0, endPtr = str.length) {
     let sliceStart = ptr;
     while (ptr < endPtr - 1) {
         let c = str[ptr++];
-        if (!isMultiline && (c === '\n' || c === '\r')) {
-            throw new TomlError('newlines are not allowed in strings', {
-                toml: str,
-                ptr: ptr - 1
-            });
+        if (c === '\n' || (c === '\r' && str[ptr] === '\n')) {
+            if (!isMultiline) {
+                throw new TomlError('newlines are not allowed in strings', {
+                    toml: str,
+                    ptr: ptr - 1
+                });
+            }
         }
-        if (c < '\t' || c === '\x0b' || c === '\x0c' || c === '\x7f' || (c > '\x0d' && c < '\x20')) {
+        else if ((c < '\x20' && c !== '\t') || c === '\x7f') {
             throw new TomlError('control characters are not allowed in strings', {
                 toml: str,
                 ptr: ptr - 1
@@ -91,7 +83,7 @@ export function parseString(str, ptr = 0, endPtr = str.length) {
                     });
                 }
                 try {
-                    parsed += String.fromCodePoint(+`0x${code}`);
+                    parsed += String.fromCodePoint(parseInt(code, 16));
                 }
                 catch {
                     throw new TomlError('invalid unicode escape', {
@@ -132,19 +124,36 @@ export function parseString(str, ptr = 0, endPtr = str.length) {
     return parsed + str.slice(sliceStart, endPtr - 1);
 }
 export function parseValue(value, toml, ptr) {
-    if (Object.hasOwn(VALUES_MAP, value))
-        return VALUES_MAP[value];
+    // 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;
     // Numbers
-    if (NUM_REGEX.test(value)) {
+    let isInt;
+    if (value === '-0')
+        return 0; // Avoid FP representation of -0
+    if ((isInt = INT_REGEX.test(value)) || 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 = +value;
-        if (INT_REGEX.test(value) && !Number.isSafeInteger(numeric)) {
+        let numeric = +(value.replace(/_/g, ''));
+        if (isNaN(numeric)) {
+            throw new TomlError('invalid number', {
+                toml: toml,
+                ptr: ptr
+            });
+        }
+        if (isInt && !Number.isSafeInteger(numeric)) {
             throw new TomlError('integer value cannot be represented losslessly', {
                 toml: toml,
                 ptr: ptr
@@ -152,9 +161,8 @@ export function parseValue(value, toml, ptr) {
         }
         return numeric;
     }
-    // Date
-    let date = new Date(value.includes('-') ? value : `0000-01-01T${value}`);
-    if (isNaN(date.getTime())) {
+    let date = new TomlDate(value);
+    if (!date.isValid()) {
         throw new TomlError('invalid value', {
             toml: toml,
             ptr: ptr

package/dist/struct.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.
  */
-export declare function parseKey(str: string, startPtr?: number, endPtr?: number): string[];
-export declare function parseInlineTable(str: string, ptr: number): [Record<string, any>, number];
-export declare function parseArray(str: string, ptr: number): [any[], number];
+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];

package/dist/struct.js

@@ -26,61 +26,81 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import { parseString } from './primitive.js';
-import { extractValue, extractKeyValue } from './parse.js';
-import { indexOfNewline } from './util.js';
+import { extractValue } from './parse.js';
+import { skipComment, indexOfNewline, getStringEnd, skipVoid } from './util.js';
 import TomlError from './error.js';
-let KEY_PART_RE = /^[a-zA-Z0-9-_ \t]+$/;
-export function parseKey(str, startPtr = 0, endPtr = str.length) {
-    let ptr;
-    let dot = -1;
+let KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+export function parseKey(str, ptr, end = '=') {
+    let dot = ptr - 1;
     let parsed = [];
-    let key = str.slice(startPtr, endPtr);
+    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 = key[ptr = ++dot];
+        let c = str[ptr = ++dot];
         // If it's whitespace, ignore
         if (c !== ' ' && c !== '\t') {
             // If it's a string
             if (c === '"' || c === "'") {
-                let eos = key.indexOf(c, ptr + 1) + 1;
-                if (!eos) {
+                if (c === str[ptr + 1] && c === str[ptr + 2]) {
+                    throw new TomlError('multiline strings are not allowed in keys', {
+                        toml: str,
+                        ptr: ptr,
+                    });
+                }
+                let eos = getStringEnd(str, ptr);
+                if (eos < 0) {
                     throw new TomlError('unfinished string encountered', {
                         toml: str,
-                        ptr: ptr
+                        ptr: ptr,
                     });
                 }
-                dot = key.indexOf('.', eos);
-                let end = key.slice(eos, dot < 0 ? void 0 : dot);
-                let newLine = indexOfNewline(end);
+                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
+                        ptr: ptr + dot + newLine,
                     });
                 }
-                if (end.trimStart()) {
+                if (strEnd.trimStart()) {
                     throw new TomlError('found extra tokens after the string part', {
                         toml: str,
-                        ptr: eos
+                        ptr: eos,
                     });
                 }
-                parsed.push(parseString(key, 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(parseString(str, ptr, eos));
             }
             else {
                 // Normal raw key part consumption and validation
-                dot = key.indexOf('.', ptr);
-                let part = key.slice(ptr, dot < 0 ? void 0 : dot);
+                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
+                        ptr: ptr,
                     });
                 }
                 parsed.push(part.trimEnd());
             }
         }
         // Until there's no more dot
-    } while (dot + 1);
-    return parsed;
+    } while (dot + 1 && dot < endPtr);
+    return [parsed, skipVoid(str, endPtr + 1, true, true)];
 }
 export function parseInlineTable(str, ptr) {
     let res = {};
@@ -89,7 +109,7 @@ export function parseInlineTable(str, ptr) {
     let comma = 0;
     ptr++;
     while ((c = str[ptr++]) !== '}' && c) {
-        if (c === '\n' || c === '\r') {
+        if (c === '\n') {
             throw new TomlError('newlines are not allowed in inline tables', {
                 toml: str,
                 ptr: ptr - 1
@@ -108,7 +128,34 @@ export function parseInlineTable(str, ptr) {
             });
         }
         else if (c !== ' ' && c !== '\t') {
-            ptr = extractKeyValue(str, ptr - 1, res, seen, true);
+            let k;
+            let t = 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, '}');
+            seen.add(value);
+            t[k] = value;
+            ptr = valueEndPtr;
             comma = str[ptr - 1] === ',' ? ptr - 1 : 0;
         }
     }
@@ -138,7 +185,7 @@ export function parseArray(str, ptr) {
             });
         }
         else if (c === '#')
-            ptr = indexOfNewline(str, ptr);
+            ptr = skipComment(str, ptr);
         else if (c !== ' ' && c !== '\t' && c !== '\n' && c !== '\r') {
             let e = extractValue(str, ptr - 1, ']');
             res.push(e[0]);

package/dist/util.d.ts

@@ -25,7 +25,12 @@
  * 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';
+export type TomlPrimitive = string | number | boolean | TomlDate | {
+    [key: string]: TomlPrimitive;
+} | TomlPrimitive[];
 export declare function indexOfNewline(str: string, start?: number, end?: number): number;
+export declare function skipComment(str: string, ptr: number): number;
 export declare function skipVoid(str: string, ptr: number, banNewLines?: boolean, banComments?: boolean): number;
-export declare function skipUntil(str: string, ptr: number, end?: string): number;
-export declare function peekTable(table: Record<string, any>, key: string[], seen: Set<any>, allowSuper?: boolean): [string, Record<string, any>] | null;
+export declare function skipUntil(str: string, ptr: number, sep: string, end?: string): number;
+export declare function getStringEnd(str: string, seek: number): number;

package/dist/util.js

@@ -27,65 +27,74 @@
  */
 import TomlError from './error.js';
 export function indexOfNewline(str, start = 0, end = str.length) {
-    for (let i = start; i < end; i++) {
-        if (str[i] === '\n' || str[i] === '\r')
+    let idx = str.indexOf('\n', start);
+    if (str[idx - 1] === '\r')
+        idx--;
+    return idx <= end ? idx : -1;
+}
+export function skipComment(str, ptr) {
+    for (let i = ptr; i < str.length; i++) {
+        let c = str[i];
+        if (c === '\n')
             return i;
+        if (c === '\r' && str[i + 1] === '\n')
+            return i + 1;
+        if ((c < '\x20' && c !== '\t') || c === '\x7f') {
+            throw new TomlError('control characters are not allowed in comments', {
+                toml: str,
+                ptr: ptr,
+            });
+        }
     }
-    return -1;
+    return str.length;
 }
 export function skipVoid(str, ptr, banNewLines, banComments) {
     let c;
-    while ((c = str[ptr]) === ' ' || c === '\t' || (!banNewLines && (c === '\n' || c === '\r')))
+    while ((c = str[ptr]) === ' ' || c === '\t' || (!banNewLines && (c === '\n' || c === '\r' && str[ptr + 1] === '\n')))
         ptr++;
-    if (banComments || c !== '#')
-        return ptr;
-    ptr = indexOfNewline(str, ptr);
-    return ptr < 0 ? str.length : skipVoid(str, ptr, banNewLines);
+    return banComments || c !== '#'
+        ? ptr
+        : skipVoid(str, skipComment(str, ptr), banNewLines);
 }
-export function skipUntil(str, ptr, end) {
+export function skipUntil(str, ptr, sep, end) {
     if (!end) {
         ptr = indexOfNewline(str, ptr);
         return ptr < 0 ? str.length : ptr;
     }
-    let nextEnd = str.indexOf(end, ptr);
-    if (nextEnd < 0) {
-        // TODO: point to start of structure instead?
-        throw new TomlError('cannot find end of structure', {
-            toml: str,
-            ptr: ptr
-        });
-    }
-    let nextSep = str.indexOf(',', ptr) + 1;
-    return !nextSep || nextEnd < nextSep ? nextEnd : nextSep;
-}
-let DESCRIPTOR = { enumerable: true, configurable: true, writable: true };
-export function peekTable(table, key, seen, allowSuper) {
-    let k = '';
-    let v;
-    let hasOwn;
-    let hadOwn;
-    for (let i = 0; i < key.length; i++) {
-        if (i) {
-            if (!(hadOwn = hasOwn)) {
-                if (k === '__proto__')
-                    Object.defineProperty(table, k, DESCRIPTOR);
-                table[k] = {};
-            }
-            table = table[k];
-            if (Array.isArray(table))
-                table = table[table.length - 1];
+    for (let i = ptr; i < str.length; i++) {
+        let c = str[i];
+        if (c === '#') {
+            i = indexOfNewline(str, i);
         }
-        k = key[i];
-        hasOwn = Object.hasOwn(table, k);
-        v = hasOwn ? table[k] : void 0;
-        if (v !== void 0 && (typeof v !== 'object' || seen.has(v))) {
-            return null;
+        else if (c === sep) {
+            return i + 1;
+        }
+        else if (c === end) {
+            return i;
         }
     }
-    if (hasOwn && (!allowSuper || (hadOwn && !Array.isArray(v)))) {
-        return null;
+    throw new TomlError('cannot find end of structure', {
+        toml: str,
+        ptr: ptr
+    });
+}
+export function getStringEnd(str, seek) {
+    let first = str[seek];
+    let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2]
+        ? str.slice(seek, seek + 3)
+        : first;
+    seek += target.length - 1;
+    do
+        seek = str.indexOf(target, ++seek);
+    while (seek > -1 && first !== "'" && str[seek - 1] === '\\' && str[seek - 2] !== '\\');
+    if (seek > -1) {
+        seek += target.length;
+        if (target.length > 1) {
+            if (str[seek] === first)
+                seek++;
+            if (str[seek] === first)
+                seek++;
+        }
     }
-    if (!hasOwn && k === '__proto__')
-        Object.defineProperty(table, k, DESCRIPTOR);
-    return [k, table];
+    return seek;
 }

package/package.json

@@ -1,7 +1,10 @@
 {
 	"name": "smol-toml",
-	"version": "0.1.0",
-	"keywords": [ "toml", "parser" ],
+	"version": "1.0.1",
+	"keywords": [
+		"toml",
+		"parser"
+	],
 	"description": "A small, fast, and correct TOML parser",
 	"repository": "git@github.com:squirrelchat/smol-toml.git",
 	"author": "Cynthia <cyyynthia@borkenware.com>",
@@ -9,7 +12,7 @@
 	"type": "module",
 	"engines": {
 		"node": ">= 18",
-		"pnpm": ">= 7.24"
+		"pnpm": ">= 8"
 	},
 	"scripts": {
 		"build": "tsc",