document-ir 0.0.7 → 0.0.8

package/package.json

@@ -2,7 +2,7 @@
   "module": "./esm/index.js",
   "main": "./script/index.js",
   "name": "document-ir",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Intermediate representation and transformers for documents",
   "license": "MIT",
   "repository": {
@@ -18,12 +18,7 @@
       "require": "./script/index.js"
     }
   },
-  "scripts": {
-    "test": "node test_runner.js"
-  },
   "devDependencies": {
-    "@types/node": "^18.11.9",
-    "picocolors": "^1.0.0",
-    "@deno/shim-deno": "~0.16.1"
+    "@types/node": "^18.11.9"
   }
 }

package/esm/ArrayCollapseTransformer_test.d.ts

@@ -1 +0,0 @@
-export {};

package/esm/ExampleDocument.d.ts

@@ -1,2 +0,0 @@
-import { DocumentNode } from "./types.js";
-export declare const ExampleDocument: DocumentNode;

package/esm/IdentityTransformer_test.d.ts

@@ -1 +0,0 @@
-export {};

package/esm/TextCollapseTransformer_test.d.ts

@@ -1 +0,0 @@
-export {};

package/esm/TextVisitor_test.d.ts

@@ -1 +0,0 @@
-export {};

package/esm/WhitespaceStretchingTransformer_test.d.ts

@@ -1 +0,0 @@
-export {};

package/esm/WhitespaceTransformer_test.d.ts

@@ -1 +0,0 @@
-export {};

package/esm/_dnt.test_shims.d.ts

@@ -1,5 +0,0 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
-export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
-    Deno: typeof Deno;
-};

package/esm/deps/deno.land/std@0.192.0/fmt/colors.d.ts

