From d9993f6b9820dc51ce3d1db709dc5033ce08f44e Mon Sep 17 00:00:00 2001 From: Jason Hall Date: Tue, 24 Aug 2021 11:55:19 -0400 Subject: [PATCH] add lock/vendor stuff, make image and base configurable --- README.md | 9 +- build.sh | 5 +- lock.json | 5 + ...947c82f87d77d469e0785906e5355363a92ff5b5ab | 703 ++++++++++++++++++ ...69e0785906e5355363a92ff5b5ab.metadata.json | 16 + ...781adeb9679718de575792a5513845ebc459f507c1 | 526 +++++++++++++ ...de575792a5513845ebc459f507c1.metadata.json | 16 + ...7c8f46f41f0a35feed44763fc422580f7f43845cd8 | 339 +++++++++ ...feed44763fc422580f7f43845cd8.metadata.json | 16 + .../Users/jasonhall/deno/example.js.buildinfo | 1 + ...c82f87d77d469e0785906e5355363a92ff5b5ab.js | 400 ++++++++++ ...2f87d77d469e0785906e5355363a92ff5b5ab.meta | 1 + ...adeb9679718de575792a5513845ebc459f507c1.js | 190 +++++ ...eb9679718de575792a5513845ebc459f507c1.meta | 1 + ...f46f41f0a35feed44763fc422580f7f43845cd8.js | 214 ++++++ ...6f41f0a35feed44763fc422580f7f43845cd8.meta | 1 + 16 files changed, 2439 insertions(+), 4 deletions(-) create mode 100644 lock.json create mode 100644 vendor/deps/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab create mode 100644 vendor/deps/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.metadata.json create mode 100644 vendor/deps/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1 create mode 100644 vendor/deps/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.metadata.json create mode 100644 vendor/deps/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8 create mode 100644 vendor/deps/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.metadata.json create mode 100644 vendor/gen/file/Users/jasonhall/deno/example.js.buildinfo create mode 100644 vendor/gen/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.js create mode 100644 vendor/gen/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.meta create mode 100644 vendor/gen/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.js create mode 100644 vendor/gen/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.meta create mode 100644 vendor/gen/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.js create mode 100644 vendor/gen/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.meta diff --git a/README.md b/README.md index d04ae6d..fa92136 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,10 @@ -# Building container images for Deno, without Docker +# Building container images for [Deno](https://deno.land), without Docker -`./build.sh` builds `example.js` using `deno compile`, then appends it on top of a [distroless](https://github.com/GoogleContainerTools/distroless) base image, and makes the `example` executable the image's entrypoint. -It does this without a Dockerfile, without invoking `docker build`, and without requiring a container runtime. +`./build.sh` builds `example.js` using [`deno compile`](https://deno.land/manual@v1.13.2/tools/compiler), then appends it on top of a default [distroless](https://github.com/GoogleContainerTools/distroless) base image, and makes the `example` executable the image's entrypoint, using [`crane`](https://github.com/google/go-containerregistry/tree/main/cmd/crane). + +It does all this without a Dockerfile, without invoking `docker build`, and without requiring a container runtime. `./run.sh` runs `./build.sh` then runs the resulting image using `docker run`. Only this step requires a container runtime. + +`./build.sh` takes two optional positional args: `./build.sh [image-to-build] [base-image]` diff --git a/build.sh b/build.sh index 917a1ee..dd64c5f 100755 --- a/build.sh +++ b/build.sh @@ -1,5 +1,8 @@ #!/usr/bin/env bash +IMAGE=${1:-gcr.io/imjasonh/deno} +BASE=${2:-gcr.io/distroless/cc-debian10} + DENO_DIR=vendor/ deno cache --reload --lock=lock.json --lock-write example.js @@ -10,6 +13,6 @@ deno compile \ example.js 1>&2 crane mutate $( - crane append -f <(tar -f - -c example) -t gcr.io/imjasonh/deno -b gcr.io/distroless/cc-debian10 + crane append -f <(tar -f - -c example) -t ${IMAGE} -b ${BASE} ) --entrypoint=/example diff --git a/lock.json b/lock.json new file mode 100644 index 0000000..48efde9 --- /dev/null +++ b/lock.json @@ -0,0 +1,5 @@ +{ + "https://deno.land/std@0.106.0/fmt/colors.ts": "d2f8355f00a74404668fc5a1e4a92983ce1a9b0a6ac1d40efbd681cb8f519586", + "https://deno.land/std@0.106.0/testing/_diff.ts": "5d3693155f561d1a5443ac751ac70aab9f5d67b4819a621d4b96b8a1a1c89620", + "https://deno.land/std@0.106.0/testing/asserts.ts": "5f3a0fddb15a9733e44737e2d52be8e696bb79bc4e3830a9f246c5b8f3b29b31" +} \ No newline at end of file diff --git a/vendor/deps/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab b/vendor/deps/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab new file mode 100644 index 0000000..6c3d54a --- /dev/null +++ b/vendor/deps/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab @@ -0,0 +1,703 @@ +// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. Do not rely on good formatting of values +// for AssertionError messages in browsers. + +import { + bgGreen, + bgRed, + bold, + gray, + green, + red, + stripColor, + white, +} from "../fmt/colors.ts"; +import { diff, DiffResult, diffstr, DiffType } from "./_diff.ts"; + +const CAN_NOT_DISPLAY = "[Cannot display]"; + +interface Constructor { + // deno-lint-ignore no-explicit-any + new (...args: any[]): any; +} + +export class AssertionError extends Error { + constructor(message: string) { + super(message); + this.name = "AssertionError"; + } +} + +/** + * 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 + */ +export function _format(v: unknown): string { + // deno-lint-ignore no-explicit-any + const { Deno } = globalThis as any; + return typeof Deno?.inspect === "function" + ? Deno.inspect(v, { + depth: Infinity, + sorted: true, + trailingComma: true, + compact: false, + iterableLimit: Infinity, + }) + : `"${String(v).replace(/(?=["\\])/g, "\\")}"`; +} + +/** + * Colors the output of assertion diffs + * @param diffType Difference type, either added or removed + */ +function createColor( + diffType: DiffType, + { background = false } = {}, +): (s: string) => string { + switch (diffType) { + case DiffType.added: + return (s: string): string => + background ? bgGreen(white(s)) : green(bold(s)); + case DiffType.removed: + return (s: string): string => 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: DiffType): string { + switch (diffType) { + case DiffType.added: + return "+ "; + case DiffType.removed: + return "- "; + default: + return " "; + } +} + +function buildMessage( + diffResult: ReadonlyArray>, + { stringDiff = false } = {}, +): string[] { + const messages: string[] = [], diffMessages: string[] = []; + messages.push(""); + messages.push(""); + messages.push( + ` ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${ + green(bold("Expected")) + }`, + ); + messages.push(""); + messages.push(""); + diffResult.forEach((result: DiffResult): void => { + 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; +} + +function isKeyedCollection(x: unknown): x is Set { + return [Symbol.iterator, "size"].every((k) => k in (x as Set)); +} + +/** + * Deep equality comparison used in assertions + * @param c actual value + * @param d expected value + */ +export function equal(c: unknown, d: unknown): boolean { + const seen = new Map(); + return (function compare(a: unknown, b: unknown): boolean { + // Have to render RegExp & Date for string comparison + // unless it's mistreated as object + if ( + a && + b && + ((a instanceof RegExp && b instanceof RegExp) || + (a instanceof URL && b instanceof URL)) + ) { + return String(a) === String(b); + } + if (a instanceof Date && b instanceof Date) { + const aTime = a.getTime(); + const bTime = b.getTime(); + // Check for NaN equality manually since NaN is not + // equal to itself. + if (Number.isNaN(aTime) && Number.isNaN(bTime)) { + return true; + } + return a.getTime() === b.getTime(); + } + if (Object.is(a, b)) { + return true; + } + if (a && typeof a === "object" && b && typeof b === "object") { + if (a && b && !constructorsEqual(a, b)) { + return false; + } + if (a instanceof WeakMap || b instanceof WeakMap) { + if (!(a instanceof WeakMap && b instanceof WeakMap)) return false; + throw new TypeError("cannot compare WeakMap instances"); + } + if (a instanceof WeakSet || b instanceof WeakSet) { + if (!(a instanceof WeakSet && b instanceof WeakSet)) return false; + throw new TypeError("cannot compare WeakSet instances"); + } + if (seen.get(a) === b) { + return true; + } + if (Object.keys(a || {}).length !== Object.keys(b || {}).length) { + return false; + } + if (isKeyedCollection(a) && isKeyedCollection(b)) { + if (a.size !== b.size) { + return false; + } + + let unmatchedEntries = a.size; + + for (const [aKey, aValue] of a.entries()) { + for (const [bKey, bValue] of b.entries()) { + /* Given that Map keys can be references, we need + * to ensure that they are also deeply equal */ + if ( + (aKey === aValue && bKey === bValue && compare(aKey, bKey)) || + (compare(aKey, bKey) && compare(aValue, bValue)) + ) { + unmatchedEntries--; + } + } + } + + return unmatchedEntries === 0; + } + const merged = { ...a, ...b }; + for ( + const key of [ + ...Object.getOwnPropertyNames(merged), + ...Object.getOwnPropertySymbols(merged), + ] + ) { + type Key = keyof typeof merged; + if (!compare(a && a[key as Key], b && b[key as Key])) { + return false; + } + if (((key in a) && (!(key in b))) || ((key in b) && (!(key in a)))) { + return false; + } + } + seen.set(a, b); + if (a instanceof WeakRef || b instanceof WeakRef) { + if (!(a instanceof WeakRef && b instanceof WeakRef)) return false; + return compare(a.deref(), b.deref()); + } + return true; + } + return false; + })(c, d); +} + +// deno-lint-ignore ban-types +function constructorsEqual(a: object, b: object) { + return a.constructor === b.constructor || + a.constructor === Object && !b.constructor || + !a.constructor && b.constructor === Object; +} + +/** Make an assertion, error will be thrown if `expr` does not have truthy value. */ +export function assert(expr: unknown, msg = ""): asserts expr { + if (!expr) { + throw new AssertionError(msg); + } +} + +/** + * Make an assertion that `actual` and `expected` are equal, deeply. If not + * deeply equal, then throw. + * + * Type parameter can be specified to ensure values under comparison have the same type. + * For example: + * ```ts + * import { assertEquals } from "./asserts.ts"; + * + * assertEquals(1, 2) + * ``` + */ +export function assertEquals( + actual: unknown, + expected: unknown, + msg?: string, +): void; +export function assertEquals(actual: T, expected: T, msg?: string): void; +export function assertEquals( + actual: unknown, + expected: unknown, + msg?: string, +): void { + if (equal(actual, expected)) { + return; + } + let message = ""; + const actualString = _format(actual); + const expectedString = _format(expected); + try { + const stringDiff = (typeof actual === "string") && + (typeof expected === "string"); + const diffResult = stringDiff + ? diffstr(actual as string, expected as string) + : diff(actualString.split("\n"), expectedString.split("\n")); + const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n"); + message = `Values are not equal:\n${diffMsg}`; + } catch { + message = `\n${red(CAN_NOT_DISPLAY)} + \n\n`; + } + if (msg) { + message = msg; + } + throw new AssertionError(message); +} + +/** + * Make an assertion that `actual` and `expected` are not equal, deeply. + * If not then throw. + * + * Type parameter can be specified to ensure values under comparison have the same type. + * For example: + * ```ts + * import { assertNotEquals } from "./asserts.ts"; + * + * assertNotEquals(1, 2) + * ``` + */ +export function assertNotEquals( + actual: unknown, + expected: unknown, + msg?: string, +): void; +export function assertNotEquals(actual: T, expected: T, msg?: string): void; +export function assertNotEquals( + actual: unknown, + expected: unknown, + msg?: string, +): void { + if (!equal(actual, expected)) { + return; + } + let actualString: string; + let expectedString: string; + try { + actualString = String(actual); + } catch { + actualString = "[Cannot display]"; + } + try { + expectedString = String(expected); + } catch { + expectedString = "[Cannot display]"; + } + if (!msg) { + msg = `actual: ${actualString} expected: ${expectedString}`; + } + throw new AssertionError(msg); +} + +/** + * Make an assertion that `actual` and `expected` are strictly equal. If + * not then throw. + * + * ```ts + * import { assertStrictEquals } from "./asserts.ts"; + * + * assertStrictEquals(1, 2) + * ``` + */ +export function assertStrictEquals( + actual: unknown, + expected: unknown, + msg?: string, +): void; +export function assertStrictEquals( + actual: T, + expected: T, + msg?: string, +): void; +export function assertStrictEquals( + actual: unknown, + expected: unknown, + msg?: string, +): void { + if (actual === expected) { + return; + } + + let message: string; + + if (msg) { + message = msg; + } else { + const actualString = _format(actual); + const expectedString = _format(expected); + + if (actualString === expectedString) { + const withOffset = actualString + .split("\n") + .map((l) => ` ${l}`) + .join("\n"); + message = + `Values have the same structure but are not reference-equal:\n\n${ + red(withOffset) + }\n`; + } else { + try { + const stringDiff = (typeof actual === "string") && + (typeof expected === "string"); + const diffResult = stringDiff + ? diffstr(actual as string, expected as string) + : diff(actualString.split("\n"), expectedString.split("\n")); + const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n"); + message = `Values are not strictly equal:\n${diffMsg}`; + } catch { + message = `\n${red(CAN_NOT_DISPLAY)} + \n\n`; + } + } + } + + throw new AssertionError(message); +} + +/** + * Make an assertion that `actual` and `expected` are not strictly equal. + * If the values are strictly equal then throw. + * + * ```ts + * import { assertNotStrictEquals } from "./asserts.ts"; + * + * assertNotStrictEquals(1, 1) + * ``` + */ +export function assertNotStrictEquals( + actual: unknown, + expected: unknown, + msg?: string, +): void; +export function assertNotStrictEquals( + actual: T, + expected: T, + msg?: string, +): void; +export function assertNotStrictEquals( + actual: unknown, + expected: unknown, + msg?: string, +): void { + if (actual !== expected) { + return; + } + + throw new AssertionError( + msg ?? `Expected "actual" to be strictly unequal to: ${_format(actual)}\n`, + ); +} + +/** + * Make an assertion that actual is not null or undefined. + * If not then throw. + */ +export function assertExists( + actual: T, + msg?: string, +): asserts actual is NonNullable { + if (actual === undefined || actual === null) { + if (!msg) { + msg = `actual: "${actual}" expected to not be null or undefined`; + } + throw new AssertionError(msg); + } +} + +/** + * Make an assertion that actual includes expected. If not + * then throw. + */ +export function assertStringIncludes( + actual: string, + expected: string, + msg?: string, +): void { + if (!actual.includes(expected)) { + if (!msg) { + msg = `actual: "${actual}" expected to contain: "${expected}"`; + } + throw new AssertionError(msg); + } +} + +/** + * Make an assertion that `actual` includes the `expected` values. + * If not then an error will be thrown. + * + * Type parameter can be specified to ensure values under comparison have the same type. + * For example: + * + * ```ts + * import { assertArrayIncludes } from "./asserts.ts"; + * + * assertArrayIncludes([1, 2], [2]) + * ``` + */ +export function assertArrayIncludes( + actual: ArrayLike, + expected: ArrayLike, + msg?: string, +): void; +export function assertArrayIncludes( + actual: ArrayLike, + expected: ArrayLike, + msg?: string, +): void; +export function assertArrayIncludes( + actual: ArrayLike, + expected: ArrayLike, + msg?: string, +): void { + const missing: unknown[] = []; + for (let i = 0; i < expected.length; i++) { + let found = false; + for (let j = 0; j < actual.length; j++) { + if (equal(expected[i], actual[j])) { + found = true; + break; + } + } + if (!found) { + missing.push(expected[i]); + } + } + if (missing.length === 0) { + return; + } + if (!msg) { + msg = `actual: "${_format(actual)}" expected to include: "${ + _format(expected) + }"\nmissing: ${_format(missing)}`; + } + throw new AssertionError(msg); +} + +/** + * Make an assertion that `actual` match RegExp `expected`. If not + * then throw. + */ +export function assertMatch( + actual: string, + expected: RegExp, + msg?: string, +): void { + if (!expected.test(actual)) { + if (!msg) { + msg = `actual: "${actual}" expected to match: "${expected}"`; + } + throw new AssertionError(msg); + } +} + +/** + * Make an assertion that `actual` not match RegExp `expected`. If match + * then throw. + */ +export function assertNotMatch( + actual: string, + expected: RegExp, + msg?: string, +): void { + if (expected.test(actual)) { + if (!msg) { + msg = `actual: "${actual}" expected to not match: "${expected}"`; + } + throw new AssertionError(msg); + } +} + +/** + * Make an assertion that `actual` object is a subset of `expected` object, deeply. + * If not, then throw. + */ +export function assertObjectMatch( + // deno-lint-ignore no-explicit-any + actual: Record, + expected: Record, +): void { + type loose = Record; + const seen = new WeakMap(); + return assertEquals( + (function filter(a: loose, b: loose): loose { + // Prevent infinite loop with circular references with same filter + if ((seen.has(a)) && (seen.get(a) === b)) { + return a; + } + seen.set(a, b); + // Filter keys and symbols which are present in both actual and expected + const filtered = {} as loose; + const entries = [ + ...Object.getOwnPropertyNames(a), + ...Object.getOwnPropertySymbols(a), + ] + .filter((key) => key in b) + .map((key) => [key, a[key as string]]) as Array<[string, unknown]>; + for (const [key, value] of entries) { + // On array references, build a filtered array and filter nested objects inside + if (Array.isArray(value)) { + const subset = (b as loose)[key]; + if (Array.isArray(subset)) { + filtered[key] = value + .slice(0, subset.length) + .map((element, index) => { + const subsetElement = subset[index]; + if ((typeof subsetElement === "object") && (subsetElement)) { + return filter(element, subsetElement); + } + return element; + }); + continue; + } + } // On nested objects references, build a filtered object recursively + else if (typeof value === "object") { + const subset = (b as loose)[key]; + if ((typeof subset === "object") && (subset)) { + filtered[key] = filter(value as loose, subset as loose); + continue; + } + } + filtered[key] = value; + } + return filtered; + })(actual, expected), + expected, + ); +} + +/** + * Forcefully throws a failed assertion + */ +export function fail(msg?: string): never { + assert(false, `Failed assertion${msg ? `: ${msg}` : "."}`); +} + +/** + * Executes a function, expecting it to throw. If it does not, then it + * throws. An error class and a string that should be included in the + * error message can also be asserted. + */ +export function assertThrows( + fn: () => T, + ErrorClass?: Constructor, + msgIncludes = "", + msg?: string, +): void { + let doesThrow = false; + try { + fn(); + } catch (e) { + if (e instanceof Error === false) { + throw new AssertionError("A non-Error object was thrown."); + } + if (ErrorClass && !(e instanceof ErrorClass)) { + msg = + `Expected error to be instance of "${ErrorClass.name}", but was "${e.constructor.name}"${ + msg ? `: ${msg}` : "." + }`; + throw new AssertionError(msg); + } + if ( + msgIncludes && + !stripColor(e.message).includes(stripColor(msgIncludes)) + ) { + msg = + `Expected error message to include "${msgIncludes}", but got "${e.message}"${ + msg ? `: ${msg}` : "." + }`; + throw new AssertionError(msg); + } + doesThrow = true; + } + if (!doesThrow) { + msg = `Expected function to throw${msg ? `: ${msg}` : "."}`; + throw new AssertionError(msg); + } +} + +/** + * Executes a function which returns a promise, expecting it to throw or reject. + * If it does not, then it throws. An error class and a string that should be + * included in the error message can also be asserted. + */ +export async function assertRejects( + fn: () => Promise, + ErrorClass?: Constructor, + msgIncludes = "", + msg?: string, +): Promise { + let doesThrow = false; + try { + await fn(); + } catch (e) { + if (e instanceof Error === false) { + throw new AssertionError("A non-Error object was thrown or rejected."); + } + if (ErrorClass && !(e instanceof ErrorClass)) { + msg = + `Expected error to be instance of "${ErrorClass.name}", but was "${e.constructor.name}"${ + msg ? `: ${msg}` : "." + }`; + throw new AssertionError(msg); + } + if ( + msgIncludes && + !stripColor(e.message).includes(stripColor(msgIncludes)) + ) { + msg = + `Expected error message to include "${msgIncludes}", but got "${e.message}"${ + msg ? `: ${msg}` : "." + }`; + throw new AssertionError(msg); + } + doesThrow = true; + } + if (!doesThrow) { + msg = `Expected function to throw${msg ? `: ${msg}` : "."}`; + throw new AssertionError(msg); + } +} + +/** + * Executes a function which returns a promise, expecting it to throw or reject. + * If it does not, then it throws. An error class and a string that should be + * included in the error message can also be asserted. + * + * @deprecated + */ +export { assertRejects as assertThrowsAsync }; + +/** Use this to stub out methods that will throw when invoked. */ +export function unimplemented(msg?: string): never { + throw new AssertionError(msg || "unimplemented"); +} + +/** Use this to assert unreachable code. */ +export function unreachable(): never { + throw new AssertionError("unreachable"); +} diff --git a/vendor/deps/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.metadata.json b/vendor/deps/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.metadata.json new file mode 100644 index 0000000..a10ba38 --- /dev/null +++ b/vendor/deps/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.metadata.json @@ -0,0 +1,16 @@ +{ + "headers": { + "cache-control": "public, max-age=31536000, immutable", + "x-amz-request-id": "5WK20JDP4JGMDA0M", + "x-amz-id-2": "0l7bjBDsKtleLd1Grvjt2SeQI/+2ua8jGuVBG2Z/h45Meq0BMgl9J82vZTLPTrORGqpznqVFs3E=", + "x-amz-version-id": "qW9eDWU3kybHVD1gOHGerosW7UEZaMeQ", + "content-length": "18928", + "content-type": "application/typescript; charset=utf-8", + "last-modified": "Mon, 23 Aug 2021 22:19:15 GMT", + "access-control-allow-origin": "*", + "server": "AmazonS3", + "date": "Tue, 24 Aug 2021 13:53:42 GMT", + "etag": "\"3c51595bb9af62c421e371635ad7b9e9\"" + }, + "url": "https://deno.land/std@0.106.0/testing/asserts.ts" +} \ No newline at end of file diff --git a/vendor/deps/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1 b/vendor/deps/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1 new file mode 100644 index 0000000..a51079d --- /dev/null +++ b/vendor/deps/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1 @@ -0,0 +1,526 @@ +// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +// A module to print ANSI terminal colors. Inspired by chalk, kleur, and colors +// on npm. +// +// ``` +// import { bgBlue, red, bold } from "https://deno.land/std/fmt/colors.ts"; +// console.log(bgBlue(red(bold("Hello world!")))); +// ``` +// +// This module supports `NO_COLOR` environmental variable disabling any coloring +// if `NO_COLOR` is set. +// +// This module is browser compatible. + +// deno-lint-ignore no-explicit-any +const { Deno } = globalThis as any; +const noColor = typeof Deno?.noColor === "boolean" + ? Deno.noColor as boolean + : true; + +interface Code { + open: string; + close: string; + regexp: RegExp; +} + +/** RGB 8-bits per channel. Each in range `0->255` or `0x00->0xff` */ +interface Rgb { + r: number; + g: number; + b: number; +} + +let enabled = !noColor; + +/** + * Set changing text color to enabled or disabled + * @param value + */ +export function setColorEnabled(value: boolean): void { + if (noColor) { + return; + } + + enabled = value; +} + +/** Get whether text color change is enabled or disabled. */ +export function getColorEnabled(): boolean { + return enabled; +} + +/** + * Builds color code + * @param open + * @param close + */ +function code(open: number[], close: number): Code { + return { + open: `\x1b[${open.join(";")}m`, + close: `\x1b[${close}m`, + regexp: new RegExp(`\\x1b\\[${close}m`, "g"), + }; +} + +/** + * Applies color and background based on color code and its associated text + * @param str text to apply color settings to + * @param code color code to apply + */ +function run(str: string, code: Code): string { + return enabled + ? `${code.open}${str.replace(code.regexp, code.open)}${code.close}` + : str; +} + +/** + * Reset the text modified + * @param str text to reset + */ +export function reset(str: string): string { + return run(str, code([0], 0)); +} + +/** + * Make the text bold. + * @param str text to make bold + */ +export function bold(str: string): string { + return run(str, code([1], 22)); +} + +/** + * The text emits only a small amount of light. + * @param str text to dim + */ +export function dim(str: string): string { + return run(str, code([2], 22)); +} + +/** + * Make the text italic. + * @param str text to make italic + */ +export function italic(str: string): string { + return run(str, code([3], 23)); +} + +/** + * Make the text underline. + * @param str text to underline + */ +export function underline(str: string): string { + return run(str, code([4], 24)); +} + +/** + * Invert background color and text color. + * @param str text to invert its color + */ +export function inverse(str: string): string { + return run(str, code([7], 27)); +} + +/** + * Make the text hidden. + * @param str text to hide + */ +export function hidden(str: string): string { + return run(str, code([8], 28)); +} + +/** + * Put horizontal line through the center of the text. + * @param str text to strike through + */ +export function strikethrough(str: string): string { + return run(str, code([9], 29)); +} + +/** + * Set text color to black. + * @param str text to make black + */ +export function black(str: string): string { + return run(str, code([30], 39)); +} + +/** + * Set text color to red. + * @param str text to make red + */ +export function red(str: string): string { + return run(str, code([31], 39)); +} + +/** + * Set text color to green. + * @param str text to make green + */ +export function green(str: string): string { + return run(str, code([32], 39)); +} + +/** + * Set text color to yellow. + * @param str text to make yellow + */ +export function yellow(str: string): string { + return run(str, code([33], 39)); +} + +/** + * Set text color to blue. + * @param str text to make blue + */ +export function blue(str: string): string { + return run(str, code([34], 39)); +} + +/** + * Set text color to magenta. + * @param str text to make magenta + */ +export function magenta(str: string): string { + return run(str, code([35], 39)); +} + +/** + * Set text color to cyan. + * @param str text to make cyan + */ +export function cyan(str: string): string { + return run(str, code([36], 39)); +} + +/** + * Set text color to white. + * @param str text to make white + */ +export function white(str: string): string { + return run(str, code([37], 39)); +} + +/** + * Set text color to gray. + * @param str text to make gray + */ +export function gray(str: string): string { + return brightBlack(str); +} + +/** + * Set text color to bright black. + * @param str text to make bright-black + */ +export function brightBlack(str: string): string { + return run(str, code([90], 39)); +} + +/** + * Set text color to bright red. + * @param str text to make bright-red + */ +export function brightRed(str: string): string { + return run(str, code([91], 39)); +} + +/** + * Set text color to bright green. + * @param str text to make bright-green + */ +export function brightGreen(str: string): string { + return run(str, code([92], 39)); +} + +/** + * Set text color to bright yellow. + * @param str text to make bright-yellow + */ +export function brightYellow(str: string): string { + return run(str, code([93], 39)); +} + +/** + * Set text color to bright blue. + * @param str text to make bright-blue + */ +export function brightBlue(str: string): string { + return run(str, code([94], 39)); +} + +/** + * Set text color to bright magenta. + * @param str text to make bright-magenta + */ +export function brightMagenta(str: string): string { + return run(str, code([95], 39)); +} + +/** + * Set text color to bright cyan. + * @param str text to make bright-cyan + */ +export function brightCyan(str: string): string { + return run(str, code([96], 39)); +} + +/** + * Set text color to bright white. + * @param str text to make bright-white + */ +export function brightWhite(str: string): string { + return run(str, code([97], 39)); +} + +/** + * Set background color to black. + * @param str text to make its background black + */ +export function bgBlack(str: string): string { + return run(str, code([40], 49)); +} + +/** + * Set background color to red. + * @param str text to make its background red + */ +export function bgRed(str: string): string { + return run(str, code([41], 49)); +} + +/** + * Set background color to green. + * @param str text to make its background green + */ +export function bgGreen(str: string): string { + return run(str, code([42], 49)); +} + +/** + * Set background color to yellow. + * @param str text to make its background yellow + */ +export function bgYellow(str: string): string { + return run(str, code([43], 49)); +} + +/** + * Set background color to blue. + * @param str text to make its background blue + */ +export function bgBlue(str: string): string { + return run(str, code([44], 49)); +} + +/** + * Set background color to magenta. + * @param str text to make its background magenta + */ +export function bgMagenta(str: string): string { + return run(str, code([45], 49)); +} + +/** + * Set background color to cyan. + * @param str text to make its background cyan + */ +export function bgCyan(str: string): string { + return run(str, code([46], 49)); +} + +/** + * Set background color to white. + * @param str text to make its background white + */ +export function bgWhite(str: string): string { + return run(str, code([47], 49)); +} + +/** + * Set background color to bright black. + * @param str text to make its background bright-black + */ +export function bgBrightBlack(str: string): string { + return run(str, code([100], 49)); +} + +/** + * Set background color to bright red. + * @param str text to make its background bright-red + */ +export function bgBrightRed(str: string): string { + return run(str, code([101], 49)); +} + +/** + * Set background color to bright green. + * @param str text to make its background bright-green + */ +export function bgBrightGreen(str: string): string { + return run(str, code([102], 49)); +} + +/** + * Set background color to bright yellow. + * @param str text to make its background bright-yellow + */ +export function bgBrightYellow(str: string): string { + return run(str, code([103], 49)); +} + +/** + * Set background color to bright blue. + * @param str text to make its background bright-blue + */ +export function bgBrightBlue(str: string): string { + return run(str, code([104], 49)); +} + +/** + * Set background color to bright magenta. + * @param str text to make its background bright-magenta + */ +export function bgBrightMagenta(str: string): string { + return run(str, code([105], 49)); +} + +/** + * Set background color to bright cyan. + * @param str text to make its background bright-cyan + */ +export function bgBrightCyan(str: string): string { + return run(str, code([106], 49)); +} + +/** + * Set background color to bright white. + * @param str text to make its background bright-white + */ +export function bgBrightWhite(str: string): string { + return run(str, code([107], 49)); +} + +/* Special Color Sequences */ + +/** + * Clam and truncate color codes + * @param n + * @param max number to truncate to + * @param min number to truncate from + */ +function clampAndTruncate(n: number, max = 255, min = 0): number { + return Math.trunc(Math.max(Math.min(n, max), min)); +} + +/** + * Set text color using paletted 8bit colors. + * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit + * @param str text color to apply paletted 8bit colors to + * @param color code + */ +export function rgb8(str: string, color: number): string { + return run(str, code([38, 5, clampAndTruncate(color)], 39)); +} + +/** + * Set background color using paletted 8bit colors. + * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit + * @param str text color to apply paletted 8bit background colors to + * @param color code + */ +export function bgRgb8(str: string, color: number): string { + return run(str, code([48, 5, clampAndTruncate(color)], 49)); +} + +/** + * Set text color using 24bit rgb. + * `color` can be a number in range `0x000000` to `0xffffff` or + * an `Rgb`. + * + * To produce the color magenta: + * + * rgb24("foo", 0xff00ff); + * rgb24("foo", {r: 255, g: 0, b: 255}); + * @param str text color to apply 24bit rgb to + * @param color code + */ +export function rgb24(str: string, color: number | Rgb): string { + if (typeof color === "number") { + return run( + str, + code( + [38, 2, (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff], + 39, + ), + ); + } + return run( + str, + code( + [ + 38, + 2, + clampAndTruncate(color.r), + clampAndTruncate(color.g), + clampAndTruncate(color.b), + ], + 39, + ), + ); +} + +/** + * Set background color using 24bit rgb. + * `color` can be a number in range `0x000000` to `0xffffff` or + * an `Rgb`. + * + * To produce the color magenta: + * + * bgRgb24("foo", 0xff00ff); + * bgRgb24("foo", {r: 255, g: 0, b: 255}); + * @param str text color to apply 24bit rgb to + * @param color code + */ +export function bgRgb24(str: string, color: number | Rgb): string { + if (typeof color === "number") { + return run( + str, + code( + [48, 2, (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff], + 49, + ), + ); + } + return run( + str, + code( + [ + 48, + 2, + clampAndTruncate(color.r), + clampAndTruncate(color.g), + clampAndTruncate(color.b), + ], + 49, + ), + ); +} + +// https://github.com/chalk/ansi-regex/blob/2b56fb0c7a07108e5b54241e8faec160d393aedb/index.js +const ANSI_PATTERN = new RegExp( + [ + "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", + "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", + ].join("|"), + "g", +); + +/** + * Remove ANSI escape codes from the string. + * @param string to remove ANSI escape codes from + */ +export function stripColor(string: string): string { + return string.replace(ANSI_PATTERN, ""); +} diff --git a/vendor/deps/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.metadata.json b/vendor/deps/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.metadata.json new file mode 100644 index 0000000..59141d1 --- /dev/null +++ b/vendor/deps/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.metadata.json @@ -0,0 +1,16 @@ +{ + "headers": { + "content-length": "11645", + "server": "AmazonS3", + "last-modified": "Mon, 23 Aug 2021 22:19:13 GMT", + "cache-control": "public, max-age=31536000, immutable", + "x-amz-id-2": "FbRGxGOy9wqib+2NQ1OVOixb8qUPq0K2NDOPKeiteZLBpxlPowodpk7eXK5IMA4skwcEmKpYG4A=", + "access-control-allow-origin": "*", + "content-type": "application/typescript; charset=utf-8", + "date": "Tue, 24 Aug 2021 13:53:42 GMT", + "x-amz-request-id": "5WK83W9VC1FTCG2T", + "x-amz-version-id": "kBd3kTxoXIUIFIrZfyw68XCGEhqwG0Jq", + "etag": "\"5450ef49e6252532f88e69f2c194528a\"" + }, + "url": "https://deno.land/std@0.106.0/fmt/colors.ts" +} \ No newline at end of file diff --git a/vendor/deps/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8 b/vendor/deps/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8 new file mode 100644 index 0000000..088f7f2 --- /dev/null +++ b/vendor/deps/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8 @@ -0,0 +1,339 @@ +// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +interface FarthestPoint { + y: number; + id: number; +} + +export enum DiffType { + removed = "removed", + common = "common", + added = "added", +} + +export interface DiffResult { + type: DiffType; + value: T; + details?: Array>; +} + +const REMOVED = 1; +const COMMON = 2; +const ADDED = 3; + +function createCommon(A: T[], B: T[], reverse?: boolean): T[] { + const common = []; + if (A.length === 0 || B.length === 0) return []; + for (let i = 0; i < Math.min(A.length, B.length); i += 1) { + if ( + A[reverse ? A.length - i - 1 : i] === B[reverse ? B.length - i - 1 : i] + ) { + common.push(A[reverse ? A.length - i - 1 : i]); + } else { + return common; + } + } + return common; +} + +/** + * Renders the differences between the actual and expected values + * @param A Actual value + * @param B Expected value + */ +export function diff(A: T[], B: T[]): Array> { + 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): DiffResult => ({ type: DiffType.common, value: c }), + ), + ...A.map( + (a): DiffResult => ({ + type: swapped ? DiffType.added : DiffType.removed, + value: a, + }), + ), + ...suffixCommon.map( + (c): DiffResult => ({ type: DiffType.common, value: c }), + ), + ]; + } + const offset = N; + const delta = M - N; + const size = M + N + 1; + const fp = new Array(size).fill({ y: -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: T[], + B: T[], + current: FarthestPoint, + swapped: boolean, + ): Array<{ + type: DiffType; + value: T; + }> { + 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: FarthestPoint, + down: FarthestPoint, + k: number, + M: number, + ): FarthestPoint { + if (slide && slide.y === -1 && down && down.y === -1) { + return { y: 0, id: 0 }; + } + if ( + (down && down.y === -1) || + k === M || + (slide && slide.y) > (down && down.y) + 1 + ) { + const prev = slide.id; + ptr++; + routes[ptr] = prev; + routes[ptr + diffTypesPtrOffset] = ADDED; + return { y: slide.y, id: ptr }; + } else { + const prev = down.id; + ptr++; + routes[ptr] = prev; + routes[ptr + diffTypesPtrOffset] = REMOVED; + return { y: down.y + 1, id: ptr }; + } + } + + function snake( + k: number, + slide: FarthestPoint, + down: FarthestPoint, + _offset: number, + A: T[], + B: T[], + ): FarthestPoint { + 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; + } + + while (fp[delta + offset].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, + ); + } + return [ + ...prefixCommon.map( + (c): DiffResult => ({ type: DiffType.common, value: c }), + ), + ...backTrace(A, B, fp[delta + offset], swapped), + ...suffixCommon.map( + (c): DiffResult => ({ 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: string, B: string) { + function tokenize(string: string, { wordDiff = false } = {}): string[] { + 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++) { + if ( + !tokens[i + 1] && tokens[i + 2] && words.test(tokens[i]) && + words.test(tokens[i + 2]) + ) { + tokens[i] += tokens[i + 2]; + tokens.splice(i + 1, 2); + i--; + } + } + return tokens.filter((token) => token); + } else { + // Split string on new lines symbols + const tokens = [], 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 (let i = 0; i < lines.length; i++) { + if (i % 2) { + tokens[tokens.length - 1] += lines[i]; + } else { + tokens.push(lines[i]); + } + } + return tokens; + } + } + + // Create details by filtering revelant word-diff for current line + // and merge "space-diff" if surrounded by word-diff for cleaner displays + function createDetails( + line: DiffResult, + tokens: Array>, + ) { + return tokens.filter(({ type }) => + type === line.type || type === DiffType.common + ).map((result, i, t) => { + if ( + (result.type === DiffType.common) && (t[i - 1]) && + (t[i - 1]?.type === t[i + 1]?.type) && /\s+/.test(result.value) + ) { + result.type = t[i - 1].type; + } + return result; + }); + } + + // Compute multi-line diff + const diffResult = diff(tokenize(`${A}\n`), tokenize(`${B}\n`)); + const added = [], 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 aLines = added.length < removed.length ? added : removed; + const bLines = aLines === removed ? added : removed; + for (const a of aLines) { + let tokens = [] as Array>, + b: undefined | DiffResult; + // Search another diff line with at least one common token + while (bLines.length) { + b = bLines.shift(); + tokens = diff( + tokenize(a.value, { wordDiff: true }), + tokenize(b?.value ?? "", { wordDiff: true }), + ); + 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; +} diff --git a/vendor/deps/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.metadata.json b/vendor/deps/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.metadata.json new file mode 100644 index 0000000..9cf5e29 --- /dev/null +++ b/vendor/deps/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.metadata.json @@ -0,0 +1,16 @@ +{ + "headers": { + "cache-control": "public, max-age=31536000, immutable", + "x-amz-request-id": "5WK6KHYNZZ5KA6AY", + "content-length": "8987", + "content-type": "application/typescript; charset=utf-8", + "etag": "\"cf6aa0f0d1f64e912327dd59540f2c89\"", + "server": "AmazonS3", + "x-amz-id-2": "RQLaFsC0gkZeP3osZE1P0ryyqAJvZzkiEUdemkaCkZe9kbozl8/YSR0E9GpLoNcZD9GrYuowmaA=", + "date": "Tue, 24 Aug 2021 13:53:42 GMT", + "x-amz-version-id": "s.ztI5zs1eOnsBLULnHd3GCV8eow4WNa", + "last-modified": "Mon, 23 Aug 2021 22:19:15 GMT", + "access-control-allow-origin": "*" + }, + "url": "https://deno.land/std@0.106.0/testing/_diff.ts" +} \ No newline at end of file diff --git a/vendor/gen/file/Users/jasonhall/deno/example.js.buildinfo b/vendor/gen/file/Users/jasonhall/deno/example.js.buildinfo new file mode 100644 index 0000000..673f9f9 --- /dev/null +++ b/vendor/gen/file/Users/jasonhall/deno/example.js.buildinfo @@ -0,0 +1 @@ +{"program":{"fileNames":["asset:///lib.es5.d.ts","asset:///lib.es2015.d.ts","asset:///lib.es2016.d.ts","asset:///lib.es2017.d.ts","asset:///lib.es2018.d.ts","asset:///lib.es2019.d.ts","asset:///lib.es2020.d.ts","asset:///lib.es2021.d.ts","asset:///lib.esnext.d.ts","asset:///lib.es2015.core.d.ts","asset:///lib.es2015.collection.d.ts","asset:///lib.es2015.generator.d.ts","asset:///lib.es2015.iterable.d.ts","asset:///lib.es2015.promise.d.ts","asset:///lib.es2015.proxy.d.ts","asset:///lib.es2015.reflect.d.ts","asset:///lib.es2015.symbol.d.ts","asset:///lib.es2015.symbol.wellknown.d.ts","asset:///lib.es2016.array.include.d.ts","asset:///lib.es2017.object.d.ts","asset:///lib.es2017.sharedmemory.d.ts","asset:///lib.es2017.string.d.ts","asset:///lib.es2017.intl.d.ts","asset:///lib.es2017.typedarrays.d.ts","asset:///lib.es2018.asyncgenerator.d.ts","asset:///lib.es2018.asynciterable.d.ts","asset:///lib.es2018.intl.d.ts","asset:///lib.es2018.promise.d.ts","asset:///lib.es2018.regexp.d.ts","asset:///lib.es2019.array.d.ts","asset:///lib.es2019.object.d.ts","asset:///lib.es2019.string.d.ts","asset:///lib.es2019.symbol.d.ts","asset:///lib.es2020.bigint.d.ts","asset:///lib.es2020.promise.d.ts","asset:///lib.es2020.sharedmemory.d.ts","asset:///lib.es2020.string.d.ts","asset:///lib.es2020.symbol.wellknown.d.ts","asset:///lib.es2020.intl.d.ts","asset:///lib.es2021.promise.d.ts","asset:///lib.es2021.string.d.ts","asset:///lib.es2021.weakref.d.ts","asset:///lib.esnext.object.d.ts","asset:///lib.esnext.error.d.ts","asset:///lib.esnext.array.d.ts","asset:///lib.esnext.intl.d.ts","asset:///lib.esnext.string.d.ts","asset:///lib.deno.window.d.ts","asset:///lib.deno.shared_globals.d.ts","asset:///lib.deno.ns.d.ts","asset:///lib.deno.url.d.ts","asset:///lib.deno.web.d.ts","asset:///lib.deno.fetch.d.ts","asset:///lib.deno.broadcast_channel.d.ts","asset:///lib.deno.webgpu.d.ts","asset:///lib.deno.net.d.ts","asset:///lib.deno.console.d.ts","asset:///lib.deno.websocket.d.ts","asset:///lib.deno.webstorage.d.ts","asset:///lib.deno.crypto.d.ts","https://deno.land/std@0.106.0/fmt/colors.ts","https://deno.land/std@0.106.0/testing/_diff.ts","https://deno.land/std@0.106.0/testing/asserts.ts","file:///Users/jasonhall/deno/example.js"],"fileInfos":[{"version":"1","affectsGlobalScope":true},"1","1","1","1","1","1","1","1",{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},{"version":"1","affectsGlobalScope":true},"9c1e0ac67df4b1c9549cf6ccad352582ce8c7c05a7d6e35b8e356b0eaef7759b","2cbc4c818f378061473f7fe2866aa13013a0f76da79ba8330669d466c5f1bf4c","aed4766fb79196e96328054a5b5418346bf0165326f0da25b753b7dc49cdd18a","56e2e9634a6df2fb40625bf13f5d8f3a9737ff3fa74b1a9fbbfec39afa51a3fe"],"options":{"emitDecoratorMetadata":false,"esModuleInterop":true,"experimentalDecorators":true,"importsNotUsedAsValues":0,"inlineSourceMap":true,"jsx":2,"module":99,"outDir":"deno://","removeComments":true,"strict":true,"target":99,"tsBuildInfoFile":"./.tsbuildinfo","useDefineForClassFields":true},"fileIdsList":[[63],[61,62]],"referencedMap":[[64,1],[63,2]],"exportedModulesMap":[[64,1],[63,2]]},"version":"4.3.5"} \ No newline at end of file diff --git a/vendor/gen/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.js b/vendor/gen/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.js new file mode 100644 index 0000000..9dfa020 --- /dev/null +++ b/vendor/gen/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.js @@ -0,0 +1,400 @@ +import { bgGreen, bgRed, bold, gray, green, red, stripColor, white, } from "../fmt/colors.ts"; +import { diff, diffstr, DiffType } from "./_diff.ts"; +const CAN_NOT_DISPLAY = "[Cannot display]"; +export class AssertionError extends Error { + constructor(message) { + super(message); + this.name = "AssertionError"; + } +} +export function _format(v) { + const { Deno } = globalThis; + return typeof Deno?.inspect === "function" + ? Deno.inspect(v, { + depth: Infinity, + sorted: true, + trailingComma: true, + compact: false, + iterableLimit: Infinity, + }) + : `"${String(v).replace(/(?=["\\])/g, "\\")}"`; +} +function createColor(diffType, { 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; + } +} +function createSign(diffType) { + switch (diffType) { + case DiffType.added: + return "+ "; + case DiffType.removed: + return "- "; + default: + return " "; + } +} +function buildMessage(diffResult, { stringDiff = false } = {}) { + const messages = [], 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; +} +function isKeyedCollection(x) { + return [Symbol.iterator, "size"].every((k) => k in x); +} +export function equal(c, d) { + const seen = new Map(); + return (function compare(a, b) { + if (a && + b && + ((a instanceof RegExp && b instanceof RegExp) || + (a instanceof URL && b instanceof URL))) { + return String(a) === String(b); + } + if (a instanceof Date && b instanceof Date) { + const aTime = a.getTime(); + const bTime = b.getTime(); + if (Number.isNaN(aTime) && Number.isNaN(bTime)) { + return true; + } + return a.getTime() === b.getTime(); + } + if (Object.is(a, b)) { + return true; + } + if (a && typeof a === "object" && b && typeof b === "object") { + if (a && b && !constructorsEqual(a, b)) { + return false; + } + if (a instanceof WeakMap || b instanceof WeakMap) { + if (!(a instanceof WeakMap && b instanceof WeakMap)) + return false; + throw new TypeError("cannot compare WeakMap instances"); + } + if (a instanceof WeakSet || b instanceof WeakSet) { + if (!(a instanceof WeakSet && b instanceof WeakSet)) + return false; + throw new TypeError("cannot compare WeakSet instances"); + } + if (seen.get(a) === b) { + return true; + } + if (Object.keys(a || {}).length !== Object.keys(b || {}).length) { + return false; + } + if (isKeyedCollection(a) && isKeyedCollection(b)) { + if (a.size !== b.size) { + return false; + } + let unmatchedEntries = a.size; + for (const [aKey, aValue] of a.entries()) { + for (const [bKey, bValue] of b.entries()) { + if ((aKey === aValue && bKey === bValue && compare(aKey, bKey)) || + (compare(aKey, bKey) && compare(aValue, bValue))) { + unmatchedEntries--; + } + } + } + return unmatchedEntries === 0; + } + const merged = { ...a, ...b }; + for (const key of [ + ...Object.getOwnPropertyNames(merged), + ...Object.getOwnPropertySymbols(merged), + ]) { + if (!compare(a && a[key], b && b[key])) { + return false; + } + if (((key in a) && (!(key in b))) || ((key in b) && (!(key in a)))) { + return false; + } + } + seen.set(a, b); + if (a instanceof WeakRef || b instanceof WeakRef) { + if (!(a instanceof WeakRef && b instanceof WeakRef)) + return false; + return compare(a.deref(), b.deref()); + } + return true; + } + return false; + })(c, d); +} +function constructorsEqual(a, b) { + return a.constructor === b.constructor || + a.constructor === Object && !b.constructor || + !a.constructor && b.constructor === Object; +} +export function assert(expr, msg = "") { + if (!expr) { + throw new AssertionError(msg); + } +} +export function assertEquals(actual, expected, msg) { + if (equal(actual, expected)) { + return; + } + let message = ""; + const actualString = _format(actual); + const expectedString = _format(expected); + try { + const stringDiff = (typeof actual === "string") && + (typeof expected === "string"); + const diffResult = stringDiff + ? diffstr(actual, expected) + : diff(actualString.split("\n"), expectedString.split("\n")); + const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n"); + message = `Values are not equal:\n${diffMsg}`; + } + catch { + message = `\n${red(CAN_NOT_DISPLAY)} + \n\n`; + } + if (msg) { + message = msg; + } + throw new AssertionError(message); +} +export function assertNotEquals(actual, expected, msg) { + if (!equal(actual, expected)) { + return; + } + let actualString; + let expectedString; + try { + actualString = String(actual); + } + catch { + actualString = "[Cannot display]"; + } + try { + expectedString = String(expected); + } + catch { + expectedString = "[Cannot display]"; + } + if (!msg) { + msg = `actual: ${actualString} expected: ${expectedString}`; + } + throw new AssertionError(msg); +} +export function assertStrictEquals(actual, expected, msg) { + if (actual === expected) { + return; + } + let message; + if (msg) { + message = msg; + } + else { + const actualString = _format(actual); + const expectedString = _format(expected); + if (actualString === expectedString) { + const withOffset = actualString + .split("\n") + .map((l) => ` ${l}`) + .join("\n"); + message = + `Values have the same structure but are not reference-equal:\n\n${red(withOffset)}\n`; + } + else { + try { + const stringDiff = (typeof actual === "string") && + (typeof expected === "string"); + const diffResult = stringDiff + ? diffstr(actual, expected) + : diff(actualString.split("\n"), expectedString.split("\n")); + const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n"); + message = `Values are not strictly equal:\n${diffMsg}`; + } + catch { + message = `\n${red(CAN_NOT_DISPLAY)} + \n\n`; + } + } + } + throw new AssertionError(message); +} +export function assertNotStrictEquals(actual, expected, msg) { + if (actual !== expected) { + return; + } + throw new AssertionError(msg ?? `Expected "actual" to be strictly unequal to: ${_format(actual)}\n`); +} +export function assertExists(actual, msg) { + if (actual === undefined || actual === null) { + if (!msg) { + msg = `actual: "${actual}" expected to not be null or undefined`; + } + throw new AssertionError(msg); + } +} +export function assertStringIncludes(actual, expected, msg) { + if (!actual.includes(expected)) { + if (!msg) { + msg = `actual: "${actual}" expected to contain: "${expected}"`; + } + throw new AssertionError(msg); + } +} +export function assertArrayIncludes(actual, expected, msg) { + const missing = []; + for (let i = 0; i < expected.length; i++) { + let found = false; + for (let j = 0; j < actual.length; j++) { + if (equal(expected[i], actual[j])) { + found = true; + break; + } + } + if (!found) { + missing.push(expected[i]); + } + } + if (missing.length === 0) { + return; + } + if (!msg) { + msg = `actual: "${_format(actual)}" expected to include: "${_format(expected)}"\nmissing: ${_format(missing)}`; + } + throw new AssertionError(msg); +} +export function assertMatch(actual, expected, msg) { + if (!expected.test(actual)) { + if (!msg) { + msg = `actual: "${actual}" expected to match: "${expected}"`; + } + throw new AssertionError(msg); + } +} +export function assertNotMatch(actual, expected, msg) { + if (expected.test(actual)) { + if (!msg) { + msg = `actual: "${actual}" expected to not match: "${expected}"`; + } + throw new AssertionError(msg); + } +} +export function assertObjectMatch(actual, expected) { + const seen = new WeakMap(); + return assertEquals((function filter(a, b) { + if ((seen.has(a)) && (seen.get(a) === b)) { + return a; + } + seen.set(a, b); + const filtered = {}; + const entries = [ + ...Object.getOwnPropertyNames(a), + ...Object.getOwnPropertySymbols(a), + ] + .filter((key) => key in b) + .map((key) => [key, a[key]]); + for (const [key, value] of entries) { + if (Array.isArray(value)) { + const subset = b[key]; + if (Array.isArray(subset)) { + filtered[key] = value + .slice(0, subset.length) + .map((element, index) => { + const subsetElement = subset[index]; + if ((typeof subsetElement === "object") && (subsetElement)) { + return filter(element, subsetElement); + } + return element; + }); + continue; + } + } + else if (typeof value === "object") { + const subset = b[key]; + if ((typeof subset === "object") && (subset)) { + filtered[key] = filter(value, subset); + continue; + } + } + filtered[key] = value; + } + return filtered; + })(actual, expected), expected); +} +export function fail(msg) { + assert(false, `Failed assertion${msg ? `: ${msg}` : "."}`); +} +export function assertThrows(fn, ErrorClass, msgIncludes = "", msg) { + let doesThrow = false; + try { + fn(); + } + catch (e) { + if (e instanceof Error === false) { + throw new AssertionError("A non-Error object was thrown."); + } + if (ErrorClass && !(e instanceof ErrorClass)) { + msg = + `Expected error to be instance of "${ErrorClass.name}", but was "${e.constructor.name}"${msg ? `: ${msg}` : "."}`; + throw new AssertionError(msg); + } + if (msgIncludes && + !stripColor(e.message).includes(stripColor(msgIncludes))) { + msg = + `Expected error message to include "${msgIncludes}", but got "${e.message}"${msg ? `: ${msg}` : "."}`; + throw new AssertionError(msg); + } + doesThrow = true; + } + if (!doesThrow) { + msg = `Expected function to throw${msg ? `: ${msg}` : "."}`; + throw new AssertionError(msg); + } +} +export async function assertRejects(fn, ErrorClass, msgIncludes = "", msg) { + let doesThrow = false; + try { + await fn(); + } + catch (e) { + if (e instanceof Error === false) { + throw new AssertionError("A non-Error object was thrown or rejected."); + } + if (ErrorClass && !(e instanceof ErrorClass)) { + msg = + `Expected error to be instance of "${ErrorClass.name}", but was "${e.constructor.name}"${msg ? `: ${msg}` : "."}`; + throw new AssertionError(msg); + } + if (msgIncludes && + !stripColor(e.message).includes(stripColor(msgIncludes))) { + msg = + `Expected error message to include "${msgIncludes}", but got "${e.message}"${msg ? `: ${msg}` : "."}`; + throw new AssertionError(msg); + } + doesThrow = true; + } + if (!doesThrow) { + msg = `Expected function to throw${msg ? `: ${msg}` : "."}`; + throw new AssertionError(msg); + } +} +export { assertRejects as assertThrowsAsync }; +export function unimplemented(msg) { + throw new AssertionError(msg || "unimplemented"); +} +export function unreachable() { + throw new AssertionError("unreachable"); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asserts.js","sourceRoot":"","sources":["asserts.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/vendor/gen/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.meta b/vendor/gen/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.meta new file mode 100644 index 0000000..c838a4a --- /dev/null +++ b/vendor/gen/https/deno.land/0238264153ff67619d83eb947c82f87d77d469e0785906e5355363a92ff5b5ab.meta @@ -0,0 +1 @@ +{"version_hash":"b9fc019860293cf104762ad4848e398e54835bf27d222c327c59b9350664a519"} \ No newline at end of file diff --git a/vendor/gen/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.js b/vendor/gen/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.js new file mode 100644 index 0000000..841e87b --- /dev/null +++ b/vendor/gen/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.js @@ -0,0 +1,190 @@ +const { Deno } = globalThis; +const noColor = typeof Deno?.noColor === "boolean" + ? Deno.noColor + : true; +let enabled = !noColor; +export function setColorEnabled(value) { + if (noColor) { + return; + } + enabled = value; +} +export function getColorEnabled() { + return enabled; +} +function code(open, close) { + return { + open: `\x1b[${open.join(";")}m`, + close: `\x1b[${close}m`, + regexp: new RegExp(`\\x1b\\[${close}m`, "g"), + }; +} +function run(str, code) { + return enabled + ? `${code.open}${str.replace(code.regexp, code.open)}${code.close}` + : str; +} +export function reset(str) { + return run(str, code([0], 0)); +} +export function bold(str) { + return run(str, code([1], 22)); +} +export function dim(str) { + return run(str, code([2], 22)); +} +export function italic(str) { + return run(str, code([3], 23)); +} +export function underline(str) { + return run(str, code([4], 24)); +} +export function inverse(str) { + return run(str, code([7], 27)); +} +export function hidden(str) { + return run(str, code([8], 28)); +} +export function strikethrough(str) { + return run(str, code([9], 29)); +} +export function black(str) { + return run(str, code([30], 39)); +} +export function red(str) { + return run(str, code([31], 39)); +} +export function green(str) { + return run(str, code([32], 39)); +} +export function yellow(str) { + return run(str, code([33], 39)); +} +export function blue(str) { + return run(str, code([34], 39)); +} +export function magenta(str) { + return run(str, code([35], 39)); +} +export function cyan(str) { + return run(str, code([36], 39)); +} +export function white(str) { + return run(str, code([37], 39)); +} +export function gray(str) { + return brightBlack(str); +} +export function brightBlack(str) { + return run(str, code([90], 39)); +} +export function brightRed(str) { + return run(str, code([91], 39)); +} +export function brightGreen(str) { + return run(str, code([92], 39)); +} +export function brightYellow(str) { + return run(str, code([93], 39)); +} +export function brightBlue(str) { + return run(str, code([94], 39)); +} +export function brightMagenta(str) { + return run(str, code([95], 39)); +} +export function brightCyan(str) { + return run(str, code([96], 39)); +} +export function brightWhite(str) { + return run(str, code([97], 39)); +} +export function bgBlack(str) { + return run(str, code([40], 49)); +} +export function bgRed(str) { + return run(str, code([41], 49)); +} +export function bgGreen(str) { + return run(str, code([42], 49)); +} +export function bgYellow(str) { + return run(str, code([43], 49)); +} +export function bgBlue(str) { + return run(str, code([44], 49)); +} +export function bgMagenta(str) { + return run(str, code([45], 49)); +} +export function bgCyan(str) { + return run(str, code([46], 49)); +} +export function bgWhite(str) { + return run(str, code([47], 49)); +} +export function bgBrightBlack(str) { + return run(str, code([100], 49)); +} +export function bgBrightRed(str) { + return run(str, code([101], 49)); +} +export function bgBrightGreen(str) { + return run(str, code([102], 49)); +} +export function bgBrightYellow(str) { + return run(str, code([103], 49)); +} +export function bgBrightBlue(str) { + return run(str, code([104], 49)); +} +export function bgBrightMagenta(str) { + return run(str, code([105], 49)); +} +export function bgBrightCyan(str) { + return run(str, code([106], 49)); +} +export function bgBrightWhite(str) { + return run(str, code([107], 49)); +} +function clampAndTruncate(n, max = 255, min = 0) { + return Math.trunc(Math.max(Math.min(n, max), min)); +} +export function rgb8(str, color) { + return run(str, code([38, 5, clampAndTruncate(color)], 39)); +} +export function bgRgb8(str, color) { + return run(str, code([48, 5, clampAndTruncate(color)], 49)); +} +export function rgb24(str, color) { + if (typeof color === "number") { + return run(str, code([38, 2, (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff], 39)); + } + return run(str, code([ + 38, + 2, + clampAndTruncate(color.r), + clampAndTruncate(color.g), + clampAndTruncate(color.b), + ], 39)); +} +export function bgRgb24(str, color) { + if (typeof color === "number") { + return run(str, code([48, 2, (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff], 49)); + } + return run(str, code([ + 48, + 2, + clampAndTruncate(color.r), + clampAndTruncate(color.g), + clampAndTruncate(color.b), + ], 49)); +} +const ANSI_PATTERN = new RegExp([ + "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", + "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", +].join("|"), "g"); +export function stripColor(string) { + return string.replace(ANSI_PATTERN, ""); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"colors.js","sourceRoot":"","sources":["colors.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/vendor/gen/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.meta b/vendor/gen/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.meta new file mode 100644 index 0000000..ce6f685 --- /dev/null +++ b/vendor/gen/https/deno.land/d04cfd2eef35a30469e39b781adeb9679718de575792a5513845ebc459f507c1.meta @@ -0,0 +1 @@ +{"version_hash":"9afb5f692fc2cd52a9b45d2dadc1c6878dadc24036e58736e00585a97211b0c4"} \ No newline at end of file diff --git a/vendor/gen/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.js b/vendor/gen/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.js new file mode 100644 index 0000000..cacb8e4 --- /dev/null +++ b/vendor/gen/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.js @@ -0,0 +1,214 @@ +export var DiffType; +(function (DiffType) { + DiffType["removed"] = "removed"; + DiffType["common"] = "common"; + DiffType["added"] = "added"; +})(DiffType || (DiffType = {})); +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) { + if (A[reverse ? A.length - i - 1 : i] === B[reverse ? B.length - i - 1 : i]) { + common.push(A[reverse ? A.length - i - 1 : i]); + } + else { + return common; + } + } + return common; +} +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 = new Array(size).fill({ y: -1 }); + 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 }; + } + if ((down && down.y === -1) || + k === M || + (slide && slide.y) > (down && down.y) + 1) { + const prev = slide.id; + ptr++; + routes[ptr] = prev; + routes[ptr + diffTypesPtrOffset] = ADDED; + return { y: slide.y, id: ptr }; + } + else { + const prev = down.id; + ptr++; + routes[ptr] = prev; + routes[ptr + diffTypesPtrOffset] = REMOVED; + return { y: down.y + 1, id: ptr }; + } + } + 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; + } + while (fp[delta + offset].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); + } + return [ + ...prefixCommon.map((c) => ({ type: DiffType.common, value: c })), + ...backTrace(A, B, fp[delta + offset], swapped), + ...suffixCommon.map((c) => ({ type: DiffType.common, value: c })), + ]; +} +export function diffstr(A, B) { + function tokenize(string, { wordDiff = false } = {}) { + if (wordDiff) { + const tokens = string.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/); + 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; + for (let i = 0; i < tokens.length - 1; i++) { + if (!tokens[i + 1] && tokens[i + 2] && words.test(tokens[i]) && + words.test(tokens[i + 2])) { + tokens[i] += tokens[i + 2]; + tokens.splice(i + 1, 2); + i--; + } + } + return tokens.filter((token) => token); + } + else { + const tokens = [], lines = string.split(/(\n|\r\n)/); + if (!lines[lines.length - 1]) { + lines.pop(); + } + for (let i = 0; i < lines.length; i++) { + if (i % 2) { + tokens[tokens.length - 1] += lines[i]; + } + else { + tokens.push(lines[i]); + } + } + return tokens; + } + } + function createDetails(line, tokens) { + return tokens.filter(({ type }) => type === line.type || type === DiffType.common).map((result, i, t) => { + if ((result.type === DiffType.common) && (t[i - 1]) && + (t[i - 1]?.type === t[i + 1]?.type) && /\s+/.test(result.value)) { + result.type = t[i - 1].type; + } + return result; + }); + } + const diffResult = diff(tokenize(`${A}\n`), tokenize(`${B}\n`)); + const added = [], removed = []; + for (const result of diffResult) { + if (result.type === DiffType.added) { + added.push(result); + } + if (result.type === DiffType.removed) { + removed.push(result); + } + } + const aLines = added.length < removed.length ? added : removed; + const bLines = aLines === removed ? added : removed; + for (const a of aLines) { + let tokens = [], b; + while (bLines.length) { + b = bLines.shift(); + tokens = diff(tokenize(a.value, { wordDiff: true }), tokenize(b?.value ?? "", { wordDiff: true })); + if (tokens.some(({ type, value }) => type === DiffType.common && value.trim().length)) { + break; + } + } + a.details = createDetails(a, tokens); + if (b) { + b.details = createDetails(b, tokens); + } + } + return diffResult; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_diff.js","sourceRoot":"","sources":["_diff.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/vendor/gen/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.meta b/vendor/gen/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.meta new file mode 100644 index 0000000..374c587 --- /dev/null +++ b/vendor/gen/https/deno.land/d939d9900b48654bc29fb07c8f46f41f0a35feed44763fc422580f7f43845cd8.meta @@ -0,0 +1 @@ +{"version_hash":"48aa556daec2980127ca50aa078501e880d5118fe3045ea105f4c64fd72f1deb"} \ No newline at end of file