@leofcoin/codec-format-interface 1.3.0 → 1.3.1

package/dist/index.js

@@ -1,559 +1,488 @@
-'use strict';
+var $kmf1g$vandeurenglennbase32 = require("@vandeurenglenn/base32");
+var $kmf1g$vandeurenglennbase58 = require("@vandeurenglenn/base58");
+var $kmf1g$vandeurenglennishex = require("@vandeurenglenn/is-hex");
+var $kmf1g$varint = require("varint");
+var $kmf1g$keccak = require("keccak");
 
-Object.defineProperty(exports, '__esModule', { value: true });
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
 
-var bs32 = require('@vandeurenglenn/base32');
-var bs58 = require('@vandeurenglenn/base58');
-var isHex = require('@vandeurenglenn/is-hex');
-var varint = require('varint');
-var createKeccakHash = require('keccak');
+$parcel$export(module.exports, "BasicInterface", () => $ddc88a2f9ee6b3c1$export$1b7dbb60aef3044);
+$parcel$export(module.exports, "FormatInterface", () => $ddc88a2f9ee6b3c1$export$a3360ca1fc583f9e);
+$parcel$export(module.exports, "CodecHash", () => $ddc88a2f9ee6b3c1$export$ea841ad44f0598a2);
+$parcel$export(module.exports, "Codec", () => $ddc88a2f9ee6b3c1$export$a111e9ced3f1d2d0);
+$parcel$export(module.exports, "Codecs", () => $ddc88a2f9ee6b3c1$export$1c4d583cbe1d2b10);
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var bs32__default = /*#__PURE__*/_interopDefaultLegacy(bs32);
-var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
-var isHex__default = /*#__PURE__*/_interopDefaultLegacy(isHex);
-var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
-var createKeccakHash__default = /*#__PURE__*/_interopDefaultLegacy(createKeccakHash);
 
