@mtkruto/node 0.1.0 → 0.1.101

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

@@ -0,0 +1,122 @@
+"use strict";
+// Copyright 2009 The Go Authors. All rights reserved.
+// https://github.com/golang/go/blob/master/LICENSE
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeHex = exports.decode = exports.encodeHex = exports.encode = void 0;
+const _util_js_1 = require("./_util.js");
+/** Port of the Go
+ * [encoding/hex](https://github.com/golang/go/blob/go1.12.5/src/encoding/hex/hex.go)
+ * library.
+ *
+ * This module is browser compatible.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   decodeHex,
+ *   encodeHex,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/hex.ts";
+ *
+ * const binary = new TextEncoder().encode("abc");
+ * const encoded = encodeHex(binary);
+ * console.log(encoded);
+ * // => "616263"
+ *
+ * console.log(decodeHex(encoded));
+ * // => Uint8Array(3) [ 97, 98, 99 ]
+ * ```
+ *
+ * @module
+ */
+const hexTable = new TextEncoder().encode("0123456789abcdef");
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function errInvalidByte(byte) {
+    return new TypeError(`Invalid byte '${String.fromCharCode(byte)}'`);
+}
+function errLength() {
+    return new RangeError("Odd length hex string");
+}
+/** Converts a hex character into its value. */
+function fromHexChar(byte) {
+    // '0' <= byte && byte <= '9'
+    if (48 <= byte && byte <= 57)
+        return byte - 48;
+    // 'a' <= byte && byte <= 'f'
+    if (97 <= byte && byte <= 102)
+        return byte - 97 + 10;
+    // 'A' <= byte && byte <= 'F'
+    if (65 <= byte && byte <= 70)
+        return byte - 65 + 10;
+    throw errInvalidByte(byte);
+}
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `encodeHex` instead.
+ *
+ * Encodes `src` into `src.length * 2` bytes.
+ */
+function encode(src) {
+    const dst = new Uint8Array(src.length * 2);
+    for (let i = 0; i < dst.length; i++) {
+        const v = src[i];
+        dst[i * 2] = hexTable[v >> 4];
+        dst[i * 2 + 1] = hexTable[v & 0x0f];
+    }
+    return dst;
+}
+exports.encode = encode;
+/** Encodes the source into hex string. */
+function encodeHex(src) {
+    const u8 = (0, _util_js_1.validateBinaryLike)(src);
+    const dst = new Uint8Array(u8.length * 2);
+    for (let i = 0; i < dst.length; i++) {
+        const v = u8[i];
+        dst[i * 2] = hexTable[v >> 4];
+        dst[i * 2 + 1] = hexTable[v & 0x0f];
+    }
+    return textDecoder.decode(dst);
+}
+exports.encodeHex = encodeHex;
+/**
+ * @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.
+ */
+function decode(src) {
+    const dst = new Uint8Array(src.length / 2);
+    for (let i = 0; i < dst.length; i++) {
+        const a = fromHexChar(src[i * 2]);
+        const b = fromHexChar(src[i * 2 + 1]);
+        dst[i] = (a << 4) | b;
+    }
+    if (src.length % 2 === 1) {
+        // Check for invalid char before reporting bad length,
+        // since the invalid char (if present) is an earlier problem.
+        fromHexChar(src[dst.length * 2]);
+        throw errLength();
+    }
+    return dst;
+}
+exports.decode = decode;
+/** Decodes the given hex string to Uint8Array.
+ * If the input is malformed, an error will be thrown. */
+function decodeHex(src) {
+    const u8 = textEncoder.encode(src);
+    const dst = new Uint8Array(u8.length / 2);
+    for (let i = 0; i < dst.length; i++) {
+        const a = fromHexChar(u8[i * 2]);
+        const b = fromHexChar(u8[i * 2 + 1]);
+        dst[i] = (a << 4) | b;
+    }
+    if (u8.length % 2 === 1) {
+        // Check for invalid char before reporting bad length,
+        // since the invalid char (if present) is an earlier problem.
+        fromHexChar(u8[dst.length * 2]);
+        throw errLength();
+    }
+    return dst;
+}
+exports.decodeHex = decodeHex;

package/script/deps/deno.land/{std@0.201.0 → std@0.203.0}/fmt/colors.js

@@ -536,7 +536,7 @@ exports.bgRgb24 = bgRgb24;
 // https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
 const ANSI_PATTERN = new RegExp([
     "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
-    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))",
 ].join("|"), "g");
 /**
  * @deprecated (will be removed in 1.0.0) Use `stripAnsiCode` instead.

package/{esm/deps/deno.land/x/tgcrypto@0.2.1 → script/deps/deno.land/x/tgcrypto@0.3.3}/mod.d.ts

@@ -16,18 +16,14 @@ export declare function ige256Encrypt(data: Uint8Array, key: Uint8Array, iv: Uin
  */
 export declare function ige256Decrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
 /**
- * Performs CTR-256 encryption.
+ * Performs CTR-256 encryption/decryption.
  *
  * @param data The data, larger than a byte
  * @param key 32-byte encryption key
  * @param iv 16-byte initialization vector
  * @param state 1-byte state
  */
