@hiero-ledger/sdk 2.70.0

package/lib/encoding/hex.browser.cjs

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decode = decode;
+exports.encode = encode;
+exports.hexZeroPadded = hexZeroPadded;
+exports.isHexString = isHexString;
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @type {string[]}
+ */
+const byteToHex = [];
+for (let n = 0; n <= 0xff; n += 1) {
+  byteToHex.push(n.toString(16).padStart(2, "0"));
+}
+
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function encode(data) {
+  let string = "";
+  for (const byte of data) {
+    string += byteToHex[byte];
+  }
+  return string;
+}
+
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+function decode(text) {
+  const str = text.startsWith("0x") ? text.substring(2) : text;
+  const result = str.match(/.{1,2}/gu);
+  return new Uint8Array((result == null ? [] : result).map(byte => parseInt(byte, 16)));
+}
+
+/**
+ * Check if a string is a valid hexadecimal string
+ * @param {string} text - The string to check
+ * @returns {boolean} - True if the string is a valid hex string, false otherwise
+ */
+function isHexString(text) {
+  if (typeof text !== "string") {
+    return false;
+  }
+  const str = text.startsWith("0x") ? text.substring(2) : text;
+
+  // Check if the string is empty after removing 0x prefix
+  if (str.length === 0) {
+    return false;
+  }
+
+  // Check if the string has even length (hex pairs)
+  if (str.length % 2 !== 0) {
+    return false;
+  }
+
+  // Check if all characters are valid hex digits
+  const hexRegex = /^[0-9a-fA-F]+$/;
+  return hexRegex.test(str);
+}
+
+/**
+ * Encode with a specified length. Supports zero padding if the most significant byte is 0
+ *
+ * https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315
+ *
+ * @param {Uint8Array} value
+ * @param {number} length
+ * @returns {string}
+ */
+function hexZeroPadded(value, length) {
+  const HexCharacters = "0123456789abcdef";
+
+  // https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L243
+  let result = "0x";
+  for (let i = 0; i < value.length; i++) {
+    let v = value[i];
+    result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];
+  }
+
+  // https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315
+  if (result.length > 2 * length + 2) {
+    console.log("result out of range", "result");
+  }
+  while (result.length < 2 * length + 2) {
+    result = "0x0" + result.substring(2);
+  }
+  return result.substring(2);
+}

package/lib/encoding/hex.browser.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+export function encode(data: Uint8Array): string;
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+export function decode(text: string): Uint8Array;
+/**
+ * Check if a string is a valid hexadecimal string
+ * @param {string} text - The string to check
+ * @returns {boolean} - True if the string is a valid hex string, false otherwise
+ */
+export function isHexString(text: string): boolean;
+/**
+ * Encode with a specified length. Supports zero padding if the most significant byte is 0
+ *
+ * https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315
+ *
+ * @param {Uint8Array} value
+ * @param {number} length
+ * @returns {string}
+ */
+export function hexZeroPadded(value: Uint8Array, length: number): string;

package/lib/encoding/hex.browser.js

@@ -0,0 +1,2 @@
+const t=[];for(let n=0;n<=255;n+=1)t.push(n.toString(16).padStart(2,"0"));function n(n){let r="";for(const s of n)r+=t[s];return r}function r(t){const n=(t.startsWith("0x")?t.substring(2):t).match(/.{1,2}/gu);return new Uint8Array((null==n?[]:n).map((t=>parseInt(t,16))))}function s(t){if("string"!=typeof t)return!1;const n=t.startsWith("0x")?t.substring(2):t;if(0===n.length)return!1;if(n.length%2!=0)return!1;return/^[0-9a-fA-F]+$/.test(n)}export{r as decode,n as encode,s as isHexString};
+//# sourceMappingURL=hex.browser.js.map