-class BasicInterface$1 {
-  handleDecode() {
-    if (!this.decode) throw new Error('bad implementation: needs decode func')
-    return this.decode()
-  }
-
-  handleEncode() {
-    if (!this.encode) throw new Error('bad implementation: needs encode func')
-    return this.encode()
-  }
-  isHex(string) {
-    return isHex__default["default"](string)
-  }
-  isBase32(string) {
-    return bs32__default["default"].isBase32(string)
-  }
-  isBase58(string) {
-    return bs58__default["default"].isBase58(string)
-  }
-  /**
+class $78f9a5b9b57d161a$export$2e2bcd8739ae039 {
+    handleDecode() {
+        if (!this.decode) throw new Error("bad implementation: needs decode func");
+        return this.decode();
+    }
+    handleEncode() {
+        if (!this.encode) throw new Error("bad implementation: needs encode func");
+        return this.encode();
+    }
+    isHex(string) {
+        return (0, ($parcel$interopDefault($kmf1g$vandeurenglennishex)))(string);
+    }
+    isBase32(string) {
+        return (0, ($parcel$interopDefault($kmf1g$vandeurenglennbase32))).isBase32(string);
+    }
+    isBase58(string) {
+        return (0, ($parcel$interopDefault($kmf1g$vandeurenglennbase58))).isBase58(string);
+    }
+    /**
    * @param {String} encoded
-   */
-  fromBs32(encoded) {
-    this.encoded = bs32__default["default"].decode(encoded);
-    return this.handleDecode()
-  }
-
-  /**
+   */ fromBs32(encoded) {
+        this.encoded = (0, ($parcel$interopDefault($kmf1g$vandeurenglennbase32))).decode(encoded);
+        return this.handleDecode();
+    }
+    /**
    * @param {String} encoded
-   */
-  fromBs58(encoded) {
-    this.encoded = bs58__default["default"].decode(encoded);
-    return this.handleDecode()
-  }
-
-  async toArray() {
-    const array = [];
-    for await (const value of this.encoded.values()) {
-      array.push(value);
-    }
-    return array
-  }
-
-  fromString(string) {
-    this.encoded = new Uint8Array(string.split(','));
-    return this.handleDecode()
-  }
-
-  fromArray(array) {
-    this.encoded = new Uint8Array([...array]);
-    return this.handleDecode()
-  }
-
-  /**
+   */ fromBs58(encoded) {
+        this.encoded = (0, ($parcel$interopDefault($kmf1g$vandeurenglennbase58))).decode(encoded);
+        return this.handleDecode();
+    }
+    async toArray() {
+        const array = [];
+        for await (const value1 of this.encoded.values())array.push(value1);
+        return array;
+    }
+    fromString(string) {
+        this.encoded = new Uint8Array(string.split(","));
+        return this.handleDecode();
+    }
+    fromArray(array) {
+        this.encoded = new Uint8Array([
+            ...array
+        ]);
+        return this.handleDecode();
+    }
+    /**
    * @param {Buffer} encoded
-   */
-  fromEncoded(encoded) {
-    this.encoded = encoded;
-    return this.handleDecode()
-  }
-
-  /**
+   */ fromEncoded(encoded) {
+        this.encoded = encoded;
+        return this.handleDecode();
+    }
+    /**
    * @param {String} encoded
-   */
-  fromHex(encoded) {
-    this.encoded = Buffer.from(encoded, 'hex');
-    return this.handleDecode()
-  }
-
-  async toString(encoding = 'utf8') {
-    if (!this.encoded) await this.handleEncode();
-    return this.encoded.toString(encoding)
-  }
-
-  /**
+   */ fromHex(encoded) {
+        this.encoded = Buffer.from(encoded, "hex");
+        return this.handleDecode();
+    }
+    async toString(encoding = "utf8") {
+        if (!this.encoded) await this.handleEncode();
+        return this.encoded.toString(encoding);
+    }
+    /**
    * @return {String} encoded
-   */
-  toHex() {
-    return this.toString('hex')
-  }
-
-  /**
+   */ toHex() {
+        return this.toString("hex");
+    }
+    /**
    * @return {String} encoded
-   */
-  async toBs32() {
-    if (!this.encoded) await this.handleEncode();
-    return bs32__default["default"].encode(this.encoded)
-  }
-
-  /**
+   */ async toBs32() {
+        if (!this.encoded) await this.handleEncode();
+        return (0, ($parcel$interopDefault($kmf1g$vandeurenglennbase32))).encode(this.encoded);
+    }
+    /**
    * @return {String} encoded
-   */
-  async toBs58() {
-    if (!this.encoded) await this.handleEncode();
-    return bs58__default["default"].encode(this.encoded)
-  }
-
-  /**
+   */ async toBs58() {
+        if (!this.encoded) await this.handleEncode();
+        return (0, ($parcel$interopDefault($kmf1g$vandeurenglennbase58))).encode(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: (val) => value = data[key],
-            get: () => data[key]
-          }
-        });
-      }
-
-      this.decoded = decoded;
-      return this.encode()
-    }
-  }
+   */ create(data) {
+        const decoded = {};
+        if (this.keys?.length > 0) {
+            for (const key of this.keys)Object.defineProperties(decoded, {
+                [key]: {
+                    enumerable: true,
+                    configurable: true,
+                    set: (val)=>value = data[key],
+                    get: ()=>data[key]
+                }
+            });
+            this.decoded = decoded;
+            return this.encode();
+        }
+    }
 }
 
