@mtkruto/node 0.2.42 → 0.2.44

package/esm/deps/deno.land/std@0.224.0/internal/diff.js

@@ -1,341 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { bgGreen, bgRed, bold, gray, green, red, white, } from "../fmt/colors.js";
-export const DiffType = {
-    removed: "removed",
-    common: "common",
-    added: "added",
-};
-const REMOVED = 1;
-const COMMON = 2;
-const ADDED = 3;
-function createCommon(A, B, reverse) {
-    const common = [];
-    if (A.length === 0 || B.length === 0)
-        return [];
-    for (let i = 0; i < Math.min(A.length, B.length); i += 1) {
-        const a = reverse ? A[A.length - i - 1] : A[i];
-        const b = reverse ? B[B.length - i - 1] : B[i];
-        if (a !== undefined && a === b) {
-            common.push(a);
-        }
-        else {
-            return common;
-        }
-    }
-    return common;
-}
-function ensureDefined(item) {
-    if (item === undefined) {
-        throw Error("Unexpected missing FarthestPoint");
-    }
-    return item;
-}
-/**
- * Renders the differences between the actual and expected values
- * @param A Actual value
- * @param B Expected value
- */
-export function diff(A, B) {
-    const prefixCommon = createCommon(A, B);
-    const suffixCommon = createCommon(A.slice(prefixCommon.length), B.slice(prefixCommon.length), true).reverse();
-    A = suffixCommon.length
-        ? A.slice(prefixCommon.length, -suffixCommon.length)
-        : A.slice(prefixCommon.length);
-    B = suffixCommon.length
-        ? B.slice(prefixCommon.length, -suffixCommon.length)
-        : B.slice(prefixCommon.length);
-    const swapped = B.length > A.length;
-    [A, B] = swapped ? [B, A] : [A, B];
-    const M = A.length;
-    const N = B.length;
-    if (!M && !N && !suffixCommon.length && !prefixCommon.length)
-        return [];
-    if (!N) {
-        return [
-            ...prefixCommon.map((c) => ({ type: DiffType.common, value: c })),
-            ...A.map((a) => ({
-                type: swapped ? DiffType.added : DiffType.removed,
-                value: a,
-            })),
-            ...suffixCommon.map((c) => ({ type: DiffType.common, value: c })),
-        ];
-    }
-    const offset = N;
-    const delta = M - N;
-    const size = M + N + 1;
-    const fp = Array.from({ length: size }, () => ({ y: -1, id: -1 }));
-    /**
-     * INFO:
-     * This buffer is used to save memory and improve performance.
-     * The first half is used to save route and last half is used to save diff
-     * type.
-     * This is because, when I kept new uint8array area to save type,performance
-     * worsened.
-     */
-    const routes = new Uint32Array((M * N + size + 1) * 2);
-    const diffTypesPtrOffset = routes.length / 2;
-    let ptr = 0;
-    let p = -1;
-    function backTrace(A, B, current, swapped) {
-        const M = A.length;
-        const N = B.length;
-        const result = [];
-        let a = M - 1;
-        let b = N - 1;
-        let j = routes[current.id];
-        let type = routes[current.id + diffTypesPtrOffset];
-        while (true) {
-            if (!j && !type)
-                break;
-            const prev = j;
-            if (type === REMOVED) {
-                result.unshift({
-                    type: swapped ? DiffType.removed : DiffType.added,
-                    value: B[b],
-                });
-                b -= 1;
-            }
-            else if (type === ADDED) {
-                result.unshift({
-                    type: swapped ? DiffType.added : DiffType.removed,
-                    value: A[a],
-                });
-                a -= 1;
-            }
-            else {
-                result.unshift({ type: DiffType.common, value: A[a] });
-                a -= 1;
-                b -= 1;
-            }
-            j = routes[prev];
-            type = routes[prev + diffTypesPtrOffset];
-        }
-        return result;
-    }
-    function createFP(slide, down, k, M) {
-        if (slide && slide.y === -1 && down && down.y === -1) {
-            return { y: 0, id: 0 };
-        }
-        const isAdding = (down?.y === -1) ||
-            k === M ||
-            (slide?.y || 0) > (down?.y || 0) + 1;
-        if (slide && isAdding) {
-            const prev = slide.id;
-            ptr++;
-            routes[ptr] = prev;
-            routes[ptr + diffTypesPtrOffset] = ADDED;
-            return { y: slide.y, id: ptr };
-        }
-        else if (down && !isAdding) {
-            const prev = down.id;
-            ptr++;
-            routes[ptr] = prev;
-            routes[ptr + diffTypesPtrOffset] = REMOVED;
-            return { y: down.y + 1, id: ptr };
-        }
-        else {
-            throw new Error("Unexpected missing FarthestPoint");
-        }
-    }
-    function snake(k, slide, down, _offset, A, B) {
-        const M = A.length;
-        const N = B.length;
-        if (k < -N || M < k)
-            return { y: -1, id: -1 };
-        const fp = createFP(slide, down, k, M);
-        while (fp.y + k < M && fp.y < N && A[fp.y + k] === B[fp.y]) {
-            const prev = fp.id;
-            ptr++;
-            fp.id = ptr;
-            fp.y += 1;
-            routes[ptr] = prev;
-            routes[ptr + diffTypesPtrOffset] = COMMON;
-        }
-        return fp;
-    }
-    let currentFP = ensureDefined(fp[delta + offset]);
-    while (currentFP && currentFP.y < N) {
-        p = p + 1;
-        for (let k = -p; k < delta; ++k) {
-            fp[k + offset] = snake(k, fp[k - 1 + offset], fp[k + 1 + offset], offset, A, B);
-        }
-        for (let k = delta + p; k > delta; --k) {
-            fp[k + offset] = snake(k, fp[k - 1 + offset], fp[k + 1 + offset], offset, A, B);
-        }
-        fp[delta + offset] = snake(delta, fp[delta - 1 + offset], fp[delta + 1 + offset], offset, A, B);
-        currentFP = ensureDefined(fp[delta + offset]);
-    }
-    return [
-        ...prefixCommon.map((c) => ({ type: DiffType.common, value: c })),
-        ...backTrace(A, B, currentFP, swapped),
-        ...suffixCommon.map((c) => ({ type: DiffType.common, value: c })),
-    ];
-}
-/**
- * Renders the differences between the actual and expected strings
- * Partially inspired from https://github.com/kpdecker/jsdiff
- * @param A Actual string
- * @param B Expected string
- */
-export function diffstr(A, B) {
-    function unescape(string) {
-        // unescape invisible characters.
-        // ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#escape_sequences
-        return string
-            .replaceAll("\b", "\\b")
-            .replaceAll("\f", "\\f")
-            .replaceAll("\t", "\\t")
-            .replaceAll("\v", "\\v")
-            .replaceAll(// does not remove line breaks
-        /\r\n|\r|\n/g, (str) => str === "\r" ? "\\r" : str === "\n" ? "\\n\n" : "\\r\\n\r\n");
-    }
-    function tokenize(string, { wordDiff = false } = {}) {
-        if (wordDiff) {
-            // Split string on whitespace symbols
-            const tokens = string.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/);
-            // Extended Latin character set
-            const words = /^[a-zA-Z\u{C0}-\u{FF}\u{D8}-\u{F6}\u{F8}-\u{2C6}\u{2C8}-\u{2D7}\u{2DE}-\u{2FF}\u{1E00}-\u{1EFF}]+$/u;
-            // Join boundary splits that we do not consider to be boundaries and merge empty strings surrounded by word chars
-            for (let i = 0; i < tokens.length - 1; i++) {
-                const token = tokens[i];
-                const tokenPlusTwo = tokens[i + 2];
-                if (!tokens[i + 1] &&
-                    token &&
-                    tokenPlusTwo &&
-                    words.test(token) &&
-                    words.test(tokenPlusTwo)) {
-                    tokens[i] += tokenPlusTwo;
-                    tokens.splice(i + 1, 2);
-                    i--;
-                }
-            }
-            return tokens.filter((token) => token);
-        }
-        else {
-            // Split string on new lines symbols
-            const tokens = [];
-            const lines = string.split(/(\n|\r\n)/);
-            // Ignore final empty token when text ends with a newline
-            if (!lines[lines.length - 1]) {
-                lines.pop();
-            }
-            // Merge the content and line separators into single tokens
-            for (const [i, line] of lines.entries()) {
-                if (i % 2) {
-                    tokens[tokens.length - 1] += line;
-                }
-                else {
-                    tokens.push(line);
-                }
-            }
-            return tokens;
-        }
-    }
-    // Create details by filtering relevant word-diff for current line
-    // and merge "space-diff" if surrounded by word-diff for cleaner displays
-    function createDetails(line, tokens) {
-        return tokens.filter(({ type }) => type === line.type || type === DiffType.common).map((result, i, t) => {
-            const token = t[i - 1];
-            if ((result.type === DiffType.common) && token &&
-                (token.type === t[i + 1]?.type) && /\s+/.test(result.value)) {
-                return {
-                    ...result,
-                    type: token.type,
-                };
-            }
-            return result;
-        });
-    }
-    // Compute multi-line diff
-    const diffResult = diff(tokenize(`${unescape(A)}\n`), tokenize(`${unescape(B)}\n`));
-    const added = [];
-    const removed = [];
-    for (const result of diffResult) {
-        if (result.type === DiffType.added) {
-            added.push(result);
-        }
-        if (result.type === DiffType.removed) {
-            removed.push(result);
-        }
-    }
-    // Compute word-diff
-    const hasMoreRemovedLines = added.length < removed.length;
-    const aLines = hasMoreRemovedLines ? added : removed;
-    const bLines = hasMoreRemovedLines ? removed : added;
-    for (const a of aLines) {
-        let tokens = [];
-        let b;
-        // Search another diff line with at least one common token
-        while (bLines.length) {
-            b = bLines.shift();
-            const tokenized = [
-                tokenize(a.value, { wordDiff: true }),
-                tokenize(b?.value ?? "", { wordDiff: true }),
-            ];
-            if (hasMoreRemovedLines)
-                tokenized.reverse();
-            tokens = diff(tokenized[0], tokenized[1]);
-            if (tokens.some(({ type, value }) => type === DiffType.common && value.trim().length)) {
-                break;
-            }
-        }
-        // Register word-diff details
-        a.details = createDetails(a, tokens);
-        if (b) {
-            b.details = createDetails(b, tokens);
-        }
-    }
-    return diffResult;
-}
-/**
- * Colors the output of assertion diffs
- * @param diffType Difference type, either added or removed
- */
-function createColor(diffType, { background = false } = {}) {
-    // TODO(@littledivy): Remove this when we can detect
-    // true color terminals.
-    // https://github.com/denoland/deno_std/issues/2575
-    background = false;
-    switch (diffType) {
-        case DiffType.added:
-            return (s) => background ? bgGreen(white(s)) : green(bold(s));
-        case DiffType.removed:
-            return (s) => background ? bgRed(white(s)) : red(bold(s));
-        default:
-            return white;
-    }
-}
-/**
- * Prefixes `+` or `-` in diff output
- * @param diffType Difference type, either added or removed
- */
-function createSign(diffType) {
-    switch (diffType) {
-        case DiffType.added:
-            return "+   ";
-        case DiffType.removed:
-            return "-   ";
-        default:
-            return "    ";
-    }
-}
-export function buildMessage(diffResult, { stringDiff = false } = {}) {
-    const messages = [];
-    const diffMessages = [];
-    messages.push("");
-    messages.push("");
-    messages.push(`    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${green(bold("Expected"))}`);
-    messages.push("");
-    messages.push("");
-    diffResult.forEach((result) => {
-        const c = createColor(result.type);
-        const line = result.details?.map((detail) => detail.type !== DiffType.common
-            ? createColor(detail.type, { background: true })(detail.value)
-            : detail.value).join("") ?? result.value;
-        diffMessages.push(c(`${createSign(result.type)}${line}`));
-    });
-    messages.push(...(stringDiff ? [diffMessages.join("")] : diffMessages));
-    messages.push("");
-    return messages;
-}