@@ -1,270 +0,0 @@
-/** RGB 8-bits per channel. Each in range `0->255` or `0x00->0xff` */
-interface Rgb {
-    r: number;
-    g: number;
-    b: number;
-}
-/**
- * Set changing text color to enabled or disabled
- * @param value
- */
-export declare function setColorEnabled(value: boolean): void;
-/** Get whether text color change is enabled or disabled. */
-export declare function getColorEnabled(): boolean;
-/**
- * Reset the text modified
- * @param str text to reset
- */
-export declare function reset(str: string): string;
-/**
- * Make the text bold.
- * @param str text to make bold
- */
-export declare function bold(str: string): string;
-/**
- * The text emits only a small amount of light.
- * @param str text to dim
- */
-export declare function dim(str: string): string;
-/**
- * Make the text italic.
- * @param str text to make italic
- */
-export declare function italic(str: string): string;
-/**
- * Make the text underline.
- * @param str text to underline
- */
-export declare function underline(str: string): string;
-/**
- * Invert background color and text color.
- * @param str text to invert its color
- */
-export declare function inverse(str: string): string;
-/**
- * Make the text hidden.
- * @param str text to hide
- */
-export declare function hidden(str: string): string;
-/**
- * Put horizontal line through the center of the text.
- * @param str text to strike through
- */
-export declare function strikethrough(str: string): string;
-/**
- * Set text color to black.
- * @param str text to make black
- */
-export declare function black(str: string): string;
-/**
- * Set text color to red.
- * @param str text to make red
- */
-export declare function red(str: string): string;
-/**
- * Set text color to green.
- * @param str text to make green
- */
-export declare function green(str: string): string;
-/**
- * Set text color to yellow.
- * @param str text to make yellow
- */
-export declare function yellow(str: string): string;
-/**
- * Set text color to blue.
- * @param str text to make blue
- */
-export declare function blue(str: string): string;
-/**
- * Set text color to magenta.
- * @param str text to make magenta
- */
-export declare function magenta(str: string): string;
-/**
- * Set text color to cyan.
- * @param str text to make cyan
- */
-export declare function cyan(str: string): string;
-/**
- * Set text color to white.
- * @param str text to make white
- */
-export declare function white(str: string): string;
-/**
- * Set text color to gray.
- * @param str text to make gray
- */
-export declare function gray(str: string): string;
-/**
- * Set text color to bright black.
- * @param str text to make bright-black
- */
-export declare function brightBlack(str: string): string;
-/**
- * Set text color to bright red.
- * @param str text to make bright-red
- */
-export declare function brightRed(str: string): string;
-/**
- * Set text color to bright green.
- * @param str text to make bright-green
- */
-export declare function brightGreen(str: string): string;
-/**
- * Set text color to bright yellow.
- * @param str text to make bright-yellow
- */
-export declare function brightYellow(str: string): string;
-/**
- * Set text color to bright blue.
- * @param str text to make bright-blue
- */
-export declare function brightBlue(str: string): string;
-/**
- * Set text color to bright magenta.
- * @param str text to make bright-magenta
- */
-export declare function brightMagenta(str: string): string;
-/**
- * Set text color to bright cyan.
- * @param str text to make bright-cyan
- */
-export declare function brightCyan(str: string): string;
-/**
- * Set text color to bright white.
- * @param str text to make bright-white
- */
-export declare function brightWhite(str: string): string;
-/**
- * Set background color to black.
- * @param str text to make its background black
- */
-export declare function bgBlack(str: string): string;
-/**
- * Set background color to red.
- * @param str text to make its background red
- */
-export declare function bgRed(str: string): string;
-/**
- * Set background color to green.
- * @param str text to make its background green
- */
-export declare function bgGreen(str: string): string;
-/**
- * Set background color to yellow.
- * @param str text to make its background yellow
- */
-export declare function bgYellow(str: string): string;
-/**
- * Set background color to blue.
- * @param str text to make its background blue
- */
-export declare function bgBlue(str: string): string;
-/**
- *  Set background color to magenta.
- * @param str text to make its background magenta
- */
-export declare function bgMagenta(str: string): string;
-/**
- * Set background color to cyan.
- * @param str text to make its background cyan
- */
-export declare function bgCyan(str: string): string;
-/**
- * Set background color to white.
- * @param str text to make its background white
- */
-export declare function bgWhite(str: string): string;
-/**
- * Set background color to bright black.
- * @param str text to make its background bright-black
- */
-export declare function bgBrightBlack(str: string): string;
-/**
- * Set background color to bright red.
- * @param str text to make its background bright-red
- */
-export declare function bgBrightRed(str: string): string;
-/**
- * Set background color to bright green.
- * @param str text to make its background bright-green
- */
-export declare function bgBrightGreen(str: string): string;
-/**
- * Set background color to bright yellow.
- * @param str text to make its background bright-yellow
- */
-export declare function bgBrightYellow(str: string): string;
-/**
- * Set background color to bright blue.
- * @param str text to make its background bright-blue
- */
-export declare function bgBrightBlue(str: string): string;
-/**
- * Set background color to bright magenta.
- * @param str text to make its background bright-magenta
- */
-export declare function bgBrightMagenta(str: string): string;
-/**
- * Set background color to bright cyan.
- * @param str text to make its background bright-cyan
- */
-export declare function bgBrightCyan(str: string): string;
-/**
- * Set background color to bright white.
- * @param str text to make its background bright-white
- */
-export declare function bgBrightWhite(str: string): string;
-/**
- * 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 declare function rgb8(str: string, color: number): string;
-/**
- * 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 declare function bgRgb8(str: string, color: number): string;
-/**
- * Set text color using 24bit rgb.
- * `color` can be a number in range `0x000000` to `0xffffff` or
- * an `Rgb`.
- *
- * To produce the color magenta:
- *
- * ```ts
- *      import { rgb24 } from "https://deno.land/std@$STD_VERSION/fmt/colors.ts";
- *      rgb24("foo", 0xff00ff);
- *      rgb24("foo", {r: 255, g: 0, b: 255});
- * ```
- * @param str text color to apply 24bit rgb to
- * @param color code
- */
-export declare function rgb24(str: string, color: number | Rgb): string;
-/**
- * Set background color using 24bit rgb.
- * `color` can be a number in range `0x000000` to `0xffffff` or
- * an `Rgb`.
- *
- * To produce the color magenta:
- *
- * ```ts
- *      import { bgRgb24 } from "https://deno.land/std@$STD_VERSION/fmt/colors.ts";
- *      bgRgb24("foo", 0xff00ff);
- *      bgRgb24("foo", {r: 255, g: 0, b: 255});
- * ```
- * @param str text color to apply 24bit rgb to
- * @param color code
- */
-export declare function bgRgb24(str: string, color: number | Rgb): string;
-/**
- * Remove ANSI escape codes from the string.
- * @param string to remove ANSI escape codes from
- */
-export declare function stripColor(string: string): string;
-export {};

