teptris 0.3.12 → 0.3.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teptris",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "TOML for JavaScript/TypeScript at libteptris speed (WebAssembly, no fallback) - version tracks the engine ({engine}.{iteration}; npm semver is 3-part)",
   "type": "module",
   "main": "src/index.js",

package/src/index.d.ts

@@ -32,7 +32,13 @@ export interface TeptrisError extends Error {
 export interface TeptrisApi {
   /** Parse TOML into a JS object (natural-JSON view: real numbers,
    *  booleans, RFC 3339 datetime strings, non-finite floats as
-   *  null). Throws TeptrisError on invalid input. */
+   *  null). Throws TeptrisError on invalid input.
+   *
+   *  Precision floor: JS numbers lose precision past 2^53, so
+   *  integer literals beyond that round (9223372036854775807 reads
+   *  back as 9223372036854776000). dump() never wraps: values past
+   *  the int64 bounds emit as floats, and bigints outside int64
+   *  throw. */
   loads(toml: string): TomlTable;
 
   /** Serialize a table to canonical TOML via the engine builder.

package/src/index.js

@@ -28,7 +28,9 @@ function parseDateTime(str) {
     return {
       kind, year: +m[1], month: +m[2], day: +m[3], hour: +m[4],
       minute: +m[5], second: +m[6],
-      nanosecond: m[7] ? Math.floor(+("0." + m[7]) * 1e9) : 0,
+      // integer string padding, not FP: 0.507029 * 1e9 floors to
+      // 507028999 (off by one)
+      nanosecond: m[7] ? +((m[7] + "000000000").slice(0, 9)) : 0,
       offset_seconds: offset,
     };
   }
@@ -42,7 +44,7 @@ function parseDateTime(str) {
   if (m) {
     return { kind: KIND_TIME, year: 0, month: 0, day: 0, hour: +m[1],
              minute: +m[2], second: +m[3],
-             nanosecond: m[4] ? Math.floor(+("0." + m[4]) * 1e9) : 0,
+             nanosecond: m[4] ? +((m[4] + "000000000").slice(0, 9)) : 0,
              offset_seconds: 0 };
   }
   return null;
@@ -51,29 +53,44 @@ function parseDateTime(str) {
 const RFC3339 =
   /^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$|^\d{2}:\d{2}:\d{2}(\.\d+)?$/;
 
+// int64 bounds for the dump integer path: Number.isInteger is true for
+// values like 1e21, and the op-stream's int64 encode wraps silently
+// past these bounds. The bound is 2^63 EXCLUSIVE (exactly representable
+// as a number; 2^63-1 is not - its literal rounds up to 2^63).
+// BigInt(number) of an integral in-range f64 is exact, so anything
+// between 2^53 and 2^63 is still lossless.
+const I64_BOUND = 9223372036854775808; /* 2 ** 63 */
+const I64_MIN_BIG = -9223372036854775808n;
+const I64_MAX_BIG = 9223372036854775807n;
+
 // cheap charset pre-check before the RFC 3339 regex: datetimes start
 // with a digit and only ever contain digits, date/time punctuation
-// and TZ marks - rejects nearly all plain strings without the regex
-const DATETIME_CHARS = /[0-9Tt: .+Zz-]/;
+// and TZ marks - rejects nearly all plain strings without the regex.
+// One whole-string regex pass (the per-char loop allocated a
+// single-char string per character).
+const DATETIME_CHARS = /^[0-9Tt: .+Zz-]*$/;
 const utf8 = new TextDecoder("utf-8");
+const utf8enc = new TextEncoder();
 function maybeRfc3339(v) {
   const c0 = v.charCodeAt(0);
-  if (!(c0 >= 48 && c0 <= 57)) return false;
-  for (let i = 1; i < v.length; i++) {
-    if (!DATETIME_CHARS.test(v[i])) return false;
-  }
-  return true;
+  return c0 >= 48 && c0 <= 57 && DATETIME_CHARS.test(v);
 }
 
 function buildValue(mod, b, key, v, errs) {
   const kp = key == null ? 0 : cstr(mod, key);
   try {
     if (v === null || v === undefined) {
-      throw new Error("null/undefined cannot round-trip through TOML");
+      throw new Error("null/undefined cannot round-trip through TOML (nan/inf parse to null in loads() and cannot re-enter)");
     }
     switch (typeof v) {
       case "number":
-        if (Number.isInteger(v)) {
+        // same int64-exactness guard as the op-stream path: put_integer
+        // truncates BigInts past the int64 bounds, and -0.0 keeps its
+        // sign only as a float
+        if (Object.is(v, -0)) {
+          mod._teptris_wasm_builder_put_float(b, kp, v);
+        } else if (Number.isInteger(v) &&
+                   v >= -I64_BOUND && v < I64_BOUND) {
           mod._teptris_wasm_builder_put_integer(b, kp, BigInt(v));
         } else {
           mod._teptris_wasm_builder_put_float(b, kp, v);
@@ -177,7 +194,9 @@ export function initApi(mod) {
   }
 
   function readOut(ptr) {
-    const out = UTF8ToString(ptr);
+    // explicit length: the emit buffer is not NUL-terminated for us,
+    // and a full strlen scan over the output is measurable
+    const out = UTF8ToString(ptr, mod._teptris_wasm_toml_len());
     mod._teptris_wasm_free(ptr);
     return out;
   }
@@ -189,7 +208,7 @@ export function initApi(mod) {
     if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
       throw new TypeError("dump expects a table object (TOML roots are tables)");
     }
-    const enc = new TextEncoder();
+
     let buf = new Uint8Array(1 << 16);
     let n = 0;
     let dv = new DataView(buf.buffer);
@@ -226,24 +245,53 @@ export function initApi(mod) {
     const wkey = (k) => {
       ensure(2 + k.length * 3);
       buf[n++] = 1;
-      const { written } = enc.encodeInto(k, buf.subarray(n + 1));
-      buf[n] = written;
-      n += 1 + written;
+      // ASCII fast path: keys are tiny, so TextEncoder.encodeInto's
+      // per-call view allocation costs more than the copy itself;
+      // non-ASCII falls back to encodeInto (overwrites from offset 1)
+      let ascii = true;
+      for (let i = 0; i < k.length; i++) {
+        const c = k.charCodeAt(i);
+        if (c > 127) { ascii = false; break; }
+        buf[n + 1 + i] = c;
+      }
+      if (ascii) {
+        buf[n] = k.length;
+        n += 1 + k.length;
+      } else {
+        const { written } = utf8enc.encodeInto(k, buf.subarray(n + 1));
+        buf[n] = written;
+        n += 1 + written;
+      }
     };
     const scalar = (k, v) => {
       if (k === null) { ensure(2); buf[n++] = 1; buf[n++] = 0; }
       else wkey(k);
       if (typeof v === "boolean") { byte(v ? 6 : 5); return; }
       if (typeof v === "number") {
-        if (Number.isInteger(v)) { byte(3); i64(v); }
-        else { byte(4); f64(v); }
+        // the integer path only for numbers the int64 op can carry
+        // EXACTLY: Number.isInteger alone is true for 1e21 and for
+        // loads-rounded values past i64max, and setBigInt64 silently
+        // WRAPS out-of-range values (9223372036854775807 dumped as
+        // INT64_MIN); -0.0 must keep its sign, so it goes to the
+        // float path too
+        if (Object.is(v, -0)) { byte(4); f64(v); return; }
+        if (Number.isInteger(v) &&
+            v >= -I64_BOUND && v < I64_BOUND) { byte(3); i64(v); return; }
+        byte(4); f64(v);
         return;
       }
-      if (typeof v === "bigint") { byte(3); i64(v); return; }
+      if (typeof v === "bigint") {
+        if (v < I64_MIN_BIG || v > I64_MAX_BIG) {
+          throw new Error(`bigint out of int64 range: ${v}`);
+        }
+        byte(3); i64(v); return;
+      }
       if (typeof v === "string") {
         if (maybeRfc3339(v) && RFC3339.test(v)) {
           const dt = parseDateTime(v);
-          wkey(k);
+          // the key prefix is already written (top of scalar()); the
+          // datetime record is value-only - re-sending the key here
+          // crashed bare array elements (k === null)
           ensure(27);
           buf[n++] = 7;
           buf[n++] = dt.kind;
@@ -256,12 +304,23 @@ export function initApi(mod) {
         }
         ensure(5 + v.length * 3);
         buf[n++] = 2;
-        const { written } = enc.encodeInto(v, buf.subarray(n + 4));
-        dv.setUint32(n, written, true);
-        n += 4 + written;
+        let ascii = true;
+        for (let i = 0; i < v.length; i++) {
+          const c = v.charCodeAt(i);
+          if (c > 127) { ascii = false; break; }
+          buf[n + 4 + i] = c;
+        }
+        if (ascii) {
+          dv.setUint32(n, v.length, true);
+          n += 4 + v.length;
+        } else {
+          const { written } = utf8enc.encodeInto(v, buf.subarray(n + 4));
+          dv.setUint32(n, written, true);
+          n += 4 + written;
+        }
         return;
       }
-      throw new Error("null/undefined cannot round-trip through TOML");
+      throw new Error("null/undefined cannot round-trip through TOML (nan/inf parse to null in loads() and cannot re-enter)");
     };
     const isScalar = (v) =>
       v !== null && (typeof v !== "object" || Array.isArray(v) === false &&
@@ -277,7 +336,7 @@ export function initApi(mod) {
         const k = keys[i], v = o[k];
         if (isScalar(v)) continue;
         if (v === null || v === undefined) {
-          throw new Error("null/undefined cannot round-trip through TOML");
+          throw new Error("null/undefined cannot round-trip through TOML (nan/inf parse to null in loads() and cannot re-enter)");
         }
         wkey(k);
         if (Array.isArray(v)) {
@@ -309,7 +368,7 @@ export function initApi(mod) {
         return;
       }
       if (el === null || el === undefined) {
-        throw new Error("null/undefined cannot round-trip through TOML");
+        throw new Error("null/undefined cannot round-trip through TOML (nan/inf parse to null in loads() and cannot re-enter)");
       }
       byte(0x0B);
       members(el, true);