-export declare function ctr256Encrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): [Uint8Array, Uint8Array];
-/**
- * Alias of `ctr256Encrypt`
- */
-export declare function ctr256Decrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): [Uint8Array, Uint8Array];
+export declare function ctr256(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): void;
 /**
  * Performs CBC-256 encryption.
  *

package/script/deps/deno.land/x/tgcrypto@0.3.3/mod.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factorize = exports.cbc256Decrypt = exports.cbc256Encrypt = exports.ctr256 = exports.ige256Decrypt = exports.ige256Encrypt = exports.init = void 0;
+const tgcrypto_js_1 = __importDefault(require("./tgcrypto.js"));
+// deno-lint-ignore no-explicit-any
+let module_;
+const promise = (0, tgcrypto_js_1.default)().then((v) => module_ = v);
+async function init() {
+    await promise;
+}
+exports.init = init;
+function checkIgeParams(data, key, iv) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (data.length % 16 != 0) {
+        throw new TypeError("data must consist of a number of bytes that is divisible by 16");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 32) {
+        throw new TypeError("iv must be 32 bytes");
+    }
+}
+/**
+ * Performs IGE-256 encryption.
+ *
+ * @param data The unencrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 32-byte initialization vector
+ */
+function ige256Encrypt(data, key, iv) {
+    checkIgeParams(data, key, iv);
+    const out = module_._malloc(data.length);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("ige256_encrypt", "void", ["pointer", "pointer", "number", "array", "array"], [datap, out, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(out, out + data.length);
+    }
+    finally {
+        module_._free(out);
+        module_._free(datap);
+    }
+}
+exports.ige256Encrypt = ige256Encrypt;
+/**
+ * Performs IGE-256 decryption.
+ *
+ * @param data The encrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 32-byte initialization vector
+ */
+function ige256Decrypt(data, key, iv) {
+    checkIgeParams(data, key, iv);
+    const out = module_._malloc(data.length);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("ige256_decrypt", "void", ["pointer", "pointer", "number", "array", "array"], [datap, out, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(out, out + data.length);
+    }
+    finally {
+        module_._free(out);
+        module_._free(datap);
+    }
+}
+exports.ige256Decrypt = ige256Decrypt;
+function checkCtrParams(data, key, iv, state) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 16) {
+        throw new TypeError("iv must be 16 bytes");
+    }
+    else if (state.length != 1) {
+        throw new TypeError("state must be 1 byte");
+    }
+}
+/**
+ * Performs CTR-256 encryption/decryption.
+ *
+ * @param data The data, larger than a byte
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ * @param state 1-byte state
+ */
+function ctr256(data, key, iv, state) {
+    checkCtrParams(data, key, iv, state);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    const ivp = module_._malloc(iv.length);
+    module_.HEAPU8.set(iv, ivp);
+    const statep = module_._malloc(state.length);
+    module_.HEAPU8.set(state, statep);
+    module_.ccall("ctr256", "void", ["pointer", "number", "array", "pointer", "pointer"], [datap, data.length, key, ivp, statep]);
+    data.set(module_.HEAPU8.slice(datap, datap + data.length));
+    iv.set(module_.HEAPU8.slice(ivp, ivp + iv.length));
+    state.set(module_.HEAPU8.slice(statep, statep + state.length));
+    module_._free(datap);
+    module_._free(ivp);
+    module_._free(statep);
+}
+exports.ctr256 = ctr256;
+function checkCbcParams(data, key, iv) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (data.length % 16 != 0) {
+        throw new TypeError("data must consist of a number of bytes that is divisible by 16");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 16) {
+        throw new TypeError("iv must be 16 bytes");
+    }
+}
+/**
+ * Performs CBC-256 encryption.
+ *
+ * @param data The unencrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ */
+function cbc256Encrypt(data, key, iv) {
+    checkCbcParams(data, key, iv);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("cbc256_encrypt", "void", ["pointer", "number", "array", "array"], [datap, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(datap, datap + data.length);
+    }
+    finally {
+        module_._free(datap);
+    }
+}
+exports.cbc256Encrypt = cbc256Encrypt;
+/**
+ * Performs CBC-256 decryption.
+ *
+ * @param data The encrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ */
+function cbc256Decrypt(data, key, iv) {
+    checkCbcParams(data, key, iv);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("cbc256_decrypt", "void", ["pointer", "number", "array", "array"], [datap, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(datap, datap + data.length);
+    }
+    finally {
+        module_._free(datap);
+    }
+}
+exports.cbc256Decrypt = cbc256Decrypt;
+function factorize(pq) {
+    const pqp = module_._malloc(16);
+    module_.ccall("factorize", "void", ["number", "pointer"], [pq, pqp]);
+    try {
+        const pqp_ = module_.HEAP64.slice(pqp / 8, pqp / 8 + 2);
+        return [pqp_[0], pqp_[1]];
+    }
+    finally {
+        module_._free(pqp);
+    }
+}
+exports.factorize = factorize;