smol-toml 1.3.4 → 1.4.0

package/README.md

@@ -16,6 +16,9 @@ parser didn't feel too out of place.
 
 *[insert xkcd 927]*
 
+Nowadays, smol-toml is the most downloaded TOML parser on npm thanks to its quality. From frameworks to tooling, it
+has been battle-tested and is actively used in production systems.
+
 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:
@@ -24,7 +27,9 @@ it doesn't pass certain tests, namely:
 - 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)
+
+Please also note that by default, the behavior regarding integers doesn't preserve type information, nor does it allow
+deserializing integers larger than 53 bits. See [Integers](#integers).
 
 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
@@ -59,11 +64,42 @@ 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.
+- By default, floats will be serialized as integers if they don't have a decimal part. See [Integers](#integers)
   - `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.
 
+### Integers
+When parsing, both integers and floats are read as plain JavaScript numbers, which essentially are floats. This means
+loss of type information, and makes it impossible to safely represent integers beyond 53 bits.
+
+When serializing, numbers without a decimal part are serialized as integers. This allows in most cases to preserve
+whether a number is an integer or not, but fails to preserve type information for numbers like `1.0`.
+
+#### Enabling BigInt support and type preservation
+To parse integers beyond 53 bits, it's possible to tell the parser to return all integers as BigInt. This will
+therefore preserve the type information at the cost of using a slightly more expensive container.
+
+```js
+import { parse } from 'smol-toml'
+
+const doc = '...'
+const parsed = parse(doc, { integersAsBigInt: true })
+```
+
+If you want to keep numbers for integers that can safely be represented as a JavaScript number, you can pass
+`"asNeeded"` instead.
+
+To get end-to-end type preservation, you can tell the serializer to always treat numbers as floating point numbers.
+Then, only BigInts will be serialized as integers and numbers without a decimal part will still be serialized as float.
+
+```js
+import { stringify } from 'smol-toml'
+
+const obj =  { ... }
+const toml = stringify(obj, { numbersAsFloat: true })
+```
+
 ### 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.
@@ -107,6 +143,10 @@ const localTime = TomlDate.wrapAsLocalTime(jsDate)
 ```
 
 ## Performance
+> [!NOTE]
+> These benchmarks are starting to get a bit old. They will be updated in the (hopefully near) future to better
+> reflect numbers of the latest version of smol-toml on the latest version of Node.js.
+
 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 share of performance.
@@ -187,7 +227,7 @@ 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
+- b) [delete the issue](https://github.com/huan231/toml-nodejs/issues/12) when pointed out links to the Node.js
 documentation about the flag removal and standard resolution algorithm.
 
 For the reference anyway, `toml-nodejs` (with proper imports) is ~8x slower on both parse benchmark with:

package/dist/extract.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 { type TomlPrimitive } from './util.js';
-export declare function extractValue(str: string, ptr: number, end?: string | undefined, depth?: number): [TomlPrimitive, number];
+import { type IntegersAsBigInt } from './primitive.js';
+import { type TomlValue } from './util.js';
+export declare function extractValue(str: string, ptr: number, end: string | undefined, depth: number, integersAsBigInt: IntegersAsBigInt): [TomlValue, number];

package/dist/extract.js

@@ -50,7 +50,7 @@ function sliceAndTrimEndOf(str, startPtr, endPtr, allowNewLines) {
     }
     return [trimmed, commentIdx];
 }
