@leofcoin/codec-format-interface 1.7.12 → 1.7.14

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 vandeurenglenn
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2022 vandeurenglenn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/exports/basic-interface.d.ts

@@ -1,5 +1,7 @@
 import type { base58String } from '@vandeurenglenn/base58';
 import type { base32String } from '@vandeurenglenn/base32';
+export declare const jsonStringifyBigInt: (key: any, value: any) => any;
+export declare const jsonParseBigInt: (key: any, value: any) => any;
 export default class BasicInterface {
     #private;
     name: string;

package/exports/basic-interface.js

@@ -4,6 +4,8 @@ import isHex from '@vandeurenglenn/is-hex';
 import proto from '@vandeurenglenn/proto-array';
 import { fromBase58, fromHex, toHex, toBase32, toBase58 } from '@vandeurenglenn/typed-array-utils';
 
+const jsonStringifyBigInt = (key, value) => typeof value === 'bigint' ? { $bigint: value.toString() } : value;
+const jsonParseBigInt = (key, value) => typeof value === 'object' && value.$bigint ? BigInt(value.$bigint) : value;
 class BasicInterface {
     #encoded;
     #decoded;
@@ -120,4 +122,4 @@ class BasicInterface {
     }
 }
 
-export { BasicInterface as default };
+export { BasicInterface as default, jsonParseBigInt, jsonStringifyBigInt };

package/exports/codec-format-interface.js

@@ -1,4 +1,4 @@
-import BasicInterface from './basic-interface.js';
+import BasicInterface, { jsonParseBigInt } from './basic-interface.js';
 import Codec from './codec.js';
 import CodecHash from './codec-hash.js';
 import '@vandeurenglenn/base32';
@@ -128,13 +128,13 @@ class FormatInterface extends BasicInterface {
         this.encoded = buffer;
         return this.hasCodec()
             ? this.decode()
-            : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
+            : this.create(JSON.parse(new TextDecoder().decode(this.encoded), jsonParseBigInt));
     }
     fromArrayBuffer(buffer) {
         this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
         return this.hasCodec()
             ? this.decode()
-            : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
+            : this.create(JSON.parse(new TextDecoder().decode(this.encoded), jsonParseBigInt));
     }
     /**
      * @param {Object} data

package/exports/codec-hash.d.ts

@@ -1,8 +1,14 @@
 import BasicInterface from './basic-interface.js';
+import Codec from './codec.js';
+type CodecHashOptions = {
+    name: string;
+    codecs: object;
+};
 export default class CodecHash extends BasicInterface {
-    codec: any;
-    discoCodec: any;
-    constructor(buffer: any, options?: {});
+    codec: Uint8Array;
+    discoCodec: Codec;
+    size: number;
+    constructor(buffer: any, options: CodecHashOptions);
     init(uint8Array: any): Promise<this>;
     get prefix(): Uint8Array;
     get length(): number[];
@@ -12,10 +18,11 @@ export default class CodecHash extends BasicInterface {
     encode(buffer: any, name?: any): Promise<Uint8Array>;
     validate(buffer: any): Promise<void>;
     decode(buffer: any): {
-        codec: any;
+        codec: Uint8Array;
         name: string;
-        size: any;
+        size: number;
         length: number[];
         digest: any;
     };
 }
+export {};

package/exports/codec-hash.js

@@ -1,5 +1,5 @@
 import varint from 'varint';
-import BasicInterface from './basic-interface.js';
+import BasicInterface, { jsonStringifyBigInt } from './basic-interface.js';
 import Codec from './codec.js';
 import '@vandeurenglenn/base32';
 import '@vandeurenglenn/base58';
@@ -11,20 +11,21 @@ import '@leofcoin/codecs';
 class CodecHash extends BasicInterface {
     codec;
     discoCodec;
-    constructor(buffer, options = {}) {
+    size;
+    constructor(buffer, options) {
         super();
-        if (options.name)
+        if (options?.name)
             this.name = options.name;
         else
             this.name = 'disco-hash';
-        if (options.codecs)
+        if (options?.codecs)
             this.codecs = options.codecs;
         return this.init(buffer);
     }
     async init(uint8Array) {
         if (uint8Array) {
             if (uint8Array instanceof Uint8Array) {
-                this.discoCodec = new Codec(uint8Array, this.codecs);
+                this.discoCodec = new Codec(uint8Array);
                 const name = this.discoCodec.name;
                 if (name) {
                     this.name = name;
@@ -66,7 +67,7 @@ class CodecHash extends BasicInterface {
         return this.encoded;
     }
     fromJSON(json) {
-        return this.encode(new TextEncoder().encode(JSON.stringify(json)));
+        return this.encode(new TextEncoder().encode(JSON.stringify(json, jsonStringifyBigInt)));
     }
     async encode(buffer, name) {
         if (!this.name && name)
@@ -140,7 +141,7 @@ class CodecHash extends BasicInterface {
             name: this.name,
             size: this.size,
             length: this.length,
-            digest: this.digest,
+            digest: this.digest
         };
     }
 }

package/package.json

@@ -1,47 +1,47 @@
-{
-  "name": "@leofcoin/codec-format-interface",
-  "version": "1.7.12",
-  "description": "",
-  "type": "module",
-  "exports": {
-    ".": "./exports/index.js"
-  },
-  "files": [
-    "exports"
-  ],
-  "typings": "exports/index.d.ts",
-  "scripts": {
-    "build": "rollup -c",
-    "test": "node test"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/leofcoin/codec-format-interface.git"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/leofcoin/codec-format-interface/issues"
-  },
-  "homepage": "https://github.com/leofcoin/codec-format-interface#readme",
-  "dependencies": {
-    "@leofcoin/codecs": "^1.0.6",
-    "@leofcoin/crypto": "^0.2.24",
-    "@vandeurenglenn/base32": "^1.2.4",
-    "@vandeurenglenn/base58": "^1.1.9",
-    "@vandeurenglenn/is-hex": "^1.1.1",
-    "@vandeurenglenn/proto-array": "^1.0.16",
-    "@vandeurenglenn/typed-array-utils": "^1.2.0",
-    "hash-wasm": "^4.11.0",
-    "varint": "^6.0.0"
-  },
-  "devDependencies": {
-    "@rollup/plugin-typescript": "^11.1.6",
-    "@types/varint": "^6.0.3",
-    "rollup": "^4.22.2",
-    "tape": "^5.9.0",
-    "tinybench": "^2.9.0",
-    "tslib": "^2.7.0"
-  }
-}
+{
+  "name": "@leofcoin/codec-format-interface",
+  "version": "1.7.14",
+  "description": "",
+  "type": "module",
+  "exports": {
+    ".": "./exports/index.js"
+  },
+  "files": [
+    "exports"
+  ],
+  "typings": "exports/index.d.ts",
+  "scripts": {
+    "build": "rollup -c",
+    "test": "node test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leofcoin/codec-format-interface.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/leofcoin/codec-format-interface/issues"
+  },
+  "homepage": "https://github.com/leofcoin/codec-format-interface#readme",
+  "dependencies": {
+    "@leofcoin/codecs": "^1.0.7",
+    "@leofcoin/crypto": "^0.2.37",
+    "@vandeurenglenn/base32": "^1.2.4",
+    "@vandeurenglenn/base58": "^1.1.9",
+    "@vandeurenglenn/is-hex": "^1.1.1",
+    "@vandeurenglenn/proto-array": "^1.0.17",
+    "@vandeurenglenn/typed-array-utils": "^1.2.0",
+    "hash-wasm": "^4.12.0",
+    "varint": "^6.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@types/varint": "^6.0.3",
+    "rollup": "^4.53.3",
+    "tape": "^5.9.0",
+    "tinybench": "^5.1.0",
+    "tslib": "^2.8.1"
+  }
+}

package/exports/codec-a830f1a0.js

@@ -1,284 +0,0 @@
-import varint from 'varint';
-import BasicInterface from './basic-interface.js';
-
-const blockchainCodecs = [
-    {
-        name: 'leofcoin-block',
-        codec: '0x6c62',
-        hashAlg: 'dbl-keccak-512',
-    },
-    {
-        name: 'leofcoin-tx',
-        codec: '0x6c74',
-        hashAlg: 'dbl-keccak-512',
-    },
-    {
-        name: 'leofcoin-itx',
-        codec: '0x6c69',
-        hashAlg: 'keccak-512',
-    },
-    {
-        name: 'leofcoin-pr',
-        codec: '0x6c70',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'contract-message',
-        codec: '0x63636d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'transaction-message',
-        codec: '0x746d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'raw-transaction-message',
-        codec: '0x772746d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'block-message',
-        codec: '0x626d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'bw-message',
-        codec: '0x62776d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'bw-request-message',
-        codec: '0x6277726d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'validator-message',
-        codec: '0x766d',
-        hashAlg: 'keccak-256'
-    }
-];
-
-const internalCodecs = [
-    {
-        name: 'disco-hash',
-        codec: '0x30',
-        hashAlg: 'dbl-keccak-256',
-    },
-    {
-        name: 'peernet-peer-response',
-        codec: '0x707072',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-peer',
-        codec: '0x7070',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-dht',
-        codec: '0x706468',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-dht-response',
-        codec: '0x706472',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-data',
-        codec: '0x706461',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-data-response',
-        codec: '0x70646172',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-message',
-        codec: '0x706d65',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-ps',
-        codec: '707073',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-response',
-        codec: '0x7072',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-request',
-        codec: '0x707271',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-file',
-        codec: '0x7066',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-file-response',
-        codec: '0x706672',
-        hashAlg: 'keccak-256',
-    }
-];
-
-var social = [{
-        name: 'chat-message',
-        codec: '0x70636d',
-        hashAlg: 'dbl-keccak-256',
-    }];
-
-const codecs = [
-    ...internalCodecs,
-    ...blockchainCodecs,
-    ...social
-];
-
-globalThis.peernetCodecs = globalThis.peernetCodecs || {};
-const addCodec = (codecInput) => {
-    let { hashAlg, codec, name } = codecInput;
-    if (!globalThis.peernetCodecs[name])
-        globalThis.peernetCodecs[name] = {
-            hashAlg,
-            codec: typeof codec === 'string' ? parseInt(codec, 16) : codec
-        };
-};
-const getCodec = (name) => {
-    if (typeof name === 'number')
-        return name;
-    return getCodecByName(name).codec;
-};
-const getCodecName = (codec) => {
-    return Object.keys(globalThis.peernetCodecs).reduce((p, c) => {
-        const item = globalThis.peernetCodecs[c];
-        if (item.codec === codec)
-            return c;
-        else
-            return p;
-    }, undefined);
-};
-const getCodecByName = (name) => globalThis.peernetCodecs[name];
-const getHashAlg = (name) => {
-    if (typeof name === 'number')
-        return getCodecByName(getCodecName(name)).hashAlg;
-    return getCodecByName(name).hashAlg;
-};
-const isCodec = (codec) => {
-    if (codec.codec !== undefined && codec.hashAlg)
-        return true;
-    return false;
-};
-const validateCodec = (codec) => {
-    if (codec.codec === undefined ||
-        codec.hashAlg === undefined ||
-        codec.name === undefined)
-        throw new Error(`invalid codecInput: ${codec}`);
-};
-for (const codec of codecs) {
-    addCodec(codec);
-}
-var utils = {
-    isCodec,
-    addCodec,
-    getCodec,
-    getHashAlg,
-    getCodecName,
-    validateCodec,
-    codecs: globalThis.peernetCodecs
-};
-
-class Codec extends BasicInterface {
-    codecBuffer;
-    codec;
-    hashAlg;
-    constructor(buffer) {
-        super();
-        if (buffer) {
-            if (buffer instanceof Uint8Array) {
-                const codec = varint.decode(buffer);
-                const name = this.getCodecName(codec);
-                if (name) {
-                    this.name = name;
-                    this.encoded = buffer;
-                    this.decode(buffer);
-                }
-                else {
-                    this.encode(Number(new TextDecoder().decode(buffer)));
-                }
-            }
-            else if (buffer instanceof ArrayBuffer) {
-                const codec = varint.decode(buffer);
-                const name = this.getCodecName(codec);
-                if (name) {
-                    this.name = name;
-                    this.decode(buffer);
-                }
-                else {
-                    this.encode(Number(new TextDecoder().decode(new Uint8Array(buffer))));
-                }
-            }
-            else if (typeof buffer === 'string') {
-                if (utils.getCodec(buffer))
-                    this.fromName(buffer);
-                else if (this.isHex(buffer))
-                    this.fromHex(buffer);
-                else if (this.isBase32(buffer))
-                    this.fromBs32(buffer);
-                else if (this.isBase58(buffer))
-                    this.fromBs58(buffer);
-                else
-                    this.fromString(buffer);
-            }
-            if (!isNaN(buffer))
-                if (utils.getCodec(buffer))
-                    this.fromCodec(buffer);
-        }
-    }
-    fromEncoded(encoded) {
-        const codec = varint.decode(encoded);
-        const name = this.getCodecName(codec);
-        this.name = name;
-        this.encoded = encoded;
-        return this.decode(encoded);
-    }
-    getCodec(name) {
-        return utils.getCodec(name);
-    }
-    getCodecName(codec) {
-        return utils.getCodecName(codec);
-    }
-    getHashAlg(name) {
-        return utils.getHashAlg(name);
-    }
-    fromCodec(codec) {
-        this.name = this.getCodecName(codec);
-        this.hashAlg = this.getHashAlg(this.name);
-        this.codec = this.getCodec(this.name);
-        this.codecBuffer = varint.encode(this.codec);
-    }
-    fromName(name) {
-        const codec = this.getCodec(name);
-        this.name = name;
-        this.codec = codec;
-        this.hashAlg = this.getHashAlg(name);
-        this.codecBuffer = varint.encode(this.codec);
-    }
-    decode(encoded) {
-        encoded = encoded || this.encoded;
-        const codec = varint.decode(encoded);
-        this.fromCodec(codec);
-        return this.decoded;
-    }
-    encode(codec) {
-        codec = codec || this.codec;
-        this.encoded = varint.encode(codec);
-        return this.encoded;
-    }
-}
-
-export { Codec as C, codecs as c };

package/exports/codec-format-interface-07c55dde.js

@@ -1,268 +0,0 @@
-import BasicInterface from './basic-interface.js';
-import { createKeccak } from 'hash-wasm';
-import varint from 'varint';
-import { C as Codec } from './codec-a830f1a0.js';
-
-class CodecHash extends BasicInterface {
-  constructor(buffer, options = {}) {
-    super();
-    if (options.name) this.name = options.name;
-    else this.name = 'disco-hash';
-    if (options.codecs) this.codecs = options.codecs;
-    return this.init(buffer)
-  }
-
-  async init(uint8Array) {
-    if (uint8Array) {
-      if (uint8Array instanceof Uint8Array) {
-        this.discoCodec = new Codec(uint8Array, this.codecs);
-        const name = this.discoCodec.name;
-
-        if (name) {
-          this.name = name;
-          this.decode(uint8Array);
-        } else {
-          await this.encode(uint8Array);
-        }
-      }
-
-      if (typeof uint8Array === 'string') {
-        if (this.isHex(uint8Array)) await this.fromHex(uint8Array);
-        if (this.isBase32(uint8Array)) await this.fromBs32(uint8Array);
-        else if (this.isBase58(uint8Array)) await this.fromBs58(uint8Array);
-        else throw new Error(`unsupported string ${uint8Array}`)
-      } else if (typeof uint8Array === 'object') await this.fromJSON(uint8Array);
-    }
-    return this
-  }
-  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);
-
-    return uint8Array
-  }
-
-  get length() {
-    return varint.encode(this.size)
-  }
-
-  get buffer() {
-    return this.encoded
-  }
-
-  get hash() {
-    return this.encoded
-  }
-
-  fromJSON(json) {
-    return this.encode(Buffer.from(JSON.stringify(json)))
-  }
-
-  async encode(buffer, name) {
-    if (!this.name && name) this.name = name;
-    if (!buffer) buffer = this.buffer;
-    this.discoCodec = new Codec(this.name, this.codecs);
-    this.discoCodec.fromName(this.name);
-    let hashAlg = this.discoCodec.hashAlg;
-    const hashVariant = Number(hashAlg.split('-')[hashAlg.split('-').length - 1]);
-    
-    if (hashAlg.includes('dbl')) {
-      hashAlg = hashAlg.replace('dbl-', '');
-      const hasher = await createKeccak(hashVariant);
-      await hasher.init();
-      hasher.update(buffer);
-      buffer = hasher.digest('binary');
-    }
-    const hasher = await createKeccak(hashVariant);
-    await hasher.init();
-    hasher.update(buffer);
-    this.digest = hasher.digest('binary');
-    this.size = this.digest.length;
-
-    this.codec = this.discoCodec.encode();
-    this.codec = this.discoCodec.codecBuffer;
-    const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
-    uint8Array.set(this.prefix);
-    uint8Array.set(this.digest, this.prefix.length);
-
-    this.encoded = uint8Array;
-
-    return this.encoded
-  }
-
-  async validate(buffer) {
-    if (Buffer.isBuffer(buffer)) {
-      const codec = varint.decode(buffer);
-      if (this.codecs[codec]) {
-        this.decode(buffer);
-      } else {
-        await this.encode(buffer);
-      }
-    }
-    if (typeof buffer === 'string') {
-      if (this.isHex(buffer)) this.fromHex(buffer);
-      if (this.isBase32(buffer)) this.fromBs32(buffer);
-    }
-    if (typeof buffer === 'object') this.fromJSON(buffer);
-  }
-
-  decode(buffer) {
-    this.encoded = buffer;
-    const codec = varint.decode(buffer);
-
-    this.discoCodec = new Codec(codec, this.codecs);
-    // TODO: validate codec
-    buffer = buffer.slice(varint.decode.bytes);
-    this.size = varint.decode(buffer);
-    this.digest = buffer.slice(varint.decode.bytes);
-    if (this.digest.length !== this.size) {
-      throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`)
-    }
-
-    // const discoCodec = new Codec(codec, this.codecs)
-
-    this.name = this.discoCodec.name;
-
-
-    this.size = this.digest.length;
-
-    return {
-      codec: this.codec,
-      name: this.name,
-      size: this.size,
-      length: this.length,
-      digest: this.digest,
-    }
-  }
-}
-
-class FormatInterface extends BasicInterface {
-    hashFormat;
-    init(buffer) {
-        if (buffer instanceof Uint8Array)
-            this.fromUint8Array(buffer);
-        else if (buffer instanceof ArrayBuffer)
-            this.fromArrayBuffer(buffer);
-        else if (buffer instanceof FormatInterface && buffer?.name === this.name)
-            return buffer;
-        else if (typeof buffer === 'string') {
-            if (this.isHex(buffer))
-                this.fromHex(buffer);
-            else if (this.isBase58(buffer))
-                this.fromBs58(buffer);
-            else if (this.isBase32(buffer))
-                this.fromBs32(buffer);
-            else
-                this.fromString(buffer);
-        }
-        else {
-            this.create(buffer);
-        }
-        return this;
-    }
-    hasCodec() {
-        if (!this.encoded)
-            return false;
-        const codec = new Codec(this.encoded);
-        if (codec.name)
-            return true;
-    }
-    decode(encoded) {
-        encoded = encoded || this.encoded;
-        const codec = new Codec(encoded);
-        if (codec.codecBuffer) {
-            encoded = encoded.slice(codec.codecBuffer.length);
-            this.name = codec.name;
-            this.decoded = this.protoDecode(encoded);
-            // try {
-            //   this.decoded = JSON.parse(this.decoded)
-            // } catch {
-            // }
-        }
-        else {
-            throw new Error(`no codec found`);
-        }
-        return this.decoded;
-    }
-    encode(decoded) {
-        let encoded;
-        decoded = decoded || this.decoded;
-        const codec = new Codec(this.name);
-        if (decoded instanceof Uint8Array)
-            encoded = decoded;
-        else
-            encoded = this.protoEncode(decoded);
-        if (codec.codecBuffer) {
-            const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
-            uint8Array.set(codec.codecBuffer);
-            uint8Array.set(encoded, codec.codecBuffer.length);
-            this.encoded = uint8Array;
-        }
-        else {
-            throw new Error(`invalid codec`);
-        }
-        return this.encoded;
-    }
-    /**
-     * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
-     * @param {Object} proto - {protoObject}
-     * @param {Object} options - {hashFormat, name}
-     */
-    constructor(buffer, proto, options) {
-        super();
-        this.proto = proto;
-        this.hashFormat = options?.hashFormat ? options.hashFormat : 'bs32';
-        if (options?.name)
-            this.name = options.name;
-        this.init(buffer);
-    }
-    /**
-     * @return {PeernetHash}
-     */
-    get peernetHash() {
-        const decoded = this.decoded;
-        // @ts-ignore
-        delete decoded.hash;
-        return new CodecHash(decoded, { name: this.name });
-    }
-    /**
-     * @return {peernetHash}
-     */
-    async hash() {
-        const upper = this.hashFormat.charAt(0).toUpperCase();
-        const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
-        return (await this.peernetHash)[`to${format}`]();
-    }
-    fromUint8Array(buffer) {
-        this.encoded = buffer;
-        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
-    }
-    fromArrayBuffer(buffer) {
-        this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
-        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
-    }
-    /**
-     * @param {Object} data
-     */
-    create(data) {
-        const decoded = {};
-        if (this.keys?.length > 0) {
-            for (const key of this.keys) {
-                Object.defineProperties(decoded, {
-                    [key]: {
-                        enumerable: true,
-                        configurable: true,
-                        set: (value) => data[key],
-                        get: () => data[key]
-                    }
-                });
-            }
-            this.decoded = decoded;
-            return this.encode(decoded);
-        }
-    }
-}
-
-export { CodecHash as C, FormatInterface as F };

