@atproto/lex-cbor 0.0.8 → 0.0.10

package/dist/index.mjs

@@ -1,21 +1,7 @@
 import { decodeCid, ifCid, cidForCbor } from "@atproto/lex-data";
-const typeofs = [
-  "string",
-  "number",
-  "bigint",
-  "symbol"
-];
 const objectTypeNames = [
-  "Function",
-  "Generator",
-  "AsyncGenerator",
-  "GeneratorFunction",
-  "AsyncGeneratorFunction",
-  "AsyncFunction",
-  "Observable",
-  "Array",
-  "Buffer",
   "Object",
+  // for Object.create(null) and other non-plain objects
   "RegExp",
   "Date",
   "Error",
@@ -30,7 +16,6 @@ const objectTypeNames = [
   "URL",
   "HTMLElement",
   "Int8Array",
-  "Uint8Array",
   "Uint8ClampedArray",
   "Int16Array",
   "Uint16Array",
@@ -52,7 +37,7 @@ function is(value) {
     return "boolean";
   }
   const typeOf = typeof value;
-  if (typeofs.includes(typeOf)) {
+  if (typeOf === "string" || typeOf === "number" || typeOf === "bigint" || typeOf === "symbol") {
     return typeOf;
   }
   if (typeOf === "function") {
@@ -61,8 +46,11 @@ function is(value) {
   if (Array.isArray(value)) {
     return "Array";
   }
-  if (isBuffer$1(value)) {
-    return "Buffer";
+  if (value instanceof Uint8Array) {
+    return "Uint8Array";
+  }
+  if (value.constructor === Object) {
+    return "Object";
   }
   const objectType = getObjectType(value);
   if (objectType) {
@@ -70,9 +58,6 @@ function is(value) {
   }
   return "Object";
 }
-function isBuffer$1(value) {
-  return value && value.constructor && value.constructor.isBuffer && value.constructor.isBuffer.call(null, value);
-}
 function getObjectType(value) {
   const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
   if (objectTypeNames.includes(objectTypeName)) {
@@ -103,6 +88,17 @@ class Type {
   compare(typ) {
     return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
   }
+  /**
+   * Check equality between two Type instances. Safe to use across different
+   * copies of the Type class (e.g., when bundlers duplicate the module).
+   * (major, name) uniquely identifies a Type; terminal is implied by these.
+   * @param {Type} a
+   * @param {Type} b
+   * @returns {boolean}
+   */
+  static equals(a, b) {
+    return a === b || a.major === b.major && a.name === b.name;
+  }
 }
 Type.uint = new Type(0, "uint", true);
 Type.negint = new Type(1, "negint", true);
@@ -139,49 +135,25 @@ const useBuffer = globalThis.process && // @ts-ignore
 !globalThis.process.browser && // @ts-ignore
 globalThis.Buffer && // @ts-ignore
 typeof globalThis.Buffer.isBuffer === "function";
-const textDecoder = new TextDecoder();
 const textEncoder = new TextEncoder();
-function isBuffer(buf2) {
-  return useBuffer && globalThis.Buffer.isBuffer(buf2);
+function isBuffer(buf) {
+  return useBuffer && globalThis.Buffer.isBuffer(buf);
 }
-function asU8A(buf2) {
-  if (!(buf2 instanceof Uint8Array)) {
-    return Uint8Array.from(buf2);
+function asU8A(buf) {
+  if (!(buf instanceof Uint8Array)) {
+    return Uint8Array.from(buf);
   }
-  return isBuffer(buf2) ? new Uint8Array(buf2.buffer, buf2.byteOffset, buf2.byteLength) : buf2;
+  return isBuffer(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf;
 }
-const toString = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} start
-   * @param {number} end
-   */
-  (bytes, start, end) => {
-    return end - start > 64 ? (
-      // eslint-disable-line operator-linebreak
-      // @ts-ignore
-      globalThis.Buffer.from(bytes.subarray(start, end)).toString("utf8")
-    ) : utf8Slice(bytes, start, end);
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} start
-   * @param {number} end
-   */
-  (bytes, start, end) => {
-    return end - start > 64 ? textDecoder.decode(bytes.subarray(start, end)) : utf8Slice(bytes, start, end);
-  }
-);
+const FROM_STRING_THRESHOLD_BUFFER = 24;
+const FROM_STRING_THRESHOLD_TEXTENCODER = 200;
 const fromString = useBuffer ? (
   // eslint-disable-line operator-linebreak
   /**
    * @param {string} string
    */
   (string) => {
-    return string.length > 64 ? (
+    return string.length >= FROM_STRING_THRESHOLD_BUFFER ? (
       // eslint-disable-line operator-linebreak
       // @ts-ignore
       globalThis.Buffer.from(string)
@@ -193,7 +165,7 @@ const fromString = useBuffer ? (
    * @param {string} string
    */
   (string) => {
-    return string.length > 64 ? textEncoder.encode(string) : utf8ToBytes(string);
+    return string.length >= FROM_STRING_THRESHOLD_TEXTENCODER ? textEncoder.encode(string) : utf8ToBytes(string);
   }
 );
 const fromArray = (arr) => {
@@ -206,6 +178,7 @@ const slice = useBuffer ? (
    * @param {number} start
    * @param {number} end
    */
+  // Buffer.slice() returns a view, not a copy, so we need special handling
   (bytes, start, end) => {
     if (isBuffer(bytes)) {
       return new Uint8Array(bytes.subarray(start, end));
@@ -306,6 +279,9 @@ function utf8ToBytes(str) {
       out[p++] = c >> 6 & 63 | 128;
       out[p++] = c & 63 | 128;
     } else {
+      if (c >= 55296 && c <= 57343) {
+        c = 65533;
+      }
       out[p++] = c >> 12 | 224;
       out[p++] = c >> 6 & 63 | 128;
       out[p++] = c & 63 | 128;
@@ -313,80 +289,6 @@ function utf8ToBytes(str) {
   }
   return out;
 }
-function utf8Slice(buf2, offset, end) {
-  const res = [];
-  while (offset < end) {
-    const firstByte = buf2[offset];
-    let codePoint = null;
-    let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
-    if (offset + bytesPerSequence <= end) {
-      let secondByte, thirdByte, fourthByte, tempCodePoint;
-      switch (bytesPerSequence) {
-        case 1:
-          if (firstByte < 128) {
-            codePoint = firstByte;
-          }
-          break;
-        case 2:
-          secondByte = buf2[offset + 1];
-          if ((secondByte & 192) === 128) {
-            tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
-            if (tempCodePoint > 127) {
-              codePoint = tempCodePoint;
-            }
-          }
-          break;
-        case 3:
-          secondByte = buf2[offset + 1];
-          thirdByte = buf2[offset + 2];
-          if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
-            tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
-            if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
-              codePoint = tempCodePoint;
-            }
-          }
-          break;
-        case 4:
-          secondByte = buf2[offset + 1];
-          thirdByte = buf2[offset + 2];
-          fourthByte = buf2[offset + 3];
-          if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
-            tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
-            if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
-              codePoint = tempCodePoint;
-            }
-          }
-      }
-    }
-    if (codePoint === null) {
-      codePoint = 65533;
-      bytesPerSequence = 1;
-    } else if (codePoint > 65535) {
-      codePoint -= 65536;
-      res.push(codePoint >>> 10 & 1023 | 55296);
-      codePoint = 56320 | codePoint & 1023;
-    }
-    res.push(codePoint);
-    offset += bytesPerSequence;
-  }
-  return decodeCodePointsArray(res);
-}
-const MAX_ARGUMENTS_LENGTH = 4096;
-function decodeCodePointsArray(codePoints) {
-  const len = codePoints.length;
-  if (len <= MAX_ARGUMENTS_LENGTH) {
-    return String.fromCharCode.apply(String, codePoints);
-  }
-  let res = "";
-  let i = 0;
-  while (i < len) {
-    res += String.fromCharCode.apply(
-      String,
-      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
-    );
-  }
-  return res;
-}
 const defaultChunkSize = 256;
 class Bl {
   /**
@@ -466,6 +368,40 @@ class Bl {
     return byts;
   }
 }
+class U8Bl {
+  /**
+   * @param {Uint8Array} dest
+   */
+  constructor(dest) {
+    this.dest = dest;
+    this.cursor = 0;
+    this.chunks = [dest];
+  }
+  reset() {
+    this.cursor = 0;
+  }
+  /**
+   * @param {Uint8Array|number[]} bytes
+   */
+  push(bytes) {
+    if (this.cursor + bytes.length > this.dest.length) {
+      throw new Error("write out of bounds, destination buffer is too small");
+    }
+    this.dest.set(bytes, this.cursor);
+    this.cursor += bytes.length;
+  }
+  /**
+   * @param {boolean} [reset]
+   * @returns {Uint8Array}
+   */
+  toBytes(reset = false) {
+    const byts = this.dest.subarray(0, this.cursor);
+    if (reset) {
+      this.reset();
+    }
+    return byts;
+  }
+}
 const decodeErrPrefix = "CBOR decode error:";
 const encodeErrPrefix = "CBOR encode error:";
 function assertEnoughData(data, pos, need) {
@@ -526,22 +462,22 @@ function decodeUint32(data, pos, _minor, options) {
 function decodeUint64(data, pos, _minor, options) {
   return new Token(Type.uint, readUint64(data, pos + 1, options), 9);
 }
-function encodeUint(buf2, token) {
-  return encodeUintValue(buf2, 0, token.value);
+function encodeUint(writer, token) {
+  return encodeUintValue(writer, 0, token.value);
 }
-function encodeUintValue(buf2, major, uint) {
+function encodeUintValue(writer, major, uint) {
   if (uint < uintBoundaries[0]) {
     const nuint = Number(uint);
-    buf2.push([major | nuint]);
+    writer.push([major | nuint]);
   } else if (uint < uintBoundaries[1]) {
     const nuint = Number(uint);
-    buf2.push([major | 24, nuint]);
+    writer.push([major | 24, nuint]);
   } else if (uint < uintBoundaries[2]) {
     const nuint = Number(uint);
-    buf2.push([major | 25, nuint >>> 8, nuint & 255]);
+    writer.push([major | 25, nuint >>> 8, nuint & 255]);
   } else if (uint < uintBoundaries[3]) {
     const nuint = Number(uint);
-    buf2.push([major | 26, nuint >>> 24 & 255, nuint >>> 16 & 255, nuint >>> 8 & 255, nuint & 255]);
+    writer.push([major | 26, nuint >>> 24 & 255, nuint >>> 16 & 255, nuint >>> 8 & 255, nuint & 255]);
   } else {
     const buint = BigInt(uint);
     if (buint < uintBoundaries[4]) {
@@ -562,7 +498,7 @@ function encodeUintValue(buf2, major, uint) {
       set[2] = hi & 255;
       hi = hi >> 8;
       set[1] = hi & 255;
-      buf2.push(set);
+      writer.push(set);
     } else {
       throw new Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`);
     }
@@ -601,8 +537,8 @@ function decodeNegint16(data, pos, _minor, options) {
 function decodeNegint32(data, pos, _minor, options) {
   return new Token(Type.negint, -1 - readUint32(data, pos + 1, options), 5);
 }
-const neg1b = BigInt(-1);
-const pos1b = BigInt(1);
+const neg1b$1 = BigInt(-1);
+const pos1b$1 = BigInt(1);
 function decodeNegint64(data, pos, _minor, options) {
   const int = readUint64(data, pos + 1, options);
   if (typeof int !== "bigint") {
@@ -614,16 +550,16 @@ function decodeNegint64(data, pos, _minor, options) {
   if (options.allowBigInt !== true) {
     throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
   }
-  return new Token(Type.negint, neg1b - BigInt(int), 9);
+  return new Token(Type.negint, neg1b$1 - BigInt(int), 9);
 }
-function encodeNegint(buf2, token) {
+function encodeNegint(writer, token) {
   const negint = token.value;
-  const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
-  encodeUintValue(buf2, token.type.majorEncoded, unsigned);
+  const unsigned = typeof negint === "bigint" ? negint * neg1b$1 - pos1b$1 : negint * -1 - 1;
+  encodeUintValue(writer, token.type.majorEncoded, unsigned);
 }
 encodeNegint.encodedSize = function encodedSize3(token) {
   const negint = token.value;
-  const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
+  const unsigned = typeof negint === "bigint" ? negint * neg1b$1 - pos1b$1 : negint * -1 - 1;
   if (unsigned < uintBoundaries[0]) {
     return 1;
   }
@@ -646,8 +582,8 @@ encodeNegint.compareTokens = function compareTokens2(tok1, tok2) {
 };
 function toToken$3(data, pos, prefix, length) {
   assertEnoughData(data, pos, prefix + length);
-  const buf2 = slice(data, pos + prefix, pos + prefix + length);
-  return new Token(Type.bytes, buf2, prefix + length);
+  const buf = data.slice(pos + prefix, pos + prefix + length);
+  return new Token(Type.bytes, buf, prefix + length);
 }
 function decodeBytesCompact(data, pos, minor, _options) {
   return toToken$3(data, pos, 1, minor);
@@ -670,14 +606,14 @@ function decodeBytes64(data, pos, _minor, options) {
 }
 function tokenBytes(token) {
   if (token.encodedBytes === void 0) {
-    token.encodedBytes = token.type === Type.string ? fromString(token.value) : token.value;
+    token.encodedBytes = Type.equals(token.type, Type.string) ? fromString(token.value) : token.value;
   }
   return token.encodedBytes;
 }
-function encodeBytes(buf2, token) {
+function encodeBytes(writer, token) {
   const bytes = tokenBytes(token);
-  encodeUintValue(buf2, token.type.majorEncoded, bytes.length);
-  buf2.push(bytes);
+  encodeUintValue(writer, token.type.majorEncoded, bytes.length);
+  writer.push(bytes);
 }
 encodeBytes.encodedSize = function encodedSize4(token) {
   const bytes = tokenBytes(token);
@@ -689,12 +625,29 @@ encodeBytes.compareTokens = function compareTokens3(tok1, tok2) {
 function compareBytes(b1, b2) {
   return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare(b1, b2);
 }
+const textDecoder = new TextDecoder();
+const ASCII_THRESHOLD = 32;
+function toStr(bytes, start, end) {
+  const len = end - start;
+  if (len < ASCII_THRESHOLD) {
+    let str = "";
+    for (let i = start; i < end; i++) {
+      const c = bytes[i];
+      if (c & 128) {
+        return textDecoder.decode(bytes.subarray(start, end));
+      }
+      str += String.fromCharCode(c);
+    }
+    return str;
+  }
+  return textDecoder.decode(bytes.subarray(start, end));
+}
 function toToken$2(data, pos, prefix, length, options) {
   const totLength = prefix + length;
   assertEnoughData(data, pos, totLength);
-  const tok = new Token(Type.string, toString(data, pos + prefix, pos + totLength), totLength);
+  const tok = new Token(Type.string, toStr(data, pos + prefix, pos + totLength), totLength);
   if (options.retainStringBytes === true) {
-    tok.byteValue = slice(data, pos + prefix, pos + totLength);
+    tok.byteValue = data.slice(pos + prefix, pos + totLength);
   }
   return tok;
 }
@@ -746,8 +699,8 @@ function decodeArrayIndefinite(data, pos, _minor, options) {
   }
   return toToken$1(data, pos, 1, Infinity);
 }
-function encodeArray(buf2, token) {
-  encodeUintValue(buf2, Type.array.majorEncoded, token.value);
+function encodeArray(writer, token) {
+  encodeUintValue(writer, Type.array.majorEncoded, token.value);
 }
 encodeArray.compareTokens = encodeUint.compareTokens;
 encodeArray.encodedSize = function encodedSize5(token) {
@@ -781,8 +734,8 @@ function decodeMapIndefinite(data, pos, _minor, options) {
   }
   return toToken(data, pos, 1, Infinity);
 }
-function encodeMap(buf2, token) {
-  encodeUintValue(buf2, Type.map.majorEncoded, token.value);
+function encodeMap(writer, token) {
+  encodeUintValue(writer, Type.map.majorEncoded, token.value);
 }
 encodeMap.compareTokens = encodeUint.compareTokens;
 encodeMap.encodedSize = function encodedSize6(token) {
@@ -803,8 +756,8 @@ function decodeTag32(data, pos, _minor, options) {
 function decodeTag64(data, pos, _minor, options) {
   return new Token(Type.tag, readUint64(data, pos + 1, options), 9);
 }
-function encodeTag(buf2, token) {
-  encodeUintValue(buf2, Type.tag.majorEncoded, token.value);
+function encodeTag(writer, token) {
+  encodeUintValue(writer, Type.tag.majorEncoded, token.value);
 }
 encodeTag.compareTokens = encodeUint.compareTokens;
 encodeTag.encodedSize = function encodedSize7(token) {
@@ -848,16 +801,16 @@ function decodeFloat32(data, pos, _minor, options) {
 function decodeFloat64(data, pos, _minor, options) {
   return createToken(readFloat64(data, pos + 1), 9, options);
 }
-function encodeFloat(buf2, token, options) {
+function encodeFloat(writer, token, options) {
   const float = token.value;
   if (float === false) {
-    buf2.push([Type.float.majorEncoded | MINOR_FALSE]);
+    writer.push([Type.float.majorEncoded | MINOR_FALSE]);
   } else if (float === true) {
-    buf2.push([Type.float.majorEncoded | MINOR_TRUE]);
+    writer.push([Type.float.majorEncoded | MINOR_TRUE]);
   } else if (float === null) {
-    buf2.push([Type.float.majorEncoded | MINOR_NULL]);
+    writer.push([Type.float.majorEncoded | MINOR_NULL]);
   } else if (float === void 0) {
-    buf2.push([Type.float.majorEncoded | MINOR_UNDEFINED]);
+    writer.push([Type.float.majorEncoded | MINOR_UNDEFINED]);
   } else {
     let decoded;
     let success = false;
@@ -866,14 +819,14 @@ function encodeFloat(buf2, token, options) {
       decoded = readFloat16(ui8a, 1);
       if (float === decoded || Number.isNaN(float)) {
         ui8a[0] = 249;
-        buf2.push(ui8a.slice(0, 3));
+        writer.push(ui8a.slice(0, 3));
         success = true;
       } else {
         encodeFloat32(float);
         decoded = readFloat32(ui8a, 1);
         if (float === decoded) {
           ui8a[0] = 250;
-          buf2.push(ui8a.slice(0, 5));
+          writer.push(ui8a.slice(0, 5));
           success = true;
         }
       }
@@ -882,7 +835,7 @@ function encodeFloat(buf2, token, options) {
       encodeFloat64(float);
       decoded = readFloat64(ui8a, 1);
       ui8a[0] = 251;
-      buf2.push(ui8a.slice(0, 9));
+      writer.push(ui8a.slice(0, 9));
     }
   }
 }
@@ -1156,7 +1109,7 @@ function makeCborEncoders() {
   return encoders;
 }
 const cborEncoders = makeCborEncoders();
-const buf = new Bl();
+const defaultWriter = new Bl();
 class Ref {
   /**
    * @param {object|any[]} obj
@@ -1335,27 +1288,38 @@ const typeEncoders = {
   Object(obj, typ, options, refStack) {
     const isMap = typ !== "Object";
     const keys = isMap ? obj.keys() : Object.keys(obj);
-    const length = isMap ? obj.size : keys.length;
-    if (!length) {
+    const maxLength = isMap ? obj.size : keys.length;
+    let entries;
+    if (maxLength) {
+      entries = new Array(maxLength);
+      refStack = Ref.createCheck(refStack, obj);
+      const skipUndefined = !isMap && options.ignoreUndefinedProperties;
+      let i = 0;
+      for (const key of keys) {
+        const value = isMap ? obj.get(key) : obj[key];
+        if (skipUndefined && value === void 0) {
+          continue;
+        }
+        entries[i++] = [
+          objectToTokens(key, options, refStack),
+          objectToTokens(value, options, refStack)
+        ];
+      }
+      if (i < maxLength) {
+        entries.length = i;
+      }
+    }
+    if (!(entries == null ? void 0 : entries.length)) {
       if (options.addBreakTokens === true) {
         return [simpleTokens.emptyMap, new Token(Type.break)];
       }
       return simpleTokens.emptyMap;
     }
-    refStack = Ref.createCheck(refStack, obj);
-    const entries = [];
-    let i = 0;
-    for (const key of keys) {
-      entries[i++] = [
-        objectToTokens(key, options, refStack),
-        objectToTokens(isMap ? obj.get(key) : obj[key], options, refStack)
-      ];
-    }
     sortMapEntries(entries, options);
     if (options.addBreakTokens) {
-      return [new Token(Type.map, length), entries, new Token(Type.break)];
+      return [new Token(Type.map, entries.length), entries, new Token(Type.break)];
     }
-    return [new Token(Type.map, length), entries];
+    return [new Token(Type.map, entries.length), entries];
   }
 };
 typeEncoders.Map = typeEncoders.Object;
@@ -1397,39 +1361,140 @@ function mapSorter(e1, e2) {
   }
   return tcmp;
 }
-function tokensToEncoded(buf2, tokens, encoders, options) {
+function tokensToEncoded(writer, tokens, encoders, options) {
   if (Array.isArray(tokens)) {
     for (const token of tokens) {
-      tokensToEncoded(buf2, token, encoders, options);
+      tokensToEncoded(writer, token, encoders, options);
     }
   } else {
-    encoders[tokens.type.major](buf2, tokens, options);
+    encoders[tokens.type.major](writer, tokens, options);
+  }
+}
+const MAJOR_UINT = Type.uint.majorEncoded;
+const MAJOR_NEGINT = Type.negint.majorEncoded;
+const MAJOR_BYTES = Type.bytes.majorEncoded;
+const MAJOR_STRING = Type.string.majorEncoded;
+const MAJOR_ARRAY = Type.array.majorEncoded;
+const SIMPLE_FALSE = Type.float.majorEncoded | MINOR_FALSE;
+const SIMPLE_TRUE = Type.float.majorEncoded | MINOR_TRUE;
+const SIMPLE_NULL = Type.float.majorEncoded | MINOR_NULL;
+const SIMPLE_UNDEFINED = Type.float.majorEncoded | MINOR_UNDEFINED;
+const neg1b = BigInt(-1);
+const pos1b = BigInt(1);
+function canDirectEncode(options) {
+  return options.addBreakTokens !== true;
+}
+function directEncode(writer, data, options, refStack) {
+  const typ = is(data);
+  const customEncoder = options.typeEncoders && options.typeEncoders[typ];
+  if (customEncoder) {
+    const tokens = customEncoder(data, typ, options, refStack);
+    if (tokens != null) {
+      tokensToEncoded(writer, tokens, cborEncoders, options);
+      return;
+    }
+  }
+  switch (typ) {
+    case "null":
+      writer.push([SIMPLE_NULL]);
+      return;
+    case "undefined":
+      writer.push([SIMPLE_UNDEFINED]);
+      return;
+    case "boolean":
+      writer.push([data ? SIMPLE_TRUE : SIMPLE_FALSE]);
+      return;
+    case "number":
+      if (!Number.isInteger(data) || !Number.isSafeInteger(data)) {
+        encodeFloat(writer, new Token(Type.float, data), options);
+      } else if (data >= 0) {
+        encodeUintValue(writer, MAJOR_UINT, data);
+      } else {
+        encodeUintValue(writer, MAJOR_NEGINT, data * -1 - 1);
+      }
+      return;
+    case "bigint":
+      if (data >= BigInt(0)) {
+        encodeUintValue(writer, MAJOR_UINT, data);
+      } else {
+        encodeUintValue(writer, MAJOR_NEGINT, data * neg1b - pos1b);
+      }
+      return;
+    case "string": {
+      const bytes = fromString(data);
+      encodeUintValue(writer, MAJOR_STRING, bytes.length);
+      writer.push(bytes);
+      return;
+    }
+    case "Uint8Array":
+      encodeUintValue(writer, MAJOR_BYTES, data.length);
+      writer.push(data);
+      return;
+    case "Array":
+      if (!data.length) {
+        writer.push([MAJOR_ARRAY]);
+        return;
+      }
+      refStack = Ref.createCheck(refStack, data);
+      encodeUintValue(writer, MAJOR_ARRAY, data.length);
+      for (const elem of data) {
+        directEncode(writer, elem, options, refStack);
+      }
+      return;
+    case "Object":
+    case "Map":
+      {
+        const tokens = typeEncoders.Object(data, typ, options, refStack);
+        tokensToEncoded(writer, tokens, cborEncoders, options);
+      }
+      return;
+    default: {
+      const typeEncoder = typeEncoders[typ];
+      if (!typeEncoder) {
+        throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`);
+      }
+      const tokens = typeEncoder(data, typ, options, refStack);
+      tokensToEncoded(writer, tokens, cborEncoders, options);
+    }
   }
 }
-function encodeCustom(data, encoders, options) {
+function encodeCustom(data, encoders, options, destination) {
+  const hasDest = destination instanceof Uint8Array;
+  let writeTo = hasDest ? new U8Bl(destination) : defaultWriter;
   const tokens = objectToTokens(data, options);
   if (!Array.isArray(tokens) && options.quickEncodeToken) {
     const quickBytes = options.quickEncodeToken(tokens);
     if (quickBytes) {
+      if (hasDest) {
+        writeTo.push(quickBytes);
+        return writeTo.toBytes();
+      }
       return quickBytes;
     }
     const encoder = encoders[tokens.type.major];
     if (encoder.encodedSize) {
       const size = encoder.encodedSize(tokens, options);
-      const buf2 = new Bl(size);
-      encoder(buf2, tokens, options);
-      if (buf2.chunks.length !== 1) {
+      if (!hasDest) {
+        writeTo = new Bl(size);
+      }
+      encoder(writeTo, tokens, options);
+      if (writeTo.chunks.length !== 1) {
         throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
       }
-      return asU8A(buf2.chunks[0]);
+      return hasDest ? writeTo.toBytes() : asU8A(writeTo.chunks[0]);
     }
   }
-  buf.reset();
-  tokensToEncoded(buf, tokens, encoders, options);
-  return buf.toBytes(true);
+  writeTo.reset();
+  tokensToEncoded(writeTo, tokens, encoders, options);
+  return writeTo.toBytes(true);
 }
 function encode$1(data, options) {
   options = Object.assign({}, defaultEncodeOptions, options);
+  if (canDirectEncode(options)) {
+    defaultWriter.reset();
+    directEncode(defaultWriter, data, options, void 0);
+    return defaultWriter.toBytes(true);
+  }
   return encodeCustom(data, cborEncoders, options);
 }
 const defaultDecodeOptions = {
@@ -1490,6 +1555,7 @@ function tokenToArray(token, tokeniser, options) {
 }
 function tokenToMap(token, tokeniser, options) {
   const useMaps = options.useMaps === true;
+  const rejectDuplicateMapKeys = options.rejectDuplicateMapKeys === true;
   const obj = useMaps ? void 0 : {};
   const m = useMaps ? /* @__PURE__ */ new Map() : void 0;
   for (let i = 0; i < token.value; i++) {
@@ -1503,11 +1569,11 @@ function tokenToMap(token, tokeniser, options) {
     if (key === DONE) {
       throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
     }
-    if (useMaps !== true && typeof key !== "string") {
+    if (!useMaps && typeof key !== "string") {
       throw new Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`);
     }
-    if (options.rejectDuplicateMapKeys === true) {
-      if (useMaps && m.has(key) || !useMaps && key in obj) {
+    if (rejectDuplicateMapKeys) {
+      if (useMaps && m.has(key) || !useMaps && Object.hasOwn(obj, key)) {
         throw new Error(`${decodeErrPrefix} found repeat map key "${key}"`);
       }
     }
@@ -1528,19 +1594,19 @@ function tokensToObject(tokeniser, options) {
     return DONE;
   }
   const token = tokeniser.next();
-  if (token.type === Type.break) {
+  if (Type.equals(token.type, Type.break)) {
     return BREAK;
   }
   if (token.type.terminal) {
     return token.value;
   }
-  if (token.type === Type.array) {
+  if (Type.equals(token.type, Type.array)) {
     return tokenToArray(token, tokeniser, options);
   }
-  if (token.type === Type.map) {
+  if (Type.equals(token.type, Type.map)) {
     return tokenToMap(token, tokeniser, options);
   }
-  if (token.type === Type.tag) {
+  if (Type.equals(token.type, Type.tag)) {
     if (options.tags && typeof options.tags[token.value] === "function") {
       const tagged = tokensToObject(tokeniser, options);
       return options.tags[token.value](tagged);
@@ -1554,7 +1620,8 @@ function decodeFirst(data, options) {
     throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`);
   }
   options = Object.assign({}, defaultDecodeOptions, options);
-  const tokeniser = options.tokenizer || new Tokeniser(data, options);
+  const u8aData = asU8A(data);
+  const tokeniser = options.tokenizer || new Tokeniser(u8aData, options);
   const decoded = tokensToObject(tokeniser, options);
   if (decoded === DONE) {
     throw new Error(`${decodeErrPrefix} did not find any content to decode`);
@@ -1572,51 +1639,41 @@ function decode$1(data, options) {
   return decoded;
 }
 const CID_CBOR_TAG = 42;
-function cidEncoder(cid) {
-  const bytes = new Uint8Array(cid.bytes.byteLength + 1);
-  bytes.set(cid.bytes, 1);
-  return [new Token(Type.tag, CID_CBOR_TAG), new Token(Type.bytes, bytes)];
-}
-function objectEncoder(obj, _typ, _options) {
-  const cid = ifCid(obj);
-  if (cid) return cidEncoder(cid);
-  return null;
-}
-function undefinedEncoder() {
-  throw new Error("`undefined` is not allowed by the AT Data Model");
-}
-function numberEncoder(num) {
-  if (Number.isInteger(num) && Number.isSafeInteger(num)) return null;
-  throw new Error("Non-integer numbers are not allowed by the AT Data Model");
-}
-function mapEncoder(map) {
-  for (const key of map.keys()) {
-    if (typeof key !== "string") {
+const encodeOptions = Object.freeze({
+  float64: true,
+  ignoreUndefinedProperties: true,
+  typeEncoders: Object.freeze({
+    Map: (map) => {
+      for (const key of map.keys()) {
+        if (typeof key !== "string") {
+          throw new Error(
+            'Only string keys are allowed in CBOR "map" by the AT Data Model'
+          );
+        }
+      }
+      return null;
+    },
+    Object: (obj) => {
+      const cid = ifCid(obj);
+      if (cid) {
+        const bytes = new Uint8Array(cid.bytes.byteLength + 1);
+        bytes.set(cid.bytes, 1);
+        return [new Token(Type.tag, CID_CBOR_TAG), new Token(Type.bytes, bytes)];
+      }
+      return null;
+    },
+    undefined: () => {
+      throw new Error("`undefined` is not supported by the AT Data Model");
+    },
+    number: (num) => {
+      if (Number.isSafeInteger(num)) return null;
       throw new Error(
-        'Only string keys are allowed in CBOR "map" by the AT Data Model'
+        `Non-integer numbers (${num}) are not supported by the AT Data Model`
       );
     }
-  }
-  return null;
-}
-const encodeOptions = {
-  float64: true,
-  typeEncoders: {
-    Map: mapEncoder,
-    Object: objectEncoder,
-    undefined: undefinedEncoder,
-    number: numberEncoder
-  }
-};
-function cidDecoder(bytes) {
-  if (bytes[0] !== 0) {
-    throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
-  }
-  return decodeCid(bytes.subarray(1));
-}
-const tagDecoders = [];
-tagDecoders[CID_CBOR_TAG] = cidDecoder;
-const decodeOptions = {
+  })
+});
+const decodeOptions = /* @__PURE__ */ Object.freeze({
   allowIndefinite: false,
   coerceUndefinedToNull: true,
   allowNaN: false,
@@ -1625,8 +1682,18 @@ const decodeOptions = {
   strict: true,
   useMaps: false,
   rejectDuplicateMapKeys: true,
-  tags: tagDecoders
-};
+  tags: /* @__PURE__ */ Object.freeze(
+    /* @__PURE__ */ Object.assign([], {
+      [CID_CBOR_TAG]: (bytes) => {
+        if (bytes[0] !== 0) {
+          throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
+        }
+        const cibBytes = bytes.subarray(1);
+        return decodeCid(cibBytes);
+      }
+    })
+  )
+});
 function encode(data) {
   return encode$1(data, encodeOptions);
 }
@@ -1650,5 +1717,7 @@ export {
   cidForLex,
   decode,
   decodeAll,
-  encode
+  decodeOptions,
+  encode,
+  encodeOptions
 };