package/esm/deps/deno.land/std@0.192.0/testing/_diff.d.ts

@@ -1,26 +0,0 @@
-export declare enum DiffType {
-    removed = "removed",
-    common = "common",
-    added = "added"
-}
-export interface DiffResult<T> {
-    type: DiffType;
-    value: T;
-    details?: Array<DiffResult<T>>;
-}
-/**
- * Renders the differences between the actual and expected values
- * @param A Actual value
- * @param B Expected value
- */
-export declare function diff<T>(A: T[], B: T[]): Array<DiffResult<T>>;
-/**
- * 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 declare function diffstr(A: string, B: string): DiffResult<string>[];
-export declare function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>, { stringDiff }?: {
-    stringDiff?: boolean | undefined;
-}): string[];

package/esm/deps/deno.land/std@0.192.0/testing/_format.d.ts

@@ -1 +0,0 @@
-export declare function format(v: unknown): string;

package/esm/deps/deno.land/std@0.192.0/testing/asserts.d.ts

@@ -1,284 +0,0 @@
-export declare class AssertionError extends Error {
-    name: string;
-    constructor(message: string);
-}
-/**
- * Deep equality comparison used in assertions
- * @param c actual value
- * @param d expected value
- */
-export declare function equal(c: unknown, d: unknown): boolean;
-/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
-export declare function assert(expr: unknown, msg?: string): asserts expr;
-/** Make an assertion, error will be thrown if `expr` have truthy value. */
-type Falsy = false | 0 | 0n | "" | null | undefined;
-export declare function assertFalse(expr: unknown, msg?: string): asserts expr is Falsy;
-/**
- * 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.
- *
- * @example
- * ```ts
- * import { assertEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("example", function (): void {
- *   assertEquals("world", "world");
- *   assertEquals({ hello: "world" }, { hello: "world" });
- * });
- * ```
- */
-export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;
-/**
- * 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.
- *
- * @example
- * ```ts
- * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * assertNotEquals<number>(1, 2)
- * ```
- */
-export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;
-/**
- * Make an assertion that `actual` and `expected` are strictly equal. If
- * not then throw.
- *
- * @example
- * ```ts
- * import { assertStrictEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("isStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = a;
- *   assertStrictEquals(a, b);
- * });
- *
- * // This test fails
- * Deno.test("isNotStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = {};
- *   assertStrictEquals(a, b);
- * });
- * ```
- */
-export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;
-/**
- * Make an assertion that `actual` and `expected` are not strictly equal.
- * If the values are strictly equal then throw.
- *
- * ```ts
- * import { assertNotStrictEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * assertNotStrictEquals(1, 1)
- * ```
- */
-export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
-/**
- * Make an assertion that `actual` and `expected` are almost equal numbers through
- * a given tolerance. It can be used to take into account IEEE-754 double-precision
- * floating-point representation limitations.
- * If the values are not almost equal then throw.
- *
- * @example
- * ```ts
- * import { assertAlmostEquals, assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * assertAlmostEquals(0.1, 0.2);
- *
- * // Using a custom tolerance value
- * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16);
- * assertThrows(() => assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17));
- * ```
- */
-export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
-type AnyConstructor = new (...args: any[]) => any;
-type GetConstructorType<T extends AnyConstructor> = T extends new (...args: any) => infer C ? C : never;
-/**
- * Make an assertion that `obj` is an instance of `type`.
- * If not then throw.
- */
-export declare function assertInstanceOf<T extends AnyConstructor>(actual: unknown, expectedType: T, msg?: string): asserts actual is GetConstructorType<T>;
-/**
- * Make an assertion that `obj` is not an instance of `type`.
- * If so, then throw.
- */
-export declare function assertNotInstanceOf<A, T>(actual: A, unexpectedType: new (...args: any[]) => T, msg?: string): asserts actual is Exclude<A, T>;
-/**
- * Make an assertion that actual is not null or undefined.
- * If not then throw.
- */
-export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;
-/**
- * Make an assertion that actual includes expected. If not
- * then throw.
- */
-export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;
-/**
- * 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.
- *
- * @example
- * ```ts
- * import { assertArrayIncludes } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * assertArrayIncludes<number>([1, 2], [2])
- * ```
- */
-export declare function assertArrayIncludes<T>(actual: ArrayLike<T>, expected: ArrayLike<T>, msg?: string): void;
-/**
- * Make an assertion that `actual` match RegExp `expected`. If not
- * then throw.
- */
-export declare function assertMatch(actual: string, expected: RegExp, msg?: string): void;
-/**
- * Make an assertion that `actual` not match RegExp `expected`. If match
- * then throw.
- */
-export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;
-/**
- * Make an assertion that `actual` object is a subset of `expected` object, deeply.
- * If not, then throw.
- */
-export declare function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>, msg?: string): void;
-/**
- * Forcefully throws a failed assertion
- */
-export declare function fail(msg?: string): never;
-/**
- * Make an assertion that `error` is an `Error`.
- * If not then an error will be thrown.
- * An error class and a string that should be included in the
- * error message can also be asserted.
- */
-export declare function assertIsError<E extends Error = Error>(error: unknown, ErrorClass?: new (...args: any[]) => E, msgIncludes?: string, msg?: string): asserts error is E;
-/**
- * Executes a function, expecting it to throw. If it does not, then it
- * throws.
- *
- * @example
- * ```ts
- * import { assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("doesThrow", function (): void {
- *   assertThrows((): void => {
- *     throw new TypeError("hello world!");
- *   });
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", function (): void {
- *   assertThrows((): void => {
- *     console.log("Hello world");
- *   });
- * });
- * ```
- */
-export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
-/**
- * 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.
- *
- * @example
- *
- * ```ts
- * import { assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("doesThrow", function (): void {
- *   assertThrows((): void => {
- *     throw new TypeError("hello world!");
- *   }, TypeError);
- *   assertThrows(
- *     (): void => {
- *       throw new TypeError("hello world!");
- *     },
- *     TypeError,
- *     "hello",
- *   );
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", function (): void {
- *   assertThrows((): void => {
- *     console.log("Hello world");
- *   });
- * });
- * ```
- */
-export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): E;
-/**
- * Executes a function which returns a promise, expecting it to reject.
- *
- * @example
- * ```ts
- * import { assertRejects } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("doesThrow", async function () {
- *   await assertRejects(
- *     async () => {
- *       throw new TypeError("hello world!");
- *     },
- *   );
- *   await assertRejects(
- *     async () => {
- *       return Promise.reject(new Error());
- *     },
- *   );
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", async function () {
- *   await assertRejects(
- *     async () => {
- *       console.log("Hello world");
- *     },
- *   );
- * });
- * ```
- */
-export declare function assertRejects(fn: () => PromiseLike<unknown>, msg?: string): Promise<unknown>;
-/**
- * Executes a function which returns a promise, expecting it to 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.
- *
- * @example
- * ```ts
- * import { assertRejects } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("doesThrow", async function () {
- *   await assertRejects(async () => {
- *     throw new TypeError("hello world!");
- *   }, TypeError);
- *   await assertRejects(
- *     async () => {
- *       throw new TypeError("hello world!");
- *     },
- *     TypeError,
- *     "hello",
- *   );
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", async function () {
- *   await assertRejects(
- *     async () => {
- *       console.log("Hello world");
- *     },
- *   );
- * });
- * ```
- */
-export declare function assertRejects<E extends Error = Error>(fn: () => PromiseLike<unknown>, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<E>;
-/** Use this to stub out methods that will throw when invoked. */
-export declare function unimplemented(msg?: string): never;
-/** Use this to assert unreachable code. */
-export declare function unreachable(): never;
-export {};

package/script/ArrayCollapseTransformer_test.d.ts

@@ -1 +0,0 @@
-export {};

package/script/ExampleDocument.d.ts

@@ -1,2 +0,0 @@
-import { DocumentNode } from "./types.js";
-export declare const ExampleDocument: DocumentNode;

package/script/IdentityTransformer_test.d.ts

@@ -1 +0,0 @@
-export {};

package/script/TextCollapseTransformer_test.d.ts

@@ -1 +0,0 @@
-export {};

package/script/TextVisitor_test.d.ts

@@ -1 +0,0 @@
-export {};

package/script/WhitespaceStretchingTransformer_test.d.ts

@@ -1 +0,0 @@
-export {};

package/script/WhitespaceTransformer_test.d.ts

@@ -1 +0,0 @@
-export {};

package/script/_dnt.test_shims.d.ts

@@ -1,5 +0,0 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
-export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
-    Deno: typeof Deno;
-};