package/exports/codec-format-interface-31a2dd5c.js

@@ -1,268 +0,0 @@
-import BasicInterface from './basic-interface.js';
-import { createKeccak } from 'hash-wasm';
-import varint from 'varint';
-import { C as Codec } from './codec-a830f1a0.js';
-
-class CodecHash extends BasicInterface {
-  constructor(buffer, options = {}) {
-    super();
-    if (options.name) this.name = options.name;
-    else this.name = 'disco-hash';
-    if (options.codecs) this.codecs = options.codecs;
-    return this.init(buffer)
-  }
-
-  async init(uint8Array) {
-    if (uint8Array) {
-      if (uint8Array instanceof Uint8Array) {
-        this.discoCodec = new Codec(uint8Array, this.codecs);
-        const name = this.discoCodec.name;
-
-        if (name) {
-          this.name = name;
-          this.decode(uint8Array);
-        } else {
-          await this.encode(uint8Array);
-        }
-      }
-
-      if (typeof uint8Array === 'string') {
-        if (this.isHex(uint8Array)) await this.fromHex(uint8Array);
-        if (this.isBase32(uint8Array)) await this.fromBs32(uint8Array);
-        else if (this.isBase58(uint8Array)) await this.fromBs58(uint8Array);
-        else throw new Error(`unsupported string ${uint8Array}`)
-      } else if (typeof uint8Array === 'object') await this.fromJSON(uint8Array);
-    }
-    return this
-  }
-  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);
-
-    return uint8Array
-  }
-
-  get length() {
-    return varint.encode(this.size)
-  }
-
-  get buffer() {
-    return this.encoded
-  }
-
-  get hash() {
-    return this.encoded
-  }
-
-  fromJSON(json) {
-    return this.encode(Buffer.from(JSON.stringify(json)))
-  }
-
-  async encode(buffer, name) {
-    if (!this.name && name) this.name = name;
-    if (!buffer) buffer = this.buffer;
-    this.discoCodec = new Codec(this.name, this.codecs);
-    this.discoCodec.fromName(this.name);
-    let hashAlg = this.discoCodec.hashAlg;
-    const hashVariant = Number(hashAlg.split('-')[hashAlg.split('-').length - 1]);
-    
-    if (hashAlg.includes('dbl')) {
-      hashAlg = hashAlg.replace('dbl-', '');
-      const hasher = await createKeccak(hashVariant);
-      await hasher.init();
-      hasher.update(buffer);
-      buffer = hasher.digest('binary');
-    }
-    const hasher = await createKeccak(hashVariant);
-    await hasher.init();
-    hasher.update(buffer);
-    this.digest = hasher.digest('binary');
-    this.size = this.digest.length;
-
-    this.codec = this.discoCodec.encode();
-    this.codec = this.discoCodec.codecBuffer;
-    const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
-    uint8Array.set(this.prefix);
-    uint8Array.set(this.digest, this.prefix.length);
-
-    this.encoded = uint8Array;
-
-    return this.encoded
-  }
-
-  async validate(buffer) {
-    if (Buffer.isBuffer(buffer)) {
-      const codec = varint.decode(buffer);
-      if (this.codecs[codec]) {
-        this.decode(buffer);
-      } else {
-        await this.encode(buffer);
-      }
-    }
-    if (typeof buffer === 'string') {
-      if (this.isHex(buffer)) this.fromHex(buffer);
-      if (this.isBase32(buffer)) this.fromBs32(buffer);
-    }
-    if (typeof buffer === 'object') this.fromJSON(buffer);
-  }
-
-  decode(buffer) {
-    this.encoded = buffer;
-    const codec = varint.decode(buffer);
-
-    this.discoCodec = new Codec(codec, this.codecs);
-    // TODO: validate codec
-    buffer = buffer.slice(varint.decode.bytes);
-    this.size = varint.decode(buffer);
-    this.digest = buffer.slice(varint.decode.bytes);
-    if (this.digest.length !== this.size) {
-      throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`)
-    }
-
-    // const discoCodec = new Codec(codec, this.codecs)
-
-    this.name = this.discoCodec.name;
-
-
-    this.size = this.digest.length;
-
-    return {
-      codec: this.codec,
-      name: this.name,
-      size: this.size,
-      length: this.length,
-      digest: this.digest,
-    }
-  }
-}
-
-class FormatInterface extends BasicInterface {
-    hashFormat;
-    init(buffer) {
-        if (buffer instanceof Uint8Array)
-            this.fromUint8Array(buffer);
-        else if (buffer instanceof ArrayBuffer)
-            this.fromArrayBuffer(buffer);
-        else if (buffer instanceof FormatInterface && buffer?.name === this.name)
-            return buffer;
-        else if (typeof buffer === 'string') {
-            if (this.isHex(buffer))
-                this.fromHex(buffer);
-            else if (this.isBase58(buffer))
-                this.fromBs58(buffer);
-            else if (this.isBase32(buffer))
-                this.fromBs32(buffer);
-            else
-                this.fromString(buffer);
-        }
-        else {
-            this.create(buffer);
-        }
-        return this;
-    }
-    hasCodec() {
-        if (!this.encoded)
-            return false;
-        const codec = new Codec(this.encoded);
-        if (codec.name)
-            return true;
-    }
-    decode(encoded) {
-        encoded = encoded || this.encoded;
-        const codec = new Codec(encoded);
-        if (codec.codecBuffer) {
-            encoded = encoded.slice(codec.codecBuffer.length);
-            this.name = codec.name;
-            this.decoded = this.protoDecode(encoded);
-            // try {
-            //   this.decoded = JSON.parse(this.decoded)
-            // } catch {
-            // }
-        }
-        else {
-            throw new Error(`no codec found`);
-        }
-        return this.decoded;
-    }
-    encode(decoded) {
-        let encoded;
-        decoded = decoded || this.decoded;
-        const codec = new Codec(this.name);
-        if (decoded instanceof Uint8Array)
-            encoded = decoded;
-        else
-            encoded = this.protoEncode(decoded);
-        if (codec.codecBuffer) {
-            const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
-            uint8Array.set(codec.codecBuffer);
-            uint8Array.set(encoded, codec.codecBuffer.length);
-            this.encoded = uint8Array;
-        }
-        else {
-            throw new Error(`invalid codec`);
-        }
-        return this.encoded;
-    }
-    /**
-     * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
-     * @param {Object} proto - {protoObject}
-     * @param {Object} options - {hashFormat, name}
-     */
-    constructor(buffer, proto, options) {
-        super();
-        this.proto = proto;
-        this.hashFormat = options?.hashFormat ? options.hashFormat : 'bs32';
-        if (options?.name)
-            this.name = options.name;
-        this.init(buffer);
-    }
-    /**
-     * @return {PeernetHash}
-     */
-    get peernetHash() {
-        const decoded = this.decoded;
-        // @ts-ignore
-        delete decoded.hash;
-        return new CodecHash(decoded, { name: this.name });
-    }
-    /**
-     * @return {peernetHash}
-     */
-    async hash() {
-        const upper = this.hashFormat.charAt(0).toUpperCase();
-        const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
-        return (await this.peernetHash)[`to${format}`]();
-    }
-    fromUint8Array(buffer) {
-        this.encoded = buffer;
-        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
-    }
-    fromArrayBuffer(buffer) {
-        this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
-        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
-    }
-    /**
-     * @param {Object} data
-     */
-    create(data) {
-        const decoded = {};
-        if (this.keys?.length > 0) {
-            for (const key of this.keys) {
-                Object.defineProperties(decoded, {
-                    [key]: {
-                        enumerable: true,
-                        configurable: true,
-                        set: (value) => data[key],
-                        get: () => data[key]
-                    }
-                });
-            }
-            this.decoded = decoded;
-            // return this.encode(decoded)
-        }
-    }
-}
-
-export { CodecHash as C, FormatInterface as F };