@mtkruto/node 0.1.100 → 0.1.101

package/esm/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/esm/deps/deno.land/std@0.203.0/crypto/unstable/keystack.js

@@ -0,0 +1,149 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+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;
+/**
+ * Provides the {@linkcode KeyStack} class which implements the
+ * {@linkcode KeyRing} interface for managing rotatable keys.
+ *
+ * @module
+ */
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { timingSafeEqual } from "../timing_safe_equal.js";
+import * as base64url from "../../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 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
+ * ```
+ */
+export 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)}`;
+    }
+}

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

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

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

@@ -0,0 +1,26 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+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";
+    }
+}
+export 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)}.`);
+}

package/esm/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/{script/deps/deno.land/std@0.201.0 → esm/deps/deno.land/std@0.203.0}/encoding/base64.js

@@ -1,10 +1,8 @@
-"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.decode = exports.encode = void 0;
+import { validateBinaryLike } from "./_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.
@@ -12,17 +10,17 @@ exports.decode = exports.encode = void 0;
  * @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==
  * ```
  *
@@ -95,16 +93,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
  */
-function encode(data) {
-    const uint8 = typeof data === "string"
-        ? new TextEncoder().encode(data)
-        : data instanceof Uint8Array
-            ? data
-            : new Uint8Array(data);
+export const encode = encodeBase64;
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `decodeBase64` instead.
+ *
+ * Decodes a given RFC4648 base64 encoded string
+ * @param b64
+ */
+export const decode = decodeBase64;
+/**
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ */
+export function encodeBase64(data) {
+    // CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+    const uint8 = validateBinaryLike(data);
     let result = "", i;
     const l = uint8.length;
     for (i = 2; i < l; i += 3) {
@@ -128,12 +136,10 @@ function encode(data) {
     }
     return result;
 }
-exports.encode = encode;
 /**
  * Decodes a given RFC4648 base64 encoded string
- * @param b64
  */
-function decode(b64) {
+export function decodeBase64(b64) {
     const binString = atob(b64);
     const size = binString.length;
     const bytes = new Uint8Array(size);
@@ -142,4 +148,3 @@ function decode(b64) {
     }
     return bytes;
 }
-exports.decode = decode;

package/esm/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/esm/deps/deno.land/std@0.203.0/encoding/base64url.js

@@ -0,0 +1,80 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * {@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
+ */
+import * as base64 from "./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
+ */
+export const encode = encodeBase64Url;
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `decodeBase64Url` instead.
+ *
+ * Converts given base64url encoded data back to original
+ * @param b64url
+ */
+export const decode = decodeBase64Url;
+/**
+ * Encodes a given ArrayBuffer or string into a base64url representation
+ * @param data
+ */
+export function encodeBase64Url(data) {
+    return convertBase64ToBase64url(base64.encodeBase64(data));
+}
+/**
+ * Converts given base64url encoded data back to original
+ * @param b64url
+ */
+export function decodeBase64Url(b64url) {
+    return base64.decodeBase64(convertBase64urlToBase64(b64url));
+}

package/esm/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;

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

@@ -0,0 +1,115 @@
+// 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.
+import { validateBinaryLike } from "./_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.
+ */
+export 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;
+}
+/** Encodes the source into hex string. */
+export function encodeHex(src) {
+    const u8 = 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);
+}
+/**
+ * @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 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;
+}
+/** Decodes the given hex string to Uint8Array.
+ * If the input is malformed, an error will be thrown. */
+export 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;
+}

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

@@ -463,7 +463,7 @@ export function bgRgb24(str, color) {
 // 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.3.2 → tgcrypto@0.3.3}/mod.js

@@ -28,13 +28,16 @@ function checkIgeParams(data, key, iv) {
  */
 export function ige256Encrypt(data, key, iv) {
     checkIgeParams(data, key, iv);
-    const out = module_._malloc(1024);
-    module_.ccall("ige256_encrypt", "void", ["array", "pointer", "number", "array", "array"], [data, out, data.length, 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);
     }
 }
 /**
@@ -46,13 +49,16 @@ export function ige256Encrypt(data, key, iv) {
  */
 export function ige256Decrypt(data, key, iv) {
     checkIgeParams(data, key, iv);
-    const out = module_._malloc(1024);
-    module_.ccall("ige256_decrypt", "void", ["array", "pointer", "number", "array", "array"], [data, out, data.length, 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);
     }
 }
 function checkCtrParams(data, key, iv, state) {