package/lib/encoding/hex.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.browser.js","sources":["../../src/encoding/hex.browser.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * @type {string[]}\n */\nconst byteToHex = [];\n\nfor (let n = 0; n <= 0xff; n += 1) {\n    byteToHex.push(n.toString(16).padStart(2, \"0\"));\n}\n\n/**\n * @param {Uint8Array} data\n * @returns {string}\n */\nexport function encode(data) {\n    let string = \"\";\n\n    for (const byte of data) {\n        string += byteToHex[byte];\n    }\n\n    return string;\n}\n\n/**\n * @param {string} text\n * @returns {Uint8Array}\n */\nexport function decode(text) {\n    const str = text.startsWith(\"0x\") ? text.substring(2) : text;\n    const result = str.match(/.{1,2}/gu);\n\n    return new Uint8Array(\n        (result == null ? [] : result).map((byte) => parseInt(byte, 16)),\n    );\n}\n\n/**\n * Check if a string is a valid hexadecimal string\n * @param {string} text - The string to check\n * @returns {boolean} - True if the string is a valid hex string, false otherwise\n */\nexport function isHexString(text) {\n    if (typeof text !== \"string\") {\n        return false;\n    }\n\n    const str = text.startsWith(\"0x\") ? text.substring(2) : text;\n\n    // Check if the string is empty after removing 0x prefix\n    if (str.length === 0) {\n        return false;\n    }\n\n    // Check if the string has even length (hex pairs)\n    if (str.length % 2 !== 0) {\n        return false;\n    }\n\n    // Check if all characters are valid hex digits\n    const hexRegex = /^[0-9a-fA-F]+$/;\n    return hexRegex.test(str);\n}\n\n/**\n * Encode with a specified length. Supports zero padding if the most significant byte is 0\n *\n * https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315\n *\n * @param {Uint8Array} value\n * @param {number} length\n * @returns {string}\n */\nexport function hexZeroPadded(value, length) {\n    const HexCharacters = \"0123456789abcdef\";\n\n    // https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L243\n    let result = \"0x\";\n    for (let i = 0; i < value.length; i++) {\n        let v = value[i];\n        result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];\n    }\n\n    // https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315\n    if (result.length > 2 * length + 2) {\n        console.log(\"result out of range\", \"result\");\n    }\n\n    while (result.length < 2 * length + 2) {\n        result = \"0x0\" + result.substring(2);\n    }\n\n    return result.substring(2);\n}\n"],"names":["byteToHex","n","push","toString","padStart","encode","data","string","byte","decode","text","result","startsWith","substring","match","Uint8Array","map","parseInt","isHexString","str","length","test"],"mappings":"AAKA,MAAMA,EAAY,GAElB,IAAK,IAAIC,EAAI,EAAGA,GAAK,IAAMA,GAAK,EAC5BD,EAAUE,KAAKD,EAAEE,SAAS,IAAIC,SAAS,EAAG,MAOvC,SAASC,EAAOC,GACnB,IAAIC,EAAS,GAEb,IAAK,MAAMC,KAAQF,EACfC,GAAUP,EAAUQ,GAGxB,OAAOD,CACX,CAMO,SAASE,EAAOC,GACnB,MACMC,GADMD,EAAKE,WAAW,MAAQF,EAAKG,UAAU,GAAKH,GACrCI,MAAM,YAEzB,OAAO,IAAIC,YACI,MAAVJ,EAAiB,GAAKA,GAAQK,KAAKR,GAASS,SAAST,EAAM,MAEpE,CAOO,SAASU,EAAYR,GACxB,GAAoB,iBAATA,EACP,OAAO,EAGX,MAAMS,EAAMT,EAAKE,WAAW,MAAQF,EAAKG,UAAU,GAAKH,EAGxD,GAAmB,IAAfS,EAAIC,OACJ,OAAO,EAIX,GAAID,EAAIC,OAAS,GAAM,EACnB,OAAO,EAKX,MADiB,iBACDC,KAAKF,EACzB"}

package/lib/encoding/hex.cjs

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decode = decode;
+exports.encode = encode;
+exports.hexZeroPadded = hexZeroPadded;
+exports.isHexString = isHexString;
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function encode(data) {
+  return Buffer.from(data).toString("hex");
+}
+
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+function decode(text) {
+  const str = text.startsWith("0x") ? text.substring(2) : text;
+  return Buffer.from(str, "hex");
+}
+
+/**
+ * Check if a string is a valid hexadecimal string
+ * @param {string} text - The string to check
+ * @returns {boolean} - True if the string is a valid hex string, false otherwise
+ */
+function isHexString(text) {
+  if (typeof text !== "string") {
+    return false;
+  }
+  const str = text.startsWith("0x") ? text.substring(2) : text;
+
+  // Check if the string is empty after removing 0x prefix
+  if (str.length === 0) {
+    return false;
+  }
+
+  // Check if the string has even length (hex pairs)
+  if (str.length % 2 !== 0) {
+    return false;
+  }
+
+  // Check if all characters are valid hex digits
+  const hexRegex = /^[0-9a-fA-F]+$/;
+  return hexRegex.test(str);
+}
+
+/**
+ * Encode with a specified length. Supports zero padding if the most significant byte is 0
+ *
+ * https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315
+ *
+ * @param {Uint8Array} value
+ * @param {number} length
+ * @returns {string}
+ */
+function hexZeroPadded(value, length) {
+  const HexCharacters = "0123456789abcdef";
+
+  // https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L243
+  let result = "0x";
+  for (let i = 0; i < value.length; i++) {
+    let v = value[i];
+    result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];
+  }
+
+  // https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315
+  if (result.length > 2 * length + 2) {
+    console.log("result out of range", "result");
+  }
+  while (result.length < 2 * length + 2) {
+    result = "0x0" + result.substring(2);
+  }
+  return result.substring(2);
+}

