omnipin 2.0.4 → 2.1.0

package/dist/index.js

@@ -818,14 +818,30 @@ function coerce(o) {
     if (ArrayBuffer.isView(o)) return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
     throw Error('Unknown type, must be binary type');
 }
-function byte_utils_isBuffer(buf) {
+function is_is(value) {
+    if (null === value) return 'null';
+    if (void 0 === value) return 'undefined';
+    if (!0 === value || !1 === value) return 'boolean';
+    let typeOf = typeof value;
+    if ('string' === typeOf || 'number' === typeOf || 'bigint' === typeOf || 'symbol' === typeOf) return typeOf;
+    if ('function' === typeOf) return 'Function';
+    if (Array.isArray(value)) return 'Array';
+    if (value instanceof Uint8Array) return 'Uint8Array';
+    if (value.constructor === Object) return 'Object';
+    let objectType = function(value) {
+        let objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
+        if (objectTypeNames.includes(objectTypeName)) return objectTypeName;
+    }(value);
+    return objectType || 'Object';
+}
+function isBuffer(buf) {
     return useBuffer && globalThis.Buffer.isBuffer(buf);
 }
 function asU8A(buf) {
-    return buf instanceof Uint8Array ? byte_utils_isBuffer(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf : Uint8Array.from(buf);
+    return buf instanceof Uint8Array ? isBuffer(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf : Uint8Array.from(buf);
 }
 function compare(b1, b2) {
-    if (byte_utils_isBuffer(b1) && byte_utils_isBuffer(b2)) return b1.compare(b2);
+    if (isBuffer(b1) && isBuffer(b2)) return b1.compare(b2);
     for(let i = 0; i < b1.length; i++)if (b1[i] !== b2[i]) return b1[i] < b2[i] ? -1 : 1;
     return 0;
 }
@@ -833,41 +849,10 @@ function byte_utils_utf8ToBytes(str) {
     let out = [], p = 0;
     for(let i = 0; i < str.length; i++){
         let c = str.charCodeAt(i);
-        c < 128 ? out[p++] = c : (c < 2048 ? out[p++] = c >> 6 | 192 : ((0xFC00 & c) == 0xD800 && i + 1 < str.length && (0xFC00 & str.charCodeAt(i + 1)) == 0xDC00 ? (c = 0x10000 + ((0x03FF & c) << 10) + (0x03FF & str.charCodeAt(++i)), out[p++] = c >> 18 | 240, out[p++] = c >> 12 & 63 | 128) : out[p++] = c >> 12 | 224, out[p++] = c >> 6 & 63 | 128), out[p++] = 63 & c | 128);
+        c < 128 ? out[p++] = c : (c < 2048 ? out[p++] = c >> 6 | 192 : ((0xFC00 & c) == 0xD800 && i + 1 < str.length && (0xFC00 & str.charCodeAt(i + 1)) == 0xDC00 ? (c = 0x10000 + ((0x03FF & c) << 10) + (0x03FF & str.charCodeAt(++i)), out[p++] = c >> 18 | 240, out[p++] = c >> 12 & 63 | 128) : (c >= 0xD800 && c <= 0xDFFF && (c = 0xFFFD), out[p++] = c >> 12 | 224), out[p++] = c >> 6 & 63 | 128), out[p++] = 63 & c | 128);
     }
     return out;
 }
-function utf8Slice(buf, offset, end) {
-    let res = [];
-    for(; offset < end;){
-        let firstByte = buf[offset], codePoint = null, bytesPerSequence = firstByte > 0xef ? 4 : firstByte > 0xdf ? 3 : firstByte > 0xbf ? 2 : 1;
-        if (offset + bytesPerSequence <= end) {
-            let secondByte, thirdByte, fourthByte, tempCodePoint;
-            switch(bytesPerSequence){
-                case 1:
-                    firstByte < 0x80 && (codePoint = firstByte);
-                    break;
-                case 2:
-                    (0xc0 & (secondByte = buf[offset + 1])) == 0x80 && (tempCodePoint = (0x1f & firstByte) << 0x6 | 0x3f & secondByte) > 0x7f && (codePoint = tempCodePoint);
-                    break;
-                case 3:
-                    secondByte = buf[offset + 1], thirdByte = buf[offset + 2], (0xc0 & secondByte) == 0x80 && (0xc0 & thirdByte) == 0x80 && (tempCodePoint = (0xf & firstByte) << 0xc | (0x3f & secondByte) << 0x6 | 0x3f & thirdByte) > 0x7ff && (tempCodePoint < 0xd800 || tempCodePoint > 0xdfff) && (codePoint = tempCodePoint);
-                    break;
-                case 4:
-                    secondByte = buf[offset + 1], thirdByte = buf[offset + 2], fourthByte = buf[offset + 3], (0xc0 & secondByte) == 0x80 && (0xc0 & thirdByte) == 0x80 && (0xc0 & fourthByte) == 0x80 && (tempCodePoint = (0xf & firstByte) << 0x12 | (0x3f & secondByte) << 0xc | (0x3f & thirdByte) << 0x6 | 0x3f & fourthByte) > 0xffff && tempCodePoint < 0x110000 && (codePoint = tempCodePoint);
-            }
-        }
-        null === codePoint ? (codePoint = 0xfffd, bytesPerSequence = 1) : codePoint > 0xffff && (codePoint -= 0x10000, res.push(codePoint >>> 10 & 0x3ff | 0xd800), codePoint = 0xdc00 | 0x3ff & codePoint), res.push(codePoint), offset += bytesPerSequence;
-    }
-    return decodeCodePointsArray(res);
-}
-function decodeCodePointsArray(codePoints) {
-    let len = codePoints.length;
-    if (len <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, codePoints);
-    let res = '', i = 0;
-    for(; i < len;)res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
-    return res;
-}
 function assertEnoughData(data, pos, need) {
     if (data.length - pos < need) throw Error(`${decodeErrPrefix} not enough data for type`);
 }
@@ -897,31 +882,31 @@ function readUint64(data, offset, options) {
     if (!0 === options.allowBigInt) return value;
     throw Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
 }
-function encodeUint(buf, token) {
-    return encodeUintValue(buf, 0, token.value);
+function encodeUint(writer, token) {
+    return encodeUintValue(writer, 0, token.value);
 }
-function encodeUintValue(buf, major, uint) {
+function encodeUintValue(writer, major, uint) {
     if (uint < uintBoundaries[0]) {
         let nuint = Number(uint);
-        buf.push([
+        writer.push([
             major | nuint
         ]);
     } else if (uint < uintBoundaries[1]) {
         let nuint = Number(uint);
-        buf.push([
+        writer.push([
             24 | major,
             nuint
         ]);
     } else if (uint < uintBoundaries[2]) {
         let nuint = Number(uint);
-        buf.push([
+        writer.push([
             25 | major,
             nuint >>> 8,
             0xff & nuint
         ]);
     } else if (uint < uintBoundaries[3]) {
         let nuint = Number(uint);
-        buf.push([
+        writer.push([
             26 | major,
             nuint >>> 24 & 0xff,
             nuint >>> 16 & 0xff,
@@ -941,34 +926,45 @@ function encodeUintValue(buf, major, uint) {
                 0,
                 0
             ], lo = Number(buint & BigInt(0xffffffff)), hi = Number(buint >> BigInt(32) & BigInt(0xffffffff));
-            set[8] = 0xff & lo, lo >>= 8, set[7] = 0xff & lo, lo >>= 8, set[6] = 0xff & lo, lo >>= 8, set[5] = 0xff & lo, set[4] = 0xff & hi, hi >>= 8, set[3] = 0xff & hi, hi >>= 8, set[2] = 0xff & hi, hi >>= 8, set[1] = 0xff & hi, buf.push(set);
+            set[8] = 0xff & lo, lo >>= 8, set[7] = 0xff & lo, lo >>= 8, set[6] = 0xff & lo, lo >>= 8, set[5] = 0xff & lo, set[4] = 0xff & hi, hi >>= 8, set[3] = 0xff & hi, hi >>= 8, set[2] = 0xff & hi, hi >>= 8, set[1] = 0xff & hi, writer.push(set);
         } else throw Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`);
     }
 }
-function encodeNegint(buf, token) {
+function encodeNegint(writer, token) {
     let negint = token.value;
-    encodeUintValue(buf, token.type.majorEncoded, 'bigint' == typeof negint ? negint * neg1b - pos1b : -1 * negint - 1);
+    encodeUintValue(writer, token.type.majorEncoded, 'bigint' == typeof negint ? negint * neg1b - pos1b : -1 * negint - 1);
 }
 function toToken(data, pos, prefix, length) {
     assertEnoughData(data, pos, prefix + length);
-    let buf = byte_utils_slice(data, pos + prefix, pos + prefix + length);
+    let buf = data.slice(pos + prefix, pos + prefix + length);
     return new Token(Type.bytes, buf, prefix + length);
 }
 function decodeBytesCompact(data, pos, minor) {
     return toToken(data, pos, 1, minor);
 }
 function tokenBytes(token) {
-    return void 0 === token.encodedBytes && (token.encodedBytes = token.type === Type.string ? byte_utils_fromString(token.value) : token.value), token.encodedBytes;
+    return void 0 === token.encodedBytes && (token.encodedBytes = Type.equals(token.type, Type.string) ? byte_utils_fromString(token.value) : token.value), token.encodedBytes;
 }
-function encodeBytes(buf, token) {
+function encodeBytes(writer, token) {
     let bytes = tokenBytes(token);
-    encodeUintValue(buf, token.type.majorEncoded, bytes.length), buf.push(bytes);
+    encodeUintValue(writer, token.type.majorEncoded, bytes.length), writer.push(bytes);
 }
 function _3string_toToken(data, pos, prefix, length, options) {
     let totLength = prefix + length;
     assertEnoughData(data, pos, totLength);
-    let tok = new Token(Type.string, byte_utils_toString(data, pos + prefix, pos + totLength), totLength);
-    return !0 === options.retainStringBytes && (tok.byteValue = byte_utils_slice(data, pos + prefix, pos + totLength)), tok;
+    let tok = new Token(Type.string, function(bytes, start, end) {
+        if (end - start < ASCII_THRESHOLD) {
+            let str = '';
+            for(let i = start; i < end; i++){
+                let c = bytes[i];
+                if (0x80 & c) return textDecoder.decode(bytes.subarray(start, end));
+                str += String.fromCharCode(c);
+            }
+            return str;
+        }
+        return textDecoder.decode(bytes.subarray(start, end));
+    }(data, pos + prefix, pos + totLength), totLength);
+    return !0 === options.retainStringBytes && (tok.byteValue = data.slice(pos + prefix, pos + totLength)), tok;
 }
 function decodeStringCompact(data, pos, minor, options) {
     return _3string_toToken(data, pos, 1, minor, options);
@@ -979,8 +975,8 @@ function _4array_toToken(_data, _pos, prefix, length) {
 function decodeArrayCompact(data, pos, minor) {
     return _4array_toToken(data, pos, 1, minor);
 }
-function encodeArray(buf, token) {
-    encodeUintValue(buf, Type.array.majorEncoded, token.value);
+function encodeArray(writer, token) {
+    encodeUintValue(writer, Type.array.majorEncoded, token.value);
 }
 function _5map_toToken(_data, _pos, prefix, length) {
     return new Token(Type.map, length, prefix);
@@ -988,14 +984,14 @@ function _5map_toToken(_data, _pos, prefix, length) {
 function decodeMapCompact(data, pos, minor) {
     return _5map_toToken(data, pos, 1, minor);
 }
-function encodeMap(buf, token) {
-    encodeUintValue(buf, Type.map.majorEncoded, token.value);
+function encodeMap(writer, token) {
+    encodeUintValue(writer, Type.map.majorEncoded, token.value);
 }
 function decodeTagCompact(_data, _pos, minor) {
     return new Token(Type.tag, minor, 1);
 }
-function encodeTag(buf, token) {
-    encodeUintValue(buf, Type.tag.majorEncoded, token.value);
+function encodeTag(writer, token) {
+    encodeUintValue(writer, Type.tag.majorEncoded, token.value);
 }
 function createToken(value, bytes, options) {
     if (options) {
@@ -1004,24 +1000,24 @@ function createToken(value, bytes, options) {
     }
     return new Token(Type.float, value, bytes);
 }
-function encodeFloat(buf, token, options) {
+function encodeFloat(writer, token, options) {
     let float = token.value;
-    if (!1 === float) buf.push([
+    if (!1 === float) writer.push([
         Type.float.majorEncoded | MINOR_FALSE
     ]);
-    else if (!0 === float) buf.push([
+    else if (!0 === float) writer.push([
         Type.float.majorEncoded | MINOR_TRUE
     ]);
-    else if (null === float) buf.push([
+    else if (null === float) writer.push([
         Type.float.majorEncoded | MINOR_NULL
     ]);
-    else if (void 0 === float) buf.push([
+    else if (void 0 === float) writer.push([
         Type.float.majorEncoded | MINOR_UNDEFINED
     ]);
     else {
         var inp;
         let success = !1;
-        options && !0 === options.float64 || (encodeFloat16(float), float === readFloat16(_7float_ui8a, 1) || Number.isNaN(float) ? (_7float_ui8a[0] = 0xf9, buf.push(_7float_ui8a.slice(0, 3)), success = !0) : (encodeFloat32(float), float === readFloat32(_7float_ui8a, 1) && (_7float_ui8a[0] = 0xfa, buf.push(_7float_ui8a.slice(0, 5)), success = !0))), success || (inp = float, _7float_dataView.setFloat64(0, inp, !1), readFloat64(_7float_ui8a, 1), _7float_ui8a[0] = 0xfb, buf.push(_7float_ui8a.slice(0, 9)));
+        options && !0 === options.float64 || (encodeFloat16(float), float === readFloat16(_7float_ui8a, 1) || Number.isNaN(float) ? (_7float_ui8a[0] = 0xf9, writer.push(_7float_ui8a.slice(0, 3)), success = !0) : (encodeFloat32(float), float === readFloat32(_7float_ui8a, 1) && (_7float_ui8a[0] = 0xfa, writer.push(_7float_ui8a.slice(0, 5)), success = !0))), success || (inp = float, _7float_dataView.setFloat64(0, inp, !1), readFloat64(_7float_ui8a, 1), _7float_ui8a[0] = 0xfb, writer.push(_7float_ui8a.slice(0, 9)));
     }
 }
 function encodeFloat16(inp) {
@@ -1120,22 +1116,7 @@ function makeCborEncoders() {
     return encoders[Type.uint.major] = encodeUint, encoders[Type.negint.major] = encodeNegint, encoders[Type.bytes.major] = encodeBytes, encoders[Type.string.major] = encodeString, encoders[Type.array.major] = encodeArray, encoders[Type.map.major] = encodeMap, encoders[Type.tag.major] = encodeTag, encoders[Type.float.major] = encodeFloat, encoders;
 }
 function encode_objectToTokens(obj, options = {}, refStack) {
-    let typ = function(value) {
-        var value1;
-        if (null === value) return 'null';
-        if (void 0 === value) return 'undefined';
-        if (!0 === value || !1 === value) return 'boolean';
-        let typeOf = typeof value;
-        if (typeofs.includes(typeOf)) return typeOf;
-        if ('function' === typeOf) return 'Function';
-        if (Array.isArray(value)) return 'Array';
-        if ((value1 = value) && value1.constructor && value1.constructor.isBuffer && value1.constructor.isBuffer.call(null, value1)) return 'Buffer';
-        let objectType = function(value) {
-            let objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
-            if (objectTypeNames.includes(objectTypeName)) return objectTypeName;
-        }(value);
-        return objectType || 'Object';
-    }(obj), customTypeEncoder = options && options.typeEncoders && options.typeEncoders[typ] || typeEncoders[typ];
+    let typ = is_is(obj), customTypeEncoder = options && options.typeEncoders && options.typeEncoders[typ] || typeEncoders[typ];
     if ('function' == typeof customTypeEncoder) {
         let tokens = customTypeEncoder(obj, typ, options, refStack);
         if (null != tokens) return tokens;
@@ -1144,35 +1125,91 @@ function encode_objectToTokens(obj, options = {}, refStack) {
     if (!typeEncoder) throw Error(`${encodeErrPrefix} unsupported type: ${typ}`);
     return typeEncoder(obj, typ, options, refStack);
 }
-function encodeCustom(data, encoders, options) {
-    let tokens = encode_objectToTokens(data, options);
+function tokensToEncoded(writer, tokens, encoders, options) {
+    if (Array.isArray(tokens)) for (let token of tokens)tokensToEncoded(writer, token, encoders, options);
+    else encoders[tokens.type.major](writer, tokens, options);
+}
+function encodeCustom(data, encoders, options, destination) {
+    let hasDest = destination instanceof Uint8Array, writeTo = hasDest ? new bl_U8Bl(destination) : defaultWriter, tokens = encode_objectToTokens(data, options);
     if (!Array.isArray(tokens) && options.quickEncodeToken) {
         let quickBytes = options.quickEncodeToken(tokens);
-        if (quickBytes) return quickBytes;
+        if (quickBytes) return hasDest ? (writeTo.push(quickBytes), writeTo.toBytes()) : quickBytes;
         let encoder = encoders[tokens.type.major];
         if (encoder.encodedSize) {
-            let buf = new bl_Bl(encoder.encodedSize(tokens, options));
-            if (encoder(buf, tokens, options), 1 !== buf.chunks.length) throw Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
-            return asU8A(buf.chunks[0]);
+            let size = encoder.encodedSize(tokens, options);
+            if (hasDest || (writeTo = new bl_Bl(size)), encoder(writeTo, tokens, options), 1 !== writeTo.chunks.length) throw Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
+            return hasDest ? writeTo.toBytes() : asU8A(writeTo.chunks[0]);
         }
     }
-    return encode_buf.reset(), !function tokensToEncoded(buf, tokens, encoders, options) {
-        if (Array.isArray(tokens)) for (let token of tokens)tokensToEncoded(buf, token, encoders, options);
-        else encoders[tokens.type.major](buf, tokens, options);
-    }(encode_buf, tokens, encoders, options), encode_buf.toBytes(!0);
+    return writeTo.reset(), tokensToEncoded(writeTo, tokens, encoders, options), writeTo.toBytes(!0);
 }
 function encode_encode(data, options) {
-    return encodeCustom(data, cborEncoders, options = Object.assign({}, defaultEncodeOptions, options));
+    return !0 !== (options = Object.assign({}, defaultEncodeOptions, options)).addBreakTokens ? (defaultWriter.reset(), !function directEncode(writer, data, options, refStack) {
+        let typ = is_is(data), customEncoder = options.typeEncoders && options.typeEncoders[typ];
+        if (customEncoder) {
+            let tokens = customEncoder(data, typ, options, refStack);
+            if (null != tokens) return void tokensToEncoded(writer, tokens, cborEncoders, options);
+        }
+        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':
+                Number.isInteger(data) && Number.isSafeInteger(data) ? data >= 0 ? encodeUintValue(writer, MAJOR_UINT, data) : encodeUintValue(writer, MAJOR_NEGINT, -1 * data - 1) : encodeFloat(writer, new Token(Type.float, data), options);
+                return;
+            case 'bigint':
+                data >= BigInt(0) ? encodeUintValue(writer, MAJOR_UINT, data) : encodeUintValue(writer, MAJOR_NEGINT, data * encode_neg1b - encode_pos1b);
+                return;
+            case 'string':
+                {
+                    let bytes = byte_utils_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) return void writer.push([
+                    MAJOR_ARRAY
+                ]);
+                for (let elem of (refStack = Ref.createCheck(refStack, data), encodeUintValue(writer, MAJOR_ARRAY, data.length), data))directEncode(writer, elem, options, refStack);
+                return;
+            case 'Object':
+            case 'Map':
+                tokensToEncoded(writer, typeEncoders.Object(data, typ, options, refStack), cborEncoders, options);
+                return;
+            default:
+                {
+                    let typeEncoder = typeEncoders[typ];
+                    if (!typeEncoder) throw Error(`${encodeErrPrefix} unsupported type: ${typ}`);
+                    tokensToEncoded(writer, typeEncoder(data, typ, options, refStack), cborEncoders, options);
+                }
+        }
+    }(defaultWriter, data, options, void 0), defaultWriter.toBytes(!0)) : encodeCustom(data, cborEncoders, options);
 }
 function decode_decode(data, options) {
     let [decoded, remainder] = function(data, options) {
         if (!(data instanceof Uint8Array)) throw Error(`${decodeErrPrefix} data to decode must be a Uint8Array`);
-        let tokeniser = (options = Object.assign({}, defaultDecodeOptions, options)).tokenizer || new Tokeniser(data, options), decoded = function tokensToObject(tokeniser, options) {
+        options = Object.assign({}, defaultDecodeOptions, options);
+        let u8aData = asU8A(data), tokeniser = options.tokenizer || new Tokeniser(u8aData, options), decoded = function tokensToObject(tokeniser, options) {
             if (tokeniser.done()) return DONE;
             let token = tokeniser.next();
-            if (token.type === Type.break) return 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)) {
                 let arr = [];
                 for(let i = 0; i < token.value; i++){
                     let value = tokensToObject(tokeniser, options);
@@ -1185,8 +1222,8 @@ function decode_decode(data, options) {
                 }
                 return arr;
             }
-            if (token.type === Type.map) return function(token, tokeniser, options) {
-                let useMaps = !0 === options.useMaps, obj = useMaps ? void 0 : {}, m = useMaps ? new Map() : void 0;
+            if (Type.equals(token.type, Type.map)) return function(token, tokeniser, options) {
+                let useMaps = !0 === options.useMaps, rejectDuplicateMapKeys = !0 === options.rejectDuplicateMapKeys, obj = useMaps ? void 0 : {}, m = useMaps ? new Map() : void 0;
                 for(let i = 0; i < token.value; i++){
                     let key = tokensToObject(tokeniser, options);
                     if (key === BREAK) {
@@ -1194,15 +1231,15 @@ function decode_decode(data, options) {
                         throw Error(`${decodeErrPrefix} got unexpected break to lengthed map`);
                     }
                     if (key === DONE) throw Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
-                    if (!0 !== useMaps && 'string' != typeof key) throw Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`);
-                    if (!0 === options.rejectDuplicateMapKeys && (useMaps && m.has(key) || !useMaps && key in obj)) throw Error(`${decodeErrPrefix} found repeat map key "${key}"`);
+                    if (!useMaps && 'string' != typeof key) throw Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`);
+                    if (rejectDuplicateMapKeys && (useMaps && m.has(key) || !useMaps && Object.hasOwn(obj, key))) throw Error(`${decodeErrPrefix} found repeat map key "${key}"`);
                     let value = tokensToObject(tokeniser, options);
                     if (value === DONE) throw Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
                     useMaps ? m.set(key, value) : obj[key] = value;
                 }
                 return useMaps ? m : obj;
             }(token, tokeniser, options);
-            if (token.type === Type.tag) {
+            if (Type.equals(token.type, Type.tag)) {
                 if (options.tags && 'function' == typeof options.tags[token.value]) {
                     let tagged = tokensToObject(tokeniser, options);
                     return options.tags[token.value](tagged);
@@ -8553,21 +8590,7 @@ class digest_Digest {
 let node_digest = (payload)=>{
     let digest = new Uint8Array(digest_prefix.length + 32);
     return digest.set(digest_prefix, 0), digest.set(__rspack_external_node_crypto_9ba42079.default.createHash('sha256').update(payload).digest(), digest_prefix.length), new digest_Digest(digest);
-}, sha256_code = 18, typeofs = [
-    'string',
-    'number',
-    'bigint',
-    'symbol'
-], objectTypeNames = [
-    'Function',
-    'Generator',
-    'AsyncGenerator',
-    'GeneratorFunction',
-    'AsyncGeneratorFunction',
-    'AsyncFunction',
-    'Observable',
-    'Array',
-    'Buffer',
+}, sha256_code = 18, objectTypeNames = [
     'Object',
     'RegExp',
     'Date',
@@ -8583,7 +8606,6 @@ let node_digest = (payload)=>{
     'URL',
     'HTMLElement',
     'Int8Array',
-    'Uint8Array',
     'Uint8ClampedArray',
     'Int16Array',
     'Uint16Array',
@@ -8604,6 +8626,9 @@ class Type {
     compare(typ) {
         return this.major < typ.major ? -1 : +(this.major > typ.major);
     }
+    static equals(a, b) {
+        return a === b || a.major === b.major && a.name === b.name;
+    }
 }
 Type.uint = new Type(0, 'uint', !0), Type.negint = new Type(1, 'negint', !0), Type.bytes = new Type(2, 'bytes', !0), Type.string = new Type(3, 'string', !0), Type.array = new Type(4, 'array', !1), Type.map = new Type(5, 'map', !1), Type.tag = new Type(6, 'tag', !1), Type.float = new Type(7, 'float', !0), Type.false = new Type(7, 'false', !0), Type.true = new Type(7, 'true', !0), Type.null = new Type(7, 'null', !0), Type.undefined = new Type(7, 'undefined', !0), Type.break = new Type(7, 'break', !0);
 class Token {
@@ -8614,11 +8639,11 @@ class Token {
         return `Token[${this.type}].${this.value}`;
     }
 }
-let useBuffer = globalThis.process && !globalThis.process.browser && globalThis.Buffer && 'function' == typeof globalThis.Buffer.isBuffer, textDecoder = new TextDecoder(), textEncoder = new TextEncoder(), byte_utils_toString = useBuffer ? (bytes, start, end)=>end - start > 64 ? globalThis.Buffer.from(bytes.subarray(start, end)).toString('utf8') : utf8Slice(bytes, start, end) : (bytes, start, end)=>end - start > 64 ? textDecoder.decode(bytes.subarray(start, end)) : utf8Slice(bytes, start, end), byte_utils_fromString = useBuffer ? (string)=>string.length > 64 ? globalThis.Buffer.from(string) : byte_utils_utf8ToBytes(string) : (string)=>string.length > 64 ? textEncoder.encode(string) : byte_utils_utf8ToBytes(string), byte_utils_fromArray = (arr)=>Uint8Array.from(arr), byte_utils_slice = useBuffer ? (bytes, start, end)=>byte_utils_isBuffer(bytes) ? new Uint8Array(bytes.subarray(start, end)) : bytes.slice(start, end) : (bytes, start, end)=>bytes.slice(start, end), byte_utils_concat = useBuffer ? (chunks, length)=>(chunks = chunks.map((c)=>c instanceof Uint8Array ? c : globalThis.Buffer.from(c)), asU8A(globalThis.Buffer.concat(chunks, length))) : (chunks, length)=>{
+let useBuffer = globalThis.process && !globalThis.process.browser && globalThis.Buffer && 'function' == typeof globalThis.Buffer.isBuffer, textEncoder = new TextEncoder(), byte_utils_fromString = useBuffer ? (string)=>string.length >= 24 ? globalThis.Buffer.from(string) : byte_utils_utf8ToBytes(string) : (string)=>string.length >= 200 ? textEncoder.encode(string) : byte_utils_utf8ToBytes(string), byte_utils_fromArray = (arr)=>Uint8Array.from(arr), byte_utils_slice = useBuffer ? (bytes, start, end)=>isBuffer(bytes) ? new Uint8Array(bytes.subarray(start, end)) : bytes.slice(start, end) : (bytes, start, end)=>bytes.slice(start, end), byte_utils_concat = useBuffer ? (chunks, length)=>(chunks = chunks.map((c)=>c instanceof Uint8Array ? c : globalThis.Buffer.from(c)), asU8A(globalThis.Buffer.concat(chunks, length))) : (chunks, length)=>{
     let out = new Uint8Array(length), off = 0;
     for (let b of chunks)off + b.length > out.length && (b = b.subarray(0, out.length - off)), out.set(b, off), off += b.length;
     return out;
-}, alloc = useBuffer ? (size)=>globalThis.Buffer.allocUnsafe(size) : (size)=>new Uint8Array(size), MAX_ARGUMENTS_LENGTH = 0x1000;
+}, alloc = useBuffer ? (size)=>globalThis.Buffer.allocUnsafe(size) : (size)=>new Uint8Array(size);
 class bl_Bl {
     constructor(chunkSize = 256){
         this.chunkSize = chunkSize, this.cursor = 0, this.maxCursor = -1, this.chunks = [], this._initReuseChunk = null;
@@ -8649,6 +8674,24 @@ class bl_Bl {
         return reset && this.reset(), byts;
     }
 }
+class bl_U8Bl {
+    constructor(dest){
+        this.dest = dest, this.cursor = 0, this.chunks = [
+            dest
+        ];
+    }
+    reset() {
+        this.cursor = 0;
+    }
+    push(bytes) {
+        if (this.cursor + bytes.length > this.dest.length) throw Error('write out of bounds, destination buffer is too small');
+        this.dest.set(bytes, this.cursor), this.cursor += bytes.length;
+    }
+    toBytes(reset = !1) {
+        let byts = this.dest.subarray(0, this.cursor);
+        return reset && this.reset(), byts;
+    }
+}
 let decodeErrPrefix = 'CBOR decode error:', encodeErrPrefix = 'CBOR encode error:', uintMinorPrefixBytes = [];
 uintMinorPrefixBytes[23] = 1, uintMinorPrefixBytes[24] = 2, uintMinorPrefixBytes[25] = 3, uintMinorPrefixBytes[26] = 5, uintMinorPrefixBytes[27] = 9;
 let uintBoundaries = [
@@ -8678,7 +8721,7 @@ encodeNegint.encodedSize = function(token) {
     var b1, b2;
     return b1 = tokenBytes(tok1), b2 = tokenBytes(tok2), b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare(b1, b2);
 };
-let encodeString = encodeBytes;
+let textDecoder = new TextDecoder(), ASCII_THRESHOLD = 32, encodeString = encodeBytes;
 encodeArray.compareTokens = encodeUint.compareTokens, encodeArray.encodedSize = function(token) {
     return encodeUintValue.encodedSize(token.value);
 }, encodeMap.compareTokens = encodeUint.compareTokens, encodeMap.encodedSize = function(token) {
@@ -8828,7 +8871,7 @@ let defaultEncodeOptions = {
         throw Error('rfc8949MapSorter: complex key types are not supported yet');
     },
     quickEncodeToken: quickEncodeToken
-}), cborEncoders = makeCborEncoders(), encode_buf = new bl_Bl();
+}), cborEncoders = makeCborEncoders(), defaultWriter = new bl_Bl();
 class Ref {
     constructor(obj, parent){
         this.obj = obj, this.parent = parent;
@@ -8879,29 +8922,35 @@ let simpleTokens = {
         ];
     },
     Object (obj, typ, options, refStack) {
-        let isMap = 'Object' !== typ, keys = isMap ? obj.keys() : Object.keys(obj), length = isMap ? obj.size : keys.length;
-        if (!length) return !0 === options.addBreakTokens ? [
+        var entries;
+        let entries1, isMap = 'Object' !== typ, keys = isMap ? obj.keys() : Object.keys(obj), maxLength = isMap ? obj.size : keys.length;
+        if (maxLength) {
+            entries1 = Array(maxLength), refStack = Ref.createCheck(refStack, obj);
+            let skipUndefined = !isMap && options.ignoreUndefinedProperties, i = 0;
+            for (let key of keys){
+                let value = isMap ? obj.get(key) : obj[key];
+                skipUndefined && void 0 === value || (entries1[i++] = [
+                    encode_objectToTokens(key, options, refStack),
+                    encode_objectToTokens(value, options, refStack)
+                ]);
+            }
+            i < maxLength && (entries1.length = i);
+        }
+        return entries1?.length ? (entries = entries1, options.mapSorter && entries.sort(options.mapSorter), options.addBreakTokens) ? [
+            new Token(Type.map, entries1.length),
+            entries1,
+            new Token(Type.break)
+        ] : [
+            new Token(Type.map, entries1.length),
+            entries1
+        ] : !0 === options.addBreakTokens ? [
             simpleTokens.emptyMap,
             new Token(Type.break)
         ] : simpleTokens.emptyMap;
-        refStack = Ref.createCheck(refStack, obj);
-        let entries = [], i = 0;
-        for (let key of keys)entries[i++] = [
-            encode_objectToTokens(key, options, refStack),
-            encode_objectToTokens(isMap ? obj.get(key) : obj[key], options, refStack)
-        ];
-        return (options.mapSorter && entries.sort(options.mapSorter), options.addBreakTokens) ? [
-            new Token(Type.map, length),
-            entries,
-            new Token(Type.break)
-        ] : [
-            new Token(Type.map, length),
-            entries
-        ];
     }
 };
 for (let typ of (typeEncoders.Map = typeEncoders.Object, typeEncoders.Buffer = typeEncoders.Uint8Array, 'Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64'.split(' ')))typeEncoders[`${typ}Array`] = typeEncoders.DataView;
-let defaultDecodeOptions = {
+let MAJOR_UINT = Type.uint.majorEncoded, MAJOR_NEGINT = Type.negint.majorEncoded, MAJOR_BYTES = Type.bytes.majorEncoded, MAJOR_STRING = Type.string.majorEncoded, MAJOR_ARRAY = Type.array.majorEncoded, SIMPLE_FALSE = Type.float.majorEncoded | MINOR_FALSE, SIMPLE_TRUE = Type.float.majorEncoded | MINOR_TRUE, SIMPLE_NULL = Type.float.majorEncoded | MINOR_NULL, SIMPLE_UNDEFINED = Type.float.majorEncoded | MINOR_UNDEFINED, encode_neg1b = BigInt(-1), encode_pos1b = BigInt(1), defaultDecodeOptions = {
     strict: !1,
     allowIndefinite: !0,
     allowUndefined: !0,
@@ -10239,7 +10288,7 @@ let filecoinMainnet = {
             address: '0xf55dDbf63F1b55c3F1D4FA7e339a68AB7b64A5eB'
         },
         storageView: {
-            address: '0x9e4e6699d8F67dFc883d6b0A7344Bd56F7E80B46'
+            address: '0x638a4986332bF9B889E5D7435B966C5ecdE077Fa'
         }
     },
     blockExplorer: 'https://filecoin.blockscout.com'
@@ -10263,7 +10312,7 @@ let filecoinMainnet = {
             address: '0x839e5c9988e4e9977d40708d0094103c0839Ac9D'
         },
         storageView: {
-            address: '0xA5D87b04086B1d591026cCE10255351B5AA4689B'
+            address: '0x53d235D474585EC102ccaB7e0cdcE951dD00f716'
         }
     },
     blockExplorer: 'https://filecoin-testnet.blockscout.com'
@@ -12697,8 +12746,24 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', estimateGas = a
     return logger.info(`Pending piece upload: ${statusUrl}`), logger.info(`Pending transaction: ${chain.blockExplorer}/tx/${hash}`), await waitForTransaction(filProvider[chainId], hash), {
         cid
     };
-}, lighthouse_providerName = 'Lighthouse', pinOnLighthouse = async ({ first, token, verbose, cid })=>{
-    if (first) throw new UploadNotSupportedError(lighthouse_providerName);
+}, lighthouse_providerName = 'Lighthouse', uploadOnLighthouse = async ({ car, name, first, token, verbose, cid })=>{
+    if (first) {
+        let fd = new FormData();
+        fd.append('file', car, `${name}.car`);
+        let res = await fetch('https://upload.lighthouse.storage/api/v0/dag/import', {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`
+            },
+            body: fd
+        });
+        verbose && logger.request('POST', res.url, res.status);
+        let json = await res.json();
+        if (!res.ok) throw new DeployError(lighthouse_providerName, json.error?.message || json.message || 'Unknown error');
+        return {
+            cid: json.data?.Hash || cid
+        };
+    }
     let res = await fetch('https://api.lighthouse.storage/api/lighthouse/pin', {
         method: 'POST',
         headers: {
@@ -13481,9 +13546,9 @@ class JSONEncoder extends Array {
     }
     prefix(buf) {
         let recurs = this.inRecursive[this.inRecursive.length - 1];
-        recurs && (recurs.type === Type.array && (recurs.elements++, 1 !== recurs.elements && buf.push([
+        recurs && (Type.equals(recurs.type, Type.array) && (recurs.elements++, 1 !== recurs.elements && buf.push([
             44
-        ])), recurs.type === Type.map && (recurs.elements++, 1 !== recurs.elements && (recurs.elements % 2 == 1 ? buf.push([
+        ])), Type.equals(recurs.type, Type.map) && (recurs.elements++, 1 !== recurs.elements && (recurs.elements % 2 == 1 ? buf.push([
             44
         ]) : buf.push([
             58
@@ -13527,10 +13592,10 @@ class JSONEncoder extends Array {
         if ('break' === token.type.name) {
             let recurs = this.inRecursive.pop();
             if (recurs) {
-                if (recurs.type === Type.array) buf.push([
+                if (Type.equals(recurs.type, Type.array)) buf.push([
                     93
                 ]);
-                else if (recurs.type === Type.map) buf.push([
+                else if (Type.equals(recurs.type, Type.map)) buf.push([
                     125
                 ]);
                 else throw Error('Unexpected recursive type; this should not happen!');
@@ -13730,7 +13795,13 @@ class Tokenizer {
                     }
                     break;
                 case 34:
-                    return this._pos++, new Token(Type.string, decodeCodePointsArray(chars), this._pos - startPos);
+                    return this._pos++, new Token(Type.string, function(codePoints) {
+                        let len = codePoints.length;
+                        if (len <= 0x1000) return String.fromCharCode.apply(String, codePoints);
+                        let res = '', i = 0;
+                        for(; i < len;)res += String.fromCharCode.apply(String, codePoints.slice(i, i += 0x1000));
+                        return res;
+                    }(chars), this._pos - startPos);
                 default:
                     if (ch < 32) throw Error(`${decodeErrPrefix} invalid control character at position ${this._pos}`);
                     ch < 0x80 ? (chars.push(ch), this._pos++) : readUtf8Char();
@@ -13865,20 +13936,24 @@ class DagJsonTokenizer extends Tokenizer {
     }
     next() {
         let token = this._next();
-        if (token.type === Type.map) {
+        if (Type.equals(token.type, Type.map)) {
             let keyToken = this._next();
-            if (keyToken.type === Type.string && '/' === keyToken.value) {
+            if (Type.equals(keyToken.type, Type.string) && '/' === keyToken.value) {
                 let valueToken = this._next();
-                if (valueToken.type === Type.string) {
-                    if (this._next().type !== Type.break) throw Error('Invalid encoded CID form');
+                if (Type.equals(valueToken.type, Type.string)) {
+                    let breakToken = this._next();
+                    if (!Type.equals(breakToken.type, Type.break)) throw Error('Invalid encoded CID form');
                     return this.tokenBuffer.push(valueToken), new Token(Type.tag, 42, 0);
                 }
-                if (valueToken.type === Type.map) {
+                if (Type.equals(valueToken.type, Type.map)) {
                     let innerKeyToken = this._next();
-                    if (innerKeyToken.type === Type.string && 'bytes' === innerKeyToken.value) {
+                    if (Type.equals(innerKeyToken.type, Type.string) && 'bytes' === innerKeyToken.value) {
                         let innerValueToken = this._next();
-                        if (innerValueToken.type === Type.string) {
-                            for(let i = 0; i < 2; i++)if (this._next().type !== Type.break) throw Error('Invalid encoded Bytes form');
+                        if (Type.equals(innerValueToken.type, Type.string)) {
+                            for(let i = 0; i < 2; i++){
+                                let breakToken = this._next();
+                                if (!Type.equals(breakToken.type, Type.break)) throw Error('Invalid encoded Bytes form');
+                            }
                             let bytes = base64.decode(`m${innerValueToken.value}`);
                             return new Token(Type.bytes, bytes, innerValueToken.value.length);
                         }
@@ -17543,7 +17618,8 @@ let uploadCAR = async (conf, car)=>{
 }, storacha_abilities = [
     'space/blob/add',
     'space/index/add',
-    'upload/add'
+    'upload/add',
+    'filecoin/offer'
 ], referenceToCID = (ref)=>{
     var multihash;
     let codeOffset, hashOffset, bytes;
@@ -17626,8 +17702,8 @@ let uploadCAR = async (conf, car)=>{
     },
     LIGHTHOUSE_TOKEN: {
         name: 'Lighthouse',
-        upload: pinOnLighthouse,
-        supported: 'pin',
+        upload: uploadOnLighthouse,
+        supported: 'both',
         protocol: 'ipfs'
     },
     SWARMY_TOKEN: {
@@ -20930,7 +21006,7 @@ let ENS_DEPLOYER_ROLE = keccak256(Bytes_fromString('ENS_DEPLOYER')), execTransac
             if (!(attempt < maxRetries)) return logger.error(gwOfflineMessage);
             logger.text(`🔄 Retrying in ${retryInterval / 1000} seconds...`), await promises_setTimeout(retryInterval);
         } catch (error) {
-            if (error instanceof DOMException && attempt < maxRetries) logger.info(`⌛ Timed out. Retrying...`), await promises_setTimeout(retryInterval);
+            if (error instanceof DOMException && attempt < maxRetries) logger.info("⌛ Timed out. Retrying..."), await promises_setTimeout(retryInterval);
             else throw logger.error(error instanceof DOMException ? gwOfflineMessage : `Error fetching endpoint: ${error.message}`), error;
         }
     }

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "omnipin",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "author": "v1rtl <hi@v1rtl.site>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/omnipin/omnipin.git"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.11",
+    "@biomejs/biome": "^2.3.13",
     "@ipld/car": "^5.4.2",
     "@ipld/dag-ucan": "^3.4.5",
-    "@rslib/core": "^0.19.1",
+    "@rslib/core": "^0.19.4",
     "@size-limit/file": "^11.2.0",
     "@stauro/filebase-upload": "npm:@jsr/stauro__filebase-upload",
     "@storacha/capabilities": "^1.12.0",
-    "@types/bun": "^1.3.5",
+    "@types/bun": "^1.3.8",
     "@types/varint": "^6.0.3",
     "@ucanto/client": "^9.0.2",
     "@ucanto/core": "^10.4.6",
     "@ucanto/principal": "^9.0.3",
     "@ucanto/transport": "^9.2.1",
     "@web3-storage/data-segment": "^5.3.0",
-    "cborg": "^4.3.2",
+    "cborg": "^4.5.8",
     "esbuild": "^0.27.2",
     "ipfs-unixfs": "^12.0.0",
     "ipfs-unixfs-importer": "^16.0.2",
@@ -55,7 +55,6 @@
   ],
   "license": "MIT",
   "overrides": {
-    "@multiformats/murmur3": "npm:@omnipin/multiformats-murmur3@2.2.0",
     "multiformats": "13.4.2"
   },
   "release": {