@goast/core 0.4.0-beta3 → 0.4.0

package/esm/deps/jsr.io/@std/expect/1.0.5/_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.5/_types.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;IACnE,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAED,MAAM,MAAM,OAAO,GAAG,CACpB,OAAO,EAAE,cAAc,EACvB,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,WAAW,GAAG,iBAAiB,CAAC;AAErC,MAAM,MAAM,QAAQ,GAAG;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC;AACzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,MAAM,CAAC;IACtB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,gEAAgE;AAChE,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAEzD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;AAEvE,qEAAqE;AACrE,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI;KACpB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,GACpD,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GACxD,CAAC,CAAC,CAAC,CAAC;CACT,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,OAAO,GAAG,KAAK;IACvC;;;;;;;;;;;;;;;;OAgBG;IACH,cAAc,CAAC,GAAG,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAE7C;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAE1C;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAEzD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAEtD;;;;;;;;;;;;;;OAcG;IACH,UAAU,IAAI,IAAI,CAAC;IAEnB;;;;;;;;;;;;;;;;;OAiBG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAExC;;;;;;;;;;;;;;;;;OAiBG;IACH,cAAc,CAAC,GAAG,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAE7C;;;;;;;;;;;;;;OAcG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzD;;;;;;;;;;OAUG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAS,IAAI,IAAI,CAAC;IAElB;;;;;;;;;;;;;OAaG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAExC;;;;;;;;;;;;;OAaG;IACH,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAE/C;;;;;;;;;;;;OAYG;IACH,cAAc,CAAC,CAAC,SAAS,cAAc,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC;IAE5D;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAErC;;;;;;;;;;;;;OAaG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5C;;;;;;;;;;;;OAYG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;;;;;;;;;OAUG;IACH,QAAQ,IAAI,IAAI,CAAC;IAEjB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,UAAU,IAAI,IAAI,CAAC;IAEnB;;;;;;;;;;OAUG;IACH,aAAa,IAAI,IAAI,CAAC;IAEtB;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAE9B;;;;;;;;;;;;;;;OAeG;IACH,cAAc,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAExC;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAEnC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAEjC;;;;;;;;;;;;;;;;OAgBG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAE9C;;;;;;;;;;;;;;;;OAgBG;IACH,oBAAoB,CAAC,GAAG,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAEnD;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,IAAI,IAAI,CAAC;IAEzB;;;;;;;;;;;;;;;;OAgBG;IACH,wBAAwB,CAAC,GAAG,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAEvD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAEnE;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAErC;;;;;;;;;;;;;;;;OAgBG;IACH,sBAAsB,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAEhD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAE5D;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAEnE;;;;;;;;;;;;;;;;OAgBG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5C;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAAkB,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAE5C;;;;;;;;;;;;;;;OAeG;IACH,cAAc,IAAI,IAAI,CAAC;IAEvB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhC;;;;;;;;;;;;OAYG;IACH,aAAa,CACX,QAAQ,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE,GACtE,IAAI,CAAC;IAER;;;;;;;;;;;;;;OAcG;IACH,QAAQ,IAAI,IAAI,CAAC;IAEjB;;;;;;;;;;;;;;;;;OAiBG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAGtC;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAEtC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,aAAa,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAExC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,OAAO,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EAC7B,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,GAAG,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,GAC3D,IAAI,CAAC;IAER;;OAEG;IACH,GAAG,EAAE,OAAO,SAAS,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAEpE;;OAEG;IACH,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IAEhC;;OAEG;IACH,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IAE/B;;OAEG;IACH,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CACzB;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,KAAK,GAAG,UAAU,GAAG,SAAS,CAAC,CAAC;AAE9E,MAAM,MAAM,YAAY,GAAG;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;IACvC,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,WAAW,eAAgB,SAAQ,cAAc;IACrD,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC,GAAG,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACxC;AACD,KAAK,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;AACvC,KAAK,KAAK,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,CAAC;AAEvC,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;AAElC,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;AAEhF,MAAM,WAAW,MAAM;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,WAAW,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,OAAO,CAAC;IACb,mBAAmB,EAAE,OAAO,CAAC;IAC7B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,OAAO,GAAG,CACpB,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,IAAI,EACV,eAAe,CAAC,EAAE,OAAO,KACtB,MAAM,CAAC;AAEZ,UAAU,aAAa;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,KAAK,IAAI,GAAG,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC;AAEnC,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,CACT,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,KACb,MAAM,CAAC;IACZ,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,CACL,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,KACX,MAAM,CAAC;IACZ,IAAI,EAAE,IAAI,CAAC;CACZ"}