package/esm/deps/deno.land/std@0.224.0/internal/format.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/internal/format.ts"],"names":[],"mappings":"AAUA,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAezC"}

package/esm/deps/deno.land/std@0.224.0/internal/format.js

@@ -1,24 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-/**
- * Converts the input into a string. Objects, Sets and Maps are sorted so as to
- * make tests less flaky
- * @param v Value to be formatted
- */
-import * as dntShim from "../../../../_dnt.shims.js";
-export function format(v) {
-    // deno-lint-ignore no-explicit-any
-    const { Deno } = dntShim.dntGlobalThis;
-    return typeof Deno?.inspect === "function"
-        ? Deno.inspect(v, {
-            depth: Infinity,
-            sorted: true,
-            trailingComma: true,
-            compact: false,
-            iterableLimit: Infinity,
-            // getters should be true in assertEquals.
-            getters: true,
-            strAbbreviateSize: Infinity,
-        })
-        : `"${String(v).replace(/(?=["\\])/g, "\\")}"`;
-}

package/esm/deps/deno.land/std@0.224.0/internal/mod.d.ts

@@ -1,10 +0,0 @@
-/**
- * Internal utilities for the public API of the Deno Standard Library.
- *
- * Note: this module is for internal use only and should not be used directly.
- *
- * @module
- */
-export * from "./format.js";
-export * from "./diff.js";
-//# sourceMappingURL=mod.d.ts.map

