@marcuspuchalla/nachos 0.1.1 → 0.1.4

package/dist/{chunk-7CFYWHS6.js → chunk-UMAX5MX5.js}

@@ -158,6 +158,9 @@ function useCborStringEncoder(globalOptions) {
   const encodeByteString = (data, encodeOptions) => {
     const isIndefinite = isCborByteString(data) && data[INDEFINITE_SYMBOL] === true;
     if (encodeOptions?.indefinite || Array.isArray(data) || isIndefinite) {
+      if (options.allowIndefinite === false) {
+        throw new Error("Indefinite-length encoding is not allowed");
+      }
       if (options.canonical) {
         throw new Error("Indefinite-length encoding not allowed in canonical mode");
       }
@@ -168,17 +171,20 @@ function useCborStringEncoder(globalOptions) {
       return encodeByteStringIndefinite(Array.isArray(bytes2) ? bytes2 : [bytes2]);
     }
     const bytes = isCborByteString(data) ? data.bytes : data;
+    if (bytes.length + 9 > options.maxOutputSize) {
+      throw new Error(`Encoded output exceeds maximum size`);
+    }
     const header = encodeLengthHeader(2, bytes.length);
     const result = concatenateUint8Arrays([header, bytes]);
-    if (result.length > options.maxOutputSize) {
-      throw new Error("Encoded output exceeds maximum size");
-    }
     return {
       bytes: result,
       hex: bytesToHex(result)
     };
   };
   const encodeByteStringIndefinite = (chunks) => {
+    if (options.allowIndefinite === false) {
+      throw new Error("Indefinite-length encoding is not allowed");
+    }
     if (options.canonical) {
       throw new Error("Indefinite-length encoding not allowed in canonical mode");
     }
@@ -198,6 +204,9 @@ function useCborStringEncoder(globalOptions) {
   const encodeTextString = (text, encodeOptions) => {
     const isIndefinite = isCborTextString(text) && text[INDEFINITE_SYMBOL] === true;
     if (encodeOptions?.indefinite || isIndefinite) {
+      if (options.allowIndefinite === false) {
+        throw new Error("Indefinite-length encoding is not allowed");
+      }
       if (options.canonical) {
         throw new Error("Indefinite-length encoding not allowed in canonical mode");
       }
@@ -210,17 +219,20 @@ function useCborStringEncoder(globalOptions) {
     const textStr = isCborTextString(text) ? text.text : text;
     const encoder = new TextEncoder();
     const utf8Bytes = encoder.encode(textStr);
+    if (utf8Bytes.length + 9 > options.maxOutputSize) {
+      throw new Error(`Encoded output exceeds maximum size`);
+    }
     const header = encodeLengthHeader(3, utf8Bytes.length);
     const result = concatenateUint8Arrays([header, utf8Bytes]);
-    if (result.length > options.maxOutputSize) {
-      throw new Error("Encoded output exceeds maximum size");
-    }
     return {
       bytes: result,
       hex: bytesToHex(result)
     };
   };
   const encodeTextStringIndefinite = (chunks) => {
+    if (options.allowIndefinite === false) {
+      throw new Error("Indefinite-length encoding is not allowed");
+    }
     if (options.canonical) {
       throw new Error("Indefinite-length encoding not allowed in canonical mode");
     }
@@ -247,11 +259,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 < 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) || 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;
@@ -266,7 +439,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;
@@ -276,6 +457,9 @@ function useCborCollectionEncoder(globalOptions) {
       const isIndefinite = value[INDEFINITE_SYMBOL] === true;
       const newCtx = { ...ctx, depth: ctx.depth + 1 };
       if (isIndefinite) {
+        if (ctx.options.allowIndefinite === false) {
+          throw new Error("Indefinite-length encoding is not allowed");
+        }
         const parts = [new Uint8Array([159])];
         for (const item of value) {
           const encoded = encodeValue(item, newCtx);
@@ -295,6 +479,9 @@ function useCborCollectionEncoder(globalOptions) {
       const isIndefinite = value[INDEFINITE_SYMBOL] === true;
       const newCtx = { ...ctx, depth: ctx.depth + 1 };
       if (isIndefinite) {
+        if (ctx.options.allowIndefinite === false) {
+          throw new Error("Indefinite-length encoding is not allowed");
+        }
         const entries = value instanceof Map ? Array.from(value.entries()) : Object.entries(value);
         const parts = [new Uint8Array([191])];
         for (const [key, val] of entries) {
@@ -340,10 +527,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)
@@ -352,6 +535,9 @@ function useCborCollectionEncoder(globalOptions) {
   const encodeArray = (array, encodeOptions) => {
     const isIndefinite = array[INDEFINITE_SYMBOL] === true;
     if (encodeOptions?.indefinite || isIndefinite) {
+      if (options.allowIndefinite === false) {
+        throw new Error("Indefinite-length encoding is not allowed");
+      }
       if (options.canonical) {
         throw new Error("Indefinite-length encoding not allowed in canonical mode");
       }
@@ -359,19 +545,20 @@ function useCborCollectionEncoder(globalOptions) {
     }
     const ctx = {
       depth: 0,
-      bytesWritten: 0,
       options
     };
     return encodeArrayInternal(array, ctx);
   };
   const encodeArrayIndefinite = (array) => {
+    if (options.allowIndefinite === false) {
+      throw new Error("Indefinite-length encoding is not allowed");
+    }
     if (options.canonical) {
       throw new Error("Indefinite-length encoding not allowed in canonical mode");
     }
     const parts = [new Uint8Array([159])];
     const ctx = {
       depth: 0,
-      bytesWritten: 0,
       options
     };
     for (const item of array) {
@@ -392,12 +579,27 @@ 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
+      }));
+      withEncodedKeys.sort((a, b) => compareBytes(a.encodedKey, b.encodedKey));
+      entries = withEncodedKeys.map((t) => t.entry);
+      preEncodedKeys = withEncodedKeys.map((t) => t.encodedKey);
+    }
+    if (ctx.options.rejectDuplicateKeys) {
+      const seen = /* @__PURE__ */ new Set();
+      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");
+        }
+        seen.add(keyHex);
+      }
     }
     const header = encodeLengthHeader(5, entries.length);
     const parts = [header];
@@ -408,10 +610,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)
@@ -420,6 +618,9 @@ function useCborCollectionEncoder(globalOptions) {
   const encodeMap = (map, encodeOptions) => {
     const isIndefinite = map[INDEFINITE_SYMBOL] === true;
     if (encodeOptions?.indefinite || isIndefinite) {
+      if (options.allowIndefinite === false) {
+        throw new Error("Indefinite-length encoding is not allowed");
+      }
       if (options.canonical) {
         throw new Error("Indefinite-length encoding not allowed in canonical mode");
       }
@@ -427,12 +628,14 @@ function useCborCollectionEncoder(globalOptions) {
     }
     const ctx = {
       depth: 0,
-      bytesWritten: 0,
       options
     };
     return encodeMapInternal(map, ctx);
   };
   const encodeMapIndefinite = (map) => {
+    if (options.allowIndefinite === false) {
+      throw new Error("Indefinite-length encoding is not allowed");
+    }
     if (options.canonical) {
       throw new Error("Indefinite-length encoding not allowed in canonical mode");
     }
@@ -440,7 +643,6 @@ function useCborCollectionEncoder(globalOptions) {
     const parts = [new Uint8Array([191])];
     const ctx = {
       depth: 0,
-      bytesWritten: 0,
       options
     };
     for (const [key, value] of entries) {
@@ -465,145 +667,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 < -14) {
-      exp16 = 0;
-      mant16 = 0;
-    } 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) => {
@@ -657,6 +720,9 @@ function useCborTagEncoder() {
 // src/encoder/composables/useCborEncoder.ts
 function useCborEncoder(globalOptions) {
   const options = { ...DEFAULT_ENCODE_OPTIONS, ...globalOptions };
+  if (options.canonical && options.allowIndefinite) {
+    options.allowIndefinite = false;
+  }
   const { encodeInteger } = useCborIntegerEncoder();
   const { encodeTextString, encodeByteString } = useCborStringEncoder(options);
   const { encodeArray, encodeMap, setMainEncode } = useCborCollectionEncoder(options);
@@ -665,11 +731,23 @@ 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;
+  };
+  const encodeValue = (value) => {
     if (value === null || value === void 0 || typeof value === "boolean") {
       return encodeSimple(value);
     }
     if (typeof value === "number") {
-      if (Number.isInteger(value) && Number.isSafeInteger(value)) {
+      if (Object.is(value, -0)) {
+        return encodeFloat(value, 16);
+      }
+      if (Number.isSafeInteger(value)) {
         return encodeInteger(value);
       }
       return encodeFloat(value);
@@ -738,5 +816,5 @@ function useCborEncoder(globalOptions) {
 }
 
 export { DEFAULT_ENCODE_OPTIONS, bytesToHex, compareBytes, concatenateUint8Arrays, useCborCollectionEncoder, useCborEncoder, useCborIntegerEncoder, useCborSimpleEncoder, useCborStringEncoder, useCborTagEncoder, writeBigUint, writeUint };
-//# sourceMappingURL=chunk-7CFYWHS6.js.map
-//# sourceMappingURL=chunk-7CFYWHS6.js.map
+//# sourceMappingURL=chunk-UMAX5MX5.js.map
+//# sourceMappingURL=chunk-UMAX5MX5.js.map