@leofcoin/workers 1.5.40 → 1.5.41

package/exports/browser/{worker-DMCj1e6z.js → worker-BDTWOCzS.js}

@@ -355,16 +355,16 @@ const ALPHABET$3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 const ALPHABET_HEX$1 = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
 const base32 = base(ALPHABET$3);
 const base32Hex = base(ALPHABET_HEX$1);
-const decode$3 = base32.decode;
+const decode$2 = base32.decode;
 const decodeHex$1 = base32Hex.decode;
-const encode$3 = base32.encode;
+const encode$2 = base32.encode;
 const encodeHex$1 = base32Hex.encode;
 const isBase32 = (string, hex = false) => {
     try {
         if (hex)
             decodeHex$1(string);
         else
-            decode$3(string);
+            decode$2(string);
         return true;
     }
     catch (e) {
@@ -374,9 +374,9 @@ const isBase32 = (string, hex = false) => {
 const isBase32Hex = (string) => {
     return isBase32(string, true);
 };
-var index$5 = {
-    encode: encode$3,
-    decode: decode$3,
+var index$4 = {
+    encode: encode$2,
+    decode: decode$2,
     encodeHex: encodeHex$1,
     decodeHex: decodeHex$1,
     isBase32,
@@ -387,13 +387,13 @@ const ALPHABET$2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 const ALPHABET_HEX = "0123456789ABCDEFGHJKLMNPQRSTUVabcdefghijklmnopqrstuv";
 const base58 = base(ALPHABET$2);
 const base58Hex = base(ALPHABET_HEX);
-const encode$2 = base58.encode;
-const decode$2 = base58.decode;
+const encode$1 = base58.encode;
+const decode$1 = base58.decode;
 const encodeHex = base58Hex.encode;
 const decodeHex = base58Hex.decode;
 const isBase58 = (string) => {
     try {
-        decode$2(string);
+        decode$1(string);
         return true;
     }
     catch (e) {
@@ -411,7 +411,7 @@ const isBase58Hex = (string) => {
 };
 const whatType = (string) => {
     try {
-        decode$2(string);
+        decode$1(string);
         return "base58";
     }
     catch (e) {
@@ -425,8 +425,8 @@ const whatType = (string) => {
     }
 };
 var base58$1 = {
-    encode: encode$2,
-    decode: decode$2,
+    encode: encode$1,
+    decode: decode$1,
     isBase58,
     isBase58Hex,
     encodeHex,
@@ -440,100 +440,228 @@ var isHex = string => /^[A-F0-9]+$/i.test(
   string
 );
 
-const MSB$1 = 0x80;
-const MSBALL = -128;
-const INT = Math.pow(2, 31);
-const encode$1 = (num, out, offset) => {
-    if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-        encode$1.bytes = 0;
-        throw new RangeError('Could not encode varint');
-    }
-    out = out || [];
-    offset = offset || 0;
-    const oldOffset = offset;
-    while (num >= INT) {
-        out[offset++] = (num & 0xFF) | MSB$1;
-        num /= 128;
-    }
-    while (num & MSBALL) {
-        out[offset++] = (num & 0xFF) | MSB$1;
-        num >>>= 7;
-    }
-    out[offset] = num | 0;
-    encode$1.bytes = offset - oldOffset + 1;
-    return out;
-};
-
-const MSB = 0x80;
-const REST = 0x7F;
-const decode$1 = (buf, offset) => {
-    offset = offset || 0;
-    const l = buf.length;
-    let counter = offset;
-    let result = 0;
-    let shift = 0;
-    let b;
-    do {
-        if (counter >= l || shift > 49) {
-            decode$1.bytes = 0;
-            throw new RangeError('Could not decode varint');
-        }
-        b = buf[counter++];
-        result += shift < 28
-            ? (b & REST) << shift
-            : (b & REST) * Math.pow(2, shift);
-        shift += 7;
-    } while (b >= MSB);
-    decode$1.bytes = counter - offset;
-    return result;
-};
-
-const N1 = Math.pow(2, 7);
-const N2 = Math.pow(2, 14);
-const N3 = Math.pow(2, 21);
-const N4 = Math.pow(2, 28);
-const N5 = Math.pow(2, 35);
-const N6 = Math.pow(2, 42);
-const N7 = Math.pow(2, 49);
-const N8 = Math.pow(2, 56);
-const N9 = Math.pow(2, 63);
-var encodingLength = (value) => (value < N1 ? 1
-    : value < N2 ? 2
-        : value < N3 ? 3
-            : value < N4 ? 4
-                : value < N5 ? 5
-                    : value < N6 ? 6
-                        : value < N7 ? 7
-                            : value < N8 ? 8
-                                : value < N9 ? 9
-                                    : 10);
+/** @leofcoin/binary: dependency-free unsigned framing, with no global byte counters. */
+const MAX_BIGINT = (1n << 256n) - 1n;
+function size(value) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new RangeError('Expected an unsigned safe integer');
+}
+function bytes(value) {
+    if (!(value instanceof Uint8Array))
+        throw new TypeError('Expected Uint8Array');
+}
+function varUintLength(value) {
+    size(value);
+    let length = 1;
+    while (value >= 128) {
+        value = Math.floor(value / 128);
+        length++;
+    }
+    return length;
+}
+function varBigIntLength(value) {
+    if (typeof value !== 'bigint')
+        throw new TypeError('Expected BigInt');
+    if (value < 0n || value > MAX_BIGINT)
+        throw new RangeError('Expected an unsigned 256-bit integer');
+    let length = 1;
+    while (value >= 128n) {
+        value >>= 7n;
+        length++;
+    }
+    return length;
+}
+/** Fixed-capacity writer. finish() is a view; copy it before reusing/resetting the writer. */
+class BinaryWriter {
+    #buffer;
+    #position = 0;
+    constructor(capacity = 64) {
+        if (typeof capacity === 'number') {
+            size(capacity);
+            this.#buffer = new Uint8Array(capacity);
+        }
+        else {
+            bytes(capacity);
+            this.#buffer = capacity;
+        }
+    }
+    get position() {
+        return this.#position;
+    }
+    get remaining() {
+        return this.#buffer.length - this.#position;
+    }
+    #require(length) {
+        size(length);
+        if (length > this.remaining)
+            throw new RangeError('Binary output buffer is too small');
+    }
+    writeVarUint(value) {
+        this.#require(varUintLength(value));
+        this.#writeVarUint(value);
+        return this;
+    }
+    #writeVarUint(value) {
+        while (value >= 128) {
+            this.#buffer[this.#position++] = value % 128 | 128;
+            value = Math.floor(value / 128);
+        }
+        this.#buffer[this.#position++] = value;
+    }
+    writeVarBigInt(value) {
+        this.#require(varBigIntLength(value));
+        do {
+            const byte = Number(value & 127n);
+            value >>= 7n;
+            this.#buffer[this.#position++] = byte | (value ? 128 : 0);
+        } while (value);
+        return this;
+    }
+    writeBytes(value) {
+        bytes(value);
+        this.#require(value.length);
+        this.#buffer.set(value, this.#position);
+        this.#position += value.length;
+        return this;
+    }
+    writeFrame(value) {
+        bytes(value);
+        // Check the complete operation before writing its length prefix.
+        const prefixLength = varUintLength(value.length);
+        this.#require(prefixLength + value.length);
+        const prefixStart = this.#buffer.byteOffset + this.#position;
+        if (value.buffer === this.#buffer.buffer &&
+            value.byteOffset < prefixStart + prefixLength &&
+            value.byteOffset + value.length > prefixStart)
+            throw new RangeError('Frame source overlaps its length prefix');
+        this.#writeVarUint(value.length);
+        this.#buffer.set(value, this.#position);
+        this.#position += value.length;
+        return this;
+    }
+    reset() {
+        this.#position = 0;
+        return this;
+    }
+    finish(copy = false) {
+        const result = this.#buffer.subarray(0, this.#position);
+        // Buffer.slice() aliases memory; this constructor copies every Uint8Array subtype.
+        return copy ? new Uint8Array(result) : result;
+    }
+}
+/** Reads views of the original buffer. Failed operations leave the cursor unchanged. */
+class BinaryReader {
+    #buffer;
+    #position = 0;
+    constructor(buffer) {
+        bytes(buffer);
+        this.#buffer = buffer;
+    }
+    get position() {
+        return this.#position;
+    }
+    get remaining() {
+        return this.#buffer.length - this.#position;
+    }
+    readVarUint(canonical = true) {
+        let result = 0;
+        let multiplier = 1;
+        for (let index = 0; index < 8; index++) {
+            const cursor = this.#position + index;
+            if (cursor >= this.#buffer.length)
+                throw new RangeError('Truncated varint');
+            const byte = this.#buffer[cursor];
+            const payload = byte & 127;
+            if (index === 7 && payload > Math.floor((Number.MAX_SAFE_INTEGER - result) / multiplier))
+                throw new RangeError('Varint exceeds safe integer range');
+            result += payload * multiplier;
+            if (byte < 128) {
+                if (canonical && index > 0 && payload === 0)
+                    throw new RangeError('Non-canonical varint');
+                this.#position = cursor + 1;
+                return result;
+            }
+            multiplier *= 128;
+        }
+        throw new RangeError('Varint exceeds safe integer range');
+    }
+    readVarBigInt(canonical = true) {
+        let result = 0n;
+        for (let index = 0; index < 37; index++) {
+            const cursor = this.#position + index;
+            if (cursor >= this.#buffer.length)
+                throw new RangeError('Truncated varint');
+            const byte = this.#buffer[cursor];
+            result |= BigInt(byte & 127) << BigInt(index * 7);
+            if (result > MAX_BIGINT)
+                throw new RangeError('Varint exceeds 256 bits');
+            if (byte < 128) {
+                if (canonical && index > 0 && byte === 0)
+                    throw new RangeError('Non-canonical varint');
+                this.#position = cursor + 1;
+                return result;
+            }
+        }
+        throw new RangeError('Varint exceeds 256 bits');
+    }
+    readBytes(length) {
+        size(length);
+        if (length > this.remaining)
+            throw new RangeError('Truncated binary field');
+        const start = this.#position;
+        this.#position += length;
+        return this.#buffer.subarray(start, this.#position);
+    }
+    readFrame(canonical = true) {
+        const start = this.#position;
+        try {
+            return this.readBytes(this.readVarUint(canonical));
+        }
+        catch (error) {
+            this.#position = start;
+            throw error;
+        }
+    }
+}
+/** Existing smart-concat bytes, with exactly one output allocation and no prefix arrays. */
+function encodeFrames(frames, prefix) {
+    if (!Array.isArray(frames))
+        throw new TypeError('Expected an array of byte frames');
+    let length = 0;
+    for (const frame of frames) {
+        bytes(frame);
+        length += varUintLength(frame.length) + frame.length;
+        size(length);
+    }
+    const writer = new BinaryWriter(length);
+    for (const frame of frames)
+        writer.writeFrame(frame);
+    return writer.finish();
+}
+/** Iterative framing: bounded by the input length, not recursive stack depth. */
+function decodeFrames(buffer, prefixLength = 0, options = {}) {
+    const reader = new BinaryReader(buffer);
+    reader.readBytes(prefixLength);
+    const maxFrames = options.maxFrames ?? buffer.length;
+    size(maxFrames);
+    const frames = [];
+    while (reader.remaining) {
+        if (frames.length >= maxFrames)
+            throw new RangeError('Too many binary frames');
+        frames.push(reader.readFrame(options.canonical ?? true));
+    }
+    return frames;
+}
 
-var index$4 = {
-    encode: encode$1,
-    decode: decode$1,
-    encodingLength
-};
-
-var index$3 = (input, prefix) => {
-    const encodedArray = [];
-    const length = input.reduce((total, current) => {
-        const encoded = index$4.encode(current.length);
-        encodedArray.push(encoded);
-        total += current.length + encoded.length;
-        return total;
-    }, 0);
-    const typedArray = new Uint8Array(length);
-    let currentIndex = 0;
-    let index = 0;
-    for (const source of input) {
-        typedArray.set(encodedArray[index], currentIndex);
-        currentIndex += encodedArray[index].length;
-        typedArray.set(source, currentIndex);
-        currentIndex += source.length;
-        index += 1;
-    }
-    return typedArray;
+const asBytes = (source) => {
+    if (source instanceof Uint8Array)
+        return source;
+    // Keep legacy ArrayLike coercion. Typed-array callers take the zero-copy path.
+    const bytes = new Uint8Array(source.length);
+    bytes.set(source);
+    return bytes;
 };
+var index$3 = (input, prefix) => encodeFrames(input.map(asBytes));
 
 /*! pako 2.2.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -7531,22 +7659,7 @@ const encode = (proto, input, compress) => {
     return compress ? pako.deflate(index$3(set)) : index$3(set);
 };
 
-var index$2 = (typedArray, prefix) => {
-    const set = [];
-    const varintAndSub = (typedArray) => {
-        const length = index$4.decode(typedArray);
-        // remove length
-        typedArray = typedArray.subarray(index$4.decode.bytes);
-        // push value
-        set.push(typedArray.subarray(0, length));
-        // remove value
-        typedArray = typedArray.subarray(length);
-        if (typedArray.length !== 0)
-            return varintAndSub(typedArray);
-        return set;
-    };
-    return varintAndSub(typedArray);
-};
+var index$2 = (typedArray, prefix) => decodeFrames(typedArray, 0, { canonical: false });
 
 const ALPHABET$1 = '0123456789ABCDEF';
 const base16 = base(ALPHABET$1);
@@ -7584,7 +7697,7 @@ const toHex = (bytes) => bytes.reduce((string, byte) => string + byte.toString(1
 const fromArrayLike = (array) => Uint8Array.from(array);
 const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
 const fromBase58 = (string) => base58$1.decode(string);
-const toBase32 = (uint8Array) => index$5.encode(uint8Array);
+const toBase32 = (uint8Array) => index$4.encode(uint8Array);
 var index$1 = {
     toString: toString$1};
 
@@ -7684,13 +7797,13 @@ class BasicInterface {
                     this.fromBs58(value);
                 }
                 catch {
-                    if (index$5.isBase32(value))
+                    if (index$4.isBase32(value))
                         this.fromBs32(value);
                     else
                         throw new Error('Invalid base58/base32 input');
                 }
             }
-            else if (index$5.isBase32(value))
+            else if (index$4.isBase32(value))
                 this.fromBs32(value);
             else
                 this.fromString(value);
@@ -7758,13 +7871,13 @@ class BasicInterface {
         return isHex(string);
     }
     isBase32(string) {
-        return index$5.isBase32(string);
+        return index$4.isBase32(string);
     }
     isBase58(string) {
         return base58$1.isBase58(string);
     }
     fromBs32(encoded) {
-        return this.decode(index$5.decode(encoded));
+        return this.decode(index$4.decode(encoded));
     }
     fromBs58(encoded) {
         return this.decode(fromBase58(encoded));
@@ -8107,7 +8220,7 @@ class Codec extends BasicInterface {
         super();
         if (buffer) {
             if (buffer instanceof Uint8Array) {
-                const codec = index$4.decode(buffer);
+                const codec = new BinaryReader(buffer).readVarUint(false);
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
@@ -8119,11 +8232,12 @@ class Codec extends BasicInterface {
                 }
             }
             else if (buffer instanceof ArrayBuffer) {
-                const codec = index$4.decode(buffer);
+                const view = new Uint8Array(buffer);
+                const codec = new BinaryReader(view).readVarUint(false);
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
-                    this.decode(buffer);
+                    this.decode(view);
                 }
                 else {
                     this.encode(Number(new TextDecoder().decode(new Uint8Array(buffer))));
@@ -8148,7 +8262,7 @@ class Codec extends BasicInterface {
         }
     }
     fromEncoded(encoded) {
-        const codec = index$4.decode(encoded);
+        const codec = new BinaryReader(encoded).readVarUint(false);
         const name = this.getCodecName(codec);
         this.name = name;
         this.encoded = encoded;
@@ -8167,7 +8281,7 @@ class Codec extends BasicInterface {
         this.name = this.getCodecName(codec);
         this.hashAlg = this.getHashAlg(this.name);
         this.codec = this.getCodec(this.name);
-        this.codecBuffer = index$4.encode(this.codec);
+        this.codecBuffer = new BinaryWriter(varUintLength(this.codec)).writeVarUint(this.codec).finish();
         this.decoded = {
             name: this.name,
             hashAlg: this.hashAlg,
@@ -8180,7 +8294,7 @@ class Codec extends BasicInterface {
         this.name = name;
         this.codec = codec;
         this.hashAlg = this.getHashAlg(name);
-        this.codecBuffer = index$4.encode(this.codec);
+        this.codecBuffer = new BinaryWriter(varUintLength(this.codec)).writeVarUint(this.codec).finish();
         this.decoded = {
             name: this.name,
             hashAlg: this.hashAlg,
@@ -8190,13 +8304,13 @@ class Codec extends BasicInterface {
     }
     decode(encoded) {
         encoded = encoded || this.encoded;
-        const codec = index$4.decode(encoded);
+        const codec = new BinaryReader(encoded).readVarUint(false);
         this.fromCodec(codec);
         return this.decoded;
     }
     encode(codec) {
         codec = codec || this.codec;
-        this.encoded = index$4.encode(codec);
+        this.encoded = new BinaryWriter(varUintLength(codec)).writeVarUint(codec).finish();
         return this.encoded;
     }
 }
@@ -8792,10 +8906,37 @@ const digestBuffer = async (hashVariant, buffer) => {
     const digest = hasher.digest('binary');
     return digest instanceof Uint8Array ? digest : new Uint8Array(digest);
 };
+const hashHeader = (buffer) => {
+    if (!(buffer instanceof Uint8Array))
+        throw new TypeError('CodecHash only supports Uint8Array input');
+    const reader = new BinaryReader(buffer);
+    const codec = reader.readVarUint();
+    const name = utils.getCodecName(codec);
+    if (!name)
+        throw new Error('unknown hash codec');
+    const size = reader.readVarUint();
+    if (size !== reader.remaining)
+        throw new Error('hash length inconsistent');
+    return { name, size, offset: reader.position };
+};
+const hasHashHeader = (buffer) => {
+    const reader = new BinaryReader(buffer);
+    try {
+        // Recognition is deliberately separate from strict parsing: a padded known
+        // codec must reach decode() and fail, not silently become raw content.
+        return Boolean(utils.getCodecName(reader.readVarUint(false)));
+    }
+    catch (error) {
+        if (!(error instanceof RangeError))
+            throw error;
+        return false;
+    }
+};
 class CodecHash extends BasicInterface {
     codec;
     discoCodec;
     size;
+    digest;
     codecs;
     constructor(options = { name: 'disco-hash', codecs: {} }) {
         super();
@@ -8803,21 +8944,14 @@ class CodecHash extends BasicInterface {
             this.name = options.name;
         else
             this.name = 'disco-hash';
-        if (options?.codecs)
-            this.codecs = options.codecs;
+        this.codecs = options?.codecs ?? {};
     }
     async init(uint8Array) {
         if (uint8Array) {
             if (!(uint8Array instanceof Uint8Array)) {
                 throw new Error('CodecHash only supports Uint8Array input');
             }
-            // For large buffers, only check first bytes for codec prefix
-            // Codec prefixes are small (varint encoded), so 100 bytes is more than enough
-            const checkBuffer = uint8Array.length > 100 ? uint8Array.subarray(0, 100) : uint8Array;
-            this.discoCodec = new Codec(checkBuffer);
-            const name = this.discoCodec.name;
-            if (name) {
-                this.name = name;
+            if (hasHashHeader(uint8Array)) {
                 this.decode(uint8Array);
             }
             else {
@@ -8826,15 +8960,19 @@ class CodecHash extends BasicInterface {
         }
         return this;
     }
+    #clearEncodingCache() {
+        for (const key of ['_bs32', '_hex', '_string'])
+            delete this[key];
+    }
     get prefix() {
         const length = this.length;
         const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length);
-        uint8Array.set(length);
-        uint8Array.set(this.discoCodec.codecBuffer, length.length);
+        uint8Array.set(this.discoCodec.codecBuffer);
+        uint8Array.set(length, this.discoCodec.codecBuffer.length);
         return uint8Array;
     }
     get length() {
-        return index$4.encode(this.size);
+        return new BinaryWriter(varUintLength(this.size)).writeVarUint(this.size).finish();
     }
     get buffer() {
         return this.encoded;
@@ -8861,6 +8999,8 @@ class CodecHash extends BasicInterface {
         const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
         uint8Array.set(this.prefix);
         uint8Array.set(this.digest, this.prefix.length);
+        this.#clearEncodingCache();
+        this.decoded = undefined;
         this.encoded = uint8Array;
         return this.encoded;
     }
@@ -8868,35 +9008,30 @@ class CodecHash extends BasicInterface {
         if (!(buffer instanceof Uint8Array)) {
             throw new Error('CodecHash only supports Uint8Array input');
         }
-        const codec = index$4.decode(buffer);
-        if (this.codecs[codec]) {
-            this.decode(buffer);
-        }
-        else {
-            await this.encode(buffer);
-        }
+        await this.init(buffer);
     }
     decode(buffer) {
+        buffer = buffer ?? this.encoded;
+        // Validate completely before changing this instance, including cached encodings.
+        const header = hashHeader(buffer);
+        const codec = new Codec(header.name);
+        const digest = new Uint8Array(buffer.subarray(header.offset));
+        this.#clearEncodingCache();
         this.encoded = buffer;
-        const codec = index$4.decode(buffer);
-        this.discoCodec = new Codec(codec, this.codecs);
-        // TODO: validate codec
-        buffer = buffer.slice(index$4.decode.bytes);
-        this.size = index$4.decode(buffer);
-        this.digest = buffer.slice(index$4.decode.bytes);
-        if (this.digest.length !== this.size) {
-            throw new Error(`hash length inconsistent: 0x${this.encoded.toString()}`);
-        }
-        // const discoCodec = new Codec(codec, this.codecs)
-        this.name = this.discoCodec.name;
-        this.size = this.digest.length;
-        return {
+        this.discoCodec = codec;
+        this.codec = codec.codecBuffer;
+        this.name = header.name;
+        this.size = header.size;
+        this.digest = digest;
+        const decoded = {
             codec: this.codec,
             name: this.name,
             size: this.size,
             length: this.length,
             digest: this.digest
         };
+        this.decoded = decoded;
+        return decoded;
     }
 }
 
@@ -9009,13 +9144,14 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
             !Object.prototype.hasOwnProperty.call(this.decoded, 'hash')) {
             // @ts-ignore
             const hash = new CodecHash({ name: this.name });
-            return hash.init(this.contentBytes);
+            // These are explicitly raw message bytes, even if they resemble a hash header.
+            return hash.encode(this.contentBytes).then(() => hash);
         }
         // Fallback: must re-encode without hash property
         const decoded = this.beforeHashing({ ...this.decoded });
         // @ts-ignore
         const hash = new CodecHash({ name: this.name });
-        return hash.init(decoded);
+        return hash.encode(this.protoEncode(decoded)).then(() => hash);
     }
     /**
      * @return {peernetHash}
@@ -9236,4 +9372,4 @@ class EasyWorker {
     }
 }
 
-export { EasyWorker as E, FormatInterface as F, proto$3 as a, index$2 as b, proto$1 as c, proto as d, jsonParseBigInt$1 as e, index$3 as i, jsonStringifyBigInt$1 as j, proto$2 as p };
+export { EasyWorker as E, FormatInterface as F, proto$3 as a, proto$1 as b, proto as c, decodeFrames as d, encodeFrames as e, jsonParseBigInt$1 as f, jsonStringifyBigInt$1 as j, proto$2 as p };