package/esm/deps/deno.land/std@0.224.0/internal/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/internal/mod.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}

package/esm/deps/deno.land/std@0.224.0/internal/mod.js

@@ -1,11 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-/**
- * Internal utilities for the public API of the Deno Standard Library.
- *
- * Note: this module is for internal use only and should not be used directly.
- *
- * @module
- */
-export * from "./format.js";
-export * from "./diff.js";

package/esm/deps/deno.land/std@0.224.0/io/_constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_constants.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/io/_constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,eAAO,MAAM,mBAAmB,QAAY,CAAC"}

package/esm/deps/deno.land/std@0.224.0/io/iterate_reader.d.ts

@@ -1,70 +0,0 @@
-import type { Reader, ReaderSync } from "./types.js";
-export type { Reader, ReaderSync };
-/**
- * Turns a {@linkcode Reader} into an async iterator.
- *
- * @example
- * ```ts
- * import { iterateReader } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
- *
- * using file = await Deno.open("/etc/passwd");
- * for await (const chunk of iterateReader(file)) {
- *   console.log(chunk);
- * }
- * ```
- *
- * Second argument can be used to tune size of a buffer.
- * Default size of the buffer is 32kB.
- *
- * @example
- * ```ts
- * import { iterateReader } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
- *
- * using file = await Deno.open("/etc/passwd");
- * const iter = iterateReader(file, {
- *   bufSize: 1024 * 1024
- * });
- * for await (const chunk of iter) {
- *   console.log(chunk);
- * }
- * ```
- */
-export declare function iterateReader(reader: Reader, options?: {
-    bufSize?: number;
-}): AsyncIterableIterator<Uint8Array>;
-/**
- * Turns a {@linkcode ReaderSync} into an iterator.
- *
- * ```ts
- * import { iterateReaderSync } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
- *
- * using file = Deno.openSync("/etc/passwd");
- * for (const chunk of iterateReaderSync(file)) {
- *   console.log(chunk);
- * }
- * ```
- *
- * Second argument can be used to tune size of a buffer.
- * Default size of the buffer is 32kB.
- *
- * ```ts
- * import { iterateReaderSync } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
-
- * using file = await Deno.open("/etc/passwd");
- * const iter = iterateReaderSync(file, {
- *   bufSize: 1024 * 1024
- * });
- * for (const chunk of iter) {
- *   console.log(chunk);
- * }
- * ```
- *
- * Iterator uses an internal buffer of fixed size for efficiency; it returns
- * a view on that buffer on each iteration. It is therefore caller's
- * responsibility to copy contents of the buffer if needed; otherwise the
- * next iteration will overwrite contents of previously returned chunk.
- */
-export declare function iterateReaderSync(reader: ReaderSync, options?: {
-    bufSize?: number;
-}): IterableIterator<Uint8Array>;
-//# sourceMappingURL=iterate_reader.d.ts.map