package/script/deps/deno.land/std@0.192.0/fmt/colors.d.ts

@@ -1,270 +0,0 @@
-/** RGB 8-bits per channel. Each in range `0->255` or `0x00->0xff` */
-interface Rgb {
-    r: number;
-    g: number;
-    b: number;
-}
-/**
- * Set changing text color to enabled or disabled
- * @param value
- */
-export declare function setColorEnabled(value: boolean): void;
-/** Get whether text color change is enabled or disabled. */
-export declare function getColorEnabled(): boolean;
-/**
- * Reset the text modified
- * @param str text to reset
- */
-export declare function reset(str: string): string;
-/**
- * Make the text bold.
- * @param str text to make bold
- */
-export declare function bold(str: string): string;
-/**
- * The text emits only a small amount of light.
- * @param str text to dim
- */
-export declare function dim(str: string): string;
-/**
- * Make the text italic.
- * @param str text to make italic
- */
-export declare function italic(str: string): string;
-/**
- * Make the text underline.
- * @param str text to underline
- */
-export declare function underline(str: string): string;
-/**
- * Invert background color and text color.
- * @param str text to invert its color
- */
-export declare function inverse(str: string): string;
-/**
- * Make the text hidden.
- * @param str text to hide
- */
-export declare function hidden(str: string): string;
-/**
- * Put horizontal line through the center of the text.
- * @param str text to strike through
- */
-export declare function strikethrough(str: string): string;
-/**
- * Set text color to black.
- * @param str text to make black
- */
-export declare function black(str: string): string;
-/**
- * Set text color to red.
- * @param str text to make red
- */
-export declare function red(str: string): string;
-/**
- * Set text color to green.
- * @param str text to make green
- */
-export declare function green(str: string): string;
-/**
- * Set text color to yellow.
- * @param str text to make yellow
- */
-export declare function yellow(str: string): string;
-/**
- * Set text color to blue.
- * @param str text to make blue
- */
-export declare function blue(str: string): string;
-/**
- * Set text color to magenta.
- * @param str text to make magenta
- */
-export declare function magenta(str: string): string;
-/**
- * Set text color to cyan.
- * @param str text to make cyan
- */
-export declare function cyan(str: string): string;
-/**
- * Set text color to white.
- * @param str text to make white
- */
-export declare function white(str: string): string;
-/**
- * Set text color to gray.
- * @param str text to make gray
- */
-export declare function gray(str: string): string;
-/**
- * Set text color to bright black.
- * @param str text to make bright-black
- */
-export declare function brightBlack(str: string): string;
-/**
- * Set text color to bright red.
- * @param str text to make bright-red
- */
-export declare function brightRed(str: string): string;
-/**
- * Set text color to bright green.
- * @param str text to make bright-green
- */
-export declare function brightGreen(str: string): string;
-/**
- * Set text color to bright yellow.
- * @param str text to make bright-yellow
- */
-export declare function brightYellow(str: string): string;
-/**
- * Set text color to bright blue.
- * @param str text to make bright-blue
- */
-export declare function brightBlue(str: string): string;
-/**
- * Set text color to bright magenta.
- * @param str text to make bright-magenta
- */
-export declare function brightMagenta(str: string): string;
-/**
- * Set text color to bright cyan.
- * @param str text to make bright-cyan
- */
-export declare function brightCyan(str: string): string;
-/**
- * Set text color to bright white.
- * @param str text to make bright-white
- */
-export declare function brightWhite(str: string): string;
-/**
- * Set background color to black.
- * @param str text to make its background black
- */
-export declare function bgBlack(str: string): string;
-/**
- * Set background color to red.
- * @param str text to make its background red
- */
-export declare function bgRed(str: string): string;
-/**
- * Set background color to green.
- * @param str text to make its background green
- */
-export declare function bgGreen(str: string): string;
-/**
- * Set background color to yellow.
- * @param str text to make its background yellow
- */
-export declare function bgYellow(str: string): string;
-/**
- * Set background color to blue.
- * @param str text to make its background blue
- */
-export declare function bgBlue(str: string): string;
-/**
- *  Set background color to magenta.
- * @param str text to make its background magenta
- */
-export declare function bgMagenta(str: string): string;
-/**
- * Set background color to cyan.
- * @param str text to make its background cyan
- */
-export declare function bgCyan(str: string): string;
-/**
- * Set background color to white.
- * @param str text to make its background white
- */
-export declare function bgWhite(str: string): string;
-/**
- * Set background color to bright black.
- * @param str text to make its background bright-black
- */
-export declare function bgBrightBlack(str: string): string;
-/**
- * Set background color to bright red.
- * @param str text to make its background bright-red
- */
-export declare function bgBrightRed(str: string): string;
-/**
- * Set background color to bright green.
- * @param str text to make its background bright-green
- */
-export declare function bgBrightGreen(str: string): string;
-/**
- * Set background color to bright yellow.
- * @param str text to make its background bright-yellow
- */
-export declare function bgBrightYellow(str: string): string;
-/**
- * Set background color to bright blue.
- * @param str text to make its background bright-blue
- */
-export declare function bgBrightBlue(str: string): string;
-/**
- * Set background color to bright magenta.
- * @param str text to make its background bright-magenta
- */
-export declare function bgBrightMagenta(str: string): string;
-/**
- * Set background color to bright cyan.
- * @param str text to make its background bright-cyan
- */
-export declare function bgBrightCyan(str: string): string;
-/**
- * Set background color to bright white.
- * @param str text to make its background bright-white
- */
-export declare function bgBrightWhite(str: string): string;
-/**
- * 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 declare function rgb8(str: string, color: number): string;
-/**
- * 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 declare function bgRgb8(str: string, color: number): string;
-/**
- * Set text color using 24bit rgb.
- * `color` can be a number in range `0x000000` to `0xffffff` or
- * an `Rgb`.
- *
- * To produce the color magenta:
- *
- * ```ts
- *      import { rgb24 } from "https://deno.land/std@$STD_VERSION/fmt/colors.ts";
- *      rgb24("foo", 0xff00ff);
- *      rgb24("foo", {r: 255, g: 0, b: 255});
- * ```
- * @param str text color to apply 24bit rgb to
- * @param color code
- */
-export declare function rgb24(str: string, color: number | Rgb): string;
-/**
- * Set background color using 24bit rgb.
- * `color` can be a number in range `0x000000` to `0xffffff` or
- * an `Rgb`.
- *
- * To produce the color magenta:
- *
- * ```ts
- *      import { bgRgb24 } from "https://deno.land/std@$STD_VERSION/fmt/colors.ts";
- *      bgRgb24("foo", 0xff00ff);
- *      bgRgb24("foo", {r: 255, g: 0, b: 255});
- * ```
- * @param str text color to apply 24bit rgb to
- * @param color code
- */
-export declare function bgRgb24(str: string, color: number | Rgb): string;
-/**
- * Remove ANSI escape codes from the string.
- * @param string to remove ANSI escape codes from
- */
-export declare function stripColor(string: string): string;
-export {};