-export function extractValue(str, ptr, end, depth = -1) {
+export function extractValue(str, ptr, end, depth, integersAsBigInt) {
     if (depth === 0) {
         throw new TomlError('document contains excessively nested structures. aborting.', {
             toml: str,
@@ -60,8 +60,8 @@ export function extractValue(str, ptr, end, depth = -1) {
     let c = str[ptr];
     if (c === '[' || c === '{') {
         let [value, endPtr] = c === '['
-            ? parseArray(str, ptr, depth)
-            : parseInlineTable(str, ptr, depth);
+            ? parseArray(str, ptr, depth, integersAsBigInt)
+            : parseInlineTable(str, ptr, depth, integersAsBigInt);
         let newPtr = end ? skipUntil(str, endPtr, ',', end) : endPtr;
         if (endPtr - newPtr && end === '}') {
             let nextNewLine = indexOfNewline(str, endPtr, newPtr);
@@ -103,7 +103,7 @@ export function extractValue(str, ptr, end, depth = -1) {
         endPtr += +(str[endPtr] === ',');
     }
     return [
-        parseValue(slice[0], str, ptr),
+        parseValue(slice[0], str, ptr, integersAsBigInt),
         endPtr,
     ];
 }

package/dist/index.cjs

@@ -315,7 +315,7 @@ function parseString(str, ptr = 0, endPtr = str.length) {
   }
   return parsed + str.slice(sliceStart, endPtr - 1);
 }
-function parseValue(value, toml, ptr) {
+function parseValue(value, toml, ptr, integersAsBigInt) {
   if (value === "true")
     return true;
   if (value === "false")
@@ -327,31 +327,36 @@ function parseValue(value, toml, ptr) {
   if (value === "nan" || value === "+nan" || value === "-nan")
     return NaN;
   if (value === "-0")
-    return 0;
-  let isInt;
-  if ((isInt = INT_REGEX.test(value)) || FLOAT_REGEX.test(value)) {
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
     if (LEADING_ZERO.test(value)) {
       throw new TomlError("leading zeroes are not allowed", {
         toml,
         ptr
       });
     }
-    let numeric = +value.replace(/_/g, "");
+    value = value.replace(/_/g, "");
+    let numeric = +value;
     if (isNaN(numeric)) {
       throw new TomlError("invalid number", {
         toml,
         ptr
       });
     }
-    if (isInt && !Number.isSafeInteger(numeric)) {
-      throw new TomlError("integer value cannot be represented losslessly", {
-        toml,
-        ptr
-      });
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", {
+          toml,
+          ptr
+        });
+      }
+      if (isInt || integersAsBigInt)
+        numeric = BigInt(value);
     }
     return numeric;
   }
-  let date = new TomlDate(value);
+  const date = new TomlDate(value);
   if (!date.isValid()) {
     throw new TomlError("invalid value", {
       toml,
@@ -381,7 +386,7 @@ function sliceAndTrimEndOf(str, startPtr, endPtr, allowNewLines) {
   }
   return [trimmed, commentIdx];
 }
-function extractValue(str, ptr, end, depth = -1) {
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
   if (depth === 0) {
     throw new TomlError("document contains excessively nested structures. aborting.", {
       toml: str,
@@ -390,7 +395,7 @@ function extractValue(str, ptr, end, depth = -1) {
   }
   let c = str[ptr];
   if (c === "[" || c === "{") {
-    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth) : parseInlineTable(str, ptr, depth);
+    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
     let newPtr = end ? skipUntil(str, endPtr2, ",", end) : endPtr2;
     if (endPtr2 - newPtr && end === "}") {
       let nextNewLine = indexOfNewline(str, endPtr2, newPtr);
@@ -432,7 +437,7 @@ function extractValue(str, ptr, end, depth = -1) {
     endPtr += +(str[endPtr] === ",");
   }
   return [
-    parseValue(slice[0], str, ptr),
+    parseValue(slice[0], str, ptr, integersAsBigInt),
     endPtr
   ];
 }
@@ -506,28 +511,20 @@ function parseKey(str, ptr, end = "=") {
   } while (dot + 1 && dot < endPtr);
   return [parsed, skipVoid(str, endPtr + 1, true, true)];
 }
-function parseInlineTable(str, ptr, depth = -1) {
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
   let res = {};
   let seen = /* @__PURE__ */ new Set();
   let c;
   let comma = 0;
   ptr++;
   while ((c = str[ptr++]) !== "}" && c) {
+    let err = { toml: str, ptr: ptr - 1 };
     if (c === "\n") {
-      throw new TomlError("newlines are not allowed in inline tables", {
-        toml: str,
-        ptr: ptr - 1
-      });
+      throw new TomlError("newlines are not allowed in inline tables", err);
     } else if (c === "#") {
-      throw new TomlError("inline tables cannot contain comments", {
-        toml: str,
-        ptr: ptr - 1
-      });
+      throw new TomlError("inline tables cannot contain comments", err);
     } else if (c === ",") {
-      throw new TomlError("expected key-value, found comma", {
-        toml: str,
-        ptr: ptr - 1
-      });
+      throw new TomlError("expected key-value, found comma", err);
     } else if (c !== " " && c !== "	") {
       let k;
       let t = res;
@@ -553,7 +550,7 @@ function parseInlineTable(str, ptr, depth = -1) {
           ptr
         });
       }
-      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1);
+      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
       seen.add(value);
       t[k] = value;
       ptr = valueEndPtr;
@@ -574,7 +571,7 @@ function parseInlineTable(str, ptr, depth = -1) {
   }
   return [res, ptr];
 }
-function parseArray(str, ptr, depth = -1) {
+function parseArray(str, ptr, depth, integersAsBigInt) {
   let res = [];
   let c;
   ptr++;
@@ -587,7 +584,7 @@ function parseArray(str, ptr, depth = -1) {
     } else if (c === "#")
       ptr = skipComment(str, ptr);
     else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
-      let e = extractValue(str, ptr - 1, "]", depth - 1);
+      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
       res.push(e[0]);
       ptr = e[1];
     }
@@ -661,8 +658,7 @@ function peekTable(key, table, meta, type) {
   }
   return [k, t, state.c];
 }
-function parse(toml, opts) {
-  let maxDepth = opts?.maxDepth ?? 1e3;
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
   let res = {};
   let meta = {};
   let tbl = res;
@@ -711,7 +707,7 @@ function parse(toml, opts) {
           ptr
         });
       }
-      let v = extractValue(toml, k[1], void 0, maxDepth);
+      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
       p[1][p[0]] = v[0];
       ptr = v[1];
     }
@@ -749,7 +745,7 @@ function isArrayOfTables(obj) {
 function formatString(s) {
   return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
 }
-function stringifyValue(val, type, depth) {
+function stringifyValue(val, type, depth, numberAsFloat) {
   if (depth === 0) {
     throw new Error("Could not stringify the object: maximum object depth exceeded");
   }
@@ -760,6 +756,8 @@ function stringifyValue(val, type, depth) {
       return "inf";
     if (val === -Infinity)
       return "-inf";
+    if (numberAsFloat && Number.isInteger(val))
+      return val.toFixed(1);
     return val.toString();
   }
   if (type === "bigint" || type === "boolean") {
@@ -775,13 +773,13 @@ function stringifyValue(val, type, depth) {
     return val.toISOString();
   }
   if (type === "object") {
-    return stringifyInlineTable(val, depth);
+    return stringifyInlineTable(val, depth, numberAsFloat);
   }
   if (type === "array") {
-    return stringifyArray(val, depth);
+    return stringifyArray(val, depth, numberAsFloat);
   }
 }
-function stringifyInlineTable(obj, depth) {
+function stringifyInlineTable(obj, depth, numberAsFloat) {
   let keys = Object.keys(obj);
   if (keys.length === 0)
     return "{}";
@@ -792,11 +790,11 @@ function stringifyInlineTable(obj, depth) {
       res += ", ";
     res += BARE_KEY.test(k) ? k : formatString(k);
     res += " = ";
-    res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1);
+    res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
   }
   return res + " }";
 }
-function stringifyArray(array, depth) {
+function stringifyArray(array, depth, numberAsFloat) {
   if (array.length === 0)
     return "[]";
   let res = "[ ";
@@ -806,11 +804,11 @@ function stringifyArray(array, depth) {
     if (array[i] === null || array[i] === void 0) {
       throw new TypeError("arrays cannot contain null or undefined values");
     }
-    res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1);
+    res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
   }
   return res + " ]";
 }
-function stringifyArrayTable(array, key, depth) {
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
   if (depth === 0) {
     throw new Error("Could not stringify the object: maximum object depth exceeded");
   }
@@ -818,12 +816,12 @@ function stringifyArrayTable(array, key, depth) {
   for (let i = 0; i < array.length; i++) {
     res += `[[${key}]]
 `;
-    res += stringifyTable(array[i], key, depth);
+    res += stringifyTable(array[i], key, depth, numberAsFloat);
     res += "\n\n";
   }
   return res;
 }
-function stringifyTable(obj, prefix, depth) {
+function stringifyTable(obj, prefix, depth, numberAsFloat) {
   if (depth === 0) {
     throw new Error("Could not stringify the object: maximum object depth exceeded");
   }
@@ -839,17 +837,17 @@ function stringifyTable(obj, prefix, depth) {
       }
       let key = BARE_KEY.test(k) ? k : formatString(k);
       if (type === "array" && isArrayOfTables(obj[k])) {
-        tables += stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1);
+        tables += stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
       } else if (type === "object") {
         let tblKey = prefix ? `${prefix}.${key}` : key;
         tables += `[${tblKey}]
 `;
-        tables += stringifyTable(obj[k], tblKey, depth - 1);
+        tables += stringifyTable(obj[k], tblKey, depth - 1, numberAsFloat);
         tables += "\n\n";
       } else {
         preamble += key;
         preamble += " = ";
-        preamble += stringifyValue(obj[k], type, depth);
+        preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
         preamble += "\n";
       }
     }
@@ -857,12 +855,11 @@ function stringifyTable(obj, prefix, depth) {
   return `${preamble}
 ${tables}`.trim();
 }
-function stringify(obj, opts) {
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
   if (extendedTypeOf(obj) !== "object") {
     throw new TypeError("stringify can only be called with an object");
   }
-  let maxDepth = opts?.maxDepth ?? 1e3;
-  return stringifyTable(obj, "", maxDepth);
+  return stringifyTable(obj, "", maxDepth, numbersAsFloat);
 }
 
 // dist/index.js

package/dist/index.d.ts

@@ -29,7 +29,7 @@ import { parse } from './parse.js';
 import { stringify } from './stringify.js';
 import { TomlDate } from './date.js';
 import { TomlError } from './error.js';
-export type { TomlPrimitive } from './util.js';
+export type { TomlValue, TomlTable, TomlValueWithoutBigInt, TomlTableWithoutBigInt } from './util.js';
 declare const _default: {
     parse: typeof parse;
     stringify: typeof stringify;
@@ -38,3 +38,6 @@ declare const _default: {
 };
 export default _default;
 export { parse, stringify, TomlDate, TomlError };
+export type { 
+/** @deprecated use TomlValue instead */
+TomlValue as TomlPrimitive } from './util.js';

package/dist/parse.d.ts

@@ -25,7 +25,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.
  */
-import { type TomlPrimitive } from './util.js';
-export declare function parse(toml: string, opts?: {
-    maxDepth: number;
-}): Record<string, TomlPrimitive>;
+import type { IntegersAsBigInt } from './primitive.js';
+import { type TomlTable, type TomlTableWithoutBigInt } from './util.js';
+export interface ParseOptions {
+    maxDepth?: number;
+    integersAsBigInt?: IntegersAsBigInt;
+}
+export declare function parse(toml: string, options?: ParseOptions & {
+    integersAsBigInt: Exclude<IntegersAsBigInt, undefined | false>;
+}): TomlTable;
+export declare function parse(toml: string, options?: ParseOptions): TomlTableWithoutBigInt;

package/dist/parse.js

@@ -93,8 +93,7 @@ function peekTable(key, table, meta, type) {
     }
     return [k, t, state.c];
 }
-export function parse(toml, opts) {
-    let maxDepth = opts?.maxDepth ?? 1000;
+export function parse(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
     let res = {};
     let meta = {};
     let tbl = res;
@@ -132,7 +131,7 @@ export function parse(toml, opts) {
                     ptr: ptr,
                 });
             }
-            let v = extractValue(toml, k[1], void 0, maxDepth);
+            let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
             p[1][p[0]] = v[0];
             ptr = v[1];
         }

package/dist/primitive.d.ts

@@ -27,4 +27,5 @@
  */
 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;
+export type IntegersAsBigInt = undefined | boolean | 'asNeeded';
+export declare function parseValue(value: string, toml: string, ptr: number, integersAsBigInt: IntegersAsBigInt): boolean | number | bigint | TomlDate;

package/dist/primitive.js

@@ -42,7 +42,7 @@ let ESC_MAP = {
     '\\': '\\',
 };
 export function parseString(str, ptr = 0, endPtr = str.length) {
-    let isLiteral = str[ptr] === "'";
+    let isLiteral = str[ptr] === '\'';
     let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
     if (isMultiline) {
         endPtr -= 2;
@@ -61,14 +61,14 @@ export function parseString(str, ptr = 0, endPtr = str.length) {
             if (!isMultiline) {
                 throw new TomlError('newlines are not allowed in strings', {
                     toml: str,
-                    ptr: ptr - 1
+                    ptr: ptr - 1,
                 });
             }
         }
         else if ((c < '\x20' && c !== '\t') || c === '\x7f') {
             throw new TomlError('control characters are not allowed in strings', {
                 toml: str,
-                ptr: ptr - 1
+                ptr: ptr - 1,
             });
         }
         if (isEscape) {
@@ -79,7 +79,7 @@ export function parseString(str, ptr = 0, endPtr = str.length) {
                 if (!ESCAPE_REGEX.test(code)) {
                     throw new TomlError('invalid unicode escape', {
                         toml: str,
-                        ptr: tmp
+                        ptr: tmp,
                     });
                 }
                 try {
@@ -88,7 +88,7 @@ export function parseString(str, ptr = 0, endPtr = str.length) {
                 catch {
                     throw new TomlError('invalid unicode escape', {
                         toml: str,
-                        ptr: tmp
+                        ptr: tmp,
                     });
                 }
             }
@@ -98,7 +98,7 @@ export function parseString(str, ptr = 0, endPtr = str.length) {
                 if (str[ptr] !== '\n' && str[ptr] !== '\r') {
                     throw new TomlError('invalid escape: only line-ending whitespace may be escaped', {
                         toml: str,
-                        ptr: tmp
+                        ptr: tmp,
                     });
                 }
                 ptr = skipVoid(str, ptr);
@@ -110,7 +110,7 @@ export function parseString(str, ptr = 0, endPtr = str.length) {
             else {
                 throw new TomlError('unrecognized escape sequence', {
                     toml: str,
-                    ptr: tmp
+                    ptr: tmp,
                 });
             }
             sliceStart = ptr;
@@ -123,7 +123,7 @@ export function parseString(str, ptr = 0, endPtr = str.length) {
     }
     return parsed + str.slice(sliceStart, endPtr - 1);
 }
-export function parseValue(value, toml, ptr) {
+export function parseValue(value, toml, ptr, integersAsBigInt) {
     // Constant values
     if (value === 'true')
         return true;
@@ -135,37 +135,43 @@ export function parseValue(value, toml, ptr) {
         return Infinity;
     if (value === 'nan' || value === '+nan' || value === '-nan')
         return NaN;
+    // Avoid FP representation of -0
     if (value === '-0')
-        return 0; // Avoid FP representation of -0
+        return integersAsBigInt ? 0n : 0;
     // Numbers
-    let isInt;
-    if ((isInt = INT_REGEX.test(value)) || FLOAT_REGEX.test(value)) {
+    let isInt = INT_REGEX.test(value);
+    if (isInt || FLOAT_REGEX.test(value)) {
         if (LEADING_ZERO.test(value)) {
             throw new TomlError('leading zeroes are not allowed', {
                 toml: toml,
-                ptr: ptr
+                ptr: ptr,
             });
         }
-        let numeric = +(value.replace(/_/g, ''));
+        value = value.replace(/_/g, '');
+        let numeric = +value;
         if (isNaN(numeric)) {
             throw new TomlError('invalid number', {
                 toml: toml,
-                ptr: ptr
+                ptr: ptr,
             });
         }
-        if (isInt && !Number.isSafeInteger(numeric)) {
-            throw new TomlError('integer value cannot be represented losslessly', {
-                toml: toml,
-                ptr: ptr
-            });
+        if (isInt) {
+            if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+                throw new TomlError('integer value cannot be represented losslessly', {
+                    toml: toml,
+                    ptr: ptr,
+                });
+            }
+            if (isInt || integersAsBigInt)
+                numeric = BigInt(value);
         }
         return numeric;
     }
-    let date = new TomlDate(value);
+    const date = new TomlDate(value);
     if (!date.isValid()) {
         throw new TomlError('invalid value', {
             toml: toml,
-            ptr: ptr
+            ptr: ptr,
         });
     }
     return date;

package/dist/stringify.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 stringify(obj: any, opts?: {
+export declare function stringify(obj: any, { maxDepth, numbersAsFloat }?: {
     maxDepth?: number;
+    numbersAsFloat?: boolean;
 }): string;

package/dist/stringify.js

@@ -46,9 +46,9 @@ function isArrayOfTables(obj) {
 function formatString(s) {
     return JSON.stringify(s).replace(/\x7f/g, '\\u007f');
 }
-function stringifyValue(val, type, depth) {
+function stringifyValue(val, type, depth, numberAsFloat) {
     if (depth === 0) {
-        throw new Error("Could not stringify the object: maximum object depth exceeded");
+        throw new Error('Could not stringify the object: maximum object depth exceeded');
     }
     if (type === 'number') {
         if (isNaN(val))
@@ -57,6 +57,8 @@ function stringifyValue(val, type, depth) {
             return 'inf';
         if (val === -Infinity)
             return '-inf';
+        if (numberAsFloat && Number.isInteger(val))
+            return val.toFixed(1);
         return val.toString();
     }
     if (type === 'bigint' || type === 'boolean') {
@@ -72,13 +74,13 @@ function stringifyValue(val, type, depth) {
         return val.toISOString();
     }
     if (type === 'object') {
-        return stringifyInlineTable(val, depth);
+        return stringifyInlineTable(val, depth, numberAsFloat);
     }
     if (type === 'array') {
-        return stringifyArray(val, depth);
+        return stringifyArray(val, depth, numberAsFloat);
     }
 }
-function stringifyInlineTable(obj, depth) {
+function stringifyInlineTable(obj, depth, numberAsFloat) {
     let keys = Object.keys(obj);
     if (keys.length === 0)
         return '{}';
@@ -89,11 +91,11 @@ function stringifyInlineTable(obj, depth) {
             res += ', ';
         res += BARE_KEY.test(k) ? k : formatString(k);
         res += ' = ';
-        res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1);
+        res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
     }
     return res + ' }';
 }
-function stringifyArray(array, depth) {
+function stringifyArray(array, depth, numberAsFloat) {
     if (array.length === 0)
         return '[]';
     let res = '[ ';
@@ -103,25 +105,25 @@ function stringifyArray(array, depth) {
         if (array[i] === null || array[i] === void 0) {
             throw new TypeError('arrays cannot contain null or undefined values');
         }
-        res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1);
+        res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
     }
     return res + ' ]';
 }
-function stringifyArrayTable(array, key, depth) {
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
     if (depth === 0) {
-        throw new Error("Could not stringify the object: maximum object depth exceeded");
+        throw new Error('Could not stringify the object: maximum object depth exceeded');
     }
     let res = '';
     for (let i = 0; i < array.length; i++) {
         res += `[[${key}]]\n`;
-        res += stringifyTable(array[i], key, depth);
+        res += stringifyTable(array[i], key, depth, numberAsFloat);
         res += '\n\n';
     }
     return res;
 }
-function stringifyTable(obj, prefix, depth) {
+function stringifyTable(obj, prefix, depth, numberAsFloat) {
     if (depth === 0) {
-        throw new Error("Could not stringify the object: maximum object depth exceeded");
+        throw new Error('Could not stringify the object: maximum object depth exceeded');
     }
     let preamble = '';
     let tables = '';
@@ -135,28 +137,27 @@ function stringifyTable(obj, prefix, depth) {
             }
             let key = BARE_KEY.test(k) ? k : formatString(k);
             if (type === 'array' && isArrayOfTables(obj[k])) {
-                tables += stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1);
+                tables += stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
             }
             else if (type === 'object') {
                 let tblKey = prefix ? `${prefix}.${key}` : key;
                 tables += `[${tblKey}]\n`;
-                tables += stringifyTable(obj[k], tblKey, depth - 1);
+                tables += stringifyTable(obj[k], tblKey, depth - 1, numberAsFloat);
                 tables += '\n\n';
             }
             else {
                 preamble += key;
                 preamble += ' = ';
-                preamble += stringifyValue(obj[k], type, depth);
+                preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
                 preamble += '\n';
             }
         }
     }
     return `${preamble}\n${tables}`.trim();
 }
-export function stringify(obj, opts) {
+export function stringify(obj, { maxDepth = 1000, numbersAsFloat = false } = {}) {
     if (extendedTypeOf(obj) !== 'object') {
         throw new TypeError('stringify can only be called with an object');
     }
-    let maxDepth = opts?.maxDepth ?? 1000;
-    return stringifyTable(obj, '', maxDepth);
+    return stringifyTable(obj, '', maxDepth, numbersAsFloat);
 }

package/dist/struct.d.ts

@@ -25,7 +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.
  */
-import { type TomlPrimitive } from './util.js';
+import { type IntegersAsBigInt } from './primitive.js';
+import { type TomlTable, type TomlValue } from './util.js';
 export declare function parseKey(str: string, ptr: number, end?: string): [string[], number];
-export declare function parseInlineTable(str: string, ptr: number, depth?: number): [Record<string, TomlPrimitive>, number];
-export declare function parseArray(str: string, ptr: number, depth?: number): [TomlPrimitive[], number];
+export declare function parseInlineTable(str: string, ptr: number, depth: number, integersAsBigInt: IntegersAsBigInt): [TomlTable, number];
+export declare function parseArray(str: string, ptr: number, depth: number, integersAsBigInt: IntegersAsBigInt): [TomlValue[], number];

package/dist/struct.js

@@ -27,7 +27,7 @@
  */
 import { parseString } from './primitive.js';
 import { extractValue } from './extract.js';
-import { skipComment, indexOfNewline, getStringEnd, skipVoid } from './util.js';
+import { getStringEnd, indexOfNewline, skipComment, skipVoid } from './util.js';
 import { TomlError } from './error.js';
 let KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
 export function parseKey(str, ptr, end = '=') {
@@ -37,7 +37,7 @@ export function parseKey(str, ptr, end = '=') {
     if (endPtr < 0) {
         throw new TomlError('incomplete key-value: cannot find end of key', {
             toml: str,
-            ptr: ptr
+            ptr: ptr,
         });
     }
     do {
@@ -45,7 +45,7 @@ export function parseKey(str, ptr, end = '=') {
         // If it's whitespace, ignore
         if (c !== ' ' && c !== '\t') {
             // If it's a string
-            if (c === '"' || c === "'") {
+            if (c === '"' || c === '\'') {
                 if (c === str[ptr + 1] && c === str[ptr + 2]) {
                     throw new TomlError('multiline strings are not allowed in keys', {
                         toml: str,
@@ -102,30 +102,22 @@ export function parseKey(str, ptr, end = '=') {
     } while (dot + 1 && dot < endPtr);
     return [parsed, skipVoid(str, endPtr + 1, true, true)];
 }
-export function parseInlineTable(str, ptr, depth = -1) {
+export function parseInlineTable(str, ptr, depth, integersAsBigInt) {
     let res = {};
     let seen = new Set();
     let c;
     let comma = 0;
     ptr++;
     while ((c = str[ptr++]) !== '}' && c) {
+        let err = { toml: str, ptr: ptr - 1 };
         if (c === '\n') {
-            throw new TomlError('newlines are not allowed in inline tables', {
-                toml: str,
-                ptr: ptr - 1
-            });
+            throw new TomlError('newlines are not allowed in inline tables', err);
         }
         else if (c === '#') {
-            throw new TomlError('inline tables cannot contain comments', {
-                toml: str,
-                ptr: ptr - 1
-            });
+            throw new TomlError('inline tables cannot contain comments', err);
         }
         else if (c === ',') {
-            throw new TomlError('expected key-value, found comma', {
-                toml: str,
-                ptr: ptr - 1
-            });
+            throw new TomlError('expected key-value, found comma', err);
         }
         else if (c !== ' ' && c !== '\t') {
             let k;
@@ -139,7 +131,7 @@ export function parseInlineTable(str, ptr, depth = -1) {
                 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
+                        ptr: ptr,
                     });
                 }
                 if (!hasOwn && k === '__proto__') {
@@ -149,10 +141,10 @@ export function parseInlineTable(str, ptr, depth = -1) {
             if (hasOwn) {
                 throw new TomlError('trying to redefine an already defined value', {
                     toml: str,
-                    ptr: ptr
+                    ptr: ptr,
                 });
             }
-            let [value, valueEndPtr] = extractValue(str, keyEndPtr, '}', depth - 1);
+            let [value, valueEndPtr] = extractValue(str, keyEndPtr, '}', depth - 1, integersAsBigInt);
             seen.add(value);
             t[k] = value;
             ptr = valueEndPtr;
@@ -162,18 +154,18 @@ export function parseInlineTable(str, ptr, depth = -1) {
     if (comma) {
         throw new TomlError('trailing commas are not allowed in inline tables', {
             toml: str,
-            ptr: comma
+            ptr: comma,
         });
     }
     if (!c) {
         throw new TomlError('unfinished table encountered', {
             toml: str,
-            ptr: ptr
+            ptr: ptr,
         });
     }
     return [res, ptr];
 }
-export function parseArray(str, ptr, depth = -1) {
+export function parseArray(str, ptr, depth, integersAsBigInt) {
     let res = [];
     let c;
     ptr++;
@@ -181,13 +173,13 @@ export function parseArray(str, ptr, depth = -1) {
         if (c === ',') {
             throw new TomlError('expected value, found comma', {
                 toml: str,
-                ptr: ptr - 1
+                ptr: ptr - 1,
             });
         }
         else if (c === '#')
             ptr = skipComment(str, ptr);
         else if (c !== ' ' && c !== '\t' && c !== '\n' && c !== '\r') {
-            let e = extractValue(str, ptr - 1, ']', depth - 1);
+            let e = extractValue(str, ptr - 1, ']', depth - 1, integersAsBigInt);
             res.push(e[0]);
             ptr = e[1];
         }
@@ -195,7 +187,7 @@ export function parseArray(str, ptr, depth = -1) {
     if (!c) {
         throw new TomlError('unfinished array encountered', {
             toml: str,
-            ptr: ptr
+            ptr: ptr,
         });
     }
     return [res, ptr];

package/dist/util.d.ts

@@ -26,9 +26,15 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import type { TomlDate } from './date.js';
-export type TomlPrimitive = string | number | boolean | TomlDate | {
-    [key: string]: TomlPrimitive;
-} | TomlPrimitive[];
+export type TomlPrimitive = string | number | bigint | boolean | TomlDate;
+export type TomlTable = {
+    [key: string]: TomlValue;
+};
+export type TomlValue = TomlPrimitive | TomlValue[] | TomlTable;
+export type TomlTableWithoutBigInt = {
+    [key: string]: TomlValueWithoutBigInt;
+};
+export type TomlValueWithoutBigInt = Exclude<TomlPrimitive, bigint> | TomlValueWithoutBigInt[] | TomlTableWithoutBigInt;
 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;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "smol-toml",
   "license": "BSD-3-Clause",
-  "version": "1.3.4",
+  "version": "1.4.0",
   "description": "A small, fast, and correct TOML parser/serializer",
   "author": "Cynthia <cyyynthia@borkenware.com>",
   "repository": "github:squirrelchat/smol-toml",
@@ -19,15 +19,15 @@
   "devDependencies": {
     "@iarna/toml": "3.0.0",
     "@ltd/j-toml": "^1.38.0",
-    "@tsconfig/node-lts": "^22.0.1",
+    "@tsconfig/node-lts": "^22.0.2",
     "@tsconfig/strictest": "^2.0.5",
-    "@types/node": "^22.14.1",
-    "@vitest/ui": "^3.1.2",
-    "esbuild": "^0.25.3",
+    "@types/node": "^24.0.7",
+    "@vitest/ui": "^3.2.4",
+    "esbuild": "^0.25.5",
     "fast-toml": "^0.5.4",
-    "pin-github-action": "^3.1.2",
+    "pin-github-action": "^3.4.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.2"
+    "vitest": "^3.2.4"
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",