package/esm/deps/jsr.io/@std/expect/1.0.5/_types.js

@@ -0,0 +1,3 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// deno-lint-ignore-file no-explicit-any
+export {};

package/esm/deps/jsr.io/@std/expect/1.0.5/_utils.d.ts

@@ -0,0 +1,8 @@
+import type { EqualOptions, EqualOptionUtil } from "./_types.js";
+import type { Tester } from "./_types.js";
+export declare function buildEqualOptions(options: EqualOptionUtil): EqualOptions;
+export declare function isPromiseLike(value: unknown): value is PromiseLike<unknown>;
+export declare function hasIterator(object: any): boolean;
+export declare function isA<T>(typeName: string, value: unknown): value is T;
+export declare function iterableEquality(a: any, b: any, customTesters?: Tester[], aStack?: unknown[], bStack?: unknown[]): boolean | undefined;
+//# sourceMappingURL=_utils.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.5/_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_utils.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.5/_utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,GAAG,YAAY,CAYxE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAAC,OAAO,CAAC,CAM3E;AAGD,wBAAgB,WAAW,CAAC,MAAM,EAAE,GAAG,WAEtC;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,CAEnE;AAiBD,wBAAgB,gBAAgB,CAE9B,CAAC,EAAE,GAAG,EAEN,CAAC,EAAE,GAAG,EACN,aAAa,GAAE,MAAM,EAAO,EAC5B,MAAM,GAAE,OAAO,EAAO,EACtB,MAAM,GAAE,OAAO,EAAO,GACrB,OAAO,GAAG,SAAS,CA2IrB"}

package/esm/deps/jsr.io/@std/expect/1.0.5/_utils.js