package/script/deps/deno.land/std@0.192.0/testing/_diff.d.ts

@@ -1,26 +0,0 @@
-export declare enum DiffType {
-    removed = "removed",
-    common = "common",
-    added = "added"
-}
-export interface DiffResult<T> {
-    type: DiffType;
-    value: T;
-    details?: Array<DiffResult<T>>;
-}
-/**
- * Renders the differences between the actual and expected values
- * @param A Actual value
- * @param B Expected value
- */
-export declare function diff<T>(A: T[], B: T[]): Array<DiffResult<T>>;
-/**
- * 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 declare function diffstr(A: string, B: string): DiffResult<string>[];
-export declare function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>, { stringDiff }?: {
-    stringDiff?: boolean | undefined;
-}): string[];

package/script/deps/deno.land/std@0.192.0/testing/_format.d.ts

@@ -1 +0,0 @@
-export declare function format(v: unknown): string;

package/script/deps/deno.land/std@0.192.0/testing/asserts.d.ts

@@ -1,284 +0,0 @@
-export declare class AssertionError extends Error {
-    name: string;
-    constructor(message: string);
-}
-/**
- * Deep equality comparison used in assertions
- * @param c actual value
- * @param d expected value
- */
-export declare function equal(c: unknown, d: unknown): boolean;
-/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
-export declare function assert(expr: unknown, msg?: string): asserts expr;
-/** Make an assertion, error will be thrown if `expr` have truthy value. */
-type Falsy = false | 0 | 0n | "" | null | undefined;
-export declare function assertFalse(expr: unknown, msg?: string): asserts expr is Falsy;
-/**
- * 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.
- *
- * @example
- * ```ts
- * import { assertEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("example", function (): void {
- *   assertEquals("world", "world");
- *   assertEquals({ hello: "world" }, { hello: "world" });
- * });
- * ```
- */
-export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;
-/**
- * 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.
- *
- * @example
- * ```ts
- * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * assertNotEquals<number>(1, 2)
- * ```
- */
-export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;
-/**
- * Make an assertion that `actual` and `expected` are strictly equal. If
- * not then throw.
- *
- * @example
- * ```ts
- * import { assertStrictEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("isStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = a;
- *   assertStrictEquals(a, b);
- * });
- *
- * // This test fails
- * Deno.test("isNotStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = {};
- *   assertStrictEquals(a, b);
- * });
- * ```
- */
-export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;
-/**
- * Make an assertion that `actual` and `expected` are not strictly equal.
- * If the values are strictly equal then throw.
- *
- * ```ts
- * import { assertNotStrictEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * assertNotStrictEquals(1, 1)
- * ```
- */
-export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
-/**
- * Make an assertion that `actual` and `expected` are almost equal numbers through
- * a given tolerance. It can be used to take into account IEEE-754 double-precision
- * floating-point representation limitations.
- * If the values are not almost equal then throw.
- *
- * @example
- * ```ts
- * import { assertAlmostEquals, assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * assertAlmostEquals(0.1, 0.2);
- *
- * // Using a custom tolerance value
- * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16);
- * assertThrows(() => assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17));
- * ```
- */
-export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
-type AnyConstructor = new (...args: any[]) => any;
-type GetConstructorType<T extends AnyConstructor> = T extends new (...args: any) => infer C ? C : never;
-/**
- * Make an assertion that `obj` is an instance of `type`.
- * If not then throw.
- */
-export declare function assertInstanceOf<T extends AnyConstructor>(actual: unknown, expectedType: T, msg?: string): asserts actual is GetConstructorType<T>;
-/**
- * Make an assertion that `obj` is not an instance of `type`.
- * If so, then throw.
- */
-export declare function assertNotInstanceOf<A, T>(actual: A, unexpectedType: new (...args: any[]) => T, msg?: string): asserts actual is Exclude<A, T>;
-/**
- * Make an assertion that actual is not null or undefined.
- * If not then throw.
- */
-export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;
-/**
- * Make an assertion that actual includes expected. If not
- * then throw.
- */
-export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;
-/**
- * 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.
- *
- * @example
- * ```ts
- * import { assertArrayIncludes } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * assertArrayIncludes<number>([1, 2], [2])
- * ```
- */
-export declare function assertArrayIncludes<T>(actual: ArrayLike<T>, expected: ArrayLike<T>, msg?: string): void;
-/**
- * Make an assertion that `actual` match RegExp `expected`. If not
- * then throw.
- */
-export declare function assertMatch(actual: string, expected: RegExp, msg?: string): void;
-/**
- * Make an assertion that `actual` not match RegExp `expected`. If match
- * then throw.
- */
-export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;
-/**
- * Make an assertion that `actual` object is a subset of `expected` object, deeply.
- * If not, then throw.
- */
-export declare function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>, msg?: string): void;
-/**
- * Forcefully throws a failed assertion
- */
-export declare function fail(msg?: string): never;
-/**
- * Make an assertion that `error` is an `Error`.
- * If not then an error will be thrown.
- * An error class and a string that should be included in the
- * error message can also be asserted.
- */
-export declare function assertIsError<E extends Error = Error>(error: unknown, ErrorClass?: new (...args: any[]) => E, msgIncludes?: string, msg?: string): asserts error is E;
-/**
- * Executes a function, expecting it to throw. If it does not, then it
- * throws.
- *
- * @example
- * ```ts
- * import { assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("doesThrow", function (): void {
- *   assertThrows((): void => {
- *     throw new TypeError("hello world!");
- *   });
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", function (): void {
- *   assertThrows((): void => {
- *     console.log("Hello world");
- *   });
- * });
- * ```
- */
-export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
-/**
- * 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.
- *
- * @example
- *
- * ```ts
- * import { assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("doesThrow", function (): void {
- *   assertThrows((): void => {
- *     throw new TypeError("hello world!");
- *   }, TypeError);
- *   assertThrows(
- *     (): void => {
- *       throw new TypeError("hello world!");
- *     },
- *     TypeError,
- *     "hello",
- *   );
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", function (): void {
- *   assertThrows((): void => {
- *     console.log("Hello world");
- *   });
- * });
- * ```
- */
-export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): E;
-/**
- * Executes a function which returns a promise, expecting it to reject.
- *
- * @example
- * ```ts
- * import { assertRejects } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("doesThrow", async function () {
- *   await assertRejects(
- *     async () => {
- *       throw new TypeError("hello world!");
- *     },
- *   );
- *   await assertRejects(
- *     async () => {
- *       return Promise.reject(new Error());
- *     },
- *   );
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", async function () {
- *   await assertRejects(
- *     async () => {
- *       console.log("Hello world");
- *     },
- *   );
- * });
- * ```
- */
-export declare function assertRejects(fn: () => PromiseLike<unknown>, msg?: string): Promise<unknown>;
-/**
- * Executes a function which returns a promise, expecting it to 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.
- *
- * @example
- * ```ts
- * import { assertRejects } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
- *
- * Deno.test("doesThrow", async function () {
- *   await assertRejects(async () => {
- *     throw new TypeError("hello world!");
- *   }, TypeError);
- *   await assertRejects(
- *     async () => {
- *       throw new TypeError("hello world!");
- *     },
- *     TypeError,
- *     "hello",
- *   );
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", async function () {
- *   await assertRejects(
- *     async () => {
- *       console.log("Hello world");
- *     },
- *   );
- * });
- * ```
- */
-export declare function assertRejects<E extends Error = Error>(fn: () => PromiseLike<unknown>, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<E>;
-/** Use this to stub out methods that will throw when invoked. */
-export declare function unimplemented(msg?: string): never;
-/** Use this to assert unreachable code. */
-export declare function unreachable(): never;
-export {};