package/lib/encoding/hex.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+export function encode(data: Uint8Array): string;
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+export function decode(text: string): Uint8Array;
+/**
+ * Check if a string is a valid hexadecimal string
+ * @param {string} text - The string to check
+ * @returns {boolean} - True if the string is a valid hex string, false otherwise
+ */
+export function isHexString(text: string): boolean;
+/**
+ * Encode with a specified length. Supports zero padding if the most significant byte is 0
+ *
+ * https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315
+ *
+ * @param {Uint8Array} value
+ * @param {number} length
+ * @returns {string}
+ */
+export function hexZeroPadded(value: Uint8Array, length: number): string;

package/lib/encoding/hex.js

@@ -0,0 +1,2 @@
+function t(t){return Buffer.from(t).toString("hex")}function r(t){const r=t.startsWith("0x")?t.substring(2):t;return Buffer.from(r,"hex")}function n(t){if("string"!=typeof t)return!1;const r=t.startsWith("0x")?t.substring(2):t;if(0===r.length)return!1;if(r.length%2!=0)return!1;return/^[0-9a-fA-F]+$/.test(r)}export{r as decode,t as encode,n as isHexString};
+//# sourceMappingURL=hex.js.map

package/lib/encoding/hex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.js","sources":["../../src/encoding/hex.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * @param {Uint8Array} data\n * @returns {string}\n */\nexport function encode(data) {\n    return Buffer.from(data).toString(\"hex\");\n}\n\n/**\n * @param {string} text\n * @returns {Uint8Array}\n */\nexport function decode(text) {\n    const str = text.startsWith(\"0x\") ? text.substring(2) : text;\n    return Buffer.from(str, \"hex\");\n}\n\n/**\n * Check if a string is a valid hexadecimal string\n * @param {string} text - The string to check\n * @returns {boolean} - True if the string is a valid hex string, false otherwise\n */\nexport function isHexString(text) {\n    if (typeof text !== \"string\") {\n        return false;\n    }\n\n    const str = text.startsWith(\"0x\") ? text.substring(2) : text;\n\n    // Check if the string is empty after removing 0x prefix\n    if (str.length === 0) {\n        return false;\n    }\n\n    // Check if the string has even length (hex pairs)\n    if (str.length % 2 !== 0) {\n        return false;\n    }\n\n    // Check if all characters are valid hex digits\n    const hexRegex = /^[0-9a-fA-F]+$/;\n    return hexRegex.test(str);\n}\n\n/**\n * Encode with a specified length. Supports zero padding if the most significant byte is 0\n *\n * https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315\n *\n * @param {Uint8Array} value\n * @param {number} length\n * @returns {string}\n */\nexport function hexZeroPadded(value, length) {\n    const HexCharacters = \"0123456789abcdef\";\n\n    // https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L243\n    let result = \"0x\";\n    for (let i = 0; i < value.length; i++) {\n        let v = value[i];\n        result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];\n    }\n\n    // https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315\n    if (result.length > 2 * length + 2) {\n        console.log(\"result out of range\", \"result\");\n    }\n\n    while (result.length < 2 * length + 2) {\n        result = \"0x0\" + result.substring(2);\n    }\n\n    return result.substring(2);\n}\n"],"names":["encode","data","Buffer","from","toString","decode","text","str","startsWith","substring","isHexString","length","test"],"mappings":"AAMO,SAASA,EAAOC,GACnB,OAAOC,OAAOC,KAAKF,GAAMG,SAAS,MACtC,CAMO,SAASC,EAAOC,GACnB,MAAMC,EAAMD,EAAKE,WAAW,MAAQF,EAAKG,UAAU,GAAKH,EACxD,OAAOJ,OAAOC,KAAKI,EAAK,MAC5B,CAOO,SAASG,EAAYJ,GACxB,GAAoB,iBAATA,EACP,OAAO,EAGX,MAAMC,EAAMD,EAAKE,WAAW,MAAQF,EAAKG,UAAU,GAAKH,EAGxD,GAAmB,IAAfC,EAAII,OACJ,OAAO,EAIX,GAAIJ,EAAII,OAAS,GAAM,EACnB,OAAO,EAKX,MADiB,iBACDC,KAAKL,EACzB"}

