@mtkruto/node 0.1.0 → 0.1.101

package/script/deps/deno.land/std@0.203.0/crypto/to_hash_string.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @deprecated (will be removed after 0.209.0) Use `std/encoding/hex.ts` or `std/encoding/base64.ts` instead.
+ *
+ * Converts a hash to a string with a given encoding.
+ * @example
+ * ```ts
+ * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/crypto.ts";
+ * import { toHashString } from "https://deno.land/std@$STD_VERSION/crypto/to_hash_string.ts"
+ *
+ * const hash = await crypto.subtle.digest("SHA-384", new TextEncoder().encode("You hear that Mr. Anderson?"));
+ *
+ * // Hex encoding by default
+ * console.log(toHashString(hash));
+ *
+ * // Or with base64 encoding
+ * console.log(toHashString(hash, "base64"));
+ * ```
+ */
+export declare function toHashString(hash: ArrayBuffer, encoding?: "hex" | "base64"): string;

package/script/deps/deno.land/std@0.203.0/crypto/to_hash_string.js

@@ -0,0 +1,35 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHashString = void 0;
+const hex_js_1 = require("../encoding/hex.js");
+const base64_js_1 = require("../encoding/base64.js");
+const decoder = new TextDecoder();
+/**
+ * @deprecated (will be removed after 0.209.0) Use `std/encoding/hex.ts` or `std/encoding/base64.ts` instead.
+ *
+ * Converts a hash to a string with a given encoding.
+ * @example
+ * ```ts
+ * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/crypto.ts";
+ * import { toHashString } from "https://deno.land/std@$STD_VERSION/crypto/to_hash_string.ts"
+ *
+ * const hash = await crypto.subtle.digest("SHA-384", new TextEncoder().encode("You hear that Mr. Anderson?"));
+ *
+ * // Hex encoding by default
+ * console.log(toHashString(hash));
+ *
+ * // Or with base64 encoding
+ * console.log(toHashString(hash, "base64"));
+ * ```
+ */
+function toHashString(hash, encoding = "hex") {
+    switch (encoding) {
+        case "hex":
+            return decoder.decode((0, hex_js_1.encode)(new Uint8Array(hash)));
+        case "base64":
+            return (0, base64_js_1.encode)(hash);
+    }
+}
+exports.toHashString = toHashString;

package/script/deps/deno.land/std@0.203.0/crypto/unstable/keystack.d.ts

@@ -0,0 +1,46 @@
+/** Types of data that can be signed cryptographically. */
+export type Data = string | number[] | ArrayBuffer | Uint8Array;
+/** Types of keys that can be used to sign data. */
+export type Key = string | number[] | ArrayBuffer | Uint8Array;
+/** A cryptographic key chain which allows signing of data to prevent tampering,
+ * but also allows for easy key rotation without needing to re-sign the data.
+ *
+ * Data is signed as SHA256 HMAC.
+ *
+ * This was inspired by [keygrip](https://github.com/crypto-utils/keygrip/).
+ *
+ * @example
+ * ```ts
+ * import { KeyStack } from "https://deno.land/std@$STD_VERSION/crypto/keystack.ts";
+ *
+ * const keyStack = new KeyStack(["hello", "world"]);
+ * const digest = await keyStack.sign("some data");
+ *
+ * const rotatedStack = new KeyStack(["deno", "says", "hello", "world"]);
+ * await rotatedStack.verify("some data", digest); // true
+ * ```
+ */
+export declare class KeyStack {
+    #private;
+    get length(): number;
+    /** A class which accepts an array of keys that are used to sign and verify
+     * data and allows easy key rotation without invalidation of previously signed
+     * data.
+     *
+     * @param keys An iterable of keys, of which the index 0 will be used to sign
+     *             data, but verification can happen against any key.
+     */
+    constructor(keys: Iterable<Key>);
+    /** Take `data` and return a SHA256 HMAC digest that uses the current 0 index
+     * of the `keys` passed to the constructor.  This digest is in the form of a
+     * URL safe base64 encoded string. */
+    sign(data: Data): Promise<string>;
+    /** Given `data` and a `digest`, verify that one of the `keys` provided the
+     * constructor was used to generate the `digest`.  Returns `true` if one of
+     * the keys was used, otherwise `false`. */
+    verify(data: Data, digest: string): Promise<boolean>;
+    /** Given `data` and a `digest`, return the current index of the key in the
+     * `keys` passed the constructor that was used to generate the digest.  If no
+     * key can be found, the method returns `-1`. */
+    indexOf(data: Data, digest: string): Promise<number>;
+}

