alinea 2.0.0-preview.0 → 2.0.0-preview.2

package/dist/chunks/chunk-6UT4N4CO.js

@@ -0,0 +1,919 @@
+// node_modules/fp16/lib/utils.js
+var float32Buffer = new ArrayBuffer(4);
+var float32View = new DataView(float32Buffer);
+var float16Precision = 10;
+var float16Emax = 15;
+var float16Emin = -14;
+var float32Precision = 23;
+var float32Emax = 127;
+var float32Emin = -126;
+
+// node_modules/fp16/lib/getFloat16.js
+function getFloat16(view, offset, littleEndian) {
+  const value = view.getUint16(offset, littleEndian);
+  const sign = value & 32768;
+  const exponent = value & 31744;
+  const mantissa = value & 1023;
+  if (exponent === 0) {
+    if (mantissa === 0) {
+      return sign ? -0 : 0;
+    } else {
+      let e = 127 - 14;
+      let m = mantissa;
+      while ((m & 1024) === 0) {
+        e--;
+        m <<= 1;
+      }
+      m &= ~1024;
+      const i = sign << 16 | e << 23 | m << 13;
+      float32View.setInt32(0, i, littleEndian);
+      return float32View.getFloat32(0, littleEndian);
+    }
+  } else if (exponent === 31744) {
+    if (mantissa === 0) {
+      return sign ? -Infinity : Infinity;
+    } else {
+      return NaN;
+    }
+  } else {
+    const e = exponent + 114688 << 13;
+    const m = mantissa << 13;
+    const i = sign << 16 | e | m;
+    float32View.setInt32(0, i, littleEndian);
+    return float32View.getFloat32(0, littleEndian);
+  }
+}
+
+// node_modules/fp16/lib/setFloat16.js
+function setFloat16(view, offset, value, littleEndian) {
+  if (isNaN(value)) {
+    return view.setUint16(offset, 32256, littleEndian);
+  } else if (value === Infinity) {
+    return view.setUint16(offset, 31744, littleEndian);
+  } else if (value === -Infinity) {
+    return view.setUint16(offset, 64512, littleEndian);
+  } else if (Object.is(value, 0)) {
+    return view.setUint16(offset, 0, littleEndian);
+  } else if (Object.is(value, -0)) {
+    return view.setUint16(offset, 32768, littleEndian);
+  }
+  float32View.setFloat32(0, value, littleEndian);
+  const i32 = float32View.getInt32(0, littleEndian);
+  const sign = i32 & 1 << 31;
+  const exponent = i32 & 2139095040;
+  const mantissa = i32 & 8388607;
+  const exponentValue = (exponent >>> float32Precision) - float32Emax;
+  const e = exponentValue + float16Emax;
+  if (float16Emax < exponentValue) {
+    return view.setUint16(offset, sign >>> 16 | 31744, littleEndian);
+  }
+  if (exponentValue < float16Emin) {
+    if (14 - e > 24) {
+      return view.setUint16(0, sign >>> 16, littleEndian);
+    } else {
+      const c = mantissa | 8388608;
+      const m = c >>> 14 - e;
+      const r2 = 1 << 13 - e;
+      if (c & r2 && c & 3 * r2 - 1) {
+        return view.setUint16(offset, sign >>> 16 | m + 1, littleEndian);
+      } else {
+        return view.setUint16(offset, sign >>> 16 | m, littleEndian);
+      }
+    }
+  }
+  const r = 4096;
+  let i16 = sign >>> 16 | e << 10 | mantissa >> 13;
+  if (mantissa & r && mantissa & 3 * r - 1) {
+    return view.setUint16(offset, i16 + 1, littleEndian);
+  } else {
+    return view.setUint16(offset, i16, littleEndian);
+  }
+}
+
+// node_modules/fp16/lib/precision.js
+var float64Buffer = new ArrayBuffer(8);
+var float64View = new DataView(float64Buffer);
+var Precision = {
+  Exact: 0,
+  Inexact: 1,
+  Underflow: 2,
+  Overflow: 3
+};
+function getFloat16Precision(value) {
+  if (isNaN(value) || value === 0) {
+    return Precision.Exact;
+  } else if (value === Infinity || value === -Infinity) {
+    return Precision.Exact;
+  }
+  float64View.setFloat64(0, value);
+  const a = float64View.getInt32(0);
+  const b = float64View.getInt32(4);
+  const exponent = a & 2146435072;
+  const exponentValue = (exponent >>> 20) - 1023;
+  if (float16Emax < exponentValue) {
+    return Precision.Overflow;
+  } else if (exponentValue < float16Emin - float16Precision) {
+    return Precision.Underflow;
+  }
+  const significantBits = getSignificantBits(a & 1048575, b);
+  if (float16Precision < significantBits) {
+    return Precision.Inexact;
+  }
+  if (exponentValue < float16Emin) {
+    if (float16Emin - exponentValue <= float16Precision - significantBits) {
+      return Precision.Exact;
+    } else {
+      return Precision.Inexact;
+    }
+  } else {
+    return Precision.Exact;
+  }
+}
+function getFloat32Precision(value) {
+  if (isNaN(value) || value === 0) {
+    return Precision.Exact;
+  } else if (value === Infinity || value === -Infinity) {
+    return Precision.Exact;
+  }
+  float64View.setFloat64(0, value);
+  const a = float64View.getInt32(0);
+  const b = float64View.getInt32(4);
+  const exponent = a & 2146435072;
+  const exponentValue = (exponent >>> 20) - 1023;
+  if (float32Emax < exponentValue) {
+    return Precision.Overflow;
+  } else if (exponentValue < float32Emin - float32Precision) {
+    return Precision.Underflow;
+  }
+  const significantBits = getSignificantBits(a & 1048575, b);
+  if (float32Precision < significantBits) {
+    return Precision.Inexact;
+  }
+  if (exponentValue < float32Emin) {
+    if (float32Emin - exponentValue <= float32Precision - significantBits) {
+      return Precision.Exact;
+    } else {
+      return Precision.Inexact;
+    }
+  } else {
+    return Precision.Exact;
+  }
+}
+function getSignificantBits(a, b) {
+  if (b) {
+    let offsetB = 0;
+    for (let shiftedB = b; shiftedB; shiftedB <<= 1) {
+      offsetB++;
+    }
+    return offsetB + 20;
+  } else {
+    let offsetA = 0;
+    for (let shiftedA = a << 12; shiftedA; shiftedA <<= 1) {
+      offsetA++;
+    }
+    return offsetA;
+  }
+}
+
+// node_modules/microcbor/lib/options.js
+var FloatSize = {
+  f16: 16,
+  f32: 32,
+  f64: 64
+};
+
+// node_modules/microcbor/lib/utils.js
+var maxSafeInteger = BigInt(Number.MAX_SAFE_INTEGER);
+var minSafeInteger = BigInt(Number.MIN_SAFE_INTEGER);
+var UnsafeIntegerError = class extends RangeError {
+  constructor(message, value) {
+    super(message);
+    this.value = value;
+  }
+};
+var AssertError = class extends Error {
+  constructor(message, props) {
+    super(message);
+    this.message = message;
+    this.props = props;
+  }
+};
+function assert(condition, message = "assertion failed", props) {
+  if (!condition) {
+    throw new AssertError(message, props);
+  }
+}
+
+// node_modules/microcbor/lib/Encoder.js
+var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = function(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Encoder_instances;
+var _Encoder_closed;
+var _Encoder_flush;
+var Encoder = class _Encoder {
+  constructor(options = {}) {
+    _Encoder_instances.add(this);
+    _Encoder_closed.set(this, void 0);
+    this.encoder = new TextEncoder();
+    this.allowUndefined = options.allowUndefined ?? true;
+    this.minFloatSize = options.minFloatSize ?? 16;
+    this.chunkRecycling = options.chunkRecycling ?? false;
+    this.chunkSize = options.chunkSize ?? _Encoder.defaultChunkSize;
+    assert(this.chunkSize >= 8, "expected chunkSize >= 8");
+    this.buffer = new ArrayBuffer(this.chunkSize);
+    this.view = new DataView(this.buffer);
+    this.array = new Uint8Array(this.buffer, 0, this.chunkSize);
+    this.offset = 0;
+    __classPrivateFieldSet(this, _Encoder_closed, false, "f");
+  }
+  get closed() {
+    return __classPrivateFieldGet(this, _Encoder_closed, "f");
+  }
+  *allocate(size) {
+    assert(size <= 8, "expected size <= 8");
+    if (this.buffer.byteLength < this.offset + size) {
+      yield __classPrivateFieldGet(this, _Encoder_instances, "m", _Encoder_flush).call(this);
+    }
+  }
+  *float16(value) {
+    yield* this.allocate(2);
+    setFloat16(this.view, this.offset, value);
+    this.offset += 2;
+  }
+  *float32(value) {
+    yield* this.allocate(4);
+    this.view.setFloat32(this.offset, value);
+    this.offset += 4;
+  }
+  *float64(value) {
+    yield* this.allocate(8);
+    this.view.setFloat64(this.offset, value);
+    this.offset += 8;
+  }
+  *uint8(value) {
+    yield* this.allocate(1);
+    this.view.setUint8(this.offset, value);
+    this.offset += 1;
+  }
+  *uint16(value) {
+    yield* this.allocate(2);
+    this.view.setUint16(this.offset, value);
+    this.offset += 2;
+  }
+  *uint32(value) {
+    yield* this.allocate(4);
+    this.view.setUint32(this.offset, value);
+    this.offset += 4;
+  }
+  *uint64(value) {
+    yield* this.allocate(8);
+    this.view.setBigUint64(this.offset, BigInt(value));
+    this.offset += 8;
+  }
+  *encodeTypeAndArgument(type, argument) {
+    const additionalInformation = _Encoder.getAdditionalInformation(argument);
+    yield* this.uint8(type << 5 | additionalInformation);
+    switch (additionalInformation) {
+      case 24:
+        return yield* this.uint8(argument);
+      case 25:
+        return yield* this.uint16(argument);
+      case 26:
+        return yield* this.uint32(argument);
+      case 27:
+        return yield* this.uint64(argument);
+    }
+  }
+  *encodeNumber(value) {
+    if (Object.is(value, 0)) {
+      yield* this.encodeInteger(value);
+    } else if (Object.is(value, -0)) {
+      yield* this.encodeFloat(value);
+    } else if (Math.floor(value) === value && Number.MIN_SAFE_INTEGER <= value && value <= Number.MAX_SAFE_INTEGER) {
+      yield* this.encodeInteger(value);
+    } else {
+      yield* this.encodeFloat(value);
+    }
+  }
+  *encodeInteger(value) {
+    if (value < 0) {
+      yield* this.encodeTypeAndArgument(1, -value - 1);
+    } else {
+      yield* this.encodeTypeAndArgument(0, value);
+    }
+  }
+  *encodeFloat(value) {
+    if (this.minFloatSize === FloatSize.f16 && getFloat16Precision(value) === Precision.Exact) {
+      yield* this.uint8(224 | 25);
+      yield* this.float16(value);
+    } else if (this.minFloatSize <= FloatSize.f32 && getFloat32Precision(value) === Precision.Exact) {
+      yield* this.uint8(224 | 26);
+      yield* this.float32(value);
+    } else {
+      yield* this.uint8(224 | 27);
+      yield* this.float64(value);
+    }
+  }
+  *encodeString(value) {
+    const bytes = this.encoder.encode(value);
+    yield* this.encodeTypeAndArgument(3, bytes.byteLength);
+    yield* this.writeBytes(bytes);
+  }
+  *encodeBytes(value) {
+    yield* this.encodeTypeAndArgument(2, value.byteLength);
+    yield* this.writeBytes(value);
+  }
+  *writeBytes(value) {
+    let start = 0;
+    while (start < value.byteLength) {
+      if (this.offset >= this.buffer.byteLength) {
+        yield __classPrivateFieldGet(this, _Encoder_instances, "m", _Encoder_flush).call(this);
+      }
+      const capacity = this.buffer.byteLength - this.offset;
+      const remaining = value.byteLength - start;
+      const chunkLength = Math.min(capacity, remaining);
+      this.array.set(value.subarray(start, start + chunkLength), this.offset);
+      start += chunkLength;
+      this.offset += chunkLength;
+    }
+  }
+  *encodeValue(value) {
+    if (__classPrivateFieldGet(this, _Encoder_closed, "f")) {
+      return;
+    }
+    if (value === false) {
+      yield* this.uint8(244);
+    } else if (value === true) {
+      yield* this.uint8(245);
+    } else if (value === null) {
+      yield* this.uint8(246);
+    } else if (value === void 0) {
+      if (this.allowUndefined) {
+        yield* this.uint8(247);
+      } else {
+        throw new TypeError("`undefined` is not allowed");
+      }
+    } else if (typeof value === "number") {
+      yield* this.encodeNumber(value);
+    } else if (typeof value === "string") {
+      yield* this.encodeString(value);
+    } else if (value instanceof Uint8Array) {
+      yield* this.encodeBytes(value);
+    } else if (Array.isArray(value)) {
+      yield* this.encodeTypeAndArgument(4, value.length);
+      for (const element of value) {
+        yield* this.encodeValue(element);
+      }
+    } else {
+      const entries = Object.entries(value).map(([key, value2]) => [this.encoder.encode(key), value2]).sort(_Encoder.compareEntries);
+      yield* this.encodeTypeAndArgument(5, entries.length);
+      for (const [key, value2] of entries) {
+        yield* this.encodeTypeAndArgument(3, key.byteLength);
+        yield* this.writeBytes(key);
+        yield* this.encodeValue(value2);
+      }
+    }
+  }
+  *flush() {
+    if (__classPrivateFieldGet(this, _Encoder_closed, "f")) {
+      return;
+    }
+    if (this.offset > 0) {
+      yield __classPrivateFieldGet(this, _Encoder_instances, "m", _Encoder_flush).call(this);
+    }
+  }
+  // Per the deterministic CBOR spec, we're supposed to sort keys
+  // the byte-wise lexicographic order of the key's CBOR encoding
+  // - ie lower major types come before higher major types.
+  // One thing we know for sure about strings is that a string with
+  // a smaller length will sort byte-wise before a string
+  // with a longer length, since strings are encoded with a length
+  // prefix (either in the additionalInformation bits, if < 24, or
+  // in the next serveral bytes, but in all cases the order holds).
+  static compareEntries([a], [b]) {
+    if (a.byteLength < b.byteLength)
+      return -1;
+    if (b.byteLength < a.byteLength)
+      return 1;
+    for (let i = 0; i < a.byteLength; i++) {
+      if (a[i] < b[i])
+        return -1;
+      if (b[i] < a[i])
+        return 1;
+    }
+    return 0;
+  }
+  static getAdditionalInformation(argument) {
+    if (argument < 24) {
+      return argument;
+    } else if (argument < 256) {
+      return 24;
+    } else if (argument < 65536) {
+      return 25;
+    } else if (argument < 4294967296) {
+      return 26;
+    } else {
+      return 27;
+    }
+  }
+};
+_Encoder_closed = /* @__PURE__ */ new WeakMap(), _Encoder_instances = /* @__PURE__ */ new WeakSet(), _Encoder_flush = function _Encoder_flush2() {
+  if (this.chunkRecycling) {
+    const chunk = new Uint8Array(this.buffer, 0, this.offset);
+    this.offset = 0;
+    return chunk;
+  } else {
+    const chunk = new Uint8Array(this.offset);
+    chunk.set(new Uint8Array(this.buffer, 0, this.offset));
+    this.offset = 0;
+    return chunk;
+  }
+};
+Encoder.defaultChunkSize = 4096;
+function encode(value, options = {}) {
+  const encoder = new Encoder({ ...options, chunkRecycling: false });
+  let byteLength = 0;
+  const chunks = [];
+  for (const chunk of encoder.encodeValue(value)) {
+    chunks.push(chunk);
+    byteLength += chunk.byteLength;
+  }
+  for (const chunk of encoder.flush()) {
+    chunks.push(chunk);
+    byteLength += chunk.byteLength;
+  }
+  const data = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    data.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return data;
+}
+
+// node_modules/microcbor/lib/Decoder.js
+var __classPrivateFieldSet2 = function(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet2 = function(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Decoder_offset;
+var _Decoder_view;
+var Decoder = class {
+  constructor(data, options = {}) {
+    this.data = data;
+    _Decoder_offset.set(this, void 0);
+    _Decoder_view.set(this, void 0);
+    this.constant = (size, f) => () => {
+      const value = f();
+      __classPrivateFieldSet2(this, _Decoder_offset, __classPrivateFieldGet2(this, _Decoder_offset, "f") + size, "f");
+      return value;
+    };
+    this.float16 = this.constant(2, () => getFloat16(__classPrivateFieldGet2(this, _Decoder_view, "f"), __classPrivateFieldGet2(this, _Decoder_offset, "f")));
+    this.float32 = this.constant(4, () => __classPrivateFieldGet2(this, _Decoder_view, "f").getFloat32(__classPrivateFieldGet2(this, _Decoder_offset, "f")));
+    this.float64 = this.constant(8, () => __classPrivateFieldGet2(this, _Decoder_view, "f").getFloat64(__classPrivateFieldGet2(this, _Decoder_offset, "f")));
+    this.uint8 = this.constant(1, () => __classPrivateFieldGet2(this, _Decoder_view, "f").getUint8(__classPrivateFieldGet2(this, _Decoder_offset, "f")));
+    this.uint16 = this.constant(2, () => __classPrivateFieldGet2(this, _Decoder_view, "f").getUint16(__classPrivateFieldGet2(this, _Decoder_offset, "f")));
+    this.uint32 = this.constant(4, () => __classPrivateFieldGet2(this, _Decoder_view, "f").getUint32(__classPrivateFieldGet2(this, _Decoder_offset, "f")));
+    this.uint64 = this.constant(8, () => __classPrivateFieldGet2(this, _Decoder_view, "f").getBigUint64(__classPrivateFieldGet2(this, _Decoder_offset, "f")));
+    __classPrivateFieldSet2(this, _Decoder_offset, 0, "f");
+    __classPrivateFieldSet2(this, _Decoder_view, new DataView(data.buffer, data.byteOffset, data.byteLength), "f");
+    this.allowUndefined = options.allowUndefined ?? true;
+    this.minFloatSize = options.minFloatSize ?? 16;
+  }
+  getOffset() {
+    return __classPrivateFieldGet2(this, _Decoder_offset, "f");
+  }
+  decodeBytes(length) {
+    const value = new Uint8Array(length);
+    value.set(this.data.subarray(__classPrivateFieldGet2(this, _Decoder_offset, "f"), __classPrivateFieldGet2(this, _Decoder_offset, "f") + length), 0);
+    __classPrivateFieldSet2(this, _Decoder_offset, __classPrivateFieldGet2(this, _Decoder_offset, "f") + length, "f");
+    return value;
+  }
+  decodeString(length) {
+    const value = new TextDecoder().decode(this.data.subarray(__classPrivateFieldGet2(this, _Decoder_offset, "f"), __classPrivateFieldGet2(this, _Decoder_offset, "f") + length));
+    __classPrivateFieldSet2(this, _Decoder_offset, __classPrivateFieldGet2(this, _Decoder_offset, "f") + length, "f");
+    return value;
+  }
+  getArgument(additionalInformation) {
+    if (additionalInformation < 24) {
+      return { value: additionalInformation };
+    } else if (additionalInformation === 24) {
+      return { value: this.uint8() };
+    } else if (additionalInformation === 25) {
+      return { value: this.uint16() };
+    } else if (additionalInformation === 26) {
+      return { value: this.uint32() };
+    } else if (additionalInformation === 27) {
+      const uint64 = this.uint64();
+      const value = maxSafeInteger < uint64 ? Infinity : Number(uint64);
+      return { value, uint64 };
+    } else if (additionalInformation === 31) {
+      throw new Error("microcbor does not support decoding indefinite-length items");
+    } else {
+      throw new Error("invalid argument encoding");
+    }
+  }
+  decodeValue() {
+    const initialByte = this.uint8();
+    const majorType = initialByte >> 5;
+    const additionalInformation = initialByte & 31;
+    if (majorType === 0) {
+      const { value, uint64 } = this.getArgument(additionalInformation);
+      if (uint64 !== void 0 && maxSafeInteger < uint64) {
+        throw new UnsafeIntegerError("cannot decode integers greater than 2^53-1", uint64);
+      } else {
+        return value;
+      }
+    } else if (majorType === 1) {
+      const { value, uint64 } = this.getArgument(additionalInformation);
+      if (uint64 !== void 0 && -1n - uint64 < minSafeInteger) {
+        throw new UnsafeIntegerError("cannot decode integers less than -2^53+1", -1n - uint64);
+      } else {
+        return -1 - value;
+      }
+    } else if (majorType === 2) {
+      const { value: length } = this.getArgument(additionalInformation);
+      return this.decodeBytes(length);
+    } else if (majorType === 3) {
+      const { value: length } = this.getArgument(additionalInformation);
+      return this.decodeString(length);
+    } else if (majorType === 4) {
+      const { value: length } = this.getArgument(additionalInformation);
+      const value = new Array(length);
+      for (let i = 0; i < length; i++) {
+        value[i] = this.decodeValue();
+      }
+      return value;
+    } else if (majorType === 5) {
+      const { value: length } = this.getArgument(additionalInformation);
+      const value = {};
+      for (let i = 0; i < length; i++) {
+        const key = this.decodeValue();
+        if (typeof key !== "string") {
+          throw new Error("microcbor only supports string keys in objects");
+        }
+        value[key] = this.decodeValue();
+      }
+      return value;
+    } else if (majorType === 6) {
+      throw new Error("microcbor does not support tagged data items");
+    } else if (majorType === 7) {
+      switch (additionalInformation) {
+        case 20:
+          return false;
+        case 21:
+          return true;
+        case 22:
+          return null;
+        case 23:
+          if (this.allowUndefined) {
+            return void 0;
+          } else {
+            throw new TypeError("`undefined` not allowed");
+          }
+        case 24:
+          throw new Error("microcbor does not support decoding unassigned simple values");
+        case 25:
+          if (this.minFloatSize <= 16) {
+            return this.float16();
+          } else {
+            throw new Error("cannot decode float16 type - below provided minFloatSize");
+          }
+        case 26:
+          if (this.minFloatSize <= 32) {
+            return this.float32();
+          } else {
+            throw new Error("cannot decode float32 type - below provided minFloatSize");
+          }
+        case 27:
+          return this.float64();
+        case 31:
+          throw new Error("microcbor does not support decoding indefinite-length items");
+        default:
+          throw new Error("invalid simple value");
+      }
+    } else {
+      throw new Error("invalid major type");
+    }
+  }
+};
+_Decoder_offset = /* @__PURE__ */ new WeakMap(), _Decoder_view = /* @__PURE__ */ new WeakMap();
+function decode(data, options = {}) {
+  return new Decoder(data, options).decodeValue();
+}
+
+// node_modules/microcbor/lib/encodeAsyncIterable.js
+async function* encodeAsyncIterable(source, options = {}) {
+  const encoder = new Encoder(options);
+  for await (const value of source) {
+    yield* encoder.encodeValue(value);
+  }
+  yield* encoder.flush();
+}
+
+// node_modules/microcbor/lib/decodeAsyncIterable.js
+var _a;
+var Decoder2 = class {
+  constructor(source, options = {}) {
+    this.offset = 0;
+    this.byteLength = 0;
+    this.chunks = [];
+    this.constantBuffer = new ArrayBuffer(8);
+    this.constantView = new DataView(this.constantBuffer);
+    this.touchedChunks = /* @__PURE__ */ new WeakSet();
+    this.freedChunks = /* @__PURE__ */ new WeakSet();
+    this[_a] = () => this;
+    this.constant = (size, f) => {
+      return async () => {
+        await this.allocate(size);
+        const array = new Uint8Array(this.constantBuffer, 0, size);
+        this.fill(array);
+        return f(this.constantView);
+      };
+    };
+    this.float16 = this.constant(2, (view) => getFloat16(view, 0));
+    this.float32 = this.constant(4, (view) => view.getFloat32(0));
+    this.float64 = this.constant(8, (view) => view.getFloat64(0));
+    this.uint8 = this.constant(1, (view) => view.getUint8(0));
+    this.uint16 = this.constant(2, (view) => view.getUint16(0));
+    this.uint32 = this.constant(4, (view) => view.getUint32(0));
+    this.uint64 = this.constant(8, (view) => view.getBigUint64(0));
+    this.onFree = options.onFree;
+    this.allowUndefined = options.allowUndefined ?? true;
+    this.minFloatSize = options.minFloatSize ?? 16;
+    this.iter = source[Symbol.asyncIterator]();
+  }
+  async allocate(size) {
+    if (this.byteLength < size && this.onFree !== void 0) {
+      for (const chunk of this.chunks) {
+        if (this.touchedChunks.has(chunk) && !this.freedChunks.has(chunk)) {
+          this.freedChunks.add(chunk);
+          this.onFree(chunk);
+        }
+      }
+    }
+    while (this.byteLength < size) {
+      const { done, value } = await this.iter.next();
+      if (done) {
+        throw new Error("stream ended prematurely");
+      } else {
+        this.chunks.push(value);
+        this.byteLength += value.byteLength;
+        if (this.byteLength < size && this.onFree !== void 0 && !this.freedChunks.has(value)) {
+          this.freedChunks.add(value);
+          this.onFree(value);
+        }
+      }
+    }
+  }
+  fill(target) {
+    if (this.byteLength < target.byteLength) {
+      throw new Error("internal error - please file a bug report!");
+    }
+    let byteLength = 0;
+    let deleteCount = 0;
+    for (let i = 0; byteLength < target.byteLength; i++) {
+      const chunk = this.chunks[i];
+      if (!this.touchedChunks.has(chunk)) {
+        this.touchedChunks.add(chunk);
+      }
+      const capacity = target.byteLength - byteLength;
+      const length = chunk.byteLength - this.offset;
+      if (length <= capacity) {
+        target.set(chunk.subarray(this.offset), byteLength);
+        byteLength += length;
+        deleteCount += 1;
+        this.offset = 0;
+        this.byteLength -= length;
+      } else {
+        target.set(chunk.subarray(this.offset, this.offset + capacity), byteLength);
+        byteLength += capacity;
+        this.offset += capacity;
+        this.byteLength -= capacity;
+      }
+    }
+    if (this.onFree !== void 0) {
+      for (let i = 0; i < deleteCount; i++) {
+        const chunk = this.chunks[i];
+        if (!this.freedChunks.has(chunk)) {
+          this.freedChunks.add(chunk);
+          this.onFree(chunk);
+        }
+      }
+    }
+    this.chunks.splice(0, deleteCount);
+  }
+  async decodeBytes(length) {
+    await this.allocate(length);
+    const array = new Uint8Array(length);
+    this.fill(array);
+    return array;
+  }
+  async decodeString(length) {
+    await this.allocate(length);
+    const data = new Uint8Array(length);
+    this.fill(data);
+    return new TextDecoder().decode(data);
+  }
+  async getArgument(additionalInformation) {
+    if (additionalInformation < 24) {
+      return { value: additionalInformation };
+    } else if (additionalInformation === 24) {
+      return { value: await this.uint8() };
+    } else if (additionalInformation === 25) {
+      return { value: await this.uint16() };
+    } else if (additionalInformation === 26) {
+      return { value: await this.uint32() };
+    } else if (additionalInformation === 27) {
+      const uint64 = await this.uint64();
+      const value = maxSafeInteger < uint64 ? Infinity : Number(uint64);
+      return { value, uint64 };
+    } else if (additionalInformation === 31) {
+      throw new Error("microcbor does not support decoding indefinite-length items");
+    } else {
+      throw new Error("invalid argument encoding");
+    }
+  }
+  async next() {
+    while (this.byteLength === 0) {
+      const { done, value: value2 } = await this.iter.next();
+      if (done) {
+        return { done: true, value: void 0 };
+      } else if (value2.byteLength > 0) {
+        this.chunks.push(value2);
+        this.byteLength += value2.byteLength;
+      }
+    }
+    const value = await this.decodeValue();
+    return { done: false, value };
+  }
+  async decodeValue() {
+    const initialByte = await this.uint8();
+    const majorType = initialByte >> 5;
+    const additionalInformation = initialByte & 31;
+    if (majorType === 0) {
+      const { value, uint64 } = await this.getArgument(additionalInformation);
+      if (uint64 !== void 0 && maxSafeInteger < uint64) {
+        throw new UnsafeIntegerError("cannot decode integers greater than 2^53-1", uint64);
+      } else {
+        return value;
+      }
+    } else if (majorType === 1) {
+      const { value, uint64 } = await this.getArgument(additionalInformation);
+      if (uint64 !== void 0 && -1n - uint64 < minSafeInteger) {
+        throw new UnsafeIntegerError("cannot decode integers less than -2^53+1", -1n - uint64);
+      } else {
+        return -1 - value;
+      }
+    } else if (majorType === 2) {
+      const { value: length } = await this.getArgument(additionalInformation);
+      return await this.decodeBytes(length);
+    } else if (majorType === 3) {
+      const { value: length } = await this.getArgument(additionalInformation);
+      return await this.decodeString(length);
+    } else if (majorType === 4) {
+      const { value: length } = await this.getArgument(additionalInformation);
+      const value = new Array(length);
+      for (let i = 0; i < length; i++) {
+        value[i] = await this.decodeValue();
+      }
+      return value;
+    } else if (majorType === 5) {
+      const { value: length } = await this.getArgument(additionalInformation);
+      const value = {};
+      for (let i = 0; i < length; i++) {
+        const key = await this.decodeValue();
+        if (typeof key !== "string") {
+          throw new Error("microcbor only supports string keys in objects");
+        }
+        value[key] = await this.decodeValue();
+      }
+      return value;
+    } else if (majorType === 6) {
+      throw new Error("microcbor does not support tagged data items");
+    } else if (majorType === 7) {
+      switch (additionalInformation) {
+        case 20:
+          return false;
+        case 21:
+          return true;
+        case 22:
+          return null;
+        case 23:
+          if (this.allowUndefined) {
+            return void 0;
+          } else {
+            throw new TypeError("`undefined` not allowed");
+          }
+        case 24:
+          throw new Error("microcbor does not support decoding unassigned simple values");
+        case 25:
+          if (this.minFloatSize <= 16) {
+            return this.float16();
+          } else {
+            throw new Error("cannot decode float16 type - below provided minFloatSize");
+          }
+        case 26:
+          if (this.minFloatSize <= 32) {
+            return this.float32();
+          } else {
+            throw new Error("cannot decode float32 type - below provided minFloatSize");
+          }
+        case 27:
+          return await this.float64();
+        case 31:
+          throw new Error("microcbor does not support decoding indefinite-length items");
+        default:
+          throw new Error("invalid simple value");
+      }
+    } else {
+      throw new Error("invalid major type");
+    }
+  }
+};
+_a = Symbol.asyncIterator;
+async function* decodeAsyncIterable(source, options = {}) {
+  yield* new Decoder2(source, options);
+}
+
+// node_modules/microcbor/lib/decodeIterable.js
+var _a2;
+_a2 = Symbol.iterator;
+
+// node_modules/microcbor/lib/CBORDecoderStream.js
+var CBORDecoderStream = class extends TransformStream {
+  constructor(options = {}) {
+    let readableController;
+    const readable = new ReadableStream({
+      start(controller) {
+        readableController = controller;
+      }
+    });
+    const chunks = /* @__PURE__ */ new WeakMap();
+    async function pipe(controller) {
+      const decoder = new Decoder2(readable.values(), {
+        ...options,
+        onFree: (chunk) => chunks.get(chunk)?.resolve()
+      });
+      for await (const value of decoder) {
+        controller.enqueue(value);
+      }
+    }
+    super({
+      start(controller) {
+        pipe(controller).catch((err) => controller.error(err));
+      },
+      transform(chunk) {
+        return new Promise((resolve) => {
+          chunks.set(chunk, { resolve });
+          readableController.enqueue(chunk);
+        });
+      },
+      flush() {
+        readableController.close();
+      }
+    });
+  }
+};
+
+// node_modules/microcbor/lib/CBOREncoderStream.js
+var CBOREncoderStream = class extends TransformStream {
+  constructor(options = {}) {
+    const encoder = new Encoder({ ...options, chunkRecycling: false });
+    super({
+      transform(value, controller) {
+        for (const chunk of encoder.encodeValue(value)) {
+          controller.enqueue(chunk);
+        }
+      },
+      flush(controller) {
+        for (const chunk of encoder.flush()) {
+          controller.enqueue(chunk);
+        }
+      }
+    });
+  }
+};
+
+export {
+  encode,
+  decode,
+  encodeAsyncIterable,
+  decodeAsyncIterable
+};