package/lib/encoding/hex.native.cjs

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decode = decode;
+exports.decodeFromByteString = decodeFromByteString;
+exports.encode = encode;
+exports.encodeToByteString = encodeToByteString;
+exports.hexZeroPadded = hexZeroPadded;
+exports.isHexString = isHexString;
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @type {string[]}
+ */
+const byteToHex = [];
+
+/**
+ * @type {string[]}
+ */
+const byteToHexByteString = ["\x00", "\x01", "\x02", "\x03", "\x04", "\x05", "\x06", "\x07", "\x08", "\x09", "\x0A", "\x0B", "\x0C", "\x0D", "\x0E", "\x0F", "\x10", "\x11", "\x12", "\x13", "\x14", "\x15", "\x16", "\x17", "\x18", "\x19", "\x1A", "\x1B", "\x1C", "\x1D", "\x1E", "\x1F", "\x20", "\x21", "\x22", "\x23", "\x24", "\x25", "\x26", "\x27", "\x28", "\x29", "\x2A", "\x2B", "\x2C", "\x2D", "\x2E", "\x2F", "\x30", "\x31", "\x32", "\x33", "\x34", "\x35", "\x36", "\x37", "\x38", "\x39", "\x3A", "\x3B", "\x3C", "\x3D", "\x3E", "\x3F", "\x40", "\x41", "\x42", "\x43", "\x44", "\x45", "\x46", "\x47", "\x48", "\x49", "\x4A", "\x4B", "\x4C", "\x4D", "\x4E", "\x4F", "\x50", "\x51", "\x52", "\x53", "\x54", "\x55", "\x56", "\x57", "\x58", "\x59", "\x5A", "\x5B", "\x5C", "\x5D", "\x5E", "\x5F", "\x60", "\x61", "\x62", "\x63", "\x64", "\x65", "\x66", "\x67", "\x68", "\x69", "\x6A", "\x6B", "\x6C", "\x6D", "\x6E", "\x6F", "\x70", "\x71", "\x72", "\x73", "\x74", "\x75", "\x76", "\x77", "\x78", "\x79", "\x7A", "\x7B", "\x7C", "\x7D", "\x7E", "\x7F", "\x80", "\x81", "\x82", "\x83", "\x84", "\x85", "\x86", "\x87", "\x88", "\x89", "\x8A", "\x8B", "\x8C", "\x8D", "\x8E", "\x8F", "\x90", "\x91", "\x92", "\x93", "\x94", "\x95", "\x96", "\x97", "\x98", "\x99", "\x9A", "\x9B", "\x9C", "\x9D", "\x9E", "\x9F", "\xA0", "\xA1", "\xA2", "\xA3", "\xA4", "\xA5", "\xA6", "\xA7", "\xA8", "\xA9", "\xAA", "\xAB", "\xAC", "\xAD", "\xAE", "\xAF", "\xB0", "\xB1", "\xB2", "\xB3", "\xB4", "\xB5", "\xB6", "\xB7", "\xB8", "\xB9", "\xBA", "\xBB", "\xBC", "\xBD", "\xBE", "\xBF", "\xC0", "\xC1", "\xC2", "\xC3", "\xC4", "\xC5", "\xC6", "\xC7", "\xC8", "\xC9", "\xCA", "\xCB", "\xCC", "\xCD", "\xCE", "\xCF", "\xD0", "\xD1", "\xD2", "\xD3", "\xD4", "\xD5", "\xD6", "\xD7", "\xD8", "\xD9", "\xDA", "\xDB", "\xDC", "\xDD", "\xDE", "\xDF", "\xE0", "\xE1", "\xE2", "\xE3", "\xE4", "\xE5", "\xE6", "\xE7", "\xE8", "\xE9", "\xEA", "\xEB", "\xEC", "\xED", "\xEE", "\xEF", "\xF0", "\xF1", "\xF2", "\xF3", "\xF4", "\xF5", "\xF6", "\xF7", "\xF8", "\xF9", "\xFA", "\xFB", "\xFC", "\xFD", "\xFE", "\xFF"];
+for (let n = 0; n <= 0xff; n += 1) {
+  byteToHex.push(n.toString(16).padStart(2, "0"));
+}
+
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function encode(data) {
+  let string = "";
+  for (const byte of data) {
+    string += byteToHex[byte];
+  }
+  return string;
+}
+
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+function decode(text) {
+  const str = text.startsWith("0x") ? text.substring(2) : text;
+  const result = str.match(/.{1,2}/gu);
+  return new Uint8Array((result == null ? [] : result).map(byte => parseInt(byte, 16)));
+}
+
+/**
+ * Check if a string is a valid hexadecimal string
+ * @param {string} text - The string to check
+ * @returns {boolean} - True if the string is a valid hex string, false otherwise
+ */
+function isHexString(text) {
+  if (typeof text !== "string") {
+    return false;
+  }
+  const str = text.startsWith("0x") ? text.substring(2) : text;
+
+  // Check if the string is empty after removing 0x prefix
+  if (str.length === 0) {
+    return false;
+  }
+
+  // Check if the string has even length (hex pairs)
+  if (str.length % 2 !== 0) {
+    return false;
+  }
+
+  // Check if all characters are valid hex digits
+  const hexRegex = /^[0-9a-fA-F]+$/;
+  return hexRegex.test(str);
+}
+
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function encodeToByteString(data) {
+  let string = "";
+  for (const byte of data) {
+    string += byteToHexByteString[byte];
+  }
+  return string;
+}
+
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+function decodeFromByteString(text) {
+  const buffer = new Uint8Array(text.length);
+  const view = new DataView(buffer.buffer);
+  for (let i = 0; i < text.length; i++) {
+    view.setUint8(i, text.charCodeAt(i));
+  }
+  return buffer;
+}
+
+/**
+ * Encode with a specified length. Supports zero padding if the most significant byte is 0
+ *
+ * https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315
+ *
+ * @param {Uint8Array} value
+ * @param {number} length
+ * @returns {string}
+ */
+function hexZeroPadded(value, length) {
+  const HexCharacters = "0123456789abcdef";
+
+  // https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L243
+  let result = "0x";
+  for (let i = 0; i < value.length; i++) {
+    let v = value[i];
+    result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];
+  }
+
+  // https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315
+  if (result.length > 2 * length + 2) {
+    console.log("result out of range", "result");
+  }
+  while (result.length < 2 * length + 2) {
+    result = "0x0" + result.substring(2);
+  }
+  return result.substring(2);
+}