@@ -0,0 +1,159 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved. MIT license.
+import { equal } from "./_equal.js";
+export function buildEqualOptions(options) {
+    const { customMessage, customTesters = [], strictCheck } = options !== null && options !== void 0 ? options : {};
+    const ret = {
+        customTesters,
+    };
+    if (customMessage !== undefined) {
+        ret.msg = customMessage;
+    }
+    if (strictCheck !== undefined) {
+        ret.strictCheck = strictCheck;
+    }
+    return ret;
+}
+export function isPromiseLike(value) {
+    if (value == null) {
+        return false;
+    }
+    else {
+        return typeof (value.then) === "function";
+    }
+}
+// deno-lint-ignore no-explicit-any
+export function hasIterator(object) {
+    return !!(object != null && object[Symbol.iterator]);
+}
+export function isA(typeName, value) {
+    return Object.prototype.toString.apply(value) === `[object ${typeName}]`;
+}
+function isObject(a) {
+    return a !== null && typeof a === "object";
+}
+// deno-lint-ignore no-explicit-any
+function entries(obj) {
+    if (!isObject(obj))
+        return [];
+    return Object.getOwnPropertySymbols(obj)
+        .filter((key) => key !== Symbol.iterator)
+        .map((key) => [key, obj[key]])
+        .concat(Object.entries(obj));
+}
+// Ported from https://github.com/jestjs/jest/blob/442c7f692e3a92f14a2fb56c1737b26fc663a0ef/packages/expect-utils/src/utils.ts#L173
+export function iterableEquality(
+// deno-lint-ignore no-explicit-any
+a, 
+// deno-lint-ignore no-explicit-any
+b, customTesters = [], aStack = [], bStack = []) {
+    if (typeof a !== "object" ||
+        typeof b !== "object" ||
+        Array.isArray(a) ||
+        Array.isArray(b) ||
+        !hasIterator(a) ||
+        !hasIterator(b)) {
+        return undefined;
+    }
+    if (a.constructor !== b.constructor) {
+        return false;
+    }
+    let length = aStack.length;
+    while (length--) {
+        // Linear search. Performance is inversely proportional to the number of
+        // unique nested structures.
+        // circular references at same depth are equal
+        // circular reference is not equal to non-circular one
+        if (aStack[length] === a) {
+            return bStack[length] === b;
+        }
+    }
+    aStack.push(a);
+    bStack.push(b);
+    // deno-lint-ignore no-explicit-any
+    const iterableEqualityWithStack = (a, b) => iterableEquality(a, b, [...filteredCustomTesters], [...aStack], [...bStack]);
+    // Replace any instance of iterableEquality with the new
+    // iterableEqualityWithStack so we can do circular detection
+    const filteredCustomTesters = [
+        ...customTesters.filter((t) => t !== iterableEquality),
+        iterableEqualityWithStack,
+    ];
+    if (a.size !== undefined) {
+        if (a.size !== b.size) {
+            return false;
+        }
+        else if (isA("Set", a)) {
+            let allFound = true;
+            for (const aValue of a) {
+                if (!b.has(aValue)) {
+                    let has = false;
+                    for (const bValue of b) {
+                        const isEqual = equal(aValue, bValue, {
+                            customTesters: filteredCustomTesters,
+                        });
+                        if (isEqual === true) {
+                            has = true;
+                        }
+                    }
+                    if (has === false) {
+                        allFound = false;
+                        break;
+                    }
+                }
+            }
+            // Remove the first value from the stack of traversed values.
+            aStack.pop();
+            bStack.pop();
+            return allFound;
+        }
+        else if (isA("Map", a)) {
+            let allFound = true;
+            for (const aEntry of a) {
+                if (!b.has(aEntry[0]) ||
+                    !equal(aEntry[1], b.get(aEntry[0]), {
+                        customTesters: filteredCustomTesters,
+                    })) {
+                    let has = false;
+                    for (const bEntry of b) {
+                        const matchedKey = equal(aEntry[0], bEntry[0], { customTesters: filteredCustomTesters });
+                        let matchedValue = false;
+                        if (matchedKey === true) {
+                            matchedValue = equal(aEntry[1], bEntry[1], { customTesters: filteredCustomTesters });
+                        }
+                        if (matchedValue === true) {
+                            has = true;
+                        }
+                    }
+                    if (has === false) {
+                        allFound = false;
+                        break;
+                    }
+                }
+            }
+            // Remove the first value from the stack of traversed values.
+            aStack.pop();
+            bStack.pop();
+            return allFound;
+        }
+    }
+    const bIterator = b[Symbol.iterator]();
+    for (const aValue of a) {
+        const nextB = bIterator.next();
+        if (nextB.done ||
+            !equal(aValue, nextB.value, { customTesters: filteredCustomTesters })) {
+            return false;
+        }
+    }
+    if (!bIterator.next().done) {
+        return false;
+    }
+    const aEntries = entries(a);
+    const bEntries = entries(b);
+    if (!equal(aEntries, bEntries)) {
+        return false;
+    }
+    // Remove the first value from the stack of traversed values.
+    aStack.pop();
+    bStack.pop();
+    return true;
+}

package/esm/deps/jsr.io/@std/expect/1.0.5/expect.d.ts

