smol-toml 1.1.4 → 1.2.1

package/README.md

@@ -2,6 +2,7 @@
 [![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)
+[![Build](https://img.shields.io/github/actions/workflow/status/squirrelchat/smol-toml/build.yml?style=flat-square&logo=github)](https://github.com/squirrelchat/smol-toml/actions/workflows/build.yml)
 
 A small, fast, and correct TOML parser and serializer. smol-toml is fully(ish) spec-compliant with TOML v1.0.0.
 
@@ -11,32 +12,20 @@ parser didn't feel too out of place.
 
 *[insert xkcd 927]*
 
-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:
+smol-toml passes most of the tests from the [`toml-test` suite](https://github.com/toml-lang/toml-test); use the
+`run-toml-test.bash` script to run the tests. 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
+- Certain invalid dates are not rejected
+  - For instance, `2023-02-30` would be accepted and parsed as `2023-03-02`. While additional checks could be performed
+	to reject these, they've not been added for performance reasons.
 - 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>
+You can see a list of all tests smol-toml fails (and the reason why it fails these) in the list of skipped tests in
+`run-toml-test.bash`. Note that some failures are *not* specification violations per-se. For instance, the TOML spec
+does not require 64-bit integer range support or sub-millisecond time precision, but are included in the `toml-test`
+suite. See https://github.com/toml-lang/toml-test/issues/154 and https://github.com/toml-lang/toml-test/issues/155
 
 ## Installation
 ```
@@ -55,6 +44,13 @@ const toml = stringify(parsed)
 console.log(toml)
 ```
 
+Alternatively, if you prefer something similar to the JSON global, you can import the library as follows
+```js
+import TOML from 'smol-toml'
+
+TOML.stringify({ ... })
+```
+
 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**.
@@ -109,10 +105,11 @@ const localTime = TomlDate.wrapAsLocalTime(jsDate)
 ## Performance
 A note on these performance numbers: in some highly synthetic tests, other parsers such as `fast-toml` greatly
 outperform other parsers, mostly due to their lack of compliance with the spec. For example, to parse a string,
-`fast-toml` skips the entire string while `smol-toml` does validate the string, costing a fair chair of performance.
+`fast-toml` skips the entire string while `smol-toml` does validate the string, costing a fair share of performance.
 
-The ~5MB test file used for benchmark here is filled with random data which attempts to be close-ish to reality. The
-idea is to have a file relatively close to a real-world application.
+The ~5MB test file used for benchmark here is filled with random data which attempts to be close-ish to reality in
+terms of structure. The idea is to have a file relatively close to a real-world application, with moderately sized
+strings etc.
 
 The large TOML generator can be found [here](https://gist.github.com/cyyynthia/e77c744cb6494dabe37d0182506526b9)
 
@@ -189,7 +186,7 @@ I initially reported this to the library author, but the author decided to
 - 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:
+For the reference anyway, `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,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 default class TomlDate extends Date {
+export declare class TomlDate extends Date {
     #private;
     constructor(date: string | Date);
     isDateTime(): boolean;

package/dist/date.js

@@ -1,3 +1,4 @@
+"use strict";
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -25,8 +26,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.TomlDate = void 0;
 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 {
+class TomlDate extends Date {
     #hasDate = false;
     #hasTime = false;
     #offset = null;
@@ -49,7 +52,7 @@ export default class TomlDate extends Date {
                 else {
                     offset = match[3] || null;
                     date = date.toUpperCase();
-                    if (!offset)
+                    if (!offset && hasTime)
                         date += 'Z';
                 }
             }
@@ -123,3 +126,4 @@ export default class TomlDate extends Date {
         return date;
     }
 }
+exports.TomlDate = TomlDate;

package/dist/error.d.ts

@@ -29,7 +29,7 @@ type TomlErrorOptions = ErrorOptions & {
     toml: string;
     ptr: number;
 };
-export default class TomlError extends Error {
+export declare class TomlError extends Error {
     line: number;
     column: number;
     codeblock: string;

package/dist/error.js

@@ -1,3 +1,4 @@
+"use strict";
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -25,6 +26,8 @@
  * 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.TomlError = void 0;
 function getLineColFromPtr(string, ptr) {
     let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
     return [lines.length, lines.pop().length + 1];
@@ -48,7 +51,7 @@ function makeCodeBlock(string, line, column) {
     }
     return codeblock;
 }
-export default class TomlError extends Error {
+class TomlError extends Error {
     line;
     column;
     codeblock;
@@ -61,3 +64,4 @@ export default class TomlError extends Error {
         this.codeblock = codeblock;
     }
 }
+exports.TomlError = TomlError;

package/dist/extract.js

@@ -1,3 +1,4 @@
+"use strict";
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -25,24 +26,26 @@
  * 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';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractValue = void 0;
+const primitive_js_1 = require("./primitive.js");
+const struct_js_1 = require("./struct.js");
+const util_js_1 = require("./util.js");
+const error_js_1 = require("./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);
+        (0, util_js_1.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', {
+            throw new error_js_1.TomlError('newlines are not allowed in inline tables', {
                 toml: str,
                 ptr: startPtr + newlineIdx
             });
@@ -50,17 +53,17 @@ function sliceAndTrimEndOf(str, startPtr, endPtr, allowNewLines) {
     }
     return [trimmed, commentIdx];
 }
-export function extractValue(str, ptr, end) {
+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);
+            ? (0, struct_js_1.parseArray)(str, ptr)
+            : (0, struct_js_1.parseInlineTable)(str, ptr);
+        let newPtr = (0, util_js_1.skipUntil)(str, endPtr, ',', end);
         if (end === '}') {
-            let nextNewLine = indexOfNewline(str, endPtr, newPtr);
+            let nextNewLine = (0, util_js_1.indexOfNewline)(str, endPtr, newPtr);
             if (nextNewLine > -1) {
-                throw new TomlError('newlines are not allowed in inline tables', {
+                throw new error_js_1.TomlError('newlines are not allowed in inline tables', {
                     toml: str,
                     ptr: nextNewLine
                 });
@@ -70,12 +73,12 @@ export function extractValue(str, ptr, end) {
     }
     let endPtr;
     if (c === '"' || c === "'") {
-        endPtr = getStringEnd(str, ptr);
-        let parsed = parseString(str, ptr, endPtr);
+        endPtr = (0, util_js_1.getStringEnd)(str, ptr);
+        let parsed = (0, primitive_js_1.parseString)(str, ptr, endPtr);
         if (end) {
-            endPtr = skipVoid(str, endPtr, end !== ']');
+            endPtr = (0, util_js_1.skipVoid)(str, endPtr, end !== ']');
             if (str[endPtr] && str[endPtr] !== ',' && str[endPtr] !== end && str[endPtr] !== '\n' && str[endPtr] !== '\r') {
-                throw new TomlError('unexpected character encountered', {
+                throw new error_js_1.TomlError('unexpected character encountered', {
                     toml: str,
                     ptr: endPtr,
                 });
@@ -84,20 +87,21 @@ export function extractValue(str, ptr, end) {
         }
         return [parsed, endPtr];
     }
-    endPtr = skipUntil(str, ptr, ',', end);
+    endPtr = (0, util_js_1.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', {
+        throw new error_js_1.TomlError('incomplete key-value declaration: no value specified', {
             toml: str,
             ptr: ptr
         });
     }
     if (end && slice[1] > -1) {
-        endPtr = skipVoid(str, ptr + slice[1]);
+        endPtr = (0, util_js_1.skipVoid)(str, ptr + slice[1]);
         endPtr += +(str[endPtr] === ',');
     }
     return [
-        parseValue(slice[0], str, ptr),
+        (0, primitive_js_1.parseValue)(slice[0], str, ptr),
         endPtr,
     ];
 }
+exports.extractValue = extractValue;

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -25,7 +26,13 @@
  * 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 as TomlError } from './error.js';
-export { default as TomlDate } from './date.js';
-export { parse } from './parse.js';
-export { stringify } from './stringify.js';
+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; } });

package/dist/parse.js

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

package/dist/primitive.d.ts

@@ -25,6 +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';
+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 | TomlDate;

package/dist/primitive.js

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

package/dist/stringify.js

@@ -1,3 +1,4 @@
+"use strict";
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -25,6 +26,8 @@
  * 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;
 function extendedTypeOf(obj) {
     let type = typeof obj;
@@ -144,9 +147,10 @@ function stringifyTable(obj, prefix = '') {
     }
     return `${preamble}\n${tables}`.trim();
 }
-export function stringify(obj) {
+function stringify(obj) {
     if (extendedTypeOf(obj) !== 'object') {
         throw new TypeError('stringify can only be called with an object');
     }
     return stringifyTable(obj);
 }
+exports.stringify = stringify;

package/dist/struct.js

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

package/dist/util.d.ts

@@ -25,7 +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 TomlDate from './date.js';
+import type { TomlDate } from './date.js';
 export type TomlPrimitive = string | number | boolean | TomlDate | {
     [key: string]: TomlPrimitive;
 } | TomlPrimitive[];

package/dist/util.js

@@ -1,3 +1,4 @@
+"use strict";
 /*!
  * Copyright (c) Squirrel Chat et al., All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
@@ -25,14 +26,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.
  */
-import TomlError from './error.js';
-export function indexOfNewline(str, start = 0, end = str.length) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStringEnd = exports.skipUntil = exports.skipVoid = exports.skipComment = exports.indexOfNewline = void 0;
+const error_js_1 = require("./error.js");
+function indexOfNewline(str, start = 0, end = str.length) {
     let idx = str.indexOf('\n', start);
     if (str[idx - 1] === '\r')
         idx--;
     return idx <= end ? idx : -1;
 }
-export function skipComment(str, ptr) {
+exports.indexOfNewline = indexOfNewline;
+function skipComment(str, ptr) {
     for (let i = ptr; i < str.length; i++) {
         let c = str[i];
         if (c === '\n')
@@ -40,7 +44,7 @@ export function skipComment(str, ptr) {
         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', {
+            throw new error_js_1.TomlError('control characters are not allowed in comments', {
                 toml: str,
                 ptr: ptr,
             });
@@ -48,7 +52,8 @@ export function skipComment(str, ptr) {
     }
     return str.length;
 }
-export function skipVoid(str, ptr, banNewLines, banComments) {
+exports.skipComment = skipComment;
+function skipVoid(str, ptr, banNewLines, banComments) {
     let c;
     while ((c = str[ptr]) === ' ' || c === '\t' || (!banNewLines && (c === '\n' || c === '\r' && str[ptr + 1] === '\n')))
         ptr++;
@@ -56,7 +61,8 @@ export function skipVoid(str, ptr, banNewLines, banComments) {
         ? ptr
         : skipVoid(str, skipComment(str, ptr), banNewLines);
 }
-export function skipUntil(str, ptr, sep, end, banNewLines = false) {
+exports.skipVoid = skipVoid;
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
     if (!end) {
         ptr = indexOfNewline(str, ptr);
         return ptr < 0 ? str.length : ptr;
@@ -76,12 +82,13 @@ export function skipUntil(str, ptr, sep, end, banNewLines = false) {
             return i;
         }
     }
-    throw new TomlError('cannot find end of structure', {
+    throw new error_js_1.TomlError('cannot find end of structure', {
         toml: str,
         ptr: ptr
     });
 }
-export function getStringEnd(str, seek) {
+exports.skipUntil = skipUntil;
+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)
@@ -101,3 +108,4 @@ export function getStringEnd(str, seek) {
     }
     return seek;
 }
+exports.getStringEnd = getStringEnd;

package/package.json

@@ -1,19 +1,21 @@
 {
 	"name": "smol-toml",
-	"version": "1.1.4",
+	"version": "1.2.1",
 	"keywords": [
 		"toml",
 		"parser",
 		"serializer"
 	],
 	"description": "A small, fast, and correct TOML parser/serializer",
-	"repository": "git@github.com:squirrelchat/smol-toml.git",
+	"repository": {
+		"type": "git",
+		"url": "git+ssh://git@github.com/squirrelchat/smol-toml.git"
+	},
 	"author": "Cynthia <cyyynthia@borkenware.com>",
 	"license": "BSD-3-Clause",
-	"type": "module",
 	"engines": {
 		"node": ">= 18",
-		"pnpm": ">= 8"
+		"pnpm": ">= 9"
 	},
 	"scripts": {
 		"build": "tsc",
@@ -24,20 +26,15 @@
 	"devDependencies": {
 		"@iarna/toml": "3.0.0",
 		"@ltd/j-toml": "^1.38.0",
-		"@tsconfig/node-lts": "^20.1.1",
-		"@tsconfig/strictest": "^2.0.2",
-		"@types/node": "^20.11.5",
-		"@vitest/ui": "^1.2.1",
+		"@tsconfig/node-lts": "^20.1.3",
+		"@tsconfig/strictest": "^2.0.5",
+		"@types/node": "^20.12.11",
+		"@vitest/ui": "^1.6.0",
 		"fast-toml": "^0.5.4",
-		"typescript": "^5.3.3",
-		"vitest": "^1.2.1"
-	},
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"default": "./dist/index.js"
-		}
+		"typescript": "^5.4.5",
+		"vitest": "^1.6.0"
 	},
+	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"files": [
 		"README.md",