package/lib/encoding/hex.native.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+export function encode(data: Uint8Array): string;
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+export function decode(text: string): Uint8Array;
+/**
+ * Check if a string is a valid hexadecimal string
+ * @param {string} text - The string to check
+ * @returns {boolean} - True if the string is a valid hex string, false otherwise
+ */
+export function isHexString(text: string): boolean;
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+export function encodeToByteString(data: Uint8Array): string;
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+export function decodeFromByteString(text: string): Uint8Array;
+/**
+ * Encode with a specified length. Supports zero padding if the most significant byte is 0
+ *
+ * https://github.com/ethers-io/ethers.js/blob/master/packages/bytes/src.ts/index.ts#L315
+ *
+ * @param {Uint8Array} value
+ * @param {number} length
+ * @returns {string}
+ */
+export function hexZeroPadded(value: Uint8Array, length: number): string;

package/lib/encoding/utf8.browser.cjs

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decode = decode;
+exports.encode = encode;
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function decode(data) {
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins
+  return new TextDecoder().decode(data);
+}
+
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+function encode(text) {
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins
+  return new TextEncoder().encode(text);
+}

package/lib/encoding/utf8.browser.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+export function decode(data: Uint8Array): string;
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+export function encode(text: string): Uint8Array;

package/lib/encoding/utf8.browser.js