@@ -0,0 +1,51 @@
+import type { Expected, Matchers } from "./_types.js";
+import * as asymmetricMatchers from "./_asymmetric_matchers.js";
+import type { Tester } from "./_types.js";
+export type { AnyConstructor, Async, Expected } from "./_types.js";
+/**
+ * **Note:** the documentation for this module is taken from [Jest](https://github.com/jestjs/jest/blob/main/website/versioned_docs/version-29.7/ExpectAPI.md)
+ * and the examples are updated for Deno.
+ *
+ * The `expect` function is used to test a value. You will use `expect` along with a
+ * "matcher" function to assert something about a value.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { expect } from "@std/expect";
+ *
+ * function bestLaCroixFlavor(): string {
+ *  return "grapefruit";
+ * }
+ *
+ * Deno.test("the best flavor is grapefruit", () => {
+ *  expect(bestLaCroixFlavor()).toBe("grapefruit");
+ * });
+ * ```
+ *
+ * In this case, `toBe` is the matcher function. There are a lot of different
+ * matcher functions, documented in the main module description.
+ *
+ * The argument to `expect` should be the value that your code produces, and any
+ * argument to the matcher should be the correct value. If you mix them up, your
+ * tests will still work, but the error messages on failing tests will look
+ * strange.
+ *
+ * @param value The value to perform assertions on.
+ * @param customMessage An optional custom message to include in the assertion error.
+ * @returns An expected object that can be used to chain matchers.
+ *
+ * @typeParam T The interface used for `expect`. This is usually needed only if you want to use `expect.extend` to create custom matchers.
+ */
+export declare function expect<T extends Expected = Expected>(value: unknown, customMessage?: string): T;
+export declare namespace expect {
+    var addEqualityTesters: (newTesters: Tester[]) => void;
+    var extend: (newExtendMatchers: Matchers) => void;
+    var anything: () => ReturnType<typeof asymmetricMatchers.anything>;
+    var any: (c: unknown) => ReturnType<typeof asymmetricMatchers.any>;
+    var arrayContaining: (c: any[]) => ReturnType<typeof asymmetricMatchers.arrayContaining>;
+    var closeTo: (num: number, numDigits?: number) => ReturnType<typeof asymmetricMatchers.closeTo>;
+    var stringContaining: (str: string) => ReturnType<typeof asymmetricMatchers.stringContaining>;
+    var stringMatching: (pattern: string | RegExp) => ReturnType<typeof asymmetricMatchers.stringMatching>;
+    var hasAssertions: () => void;
+}
+//# sourceMappingURL=expect.d.ts.map

package/esm/deps/jsr.io/@std/expect/1.0.5/expect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/expect/1.0.5/expect.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,QAAQ,EAKR,QAAQ,EACT,MAAM,aAAa,CAAC;AA4CrB,OAAO,KAAK,kBAAkB,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,YAAY,EAAE,cAAc,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AA+CnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAClD,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,MAAM,GACrB,CAAC,CAwFH;yBA3Fe,MAAM;yCAsJR,MAAM,EAAE,KACjB,IAAI;oCAyDgD,QAAQ,KAAK,IAAI;wBAgBnB,UAAU,CAC/D,OAAO,kBAAkB,CAAC,QAAQ,CACnC;iBAuBI,OAAO,KACP,UAAU,CAAC,OAAO,kBAAkB,CAAC,GAAG,CAAC;6BA0BzC,GAAG,EAAE,KACL,UAAU,CAAC,OAAO,kBAAkB,CAAC,eAAe,CAAC;uBA0BnD,MAAM,cACC,MAAM,KACf,UAAU,CAAC,OAAO,kBAAkB,CAAC,OAAO,CAAC;gCAmB3C,MAAM,KACR,UAAU,CAAC,OAAO,kBAAkB,CAAC,gBAAgB,CAAC;kCAwBhD,MAAM,GAAG,MAAM,KACrB,UAAU,CAAC,OAAO,kBAAkB,CAAC,cAAc,CAAC;6BAkBX,IAAI"}

package/esm/deps/jsr.io/@std/expect/1.0.5/expect.js

