@marcuspuchalla/nachos 0.1.3 → 0.2.0

package/dist/{chunk-2MTLSQ7E.js → chunk-EDXZTSIA.js}

@@ -1,10 +1,11 @@
-import { useCborByteString, useCborTextString, INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL } from './chunk-ZDZ2B5PE.js';
+import { useCborByteString, useCborTextString, INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL } from './chunk-JESIF5IF.js';
 
 // src/encoder/types.ts
 var DEFAULT_ENCODE_OPTIONS = {
   canonical: false,
   allowIndefinite: true,
   rejectDuplicateKeys: false,
+  mapKeyOrder: "length-first",
   maxDepth: 64,
   maxOutputSize: 100 * 1024 * 1024
   // 100 MB
@@ -40,6 +41,20 @@ function compareBytes(a, b) {
   }
   return 0;
 }
+function compareBytesLexicographic(a, b) {
+  const min = Math.min(a.length, b.length);
+  for (let i = 0; i < min; i++) {
+    const byteA = a[i];
+    const byteB = b[i];
+    if (byteA !== byteB) {
+      return byteA - byteB;
+    }
+  }
+  return a.length - b.length;
+}
+function compareMapKeys(a, b, order = "length-first") {
+  return order === "bytewise" ? compareBytesLexicographic(a, b) : compareBytes(a, b);
+}
 function writeUint(value, bytes) {
   const result = new Uint8Array(bytes);
   for (let i = bytes - 1; i >= 0; i--) {
@@ -259,11 +274,172 @@ function useCborStringEncoder(globalOptions) {
   };
 }
 
+// src/encoder/composables/useCborSimpleEncoder.ts
+function useCborSimpleEncoder(_globalOptions) {
+  const { encodeInteger } = useCborIntegerEncoder();
+  const encodeSimple = (value) => {
+    let byte;
+    if (value === false) {
+      byte = 244;
+    } else if (value === true) {
+      byte = 245;
+    } else if (value === null) {
+      byte = 246;
+    } else if (value === void 0) {
+      byte = 247;
+    } else {
+      throw new Error(`Unsupported simple value: ${value}`);
+    }
+    return {
+      bytes: new Uint8Array([byte]),
+      hex: bytesToHex(new Uint8Array([byte]))
+    };
+  };
+  const encodeFloat16Bytes = (value) => {
+    if (Object.is(value, -0)) return new Uint8Array([128, 0]);
+    if (value === 0) return new Uint8Array([0, 0]);
+    if (Number.isNaN(value)) return new Uint8Array([126, 0]);
+    if (value === Infinity) return new Uint8Array([124, 0]);
+    if (value === -Infinity) return new Uint8Array([252, 0]);
+    const sign = value < 0 ? 1 : 0;
+    const absValue = Math.abs(value);
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setFloat64(0, absValue, false);
+    const bits = view.getBigUint64(0, false);
+    const exp64 = Number(bits >> 52n & 0x7ffn) - 1023;
+    const mant64 = Number(bits & 0xfffffffffffffn);
+    const mant64n = BigInt(mant64);
+    let exp16;
+    let mant16;
+    if (exp64 < -24) {
+      exp16 = 0;
+      mant16 = 0;
+    } else if (exp64 < -14) {
+      exp16 = 0;
+      const shift = -14 - exp64;
+      const fullMant = 1n << 10n | mant64n >> 42n;
+      const lostFromExtract = mant64n & (1n << 42n) - 1n;
+      const shiftN = BigInt(shift);
+      const guardBit = Number(fullMant >> shiftN - 1n & 1n);
+      const stickyBitsBelow = shiftN > 1n ? fullMant & (1n << shiftN - 1n) - 1n : 0n;
+      const sticky = stickyBitsBelow !== 0n || lostFromExtract !== 0n ? 1 : 0;
+      const truncated = Number(fullMant >> shiftN);
+      const lsb = truncated & 1;
+      mant16 = truncated + (guardBit & (sticky | lsb));
+    } else if (exp64 > 15) {
+      exp16 = 31;
+      mant16 = 0;
+    } else {
+      exp16 = exp64 + 15;
+      const truncated = Number(mant64n >> 42n);
+      const guardBit = Number(mant64n >> 41n & 1n);
+      const stickyBits = (mant64n & (1n << 41n) - 1n) !== 0n ? 1 : 0;
+      const lsb = truncated & 1;
+      mant16 = truncated + (guardBit & (stickyBits | lsb));
+      if (mant16 > 1023) {
+        mant16 = 0;
+        exp16 += 1;
+      }
+    }
+    const float16 = sign << 15 | exp16 << 10 | mant16;
+    return new Uint8Array([
+      float16 >> 8 & 255,
+      float16 & 255
+    ]);
+  };
+  const encodeFloat32Bytes = (value) => {
+    const buffer = new ArrayBuffer(4);
+    const view = new DataView(buffer);
+    view.setFloat32(0, value, false);
+    return new Uint8Array(buffer);
+  };
+  const encodeFloat64Bytes = (value) => {
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setFloat64(0, value, false);
+    return new Uint8Array(buffer);
+  };
+  const canBeFloat16 = (value) => {
+    if (!Number.isFinite(value) || Object.is(value, 0) || Object.is(value, -0)) {
+      return true;
+    }
+    const absValue = Math.abs(value);
+    if (absValue < 5960464477539063e-23 || absValue > 65504) {
+      return false;
+    }
+    const bytes = encodeFloat16Bytes(value);
+    const view = new DataView(bytes.buffer);
+    const bits = view.getUint16(0, false);
+    const sign = bits >> 15 & 1;
+    const exp = bits >> 10 & 31;
+    const mant = bits & 1023;
+    let decoded;
+    if (exp === 0) {
+      decoded = (sign ? -1 : 1) * Math.pow(2, -14) * (mant / 1024);
+    } else if (exp === 31) {
+      decoded = mant === 0 ? sign ? -Infinity : Infinity : NaN;
+    } else {
+      decoded = (sign ? -1 : 1) * Math.pow(2, exp - 15) * (1 + mant / 1024);
+    }
+    return decoded === value;
+  };
+  const canBeFloat32 = (value) => {
+    if (!Number.isFinite(value) || Object.is(value, 0) || Object.is(value, -0)) {
+      return true;
+    }
+    const buffer = new ArrayBuffer(4);
+    const view = new DataView(buffer);
+    view.setFloat32(0, value, false);
+    const decoded = view.getFloat32(0, false);
+    return decoded === value;
+  };
+  const isInteger = (value) => {
+    return Number.isInteger(value) && Number.isSafeInteger(value);
+  };
+  const encodeFloat = (value, precision) => {
+    let bytes;
+    if (isInteger(value) && !precision) {
+      return encodeInteger(value);
+    }
+    if (precision === 16) {
+      const floatBytes = encodeFloat16Bytes(value);
+      bytes = new Uint8Array([249, ...floatBytes]);
+    } else if (precision === 32) {
+      const floatBytes = encodeFloat32Bytes(value);
+      bytes = new Uint8Array([250, ...floatBytes]);
+    } else if (precision === 64) {
+      const floatBytes = encodeFloat64Bytes(value);
+      bytes = new Uint8Array([251, ...floatBytes]);
+    } else {
+      if (canBeFloat16(value)) {
+        const floatBytes = encodeFloat16Bytes(value);
+        bytes = new Uint8Array([249, ...floatBytes]);
+      } else if (canBeFloat32(value)) {
+        const floatBytes = encodeFloat32Bytes(value);
+        bytes = new Uint8Array([250, ...floatBytes]);
+      } else {
+        const floatBytes = encodeFloat64Bytes(value);
+        bytes = new Uint8Array([251, ...floatBytes]);
+      }
+    }
+    return {
+      bytes,
+      hex: bytesToHex(bytes)
+    };
+  };
+  return {
+    encodeSimple,
+    encodeFloat
+  };
+}
+
 // src/encoder/composables/useCborCollectionEncoder.ts
 function useCborCollectionEncoder(globalOptions) {
   const options = { ...DEFAULT_ENCODE_OPTIONS, ...globalOptions };
   const { encodeInteger } = useCborIntegerEncoder();
   const { encodeTextString, encodeByteString } = useCborStringEncoder(globalOptions);
+  const { encodeFloat } = useCborSimpleEncoder();
   const { isCborByteString } = useCborByteString();
   const { isCborTextString } = useCborTextString();
   let mainEncode = null;
@@ -278,7 +454,15 @@ function useCborCollectionEncoder(globalOptions) {
       return new Uint8Array([246]);
     } else if (typeof value === "boolean") {
       return new Uint8Array([value ? 245 : 244]);
-    } else if (typeof value === "number" || typeof value === "bigint") {
+    } else if (typeof value === "number") {
+      if (Object.is(value, -0)) {
+        return encodeFloat(value, 16).bytes;
+      }
+      if (Number.isInteger(value) && Number.isSafeInteger(value)) {
+        return encodeInteger(value).bytes;
+      }
+      return encodeFloat(value).bytes;
+    } else if (typeof value === "bigint") {
       return encodeInteger(value).bytes;
     } else if (typeof value === "string" || isCborTextString(value)) {
       return encodeTextString(value).bytes;
@@ -358,10 +542,6 @@ function useCborCollectionEncoder(globalOptions) {
       parts.push(encoded);
     }
     const result = concatenateUint8Arrays(parts);
-    ctx.bytesWritten += result.length;
-    if (ctx.bytesWritten > ctx.options.maxOutputSize) {
-      throw new Error("Encoded output exceeds maximum size");
-    }
     return {
       bytes: result,
       hex: bytesToHex(result)
@@ -380,7 +560,6 @@ function useCborCollectionEncoder(globalOptions) {
     }
     const ctx = {
       depth: 0,
-      bytesWritten: 0,
       options
     };
     return encodeArrayInternal(array, ctx);
@@ -395,7 +574,6 @@ function useCborCollectionEncoder(globalOptions) {
     const parts = [new Uint8Array([159])];
     const ctx = {
       depth: 0,
-      bytesWritten: 0,
       options
     };
     for (const item of array) {
@@ -416,17 +594,22 @@ function useCborCollectionEncoder(globalOptions) {
     } else {
       entries = map instanceof Map ? Array.from(map.entries()) : Object.entries(map);
     }
+    let preEncodedKeys = null;
     if (ctx.options.canonical && !map[ALL_ENTRIES_SYMBOL]) {
-      entries.sort((a, b) => {
-        const keyA = encodeValue(a[0], { ...ctx, depth: ctx.depth + 1 });
-        const keyB = encodeValue(b[0], { ...ctx, depth: ctx.depth + 1 });
-        return compareBytes(keyA, keyB);
-      });
+      const childCtx = { ...ctx, depth: ctx.depth + 1 };
+      const withEncodedKeys = entries.map((entry) => ({
+        encodedKey: encodeValue(entry[0], childCtx),
+        entry
+      }));
+      const keyOrder = ctx.options.mapKeyOrder ?? "length-first";
+      withEncodedKeys.sort((a, b) => compareMapKeys(a.encodedKey, b.encodedKey, keyOrder));
+      entries = withEncodedKeys.map((t) => t.entry);
+      preEncodedKeys = withEncodedKeys.map((t) => t.encodedKey);
     }
     if (ctx.options.rejectDuplicateKeys) {
       const seen = /* @__PURE__ */ new Set();
-      for (const [key] of entries) {
-        const keyBytes = encodeValue(key, { ...ctx, depth: ctx.depth + 1, bytesWritten: 0 });
+      const keysForDupCheck = preEncodedKeys ?? entries.map((e) => encodeValue(e[0], { ...ctx, depth: ctx.depth + 1 }));
+      for (const keyBytes of keysForDupCheck) {
         const keyHex = bytesToHex(keyBytes);
         if (seen.has(keyHex)) {
           throw new Error("Duplicate map key detected");
@@ -443,10 +626,6 @@ function useCborCollectionEncoder(globalOptions) {
       parts.push(encodedValue);
     }
     const result = concatenateUint8Arrays(parts);
-    ctx.bytesWritten += result.length;
-    if (ctx.bytesWritten > ctx.options.maxOutputSize) {
-      throw new Error("Encoded output exceeds maximum size");
-    }
     return {
       bytes: result,
       hex: bytesToHex(result)
@@ -465,7 +644,6 @@ function useCborCollectionEncoder(globalOptions) {
     }
     const ctx = {
       depth: 0,
-      bytesWritten: 0,
       options
     };
     return encodeMapInternal(map, ctx);
@@ -481,7 +659,6 @@ function useCborCollectionEncoder(globalOptions) {
     const parts = [new Uint8Array([191])];
     const ctx = {
       depth: 0,
-      bytesWritten: 0,
       options
     };
     for (const [key, value] of entries) {
@@ -506,149 +683,6 @@ function useCborCollectionEncoder(globalOptions) {
   };
 }
 
-// src/encoder/composables/useCborSimpleEncoder.ts
-function useCborSimpleEncoder(_globalOptions) {
-  const { encodeInteger } = useCborIntegerEncoder();
-  const encodeSimple = (value) => {
-    let byte;
-    if (value === false) {
-      byte = 244;
-    } else if (value === true) {
-      byte = 245;
-    } else if (value === null) {
-      byte = 246;
-    } else if (value === void 0) {
-      byte = 247;
-    } else {
-      throw new Error(`Unsupported simple value: ${value}`);
-    }
-    return {
-      bytes: new Uint8Array([byte]),
-      hex: bytesToHex(new Uint8Array([byte]))
-    };
-  };
-  const encodeFloat16Bytes = (value) => {
-    if (value === 0) return new Uint8Array([0, 0]);
-    if (value === -0) return new Uint8Array([128, 0]);
-    if (Number.isNaN(value)) return new Uint8Array([126, 0]);
-    if (value === Infinity) return new Uint8Array([124, 0]);
-    if (value === -Infinity) return new Uint8Array([252, 0]);
-    const sign = value < 0 ? 1 : 0;
-    const absValue = Math.abs(value);
-    const buffer = new ArrayBuffer(8);
-    const view = new DataView(buffer);
-    view.setFloat64(0, absValue, false);
-    const bits = view.getBigUint64(0, false);
-    const exp64 = Number(bits >> 52n & 0x7ffn) - 1023;
-    const mant64 = Number(bits & 0xfffffffffffffn);
-    let exp16;
-    let mant16;
-    if (exp64 < -24) {
-      exp16 = 0;
-      mant16 = 0;
-    } else if (exp64 < -14) {
-      exp16 = 0;
-      const shift = -14 - exp64;
-      mant16 = (1 << 10 | mant64 >> 42) + ((1 << shift - 1) - 1) >> shift;
-    } else if (exp64 > 15) {
-      exp16 = 31;
-      mant16 = 0;
-    } else {
-      exp16 = exp64 + 15;
-      mant16 = mant64 >> 42;
-    }
-    const float16 = sign << 15 | exp16 << 10 | mant16;
-    return new Uint8Array([
-      float16 >> 8 & 255,
-      float16 & 255
-    ]);
-  };
-  const encodeFloat32Bytes = (value) => {
-    const buffer = new ArrayBuffer(4);
-    const view = new DataView(buffer);
-    view.setFloat32(0, value, false);
-    return new Uint8Array(buffer);
-  };
-  const encodeFloat64Bytes = (value) => {
-    const buffer = new ArrayBuffer(8);
-    const view = new DataView(buffer);
-    view.setFloat64(0, value, false);
-    return new Uint8Array(buffer);
-  };
-  const canBeFloat16 = (value) => {
-    if (!Number.isFinite(value) || value === 0 || value === -0) {
-      return true;
-    }
-    const absValue = Math.abs(value);
-    if (absValue < 6103515625e-14 || absValue > 65504) {
-      return false;
-    }
-    const bytes = encodeFloat16Bytes(value);
-    const view = new DataView(bytes.buffer);
-    const bits = view.getUint16(0, false);
-    const sign = bits >> 15 & 1;
-    const exp = bits >> 10 & 31;
-    const mant = bits & 1023;
-    let decoded;
-    if (exp === 0) {
-      decoded = (sign ? -1 : 1) * Math.pow(2, -14) * (mant / 1024);
-    } else if (exp === 31) {
-      decoded = mant === 0 ? sign ? -Infinity : Infinity : NaN;
-    } else {
-      decoded = (sign ? -1 : 1) * Math.pow(2, exp - 15) * (1 + mant / 1024);
-    }
-    return decoded === value;
-  };
-  const canBeFloat32 = (value) => {
-    if (!Number.isFinite(value) || value === 0 || value === -0) {
-      return true;
-    }
-    const buffer = new ArrayBuffer(4);
-    const view = new DataView(buffer);
-    view.setFloat32(0, value, false);
-    const decoded = view.getFloat32(0, false);
-    return decoded === value;
-  };
-  const isInteger = (value) => {
-    return Number.isInteger(value) && Number.isSafeInteger(value);
-  };
-  const encodeFloat = (value, precision) => {
-    let bytes;
-    if (isInteger(value) && !precision) {
-      return encodeInteger(value);
-    }
-    if (precision === 16) {
-      const floatBytes = encodeFloat16Bytes(value);
-      bytes = new Uint8Array([249, ...floatBytes]);
-    } else if (precision === 32) {
-      const floatBytes = encodeFloat32Bytes(value);
-      bytes = new Uint8Array([250, ...floatBytes]);
-    } else if (precision === 64) {
-      const floatBytes = encodeFloat64Bytes(value);
-      bytes = new Uint8Array([251, ...floatBytes]);
-    } else {
-      if (canBeFloat16(value)) {
-        const floatBytes = encodeFloat16Bytes(value);
-        bytes = new Uint8Array([249, ...floatBytes]);
-      } else if (canBeFloat32(value)) {
-        const floatBytes = encodeFloat32Bytes(value);
-        bytes = new Uint8Array([250, ...floatBytes]);
-      } else {
-        const floatBytes = encodeFloat64Bytes(value);
-        bytes = new Uint8Array([251, ...floatBytes]);
-      }
-    }
-    return {
-      bytes,
-      hex: bytesToHex(bytes)
-    };
-  };
-  return {
-    encodeSimple,
-    encodeFloat
-  };
-}
-
 // src/encoder/composables/useCborTagEncoder.ts
 function useCborTagEncoder() {
   const encodeTagNumber = (tagNumber) => {
@@ -713,10 +747,34 @@ function useCborEncoder(globalOptions) {
   const { isCborByteString } = useCborByteString();
   const { isCborTextString } = useCborTextString();
   const encode = (value) => {
+    const result = encodeValue(value);
+    if (options.maxOutputSize && result.bytes.length > options.maxOutputSize) {
+      throw new Error(
+        `Encoded output size ${result.bytes.length} bytes exceeds limit of ${options.maxOutputSize} bytes`
+      );
+    }
+    return result;
+  };
+  let currentDepth = 0;
+  const encodeValue = (value) => {
+    if (currentDepth > options.maxDepth) {
+      throw new Error(`Maximum nesting depth ${options.maxDepth} exceeded`);
+    }
+    currentDepth++;
+    try {
+      return encodeValueInner(value);
+    } finally {
+      currentDepth--;
+    }
+  };
+  const encodeValueInner = (value) => {
     if (value === null || value === void 0 || typeof value === "boolean") {
       return encodeSimple(value);
     }
     if (typeof value === "number") {
+      if (Object.is(value, -0)) {
+        return encodeFloat(value, 16);
+      }
       if (Number.isSafeInteger(value)) {
         return encodeInteger(value);
       }
@@ -786,5 +844,5 @@ function useCborEncoder(globalOptions) {
 }
 
 export { DEFAULT_ENCODE_OPTIONS, bytesToHex, compareBytes, concatenateUint8Arrays, useCborCollectionEncoder, useCborEncoder, useCborIntegerEncoder, useCborSimpleEncoder, useCborStringEncoder, useCborTagEncoder, writeBigUint, writeUint };
-//# sourceMappingURL=chunk-2MTLSQ7E.js.map
-//# sourceMappingURL=chunk-2MTLSQ7E.js.map
+//# sourceMappingURL=chunk-EDXZTSIA.js.map
+//# sourceMappingURL=chunk-EDXZTSIA.js.map