-var codecs = {
-  // just a hash
-  'disco-hash': {
-    codec: parseInt('30', 16),
-    hashAlg: 'dbl-keccak-256', // ,
-    // testnet: 'olivia'
-  },
-  'peernet-peer-response': {
-    codec: parseInt('707072', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-peer': {
-    codec: parseInt('7070', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-dht': {
-    codec: parseInt('706468', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-dht-response': {
-    codec: parseInt('706472', 16),
-    hashAlg: 'keccak-256',
-  },
-  // data
-  'peernet-data': {
-    codec: parseInt('706461', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-data-response': {
-    codec: parseInt('70646172', 16),
-    hashAlg: 'keccak-256',
-  },
-  // message
-  'peernet-message': {
-    codec: parseInt('706d65', 16),
-    hashAlg: 'keccak-256',
-  },
-  // pubsub
-  'peernet-ps': {
-    codec: parseInt('707073', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-response': {
-    codec: parseInt('7072', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-request': {
-    codec: parseInt('707271', 16),
-    hashAlg: 'keccak-256',
-  },
-  // normal block
-  'leofcoin-block': {
-    codec: parseInt('6c62', 16),
-    hashAlg: 'dbl-keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  'leofcoin-tx': {
-    codec: parseInt('6c74', 16),
-    hashAlg: 'dbl-keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  // itx
-  'leofcoin-itx': {
-    codec: parseInt('6c69', 16),
-    hashAlg: 'keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  // peer reputation
-  'leofcoin-pr': {
-    codec: parseInt('6c70', 16),
-    hashAlg: 'keccak-256', // ,
-    // testnet: 'olivia'
-  },
-  // chat message
-  'chat-message': {
-    codec: parseInt('636d', 16),
-    hashAlg: 'dbl-keccak-256',
-  },
-  'peernet-file' : {
-    codec: parseInt('7066', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-file-response' : {
-    codec: parseInt('706672', 16),
-    hashAlg: 'keccak-256',
-  }
+
+
+
+var $e02c0eac1ab634b5$export$2e2bcd8739ae039 = {
+    // just a hash
+    "disco-hash": {
+        codec: parseInt("30", 16),
+        hashAlg: "dbl-keccak-256"
+    },
+    "peernet-peer-response": {
+        codec: parseInt("707072", 16),
+        hashAlg: "keccak-256"
+    },
+    "peernet-peer": {
+        codec: parseInt("7070", 16),
+        hashAlg: "keccak-256"
+    },
+    "peernet-dht": {
+        codec: parseInt("706468", 16),
+        hashAlg: "keccak-256"
+    },
+    "peernet-dht-response": {
+        codec: parseInt("706472", 16),
+        hashAlg: "keccak-256"
+    },
+    // data
+    "peernet-data": {
+        codec: parseInt("706461", 16),
+        hashAlg: "keccak-256"
+    },
+    "peernet-data-response": {
+        codec: parseInt("70646172", 16),
+        hashAlg: "keccak-256"
+    },
+    // message
+    "peernet-message": {
+        codec: parseInt("706d65", 16),
+        hashAlg: "keccak-256"
+    },
+    // pubsub
+    "peernet-ps": {
+        codec: parseInt("707073", 16),
+        hashAlg: "keccak-256"
+    },
+    "peernet-response": {
+        codec: parseInt("7072", 16),
+        hashAlg: "keccak-256"
+    },
+    "peernet-request": {
+        codec: parseInt("707271", 16),
+        hashAlg: "keccak-256"
+    },
+    // normal block
+    "leofcoin-block": {
+        codec: parseInt("6c62", 16),
+        hashAlg: "dbl-keccak-512"
+    },
+    "leofcoin-tx": {
+        codec: parseInt("6c74", 16),
+        hashAlg: "dbl-keccak-512"
+    },
+    // itx
+    "leofcoin-itx": {
+        codec: parseInt("6c69", 16),
+        hashAlg: "keccak-512"
+    },
+    // peer reputation
+    "leofcoin-pr": {
+        codec: parseInt("6c70", 16),
+        hashAlg: "keccak-256"
+    },
+    // chat message
+    "chat-message": {
+        codec: parseInt("636d", 16),
+        hashAlg: "dbl-keccak-256"
+    },
+    "peernet-file": {
+        codec: parseInt("7066", 16),
+        hashAlg: "keccak-256"
+    },
+    "peernet-file-response": {
+        codec: parseInt("706672", 16),
+        hashAlg: "keccak-256"
+    }
 };
 
-class PeernetCodec extends BasicInterface$1 {
-  get codecs() {
-    return {...globalThis.peernet.codecs, ...codecs}
-  }
-  constructor(buffer) {
-    super();
-    if (buffer) {
-      if (buffer instanceof Uint8Array) {
-        const codec = varint__default["default"].decode(buffer);
-        const name = this.getCodecName(codec);
-        if (name) {
-          this.name = name;
-          this.encoded = buffer;
-          this.decode(buffer);
-        } else {
-          this.encode(buffer);
-        }
-      } else if (buffer instanceof ArrayBuffer) {
-        const encoded = new Uint8Array(buffer.byteLength);
-
-        for (let i = 0; i < buffer.byteLength; i++) {
-          encoded[i] = buffer[i];
-        }
-        this.encoded = encoded;
-        // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
-        this.decode(buffer);
-        return
-      }
-      if (typeof buffer === 'string') {
-        if (this.codecs[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 throw new Error(`unsupported string ${buffer}`)
-      }
-      if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer);
-    }
-  }
-
-  fromEncoded(encoded) {
-    const codec = varint__default["default"].decode(encoded);
-    const name = this.getCodecName(codec);
-    this.name = name;
-    this.encoded = encoded;
-    this.decode(encoded);
-  }
-
-  getCodec(name) {
-    return this.codecs[name].codec
-  }
-
-  getCodecName(codec) {
-    return Object.keys(this.codecs).reduce((p, c) => {
-      const item = this.codecs[c];
-      if (item.codec === codec) return c;
-      else return p;
-    }, undefined)
-  }
-
-  getHashAlg(name) {
-    return this.codecs[name].hashAlg
-  }
-
-  fromCodec(codec) {
-    this.name = this.getCodecName(codec);
-    this.hashAlg = this.getHashAlg(this.name);
-
-    this.codec = this.getCodec(this.name);
-    this.codecBuffer = varint__default["default"].encode(codec);
-  }
-
-  fromName(name) {
-    const codec = this.getCodec(name);
-    this.name = name;
-    this.codec = codec;
-    this.hashAlg = this.getHashAlg(name);
-    this.codecBuffer = varint__default["default"].encode(codec);
-  }
-
-  decode() {
-    const codec = varint__default["default"].decode(this.encoded);
-    this.fromCodec(codec);
-  }
-
-  encode() {
-    const codec = varint__default["default"].encode(this.decoded);
-    this.encoded = codec;
-    return this.encoded
-  }
+
+
+class $40c292043964c309$export$2e2bcd8739ae039 extends (0, $78f9a5b9b57d161a$export$2e2bcd8739ae039) {
+    get codecs() {
+        return {
+            ...globalThis.peernet.codecs,
+            ...(0, $e02c0eac1ab634b5$export$2e2bcd8739ae039)
+        };
+    }
+    constructor(buffer){
+        super();
+        if (buffer) {
+            if (buffer instanceof Uint8Array) {
+                const codec = (0, ($parcel$interopDefault($kmf1g$varint))).decode(buffer);
+                const name = this.getCodecName(codec);
+                if (name) {
+                    this.name = name;
+                    this.encoded = buffer;
+                    this.decode(buffer);
+                } else this.encode(buffer);
+            } else if (buffer instanceof ArrayBuffer) {
+                const encoded = new Uint8Array(buffer.byteLength);
+                for(let i = 0; i < buffer.byteLength; i++)encoded[i] = buffer[i];
+                this.encoded = encoded;
+                // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
+                this.decode(buffer);
+                return;
+            }
+            if (typeof buffer === "string") {
+                if (this.codecs[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 throw new Error(`unsupported string ${buffer}`);
+            }
+            if (!isNaN(buffer)) {
+                if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer);
+            }
+        }
+    }
+    fromEncoded(encoded) {
+        const codec = (0, ($parcel$interopDefault($kmf1g$varint))).decode(encoded);
+        const name = this.getCodecName(codec);
+        this.name = name;
+        this.encoded = encoded;
+        this.decode(encoded);
+    }
+    getCodec(name) {
+        return this.codecs[name].codec;
+    }
+    getCodecName(codec) {
+        return Object.keys(this.codecs).reduce((p, c)=>{
+            const item = this.codecs[c];
+            if (item.codec === codec) return c;
+            else return p;
+        }, undefined);
+    }
+    getHashAlg(name) {
+        return this.codecs[name].hashAlg;
+    }
+    fromCodec(codec) {
+        this.name = this.getCodecName(codec);
+        this.hashAlg = this.getHashAlg(this.name);
+        this.codec = this.getCodec(this.name);
+        this.codecBuffer = (0, ($parcel$interopDefault($kmf1g$varint))).encode(codec);
+    }
+    fromName(name) {
+        const codec = this.getCodec(name);
+        this.name = name;
+        this.codec = codec;
+        this.hashAlg = this.getHashAlg(name);
+        this.codecBuffer = (0, ($parcel$interopDefault($kmf1g$varint))).encode(codec);
+    }
+    decode() {
+        const codec = (0, ($parcel$interopDefault($kmf1g$varint))).decode(this.encoded);
+        this.fromCodec(codec);
+    }
+    encode() {
+        const codec = (0, ($parcel$interopDefault($kmf1g$varint))).encode(this.decoded);
+        this.encoded = codec;
+        return this.encoded;
+    }
 }
 
-class CodecHash$1 extends BasicInterface$1 {
-  constructor(buffer, options = {}) {
-    super();
-    if (options.name) this.name = options.name;
-    else this.name = 'disco-hash';
-    if (options.codecs) this.codecs = options.codecs;
-    if (buffer) {
-      if (buffer instanceof Uint8Array) {
-        this.discoCodec = new PeernetCodec(buffer, this.codecs);
-        const name = this.discoCodec.name;
-
-        if (name) {
-          this.name = name;
-          this.decode(buffer);
-        } else {
-          this.encode(buffer);
-        }
-      }
-
-      if (typeof buffer === 'string') {
-        if (this.isHex(buffer)) this.fromHex(buffer);
-        if (this.isBase32(buffer)) this.fromBs32(buffer);
-        else if (this.isBase58(buffer)) this.fromBs58(buffer);
-        else throw new Error(`unsupported string ${buffer}`)
-      } else if (typeof buffer === 'object') this.fromJSON(buffer);
-    }
-  }
-
-  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__default["default"].encode(this.size)
-  }
-
-  get buffer() {
-    return this.encoded
-  }
-
-  get hash() {
-    return this.encoded
-  }
-
-  fromJSON(json) {
-    return this.encode(Buffer.from(JSON.stringify(json)))
-  }
-
-  encode(buffer, name) {
-    if (!this.name && name) this.name = name;
-    if (!buffer) buffer = this.buffer;
-    this.discoCodec = new PeernetCodec(this.name, this.codecs);
-    this.discoCodec.fromName(this.name);
-    let hashAlg = this.discoCodec.hashAlg;
-    if (hashAlg.includes('dbl')) {
-      hashAlg = hashAlg.replace('dbl-', '');
-      buffer = createKeccakHash__default["default"](hashAlg.replace('-', '')).update(buffer).digest();
-    }
-    this.digest = createKeccakHash__default["default"](hashAlg.replace('-', '')).update(buffer).digest();
-    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
-  }
-
-  validate(buffer) {
-    if (Buffer.isBuffer(buffer)) {
-      const codec = varint__default["default"].decode(buffer);
-      if (this.codecs[codec]) {
-        this.decode(buffer);
-      } else {
-        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__default["default"].decode(buffer);
-
-    this.discoCodec = new PeernetCodec(codec, this.codecs);
-    // TODO: validate codec
-    buffer = buffer.slice(varint__default["default"].decode.bytes);
-    this.size = varint__default["default"].decode(buffer);
-    this.digest = buffer.slice(varint__default["default"].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 $49a5bac9b2dfe7a8$export$2e2bcd8739ae039 extends (0, $78f9a5b9b57d161a$export$2e2bcd8739ae039) {
+    constructor(buffer, options = {}){
+        super();
+        if (options.name) this.name = options.name;
+        else this.name = "disco-hash";
+        if (options.codecs) this.codecs = options.codecs;
+        if (buffer) {
+            if (buffer instanceof Uint8Array) {
+                this.discoCodec = new (0, $40c292043964c309$export$2e2bcd8739ae039)(buffer, this.codecs);
+                const name = this.discoCodec.name;
+                if (name) {
+                    this.name = name;
+                    this.decode(buffer);
+                } else this.encode(buffer);
+            }
+            if (typeof buffer === "string") {
+                if (this.isHex(buffer)) this.fromHex(buffer);
+                if (this.isBase32(buffer)) this.fromBs32(buffer);
+                else if (this.isBase58(buffer)) this.fromBs58(buffer);
+                else throw new Error(`unsupported string ${buffer}`);
+            } else if (typeof buffer === "object") this.fromJSON(buffer);
+        }
+    }
+    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 (0, ($parcel$interopDefault($kmf1g$varint))).encode(this.size);
+    }
+    get buffer() {
+        return this.encoded;
+    }
+    get hash() {
+        return this.encoded;
+    }
+    fromJSON(json) {
+        return this.encode(Buffer.from(JSON.stringify(json)));
+    }
+    encode(buffer, name) {
+        if (!this.name && name) this.name = name;
+        if (!buffer) buffer = this.buffer;
+        this.discoCodec = new (0, $40c292043964c309$export$2e2bcd8739ae039)(this.name, this.codecs);
+        this.discoCodec.fromName(this.name);
+        let hashAlg = this.discoCodec.hashAlg;
+        if (hashAlg.includes("dbl")) {
+            hashAlg = hashAlg.replace("dbl-", "");
+            buffer = (0, ($parcel$interopDefault($kmf1g$keccak)))(hashAlg.replace("-", "")).update(buffer).digest();
+        }
+        this.digest = (0, ($parcel$interopDefault($kmf1g$keccak)))(hashAlg.replace("-", "")).update(buffer).digest();
+        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;
+    }
+    validate(buffer) {
+        if (Buffer.isBuffer(buffer)) {
+            const codec = (0, ($parcel$interopDefault($kmf1g$varint))).decode(buffer);
+            if (this.codecs[codec]) this.decode(buffer);
+            else 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 = (0, ($parcel$interopDefault($kmf1g$varint))).decode(buffer);
+        this.discoCodec = new (0, $40c292043964c309$export$2e2bcd8739ae039)(codec, this.codecs);
+        // TODO: validate codec
+        buffer = buffer.slice((0, ($parcel$interopDefault($kmf1g$varint))).decode.bytes);
+        this.size = (0, ($parcel$interopDefault($kmf1g$varint))).decode(buffer);
+        this.digest = buffer.slice((0, ($parcel$interopDefault($kmf1g$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$1 extends BasicInterface$1 {
-
-  async protoEncode(data) {
-    // check schema
-    return new TextEncoder().encode(data)
-  }
-
-  async protoDecode(data) {
-    // check schema
-    return new TextDecoder().decode(data)
-  }
-
-  async init(buffer) {
-    if (buffer instanceof Uint8Array) await this.fromUint8Array(buffer);
-    else if (buffer instanceof ArrayBuffer) await this.fromArrayBuffer(buffer);
-    else if (buffer?.name === this.name) return buffer
-    else if (buffer instanceof String) {
-      if (this.isHex(buffer)) await this.fromHex(buffer);
-      else if (this.isBase32(buffer)) await this.fromBs32(buffer);
-      else if (this.isBase58(buffer)) await this.fromBs58(buffer);
-      else throw new Error(`unsupported string ${buffer}`)
-    } else {
-      await this.create(buffer);
-    }
-    return this
-  }
-
-  /**
+
+class $ac9428d02c14dab1$export$2e2bcd8739ae039 extends (0, $78f9a5b9b57d161a$export$2e2bcd8739ae039) {
+    async protoEncode(data) {
+        // check schema
+        return new TextEncoder().encode(data);
+    }
+    async protoDecode(data) {
+        // check schema
+        return new TextDecoder().decode(data);
+    }
+    async init(buffer) {
+        if (buffer instanceof Uint8Array) await this.fromUint8Array(buffer);
+        else if (buffer instanceof ArrayBuffer) await this.fromArrayBuffer(buffer);
+        else if (buffer?.name === this.name) return buffer;
+        else if (buffer instanceof String) {
+            if (this.isHex(buffer)) await this.fromHex(buffer);
+            else if (this.isBase32(buffer)) await this.fromBs32(buffer);
+            else if (this.isBase58(buffer)) await this.fromBs58(buffer);
+            else throw new Error(`unsupported string ${buffer}`);
+        } else await this.create(buffer);
+        return this;
+    }
+    /**
    * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
    * @param {Object} proto - {encode, decode}
    * @param {Object} options - {hashFormat, name}
-   */
-  constructor(buffer, proto, options = {}) {
-    super();
-    this.proto = proto;
-    this.hashFormat = options.hashFormat || 'bs32';
-    if (options.name) this.name = options.name;
-    return this.init(buffer)
-  }
-
-  /**
+   */ constructor(buffer, proto, options = {}){
+        super();
+        this.proto = proto;
+        this.hashFormat = options.hashFormat || "bs32";
+        if (options.name) this.name = options.name;
+        return this.init(buffer);
+    }
+    /**
    * @return {PeernetHash}
-   */
-  get peernetHash() {
-    return new CodecHash$1(this.decoded, {name: this.name})
-  }
-
-  /**
+   */ get peernetHash() {
+        return new (0, $49a5bac9b2dfe7a8$export$2e2bcd8739ae039)(this.decoded, {
+            name: this.name
+        });
+    }
+    /**
    * @return {peernetHash}
-   */
-  get hash() {
-    const upper = this.hashFormat.charAt(0).toUpperCase();
-    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
-    return this.peernetHash[`to${format}`]()
-  }
-
-  /**
+   */ get hash() {
+        const upper = this.hashFormat.charAt(0).toUpperCase();
+        const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
+        return this.peernetHash[`to${format}`]();
+    }
+    /**
    * @return {Object}
-   */
-  async decode() {
-    let encoded = this.encoded;
-    const discoCodec = new PeernetCodec(this.encoded);
-    encoded = encoded.slice(discoCodec.codecBuffer.length);
-    this.name = discoCodec.name;
-    this.decoded = await this.protoDecode(encoded);
-    try {
-      this.decoded = JSON.parse(this.decoded);
-    } catch {
-      
-    }
-    return this.decoded
-  }
-
-  /**
+   */ async decode() {
+        let encoded = this.encoded;
+        const discoCodec = new (0, $40c292043964c309$export$2e2bcd8739ae039)(this.encoded);
+        encoded = encoded.slice(discoCodec.codecBuffer.length);
+        this.name = discoCodec.name;
+        this.decoded = await this.protoDecode(encoded);
+        try {
+            this.decoded = JSON.parse(this.decoded);
+        } catch  {}
+        return this.decoded;
+    }
+    /**
    * @return {Buffer}
-   */
-  async encode(decoded) {
-    if (!decoded) decoded = this.decoded;
-    const codec = new PeernetCodec(this.name);
-    const encoded = await this.protoEncode(typeof decoded === 'object' ? JSON.stringify(decoded) : decoded);
-    const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
-    uint8Array.set(codec.codecBuffer);
-    uint8Array.set(encoded, codec.codecBuffer.length);
-    this.encoded = uint8Array;
-    return this.encoded
-  }
-
-  hasCodec() {
-    if (!this.encoded) return false
-    const codec = new PeernetCodec(this.encoded);
-    if (codec.name) return true
-  }
-
-  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))
-    )
-  }
+   */ async encode(decoded) {
+        if (!decoded) decoded = this.decoded;
+        const codec = new (0, $40c292043964c309$export$2e2bcd8739ae039)(this.name);
+        const encoded = await this.protoEncode(typeof decoded === "object" ? JSON.stringify(decoded) : decoded);
+        const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
+        uint8Array.set(codec.codecBuffer);
+        uint8Array.set(encoded, codec.codecBuffer.length);
+        this.encoded = uint8Array;
+        return this.encoded;
+    }
+    hasCodec() {
+        if (!this.encoded) return false;
+        const codec = new (0, $40c292043964c309$export$2e2bcd8739ae039)(this.encoded);
+        if (codec.name) return true;
+    }
+    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)));
+    }
 }
 
-const BasicInterface = BasicInterface$1;
-const FormatInterface = FormatInterface$1;
-const CodecHash = CodecHash$1;
-const Codec = PeernetCodec;
-const Codecs = codecs;
 
-exports.BasicInterface = BasicInterface;
-exports.Codec = Codec;
-exports.CodecHash = CodecHash;
-exports.Codecs = Codecs;
-exports.FormatInterface = FormatInterface;
+
+
+
+const $ddc88a2f9ee6b3c1$export$1b7dbb60aef3044 = (0, $78f9a5b9b57d161a$export$2e2bcd8739ae039);
+const $ddc88a2f9ee6b3c1$export$a3360ca1fc583f9e = (0, $ac9428d02c14dab1$export$2e2bcd8739ae039);
+const $ddc88a2f9ee6b3c1$export$ea841ad44f0598a2 = (0, $49a5bac9b2dfe7a8$export$2e2bcd8739ae039);
+const $ddc88a2f9ee6b3c1$export$a111e9ced3f1d2d0 = (0, $40c292043964c309$export$2e2bcd8739ae039);
+const $ddc88a2f9ee6b3c1$export$1c4d583cbe1d2b10 = (0, $e02c0eac1ab634b5$export$2e2bcd8739ae039);
+
+
+//# sourceMappingURL=index.js.map