@@ -0,0 +1,425 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+// Copyright 2019 Allain Lalonde. All rights reserved. ISC License.
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// The documentation is extracted from https://github.com/jestjs/jest/blob/main/website/versioned_docs/version-29.7/ExpectAPI.md
+// and updated for the Deno ecosystem.
+import { AssertionError } from "../../assert/1.0.6/assertion_error.js";
+import { emitAssertionTrigger, hasAssertions } from "./_assertion.js";
+import { addCustomEqualityTesters, getCustomEqualityTesters, } from "./_custom_equality_tester.js";
+import { equal } from "./_equal.js";
+import { getExtendMatchers, setExtendMatchers } from "./_extend.js";
+import { toBe, toBeCloseTo, toBeDefined, toBeFalsy, toBeGreaterThan, toBeGreaterThanOrEqual, toBeInstanceOf, toBeLessThan, toBeLessThanOrEqual, toBeNaN, toBeNull, toBeTruthy, toBeUndefined, toContain, toContainEqual, toEqual, toHaveBeenCalled, toHaveBeenCalledTimes, toHaveBeenCalledWith, toHaveBeenLastCalledWith, toHaveBeenNthCalledWith, toHaveLastReturnedWith, toHaveLength, toHaveNthReturnedWith, toHaveProperty, toHaveReturned, toHaveReturnedTimes, toHaveReturnedWith, toMatch, toMatchObject, toStrictEqual, toThrow, } from "./_matchers.js";
+import { isPromiseLike } from "./_utils.js";
+import * as asymmetricMatchers from "./_asymmetric_matchers.js";
+const matchers = {
+    lastCalledWith: toHaveBeenLastCalledWith,
+    lastReturnedWith: toHaveLastReturnedWith,
+    nthCalledWith: toHaveBeenNthCalledWith,
+    nthReturnedWith: toHaveNthReturnedWith,
+    toBeCalled: toHaveBeenCalled,
+    toBeCalledTimes: toHaveBeenCalledTimes,
+    toBeCalledWith: toHaveBeenCalledWith,
+    toBeCloseTo,
+    toBeDefined,
+    toBeFalsy,
+    toBeGreaterThanOrEqual,
+    toBeGreaterThan,
+    toBeInstanceOf,
+    toBeLessThanOrEqual,
+    toBeLessThan,
+    toBeNaN,
+    toBeNull,
+    toBeTruthy,
+    toBeUndefined,
+    toBe,
+    toContainEqual,
+    toContain,
+    toEqual,
+    toHaveBeenCalledTimes,
+    toHaveBeenCalledWith,
+    toHaveBeenCalled,
+    toHaveBeenLastCalledWith,
+    toHaveBeenNthCalledWith,
+    toHaveLength,
+    toHaveLastReturnedWith,
+    toHaveNthReturnedWith,
+    toHaveProperty,
+    toHaveReturnedTimes,
+    toHaveReturnedWith,
+    toHaveReturned,
+    toMatchObject,
+    toMatch,
+    toReturn: toHaveReturned,
+    toReturnTimes: toHaveReturnedTimes,
+    toReturnWith: toHaveReturnedWith,
+    toStrictEqual,
+    toThrow,
+};
+/**
+ * **Note:** the documentation for this module is taken from [Jest](https://github.com/jestjs/jest/blob/main/website/versioned_docs/version-29.7/ExpectAPI.md)
+ * and the examples are updated for Deno.
+ *
+ * The `expect` function is used to test a value. You will use `expect` along with a
+ * "matcher" function to assert something about a value.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { expect } from "@std/expect";
+ *
+ * function bestLaCroixFlavor(): string {
+ *  return "grapefruit";
+ * }
+ *
+ * Deno.test("the best flavor is grapefruit", () => {
+ *  expect(bestLaCroixFlavor()).toBe("grapefruit");
+ * });
+ * ```
+ *
+ * In this case, `toBe` is the matcher function. There are a lot of different
+ * matcher functions, documented in the main module description.
+ *
+ * The argument to `expect` should be the value that your code produces, and any
+ * argument to the matcher should be the correct value. If you mix them up, your
+ * tests will still work, but the error messages on failing tests will look
+ * strange.
+ *
+ * @param value The value to perform assertions on.
+ * @param customMessage An optional custom message to include in the assertion error.
+ * @returns An expected object that can be used to chain matchers.
+ *
+ * @typeParam T The interface used for `expect`. This is usually needed only if you want to use `expect.extend` to create custom matchers.
+ */
+export function expect(value, customMessage) {
+    let isNot = false;
+    let isPromised = false;
+    const self = new Proxy({}, {
+        get(_, name) {
+            if (name === "not") {
+                isNot = !isNot;
+                return self;
+            }
+            if (name === "resolves") {
+                if (!isPromiseLike(value)) {
+                    throw new AssertionError("Expected value must be PromiseLike");
+                }
+                isPromised = true;
+                return self;
+            }
+            if (name === "rejects") {
+                if (!isPromiseLike(value)) {
+                    throw new AssertionError("Expected value must be a PromiseLike");
+                }
+                value = value.then((value) => {
+                    throw new AssertionError(`Promise did not reject: resolved to ${value}`);
+                }, (err) => err);
+                isPromised = true;
+                return self;
+            }
+            const extendMatchers = getExtendMatchers();
+            const allMatchers = {
+                ...matchers,
+                ...extendMatchers,
+            };
+            const matcher = allMatchers[name];
+            if (!matcher) {
+                throw new TypeError(typeof name === "string"
+                    ? `matcher not found: ${name}`
+                    : "matcher not found");
+            }
+            return (...args) => {
+                function applyMatcher(value, args) {
+                    const context = {
+                        value,
+                        equal,
+                        isNot: false,
+                        customMessage,
+                        customTesters: getCustomEqualityTesters(),
+                    };
+                    if (isNot) {
+                        context.isNot = true;
+                    }
+                    if (name in extendMatchers) {
+                        const result = matcher(context, ...args);
+                        if (context.isNot) {
+                            if (result.pass) {
+                                throw new AssertionError(result.message());
+                            }
+                        }
+                        else if (!result.pass) {
+                            throw new AssertionError(result.message());
+                        }
+                    }
+                    else {
+                        matcher(context, ...args);
+                    }
+                    emitAssertionTrigger();
+                }
+                return isPromised
+                    ? value.then((value) => applyMatcher(value, args))
+                    : applyMatcher(value, args);
+            };
+        },
+    });
+    return self;
+}
+/**
+ * You can use `expect.addEqualityTesters` to add your own methods to test if two
+ * objects are equal. For example, let's say you have a class in your code that
+ * represents volume and can determine if two volumes using different units are
+ * equal. You may want `toEqual` (and other equality matchers) to use this custom
+ * equality method when comparing to Volume classes. You can add a custom equality
+ * tester to have `toEqual` detect and apply custom logic when comparing Volume
+ * classes:
+ *
+ * @example
+ * ```ts
+ * import { expect } from "@std/expect";
+ *
+ * class Volume {
+ *   amount: number;
+ *   unit: "L" | "mL";
+ *
+ *   constructor(amount: number, unit: "L" | "mL") {
+ *     this.amount = amount;
+ *     this.unit = unit;
+ *   }
+ *
+ *   toString() {
+ *     return `[Volume ${this.amount}${this.unit}]`;
+ *   }
+ *
+ *   equals(other: Volume) {
+ *     if (this.unit === other.unit) {
+ *       return this.amount === other.amount;
+ *     } else if (this.unit === "L" && other.unit === "mL") {
+ *       return this.amount * 1000 === other.amount;
+ *     } else {
+ *       return this.amount === other.amount * 1000;
+ *     }
+ *   }
+ * }
+ *
+ * function areVolumesEqual(a: Volume, b: Volume) {
+ *   const isAVolume = a instanceof Volume;
+ *   const isBVolume = b instanceof Volume;
+ *   if (isAVolume && isBVolume) {
+ *     return a.equals(b);
+ *   } else if (isAVolume === isBVolume) {
+ *     return undefined;
+ *   } else {
+ *     return false;
+ *   }
+ * }
+ *
+ * expect.addEqualityTesters([areVolumesEqual]);
+ *
+ * Deno.test("are equal with different units", () => {
+ *   expect(new Volume(1, "L")).toEqual(new Volume(1000, "mL"));
+ * });
+ * ```
+ */
+expect.addEqualityTesters = addCustomEqualityTesters;
+/**
+ * Extend `expect()` with custom provided matchers.
+ *
+ * To do so, you will need to extend the interface `Expected` to define the new signature of the `expect`.
+ *
+ * ```ts
+ * import type { Async, Expected } from "./expect.ts";
+ * import { expect } from "./expect.ts";
+ *
+ * // Extends the `Expected` interface with your new matchers signatures
+ * interface ExtendedExpected<IsAsync = false> extends Expected<IsAsync> {
+ *   // Matcher that asserts value is a dinosaur
+ *   toBeDinosaur: (options?: { includeTrexs?: boolean }) => unknown;
+ *
+ *   // NOTE: You also need to overrides the following typings to allow modifiers to correctly infer typing
+ *   not: IsAsync extends true ? Async<ExtendedExpected<true>>
+ *     : ExtendedExpected<false>;
+ *   resolves: Async<ExtendedExpected<true>>;
+ *   rejects: Async<ExtendedExpected<true>>;
+ * }
+ *
+ * // Call `expect.extend()` with your new matchers definitions
+ * expect.extend({
+ *   toBeDinosaur(context, options) {
+ *     const dino = `${context.value}`;
+ *     const allowed = ["🦕"];
+ *     if (options?.includeTrexs) {
+ *       allowed.push("🦖");
+ *     }
+ *     const pass = allowed.includes(dino);
+ *     if (context.isNot) {
+ *       // Note: when `context.isNot` is set, the test is considered successful when `pass` is false
+ *       return {
+ *         message: () => `Expected "${dino}" to NOT be a dinosaur`,
+ *         pass,
+ *       };
+ *     }
+ *     return { message: () => `Expected "${dino}" to be a dinosaur`, pass };
+ *   },
+ * });
+ *
+ * // Alias expect to avoid having to pass the generic typing argument each time
+ * // This is probably what you want to export and reuse across your tests
+ * const myexpect = expect<ExtendedExpected>;
+ *
+ * // Perform some tests
+ * myexpect("🦕").toBeDinosaur();
+ * myexpect("🦧").not.toBeDinosaur();
+ * await myexpect(Promise.resolve("🦕")).resolves.toBeDinosaur();
+ * await myexpect(Promise.resolve("🦧")).resolves.not.toBeDinosaur();
+ *
+ * // Regular matchers will still be available
+ * myexpect("foo").not.toBeNull()
+ * myexpect.anything
+ * ```
+ */
+expect.extend = setExtendMatchers;
+/**
+ * `expect.anything()` matches anything but `null` or `undefined`. You can use it
+ * inside `toEqual` or `toHaveBeenCalledWith` instead of a literal value.
+ *
+ * @example
+ * ```ts
+ * import { expect, fn } from "@std/expect";
+ *
+ * Deno.test("map calls its argument with a non-null argument", () => {
+ *   const mock = fn();
+ *   [1].map((x) => mock(x));
+ *   expect(mock).toHaveBeenCalledWith(expect.anything());
+ * });
+```
+ */
+expect.anything = asymmetricMatchers.anything;
+/**
+ * `expect.any(constructor)` matches anything that was created with the given
+ * constructor or if it's a primitive that is of the passed type. You can use it
+ * inside `toEqual` or `toHaveBeenCalledWith` instead of a literal value.
+ *
+ * @example
+ * ```ts
+ * import { expect } from "@std/expect";
+ *
+ * class Cat {}
+ * Deno.test("expect.any()", () => {
+ *   expect(new Cat()).toEqual(expect.any(Cat));
+ *   expect("Hello").toEqual(expect.any(String));
+ *   expect(1).toEqual(expect.any(Number));
+ *   expect(() => {}).toEqual(expect.any(Function));
+ *   expect(false).toEqual(expect.any(Boolean));
+ *   expect(BigInt(1)).toEqual(expect.any(BigInt));
+ *   expect(Symbol("sym")).toEqual(expect.any(Symbol));
+ * });
+ * ```
+ */
+expect.any = asymmetricMatchers.any;
+/**
+ * `expect.arrayContaining(array)` matches a received array which contains all of
+ * the elements in the expected array. That is, the expected array is a **subset**
+ * of the received array. Therefore, it matches a received array which contains
+ * elements that are **not** in the expected array.
+ *
+ * You can use it instead of a literal value:
+ *
+ * - in `toEqual` or `toHaveBeenCalledWith`
+ * - to match a property in `objectContaining` or `toMatchObject`
+ *
+ * @example
+ * ```ts
+ * import { expect } from "@std/expect";
+ *
+ * Deno.test("expect.arrayContaining() with array of numbers", () => {
+ *   const arr = [1, 2, 3];
+ *   expect([1, 2, 3, 4]).toEqual(expect.arrayContaining(arr));
+ *   expect([4, 5, 6]).not.toEqual(expect.arrayContaining(arr));
+ *   expect([1, 2, 3]).toEqual(expect.arrayContaining(arr));
+ * });
+ * ```
+ */
+expect.arrayContaining = asymmetricMatchers.arrayContaining;
+/**
+ * `expect.closeTo(number, numDigits?)` is useful when comparing floating point
+ * numbers in object properties or array item. If you need to compare a number,
+ * please use `.toBeCloseTo` instead.
+ *
+ * The optional `numDigits` argument limits the number of digits to check **after**
+ * the decimal point. For the default value `2`, the test criterion is
+ * `Math.abs(expected - received) < 0.005 (that is, 10 ** -2 / 2)`.
+ *
+ * @example
+ * ```ts
+ * import { expect } from "@std/expect";
+ *
+ * Deno.test("compare float in object properties", () => {
+ *   expect({
+ *     title: "0.1 + 0.2",
+ *     sum: 0.1 + 0.2,
+ *   }).toEqual({
+ *     title: "0.1 + 0.2",
+ *     sum: expect.closeTo(0.3, 5),
+ *   });
+ * });
+ * ```
+ */
+expect.closeTo = asymmetricMatchers.closeTo;
+/**
+ * `expect.stringContaining(string)` matches the received value if it is a string
+ * that contains the exact expected string.
+ *
+ * @example
+ * ```ts
+ * import { expect } from "@std/expect";
+ *
+ * Deno.test("expect.stringContaining() with strings", () => {
+ *   expect("https://deno.com/").toEqual(expect.stringContaining("deno"));
+ *   expect("function").toEqual(expect.stringContaining("func"));
+ *
+ *   expect("Hello, World").not.toEqual(expect.stringContaining("hello"));
+ *   expect("foobar").not.toEqual(expect.stringContaining("bazz"));
+ * });
+ * ```
+ */
+expect.stringContaining = asymmetricMatchers.stringContaining;
+/**
+ * `expect.stringMatching(string | regexp)` matches the received value if it is a
+ * string that matches the expected string or regular expression.
+ *
+ * You can use it instead of a literal value:
+ *
+ * - in `toEqual` or `toHaveBeenCalledWith`
+ * - to match an element in `arrayContaining`
+ * - to match a property in `objectContaining` (not available yet) or `toMatchObject`
+ *
+ * @example
+ * ```ts
+ * import { expect } from "@std/expect";
+ *
+ * Deno.test("example", () => {
+ *   expect("deno_std").toEqual(expect.stringMatching(/std/));
+ *   expect("0123456789").toEqual(expect.stringMatching(/\d+/));
+ *   expect("e").not.toEqual(expect.stringMatching(/\s/));
+ *   expect("queue").not.toEqual(expect.stringMatching(/en/));
+ * });
+ * ```
+ */
+expect.stringMatching = asymmetricMatchers.stringMatching;
+/**
+ * `expect.hasAssertions` verifies that at least one assertion is called during a test.
+ *
+ * Note: expect.hasAssertions only can use in bdd function test suite, such as `test` or `it`.
+ *
+ * @example
+ * ```ts
+ *
+ * import { test } from "@std/testing/bdd";
+ * import { expect } from "@std/expect";
+ *
+ * test("it works", () => {
+ *   expect.hasAssertions();
+ *   expect("a").not.toBe("b");
+ * });
+ * ```
+ */
+expect.hasAssertions = hasAssertions;