package/script/deps/deno.land/std@0.203.0/crypto/unstable/keystack.js

@@ -0,0 +1,176 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _KeyStack_instances, _KeyStack_cryptoKeys, _KeyStack_keys, _KeyStack_toCryptoKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyStack = void 0;
+/**
+ * Provides the {@linkcode KeyStack} class which implements the
+ * {@linkcode KeyRing} interface for managing rotatable keys.
+ *
+ * @module
+ */
+const dntShim = __importStar(require("../../../../../_dnt.shims.js"));
+const timing_safe_equal_js_1 = require("../timing_safe_equal.js");
+const base64url = __importStar(require("../../encoding/base64url.js"));
+const encoder = new TextEncoder();
+function importKey(key) {
+    if (typeof key === "string") {
+        key = encoder.encode(key);
+    }
+    else if (Array.isArray(key)) {
+        key = new Uint8Array(key);
+    }
+    return dntShim.crypto.subtle.importKey("raw", key, {
+        name: "HMAC",
+        hash: { name: "SHA-256" },
+    }, true, ["sign", "verify"]);
+}
+function sign(data, key) {
+    if (typeof data === "string") {
+        data = encoder.encode(data);
+    }
+    else if (Array.isArray(data)) {
+        data = Uint8Array.from(data);
+    }
+    return dntShim.crypto.subtle.sign("HMAC", key, data);
+}
+/** Compare two strings, Uint8Arrays, ArrayBuffers, or arrays of numbers in a
+ * way that avoids timing based attacks on the comparisons on the values.
+ *
+ * The function will return `true` if the values match, or `false`, if they
+ * do not match.
+ *
+ * This was inspired by https://github.com/suryagh/tsscmp which provides a
+ * timing safe string comparison to avoid timing attacks as described in
+ * https://codahale.com/a-lesson-in-timing-attacks/.
+ */
+async function compare(a, b) {
+    const key = new Uint8Array(32);
+    dntShim.dntGlobalThis.crypto.getRandomValues(key);
+    const cryptoKey = await importKey(key);
+    const ah = await sign(a, cryptoKey);
+    const bh = await sign(b, cryptoKey);
+    return (0, timing_safe_equal_js_1.timingSafeEqual)(ah, bh);
+}
+/** A cryptographic key chain which allows signing of data to prevent tampering,
+ * but also allows for easy key rotation without needing to re-sign the data.
+ *
+ * Data is signed as SHA256 HMAC.
+ *
+ * This was inspired by [keygrip](https://github.com/crypto-utils/keygrip/).
+ *
+ * @example
+ * ```ts
+ * import { KeyStack } from "https://deno.land/std@$STD_VERSION/crypto/keystack.ts";
+ *
+ * const keyStack = new KeyStack(["hello", "world"]);
+ * const digest = await keyStack.sign("some data");
+ *
+ * const rotatedStack = new KeyStack(["deno", "says", "hello", "world"]);
+ * await rotatedStack.verify("some data", digest); // true
+ * ```
+ */
+class KeyStack {
+    get length() {
+        return __classPrivateFieldGet(this, _KeyStack_keys, "f").length;
+    }
+    /** A class which accepts an array of keys that are used to sign and verify
+     * data and allows easy key rotation without invalidation of previously signed
+     * data.
+     *
+     * @param keys An iterable of keys, of which the index 0 will be used to sign
+     *             data, but verification can happen against any key.
+     */
+    constructor(keys) {
+        _KeyStack_instances.add(this);
+        _KeyStack_cryptoKeys.set(this, new Map());
+        _KeyStack_keys.set(this, void 0);
+        const values = Array.isArray(keys) ? keys : [...keys];
+        if (!(values.length)) {
+            throw new TypeError("keys must contain at least one value");
+        }
+        __classPrivateFieldSet(this, _KeyStack_keys, values, "f");
+    }
+    /** Take `data` and return a SHA256 HMAC digest that uses the current 0 index
+     * of the `keys` passed to the constructor.  This digest is in the form of a
+     * URL safe base64 encoded string. */
+    async sign(data) {
+        const key = await __classPrivateFieldGet(this, _KeyStack_instances, "m", _KeyStack_toCryptoKey).call(this, __classPrivateFieldGet(this, _KeyStack_keys, "f")[0]);
+        return base64url.encode(await sign(data, key));
+    }
+    /** Given `data` and a `digest`, verify that one of the `keys` provided the
+     * constructor was used to generate the `digest`.  Returns `true` if one of
+     * the keys was used, otherwise `false`. */
+    async verify(data, digest) {
+        return (await this.indexOf(data, digest)) > -1;
+    }
+    /** Given `data` and a `digest`, return the current index of the key in the
+     * `keys` passed the constructor that was used to generate the digest.  If no
+     * key can be found, the method returns `-1`. */
+    async indexOf(data, digest) {
+        for (let i = 0; i < __classPrivateFieldGet(this, _KeyStack_keys, "f").length; i++) {
+            const cryptoKey = await __classPrivateFieldGet(this, _KeyStack_instances, "m", _KeyStack_toCryptoKey).call(this, __classPrivateFieldGet(this, _KeyStack_keys, "f")[i]);
+            if (await compare(digest, base64url.encode(await sign(data, cryptoKey)))) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    [(_KeyStack_cryptoKeys = new WeakMap(), _KeyStack_keys = new WeakMap(), _KeyStack_instances = new WeakSet(), _KeyStack_toCryptoKey = async function _KeyStack_toCryptoKey(key) {
+        if (!__classPrivateFieldGet(this, _KeyStack_cryptoKeys, "f").has(key)) {
+            __classPrivateFieldGet(this, _KeyStack_cryptoKeys, "f").set(key, await importKey(key));
+        }
+        return __classPrivateFieldGet(this, _KeyStack_cryptoKeys, "f").get(key);
+    }, Symbol.for("Deno.customInspect"))](inspect) {
+        const { length } = this;
+        return `${this.constructor.name} ${inspect({ length })}`;
+    }
+    [Symbol.for("nodejs.util.inspect.custom")](depth, 
+    // deno-lint-ignore no-explicit-any
+    options, inspect) {
+        if (depth < 0) {
+            return options.stylize(`[${this.constructor.name}]`, "special");
+        }
+        const newOptions = Object.assign({}, options, {
+            depth: options.depth === null ? null : options.depth - 1,
+        });
+        const { length } = this;
+        return `${options.stylize(this.constructor.name, "special")} ${inspect({ length }, newOptions)}`;
+    }
+}
+exports.KeyStack = KeyStack;

package/script/deps/deno.land/std@0.203.0/encoding/_util.d.ts

@@ -0,0 +1 @@
+export declare function validateBinaryLike(source: unknown): Uint8Array;

package/script/deps/deno.land/std@0.203.0/encoding/_util.js

@@ -0,0 +1,30 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBinaryLike = void 0;
+const encoder = new TextEncoder();
+function getTypeName(value) {
+    const type = typeof value;
+    if (type !== "object") {
+        return type;
+    }
+    else if (value === null) {
+        return "null";
+    }
+    else {
+        return value?.constructor?.name ?? "object";
+    }
+}
+function validateBinaryLike(source) {
+    if (typeof source === "string") {
+        return encoder.encode(source);
+    }
+    else if (source instanceof Uint8Array) {
+        return source;
+    }
+    else if (source instanceof ArrayBuffer) {
+        return new Uint8Array(source);
+    }
+    throw new TypeError(`The input must be a Uint8Array, a string, or an ArrayBuffer. Received a value of the type ${getTypeName(source)}.`);
+}
+exports.validateBinaryLike = validateBinaryLike;

package/script/deps/deno.land/std@0.203.0/encoding/base64.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `encodeBase64` instead.
+ *
+ * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * @param data
+ */
+export declare const encode: typeof encodeBase64;
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `decodeBase64` instead.
+ *
+ * Decodes a given RFC4648 base64 encoded string
+ * @param b64
+ */
+export declare const decode: typeof decodeBase64;
+/**
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ */
+export declare function encodeBase64(data: ArrayBuffer | Uint8Array | string): string;
+/**
+ * Decodes a given RFC4648 base64 encoded string
+ */
+export declare function decodeBase64(b64: string): Uint8Array;

package/{esm/deps/deno.land/std@0.201.0 → script/deps/deno.land/std@0.203.0}/encoding/base64.js

@@ -1,7 +1,11 @@
+"use strict";
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBase64 = exports.encodeBase64 = exports.decode = exports.encode = void 0;
+const _util_js_1 = require("./_util.js");
 /**
- * {@linkcode encode} and {@linkcode decode} for
+ * {@linkcode encodeBase64} and {@linkcode decodeBase64} for
  * [base64](https://en.wikipedia.org/wiki/Base64) encoding.
  *
  * This module is browser compatible.
@@ -9,17 +13,17 @@
  * @example
  * ```ts
  * import {
- *   decode,
- *   encode,
+ *   decodeBase64,
+ *   encodeBase64,
  * } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
  *
  * const b64Repr = "Zm9vYg==";
  *
- * const binaryData = decode(b64Repr);
+ * const binaryData = decodeBase64(b64Repr);
  * console.log(binaryData);
  * // => Uint8Array [ 102, 111, 111, 98 ]
  *
- * console.log(encode(binaryData));
+ * console.log(encodeBase64(binaryData));
  * // => Zm9vYg==
  * ```
  *
@@ -92,16 +96,26 @@ const base64abc = [
     "/",
 ];
 /**
+ * @deprecated (will be removed in 0.210.0) Use a `encodeBase64` instead.
+ *
  * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
  * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
  * @param data
  */
-export function encode(data) {
-    const uint8 = typeof data === "string"
-        ? new TextEncoder().encode(data)
-        : data instanceof Uint8Array
-            ? data
-            : new Uint8Array(data);
+exports.encode = encodeBase64;
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `decodeBase64` instead.
+ *
+ * Decodes a given RFC4648 base64 encoded string
+ * @param b64
+ */
+exports.decode = decodeBase64;
+/**
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ */
+function encodeBase64(data) {
+    // CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+    const uint8 = (0, _util_js_1.validateBinaryLike)(data);
     let result = "", i;
     const l = uint8.length;
     for (i = 2; i < l; i += 3) {
@@ -125,11 +139,11 @@ export function encode(data) {
     }
     return result;
 }
+exports.encodeBase64 = encodeBase64;
 /**
  * Decodes a given RFC4648 base64 encoded string
- * @param b64
  */
-export function decode(b64) {
+function decodeBase64(b64) {
     const binString = atob(b64);
     const size = binString.length;
     const bytes = new Uint8Array(size);
@@ -138,3 +152,4 @@ export function decode(b64) {
     }
     return bytes;
 }
+exports.decodeBase64 = decodeBase64;

package/script/deps/deno.land/std@0.203.0/encoding/base64url.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `encodeBase64Url` instead.
+ *
+ * Encodes a given ArrayBuffer or string into a base64url representation
+ * @param data
+ */
+export declare const encode: typeof encodeBase64Url;
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `decodeBase64Url` instead.
+ *
+ * Converts given base64url encoded data back to original
+ * @param b64url
+ */
+export declare const decode: typeof decodeBase64Url;
+/**
+ * Encodes a given ArrayBuffer or string into a base64url representation
+ * @param data
+ */
+export declare function encodeBase64Url(data: ArrayBuffer | Uint8Array | string): string;
+/**
+ * Converts given base64url encoded data back to original
+ * @param b64url
+ */
+export declare function decodeBase64Url(b64url: string): Uint8Array;

package/script/deps/deno.land/std@0.203.0/encoding/base64url.js

@@ -0,0 +1,108 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBase64Url = exports.encodeBase64Url = exports.decode = exports.encode = void 0;
+/**
+ * {@linkcode encodeBase64Url} and {@linkcode decodeBase64Url} for
+ * [base64 URL safe](https://en.wikipedia.org/wiki/Base64#URL_applications) encoding.
+ *
+ * This module is browser compatible.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   decodeBase64Url,
+ *   encodeBase64Url,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/base64url.ts";
+ *
+ * const binary = new TextEncoder().encode("foobar");
+ * const encoded = encodeBase64Url(binary);
+ * console.log(encoded);
+ * // => "Zm9vYmFy"
+ *
+ * console.log(decodeBase64Url(encoded));
+ * // => Uint8Array(6) [ 102, 111, 111, 98, 97, 114 ]
+ * ```
+ *
+ * @module
+ */
+const base64 = __importStar(require("./base64.js"));
+/*
+ * Some variants allow or require omitting the padding '=' signs:
+ * https://en.wikipedia.org/wiki/Base64#The_URL_applications
+ * @param base64url
+ */
+function addPaddingToBase64url(base64url) {
+    if (base64url.length % 4 === 2)
+        return base64url + "==";
+    if (base64url.length % 4 === 3)
+        return base64url + "=";
+    if (base64url.length % 4 === 1) {
+        throw new TypeError("Illegal base64url string!");
+    }
+    return base64url;
+}
+function convertBase64urlToBase64(b64url) {
+    if (!/^[-_A-Z0-9]*?={0,2}$/i.test(b64url)) {
+        // Contains characters not part of base64url spec.
+        throw new TypeError("Failed to decode base64url: invalid character");
+    }
+    return addPaddingToBase64url(b64url).replace(/\-/g, "+").replace(/_/g, "/");
+}
+function convertBase64ToBase64url(b64) {
+    return b64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `encodeBase64Url` instead.
+ *
+ * Encodes a given ArrayBuffer or string into a base64url representation
+ * @param data
+ */
+exports.encode = encodeBase64Url;
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `decodeBase64Url` instead.
+ *
+ * Converts given base64url encoded data back to original
+ * @param b64url
+ */
+exports.decode = decodeBase64Url;
+/**
+ * Encodes a given ArrayBuffer or string into a base64url representation
+ * @param data
+ */
+function encodeBase64Url(data) {
+    return convertBase64ToBase64url(base64.encodeBase64(data));
+}
+exports.encodeBase64Url = encodeBase64Url;
+/**
+ * Converts given base64url encoded data back to original
+ * @param b64url
+ */
+function decodeBase64Url(b64url) {
+    return base64.decodeBase64(convertBase64urlToBase64(b64url));
+}
+exports.decodeBase64Url = decodeBase64Url;

package/script/deps/deno.land/std@0.203.0/encoding/hex.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `encodeHex` instead.
+ *
+ * Encodes `src` into `src.length * 2` bytes.
+ */
+export declare function encode(src: Uint8Array): Uint8Array;
+/** Encodes the source into hex string. */
+export declare function encodeHex(src: string | Uint8Array | ArrayBuffer): string;
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `decodeHex` instead.
+ *
+ * Decodes `src` into `src.length / 2` bytes.
+ * If the input is malformed, an error will be thrown.
+ */
+export declare function decode(src: Uint8Array): Uint8Array;
+/** Decodes the given hex string to Uint8Array.
+ * If the input is malformed, an error will be thrown. */
+export declare function decodeHex(src: string): Uint8Array;