package/esm/deps/deno.land/std@0.224.0/io/iterate_reader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"iterate_reader.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/io/iterate_reader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAuB,aAAa,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IACR,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GACA,qBAAqB,CAAC,UAAU,CAAC,CAWnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAiB,iBAAiB,CAChC,MAAM,EAAE,UAAU,EAClB,OAAO,CAAC,EAAE;IACR,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GACA,gBAAgB,CAAC,UAAU,CAAC,CAW9B"}

package/esm/deps/deno.land/std@0.224.0/io/iterate_reader.js

@@ -1,86 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { DEFAULT_BUFFER_SIZE } from "./_constants.js";
-/**
- * Turns a {@linkcode Reader} into an async iterator.
- *
- * @example
- * ```ts
- * import { iterateReader } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
- *
- * using file = await Deno.open("/etc/passwd");
- * for await (const chunk of iterateReader(file)) {
- *   console.log(chunk);
- * }
- * ```
- *
- * Second argument can be used to tune size of a buffer.
- * Default size of the buffer is 32kB.
- *
- * @example
- * ```ts
- * import { iterateReader } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
- *
- * using file = await Deno.open("/etc/passwd");
- * const iter = iterateReader(file, {
- *   bufSize: 1024 * 1024
- * });
- * for await (const chunk of iter) {
- *   console.log(chunk);
- * }
- * ```
- */
-export async function* iterateReader(reader, options) {
-    const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;
-    const b = new Uint8Array(bufSize);
-    while (true) {
-        const result = await reader.read(b);
-        if (result === null) {
-            break;
-        }
-        yield b.slice(0, result);
-    }
-}
-/**
- * Turns a {@linkcode ReaderSync} into an iterator.
- *
- * ```ts
- * import { iterateReaderSync } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
- *
- * using file = Deno.openSync("/etc/passwd");
- * for (const chunk of iterateReaderSync(file)) {
- *   console.log(chunk);
- * }
- * ```
- *
- * Second argument can be used to tune size of a buffer.
- * Default size of the buffer is 32kB.
- *
- * ```ts
- * import { iterateReaderSync } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
-
- * using file = await Deno.open("/etc/passwd");
- * const iter = iterateReaderSync(file, {
- *   bufSize: 1024 * 1024
- * });
- * for (const chunk of iter) {
- *   console.log(chunk);
- * }
- * ```
- *
- * Iterator uses an internal buffer of fixed size for efficiency; it returns
- * a view on that buffer on each iteration. It is therefore caller's
- * responsibility to copy contents of the buffer if needed; otherwise the
- * next iteration will overwrite contents of previously returned chunk.
- */
-export function* iterateReaderSync(reader, options) {
-    const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;
-    const b = new Uint8Array(bufSize);
-    while (true) {
-        const result = reader.readSync(b);
-        if (result === null) {
-            break;
-        }
-        yield b.slice(0, result);
-    }
-}