@@ -0,0 +1,2 @@
+function e(e){return(new TextDecoder).decode(e)}function n(e){return(new TextEncoder).encode(e)}export{e as decode,n as encode};
+//# sourceMappingURL=utf8.browser.js.map

package/lib/encoding/utf8.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8.browser.js","sources":["../../src/encoding/utf8.browser.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * @param {Uint8Array} data\n * @returns {string}\n */\nexport function decode(data) {\n    // eslint-disable-next-line n/no-unsupported-features/node-builtins\n    return new TextDecoder().decode(data);\n}\n\n/**\n * @param {string} text\n * @returns {Uint8Array}\n */\nexport function encode(text) {\n    // eslint-disable-next-line n/no-unsupported-features/node-builtins\n    return new TextEncoder().encode(text);\n}\n"],"names":["decode","data","TextDecoder","encode","text","TextEncoder"],"mappings":"AAMO,SAASA,EAAOC,GAEnB,OAAO,IAAIC,aAAcF,OAAOC,EACpC,CAMO,SAASE,EAAOC,GAEnB,OAAO,IAAIC,aAAcF,OAAOC,EACpC"}

package/lib/encoding/utf8.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decode = decode;
+exports.encode = encode;
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function decode(data) {
+  return Buffer.from(data).toString("utf8");
+}
+
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+function encode(text) {
+  return Buffer.from(text, "utf8");
+}

package/lib/encoding/utf8.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+export function decode(data: Uint8Array): string;
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+export function encode(text: string): Uint8Array;

package/lib/encoding/utf8.js

@@ -0,0 +1,2 @@
+function f(f){return Buffer.from(f).toString("utf8")}function r(f){return Buffer.from(f,"utf8")}export{f as decode,r as encode};
+//# sourceMappingURL=utf8.js.map

package/lib/encoding/utf8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8.js","sources":["../../src/encoding/utf8.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\n/**\n * @param {Uint8Array} data\n * @returns {string}\n */\nexport function decode(data) {\n    return Buffer.from(data).toString(\"utf8\");\n}\n\n/**\n * @param {string} text\n * @returns {Uint8Array}\n */\nexport function encode(text) {\n    return Buffer.from(text, \"utf8\");\n}\n"],"names":["decode","data","Buffer","from","toString","encode","text"],"mappings":"AAMO,SAASA,EAAOC,GACnB,OAAOC,OAAOC,KAAKF,GAAMG,SAAS,OACtC,CAMO,SAASC,EAAOC,GACnB,OAAOJ,OAAOC,KAAKG,EAAM,OAC7B"}

package/lib/encoding/utf8.native.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decode = decode;
+exports.encode = encode;
+var _utf = _interopRequireDefault(require("utf8"));
+var hex = _interopRequireWildcard(require("./hex.native.cjs"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function decode(data) {
+  return _utf.default.decode(hex.encodeToByteString(data));
+}
+
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+function encode(text) {
+  return hex.decodeFromByteString(_utf.default.encode(text));
+}

package/lib/encoding/utf8.native.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+export function decode(data: Uint8Array): string;
+/**
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+export function encode(text: string): Uint8Array;