@marcuspuchalla/nachos 0.1.0 → 0.1.3

package/dist/{chunk-2HBCILJS.cjs → chunk-PTWN7K3Y.cjs}

@@ -363,6 +363,14 @@ function useCborString() {
           currentOffset++;
           break;
         }
+        const chunkInitialByte = readByte(buffer, currentOffset);
+        const chunkHeader = extractCborHeader(chunkInitialByte);
+        if (chunkHeader.majorType !== 2) {
+          throw new Error(`Indefinite byte string chunks must be byte strings (major type 2), got ${chunkHeader.majorType}`);
+        }
+        if (chunkHeader.additionalInfo === 31) {
+          throw new Error("Indefinite byte string chunks must be definite-length (RFC 8949 Section 3.2.3)");
+        }
         let chunkResult;
         try {
           chunkResult = parseByteString(buffer, currentOffset, options);
@@ -426,6 +434,14 @@ function useCborString() {
           currentOffset++;
           break;
         }
+        const chunkInitialByte = readByte(buffer, currentOffset);
+        const chunkHeader = extractCborHeader(chunkInitialByte);
+        if (chunkHeader.majorType !== 3) {
+          throw new Error(`Indefinite text string chunks must be text strings (major type 3), got ${chunkHeader.majorType}`);
+        }
+        if (chunkHeader.additionalInfo === 31) {
+          throw new Error("Indefinite text string chunks must be definite-length (RFC 8949 Section 3.2.3)");
+        }
         let chunkResult;
         try {
           chunkResult = parseTextString(buffer, currentOffset, options);
@@ -508,6 +524,45 @@ function useCborFloat() {
     }
     return (sign === 0 ? 1 : -1) * Math.pow(2, exponent - 15) * (1 + fraction / 1024);
   };
+  const fitsInFloat16 = (value) => {
+    if (Number.isNaN(value) || value === Infinity || value === -Infinity) return true;
+    if (Object.is(value, 0) || Object.is(value, -0)) return true;
+    const abs = Math.abs(value);
+    if (abs > 65504) return false;
+    if (abs < 5960464477539063e-23) return false;
+    const sign = value < 0 ? 1 : 0;
+    const buf = new ArrayBuffer(8);
+    const view = new DataView(buf);
+    view.setFloat64(0, abs, false);
+    const bits64 = view.getBigUint64(0, false);
+    const exp64 = Number(bits64 >> 52n & 0x7ffn) - 1023;
+    const mant64 = Number(bits64 & 0xfffffffffffffn);
+    let exp16;
+    let mant16;
+    if (exp64 < -14) {
+      exp16 = 0;
+      const shift = -14 - exp64;
+      mant16 = (1 << 10 | mant64 >> 42) >> shift;
+    } else if (exp64 > 15) {
+      return false;
+    } else {
+      exp16 = exp64 + 15;
+      mant16 = mant64 >> 42;
+    }
+    const float16Bits = sign << 15 | exp16 << 10 | mant16;
+    const s = (float16Bits & 32768) >> 15;
+    const e = (float16Bits & 31744) >> 10;
+    const f = float16Bits & 1023;
+    let reconstructed;
+    if (e === 0) {
+      reconstructed = (s === 0 ? 1 : -1) * Math.pow(2, -14) * (f / 1024);
+    } else if (e === 31) {
+      reconstructed = f === 0 ? s === 0 ? Infinity : -Infinity : NaN;
+    } else {
+      reconstructed = (s === 0 ? 1 : -1) * Math.pow(2, e - 15) * (1 + f / 1024);
+    }
+    return reconstructed === value;
+  };
   const parseSimpleFromBuffer = (buffer, offset) => {
     const initialByte = readByte(buffer, offset);
     const { majorType, additionalInfo } = extractCborHeader(initialByte);
@@ -558,7 +613,7 @@ function useCborFloat() {
         throw new Error(`Invalid additional info: ${additionalInfo}`);
     }
   };
-  const parseFloatFromBuffer = (buffer, offset) => {
+  const parseFloatFromBuffer = (buffer, offset, options) => {
     const initialByte = readByte(buffer, offset);
     const { majorType, additionalInfo } = extractCborHeader(initialByte);
     if (majorType !== 7) {
@@ -569,6 +624,16 @@ function useCborFloat() {
         if (offset + 2 >= buffer.length) {
           throw new Error("Unexpected end of buffer while reading Float16");
         }
+        if (options?.validateCanonical) {
+          const byte1 = readByte(buffer, offset + 1);
+          const byte2 = readByte(buffer, offset + 2);
+          const bits = byte1 << 8 | byte2;
+          const exp = bits >> 10 & 31;
+          const mant = bits & 1023;
+          if (exp === 31 && mant !== 0 && bits !== 32256) {
+            throw new Error("Non-canonical NaN encoding: use 0xf97e00");
+          }
+        }
         const value = float16ToFloat64(buffer, offset + 1);
         return { value, bytesRead: 3 };
       }
@@ -578,6 +643,14 @@ function useCborFloat() {
         }
         const dataView = new DataView(buffer.buffer, buffer.byteOffset + offset + 1, 4);
         const value = dataView.getFloat32(0, false);
+        if (options?.validateCanonical) {
+          if (Number.isNaN(value)) {
+            throw new Error("Non-canonical NaN encoding: NaN must use float16 0xf97e00");
+          }
+          if (fitsInFloat16(value)) {
+            throw new Error("Non-canonical float32: value fits in float16, use shortest encoding");
+          }
+        }
         return { value, bytesRead: 5 };
       }
       case 27: {
@@ -586,20 +659,32 @@ function useCborFloat() {
         }
         const dataView = new DataView(buffer.buffer, buffer.byteOffset + offset + 1, 8);
         const value = dataView.getFloat64(0, false);
+        if (options?.validateCanonical) {
+          if (Number.isNaN(value)) {
+            throw new Error("Non-canonical NaN encoding: NaN must use float16 0xf97e00");
+          }
+          if (fitsInFloat16(value)) {
+            throw new Error("Non-canonical float64: value fits in float16/float32, use shortest encoding");
+          }
+          const f32 = Math.fround(value);
+          if (f32 === value || Object.is(value, -0) && Object.is(f32, -0)) {
+            throw new Error("Non-canonical float64: value fits in float16/float32, use shortest encoding");
+          }
+        }
         return { value, bytesRead: 9 };
       }
       default:
         throw new Error(`Additional info ${additionalInfo} is not a float type`);
     }
   };
-  const parseFromBuffer = (buffer, offset) => {
+  const parseFromBuffer = (buffer, offset, options) => {
     const initialByte = readByte(buffer, offset);
     const { majorType, additionalInfo } = extractCborHeader(initialByte);
     if (majorType !== 7) {
       throw new Error(`Expected major type 7 (simple/float), got ${majorType}`);
     }
     if (additionalInfo === 25 || additionalInfo === 26 || additionalInfo === 27) {
-      return parseFloatFromBuffer(buffer, offset);
+      return parseFloatFromBuffer(buffer, offset, options);
     } else {
       return parseSimpleFromBuffer(buffer, offset);
     }
@@ -608,13 +693,13 @@ function useCborFloat() {
     const buffer = hexToBytes(hexString);
     return parseSimpleFromBuffer(buffer, 0);
   };
-  const parseFloat = (hexString, _options) => {
+  const parseFloat = (hexString, options) => {
     const buffer = hexToBytes(hexString);
-    return parseFloatFromBuffer(buffer, 0);
+    return parseFloatFromBuffer(buffer, 0, options);
   };
-  const parse = (hexString, _options) => {
+  const parse = (hexString, options) => {
     const buffer = hexToBytes(hexString);
-    return parseFromBuffer(buffer, 0);
+    return parseFromBuffer(buffer, 0, options);
   };
   return {
     parse,
@@ -628,7 +713,7 @@ function useCborTag() {
   const { parseInteger } = useCborInteger();
   const { parseByteString, parseTextString } = useCborString();
   const { parseFloat, parseSimple } = useCborFloat();
-  const parseItem = (buffer, offset, options, tagDepth = 0) => {
+  const parseItem = (buffer, offset, options, tagDepth = 0, collectionDepth = 0) => {
     if (offset >= buffer.length) {
       throw new Error(`Unexpected end of buffer at offset ${offset}`);
     }
@@ -647,9 +732,9 @@ function useCborTag() {
       case 3:
         return parseTextString(buffer, offset, options);
       case 4:
-        return parseArrayInternal(buffer, offset, options);
+        return parseArrayInternal(buffer, offset, options, collectionDepth);
       case 5:
-        return parseMapInternal(buffer, offset, options);
+        return parseMapInternal(buffer, offset, options, collectionDepth);
       case 6:
         return parseTagFromBuffer(buffer, offset, options, tagDepth);
       case 7: {
@@ -666,12 +751,20 @@ function useCborTag() {
         throw new Error(`Unknown major type: ${majorType}`);
     }
   };
-  const parseArrayInternal = (buffer, offset, options) => {
+  const parseArrayInternal = (buffer, offset, options, depth = 0) => {
     const initialByte = readByte(buffer, offset);
     const { majorType, additionalInfo } = extractCborHeader(initialByte);
     if (majorType !== 4) {
       throw new Error(`Expected major type 4 (array), got ${majorType}`);
     }
+    const isIndefiniteAllowed = options?.allowIndefinite ?? !(options?.validateCanonical || options?.strict);
+    if (additionalInfo === 31 && !isIndefiniteAllowed) {
+      throw new Error("Indefinite-length encoding is not allowed (strict/canonical mode)");
+    }
+    const maxDepth = options?.limits?.maxDepth ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxDepth;
+    if (depth >= maxDepth) {
+      throw new Error(`Maximum nesting depth ${maxDepth} exceeded`);
+    }
     let length;
     let bytesConsumed;
     if (additionalInfo < 24) {
@@ -699,23 +792,39 @@ function useCborTag() {
     } else {
       throw new Error(`Invalid additional info for array: ${additionalInfo}`);
     }
+    if (length !== null && options?.limits?.maxArrayLength && length > options.limits.maxArrayLength) {
+      throw new Error(`Array length ${length} exceeds limit of ${options.limits.maxArrayLength}`);
+    }
     let currentOffset = offset + 1 + bytesConsumed;
     const items = [];
     if (length === null) {
+      let index = 0;
+      let foundBreak = false;
       while (currentOffset < buffer.length) {
         const nextByte = readByte(buffer, currentOffset);
         if (nextByte === 255) {
           currentOffset++;
+          foundBreak = true;
           break;
         }
-        const itemResult = parseItem(buffer, currentOffset, options);
+        if (options?.limits?.maxArrayLength && index >= options.limits.maxArrayLength) {
+          throw new Error(`Array length exceeds limit of ${options.limits.maxArrayLength}`);
+        }
+        const itemResult = parseItem(buffer, currentOffset, options, 0, depth + 1);
         items.push(itemResult.value);
         currentOffset += itemResult.bytesRead;
+        index++;
+      }
+      if (!foundBreak) {
+        throw new Error("Indefinite-length array missing break code (0xFF)");
       }
       items[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] = true;
     } else {
       for (let i = 0; i < length; i++) {
-        const itemResult = parseItem(buffer, currentOffset, options);
+        if (currentOffset >= buffer.length) {
+          throw new Error(`Unexpected end of buffer while parsing array element ${i}/${length}`);
+        }
+        const itemResult = parseItem(buffer, currentOffset, options, 0, depth + 1);
         items.push(itemResult.value);
         currentOffset += itemResult.bytesRead;
       }
@@ -725,12 +834,20 @@ function useCborTag() {
       bytesRead: currentOffset - offset
     };
   };
-  const parseMapInternal = (buffer, offset, options) => {
+  const parseMapInternal = (buffer, offset, options, depth = 0) => {
     const initialByte = readByte(buffer, offset);
     const { majorType, additionalInfo } = extractCborHeader(initialByte);
     if (majorType !== 5) {
       throw new Error(`Expected major type 5 (map), got ${majorType}`);
     }
+    const isIndefiniteAllowed = options?.allowIndefinite ?? !(options?.validateCanonical || options?.strict);
+    if (additionalInfo === 31 && !isIndefiniteAllowed) {
+      throw new Error("Indefinite-length encoding is not allowed (strict/canonical mode)");
+    }
+    const maxDepth = options?.limits?.maxDepth ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxDepth;
+    if (depth >= maxDepth) {
+      throw new Error(`Maximum nesting depth ${maxDepth} exceeded`);
+    }
     let length;
     let bytesConsumed;
     if (additionalInfo < 24) {
@@ -758,27 +875,43 @@ function useCborTag() {
     } else {
       throw new Error(`Invalid additional info for map: ${additionalInfo}`);
     }
+    if (length !== null && options?.limits?.maxMapSize && length > options.limits.maxMapSize) {
+      throw new Error(`Map size ${length} exceeds limit of ${options.limits.maxMapSize}`);
+    }
     let currentOffset = offset + 1 + bytesConsumed;
     const map = /* @__PURE__ */ new Map();
     if (length === null) {
+      let index = 0;
+      let foundBreak = false;
       while (currentOffset < buffer.length) {
         const nextByte = readByte(buffer, currentOffset);
         if (nextByte === 255) {
           currentOffset++;
+          foundBreak = true;
           break;
         }
-        const keyResult = parseItem(buffer, currentOffset, options);
+        if (options?.limits?.maxMapSize && index >= options.limits.maxMapSize) {
+          throw new Error(`Map size exceeds limit of ${options.limits.maxMapSize}`);
+        }
+        const keyResult = parseItem(buffer, currentOffset, options, 0, depth + 1);
         currentOffset += keyResult.bytesRead;
-        const valueResult = parseItem(buffer, currentOffset, options);
+        const valueResult = parseItem(buffer, currentOffset, options, 0, depth + 1);
         currentOffset += valueResult.bytesRead;
         map.set(keyResult.value, valueResult.value);
+        index++;
+      }
+      if (!foundBreak) {
+        throw new Error("Indefinite-length map missing break code (0xFF)");
       }
       map[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] = true;
     } else {
       for (let i = 0; i < length; i++) {
-        const keyResult = parseItem(buffer, currentOffset, options);
+        if (currentOffset >= buffer.length) {
+          throw new Error(`Unexpected end of buffer while parsing map entry ${i}/${length}`);
+        }
+        const keyResult = parseItem(buffer, currentOffset, options, 0, depth + 1);
         currentOffset += keyResult.bytesRead;
-        const valueResult = parseItem(buffer, currentOffset, options);
+        const valueResult = parseItem(buffer, currentOffset, options, 0, depth + 1);
         currentOffset += valueResult.bytesRead;
         map.set(keyResult.value, valueResult.value);
       }
@@ -828,6 +961,13 @@ function useCborTag() {
     }
     return false;
   };
+  const isByteString = (value) => {
+    if (value instanceof Uint8Array) return true;
+    if (value && typeof value === "object" && "type" in value && value.type === "cbor-byte-string") {
+      return true;
+    }
+    return false;
+  };
   const getTextStringValue = (value) => {
     if (typeof value === "string") return value;
     if (value && typeof value === "object" && "text" in value) {
@@ -854,6 +994,14 @@ function useCborTag() {
           throw new Error(`Tag 1 (epoch time) must contain a number (integer or float), got ${typeof value}`);
         }
         break;
+      case 2:
+      // Positive bignum
+      case 3:
+        if (!shouldValidateStandard) break;
+        if (!isByteString(value)) {
+          throw new Error(`Tag ${tagNumber} (bignum) must contain a byte string, got ${typeof value}`);
+        }
+        break;
       case 4:
         if (!shouldValidateStandard) break;
         if (!Array.isArray(value)) {
@@ -1041,7 +1189,7 @@ function useCborTag() {
     if (majorType !== 6) {
       throw new Error(`Expected major type 6 (tag), got ${majorType}`);
     }
-    const maxTagDepth = options?.limits?.maxTagDepth ?? 64;
+    const maxTagDepth = options?.limits?.maxTagDepth ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxTagDepth;
     if (tagDepth >= maxTagDepth) {
       throw new Error(`Tag nesting depth ${tagDepth} exceeds limit of ${maxTagDepth}`);
     }
@@ -2030,5 +2178,5 @@ exports.useCborParser = useCborParser;
 exports.useCborString = useCborString;
 exports.useCborTag = useCborTag;
 exports.validateUtf8Strict = validateUtf8Strict;
-//# sourceMappingURL=chunk-2HBCILJS.cjs.map
-//# sourceMappingURL=chunk-2HBCILJS.cjs.map
+//# sourceMappingURL=chunk-PTWN7K3Y.cjs.map
+//# sourceMappingURL=chunk-PTWN7K3Y.cjs.map