@goast/typescript 0.4.0-beta4 → 0.4.0

package/script/src/import-collection.test.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../_dnt.test_polyfills.js");
+const mod_js_1 = require("../deps/jsr.io/@std/expect/1.0.5/mod.js");
+const bdd_js_1 = require("../deps/jsr.io/@std/testing/1.0.3/bdd.js");
+const import_collection_js_1 = require("./import-collection.js");
+(0, bdd_js_1.describe)('ImportExportCollection', () => {
+    let collection;
+    let sourceBuilderOptions;
+    (0, bdd_js_1.beforeEach)(() => {
+        collection = new import_collection_js_1.ImportExportCollection({ importModuleTransformer: 'omit-extension' });
+        sourceBuilderOptions = { newLine: '\n' };
+    });
+    (0, bdd_js_1.describe)('addImport', () => {
+        (0, bdd_js_1.it)('should add a new import to the collection', () => {
+            collection.addImport('myImport', 'myModule');
+            (0, mod_js_1.expect)(collection.hasImports).toBe(true);
+            (0, mod_js_1.expect)(collection.hasExports).toBe(false);
+            (0, mod_js_1.expect)(collection.toString(sourceBuilderOptions)).toBe("import { myImport } from 'myModule';\n");
+        });
+        (0, bdd_js_1.it)('should add a new import to an existing module', () => {
+            collection.addImport('myImport1', 'myModule');
+            collection.addImport('myImport2', 'myModule');
+            (0, mod_js_1.expect)(collection.hasImports).toBe(true);
+            (0, mod_js_1.expect)(collection.hasExports).toBe(false);
+            (0, mod_js_1.expect)(collection.toString(sourceBuilderOptions)).toBe("import { myImport1, myImport2 } from 'myModule';\n");
+        });
+    });
+    (0, bdd_js_1.describe)('addExport', () => {
+        (0, bdd_js_1.it)('should add a new export to the collection', () => {
+            collection.addExport('myExport', 'myModule');
+            (0, mod_js_1.expect)(collection.hasImports).toBe(false);
+            (0, mod_js_1.expect)(collection.hasExports).toBe(true);
+            (0, mod_js_1.expect)(collection.toString(sourceBuilderOptions)).toBe("export { myExport } from 'myModule';\n");
+        });
+        (0, bdd_js_1.it)('should add a new export to an existing module', () => {
+            collection.addExport('myExport1', 'myModule');
+            collection.addExport('myExport2', 'myModule');
+            (0, mod_js_1.expect)(collection.hasImports).toBe(false);
+            (0, mod_js_1.expect)(collection.hasExports).toBe(true);
+            (0, mod_js_1.expect)(collection.toString(sourceBuilderOptions)).toBe("export { myExport1, myExport2 } from 'myModule';\n");
+        });
+    });
+    (0, bdd_js_1.describe)('clear', () => {
+        (0, bdd_js_1.it)('should clear the collection', () => {
+            collection.addImport('myImport', 'myModule');
+            collection.addExport('myExport', 'myModule');
+            (0, mod_js_1.expect)(collection.hasImports).toBe(true);
+            (0, mod_js_1.expect)(collection.hasExports).toBe(true);
+            collection.clear();
+            (0, mod_js_1.expect)(collection.hasImports).toBe(false);
+            (0, mod_js_1.expect)(collection.hasExports).toBe(false);
+            (0, mod_js_1.expect)(collection.toString(sourceBuilderOptions)).toBe('');
+        });
+    });
+    (0, bdd_js_1.describe)('toString', () => {
+        (0, bdd_js_1.it)('should return an empty string if the collection is empty', () => {
+            (0, mod_js_1.expect)(collection.toString(sourceBuilderOptions)).toBe('');
+        });
+        (0, bdd_js_1.it)('should return a string representation of the collection', () => {
+            collection.addImport('myImport', 'myModule');
+            collection.addExport('myExport', 'myModule');
+            (0, mod_js_1.expect)(collection.toString(sourceBuilderOptions)).toBe("import { myImport } from 'myModule';\n\nexport { myExport } from 'myModule';\n");
+        });
+    });
+});

package/script/src/utils.d.ts

@@ -0,0 +1,8 @@
+import type { Nullable } from '@goast/core';
+export type ImportModuleTransformer = 'omit-extension' | 'with-extension' | 'js-extension' | ((module: string) => string);
+export declare function toTypeScriptStringLiteral(value: string, useSingleQuotes: boolean): string;
+export declare function toTypeScriptPropertyName(value: string, useSingleQuotes: boolean): string;
+export declare function getModulePathRelativeToFile(from: string, to: string, transformer: ImportModuleTransformer): string;
+export declare function getModulePathRelativeToDirectory(from: string, to: string, transformer: ImportModuleTransformer): string;
+export declare function modifyString<TArgs extends unknown[]>(value: string, modifier: Nullable<string | RegExp | ((value: string, ...args: TArgs) => string)>, ...args: TArgs): string;
+//# sourceMappingURL=utils.d.ts.map

package/script/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,MAAM,MAAM,uBAAuB,GAC/B,gBAAgB,GAChB,gBAAgB,GAChB,cAAc,GACd,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;AAMjC,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,GAAG,MAAM,CAEzF;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,GAAG,MAAM,CAKxF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,uBAAuB,GAAG,MAAM,CAElH;AAED,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,uBAAuB,GACnC,MAAM,CAER;AAoBD,wBAAgB,YAAY,CAAC,KAAK,SAAS,OAAO,EAAE,EAClD,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,QAAQ,CAAC,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,KAAK,MAAM,CAAC,CAAC,EACjF,GAAG,IAAI,EAAE,KAAK,GACb,MAAM,CAYR"}

package/script/tests/openapi-models.test.d.ts

@@ -0,0 +1,2 @@
+import "../_dnt.test_polyfills.js";
+//# sourceMappingURL=openapi-models.test.d.ts.map

package/script/tests/openapi-models.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-models.test.d.ts","sourceRoot":"","sources":["../../src/tests/openapi-models.test.ts"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAC"}

package/script/tests/openapi-models.test.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("../_dnt.test_polyfills.js");
+const node_path_1 = require("node:path");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const core_1 = require("@goast/core");
+const test_utils_1 = require("@goast/test-utils");
+const bdd_js_1 = require("../deps/jsr.io/@std/testing/1.0.3/bdd.js");
+const mock_js_1 = require("../deps/jsr.io/@std/testing/1.0.3/mock.js");
+const models_generator_js_1 = require("../src/generators/models/models-generator.js");
+const filePaths = {
+    '2.0': test_utils_1.openApiV2FilesDir,
+    '3.0': test_utils_1.openApiV3FilesDir,
+    '3.1': test_utils_1.openApiV3_1FilesDir,
+};
+const testFilesAllVersions = ['simple-schemas.yml', 'detailed-schemas.yml', 'object-schemas.yml'];
+const testFilesV3x = ['oneof-schemas.yml', 'discriminated-schemas.yml'];
+for (const [version, path] of Object.entries(filePaths)) {
+    (0, bdd_js_1.describe)(`OpenAPI V${version}`, () => {
+        (0, bdd_js_1.afterEach)(() => {
+            (0, mock_js_1.restore)();
+        });
+        const testFiles = version.startsWith('3') ? testFilesAllVersions.concat(testFilesV3x) : testFilesAllVersions;
+        for (const file of testFiles) {
+            const fileWithoutExt = file.replace(/\.[^/.]+$/, '');
+            (0, bdd_js_1.test)((0, core_1.toCustomCase)(fileWithoutExt, { wordCasing: 'all-lower', wordSeparator: ' ' }), async (t) => {
+                const filePath = (0, node_path_1.join)(path, file);
+                const result = new test_utils_1.MultipartData();
+                (0, mock_js_1.stub)(fs_extra_1.default, 'ensureDirSync');
+                (0, mock_js_1.stub)(fs_extra_1.default, 'writeFileSync', (path, data) => {
+                    result.push([path.toString(), data.toString()]);
+                });
+                const generatorOptions = {
+                    outputDir: 'out',
+                    newLine: '\n',
+                };
+                const state = await new core_1.OpenApiGenerator(generatorOptions)
+                    // deno-lint-ignore no-explicit-any
+                    .useType(models_generator_js_1.TypeScriptModelsGenerator, { __test__: true })
+                    .parseAndGenerate(filePath);
+                result.splice(0, 0, ['state', state]);
+                (0, mock_js_1.restore)();
+                await (0, test_utils_1.verify)(t, result);
+            });
+        }
+    });
+}

package/src/_dnt.test_polyfills.ts

@@ -0,0 +1,43 @@
+declare global {
+  // https://github.com/microsoft/TypeScript/blob/main/lib/lib.es2021.string.d.ts
+  interface String {
+    /**
+     * Replace all instances of a substring in a string, using a regular expression or search string.
+     * @param searchValue A string to search for.
+     * @param replaceValue A string containing the text to replace for every successful match of searchValue in this string.
+     */
+    replaceAll(searchValue: string | RegExp, replaceValue: string): string;
+
+    /**
+     * Replace all instances of a substring in a string, using a regular expression or search string.
+     * @param searchValue A string to search for.
+     * @param replacer A function that returns the replacement text.
+     */
+    replaceAll(
+      searchValue: string | RegExp,
+      replacer: (substring: string, ...args: any[]) => string,
+    ): string;
+  }
+}
+
+/**
+ * String.prototype.replaceAll() polyfill
+ * https://gomakethings.com/how-to-replace-a-section-of-a-string-with-another-one-with-vanilla-js/
+ * @author Chris Ferdinandi
+ * @license MIT
+ */
+if (!String.prototype.replaceAll) {
+  String.prototype.replaceAll = function (str: any, newStr: any) {
+    // If a regex pattern
+    if (
+      Object.prototype.toString.call(str).toLowerCase() === "[object regexp]"
+    ) {
+      return this.replace(str, newStr);
+    }
+
+    // If a string
+    return this.replace(new RegExp(str, "g"), newStr);
+  };
+}
+
+export {};

package/src/_dnt.test_shims.ts

@@ -0,0 +1,64 @@
+import { Deno } from "@deno/shim-deno-test";
+export { Deno } from "@deno/shim-deno-test";
+
+const dntGlobals = {
+  Deno,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+
+function createMergeProxy<T extends object, U extends object>(
+  baseObj: T,
+  extObj: U,
+): Omit<T, keyof U> & U {
+  return new Proxy(baseObj, {
+    get(_target, prop, _receiver) {
+      if (prop in extObj) {
+        return (extObj as any)[prop];
+      } else {
+        return (baseObj as any)[prop];
+      }
+    },
+    set(_target, prop, value) {
+      if (prop in extObj) {
+        delete (extObj as any)[prop];
+      }
+      (baseObj as any)[prop] = value;
+      return true;
+    },
+    deleteProperty(_target, prop) {
+      let success = false;
+      if (prop in extObj) {
+        delete (extObj as any)[prop];
+        success = true;
+      }
+      if (prop in baseObj) {
+        delete (baseObj as any)[prop];
+        success = true;
+      }
+      return success;
+    },
+    ownKeys(_target) {
+      const baseKeys = Reflect.ownKeys(baseObj);
+      const extKeys = Reflect.ownKeys(extObj);
+      const extKeysSet = new Set(extKeys);
+      return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+    },
+    defineProperty(_target, prop, desc) {
+      if (prop in extObj) {
+        delete (extObj as any)[prop];
+      }
+      Reflect.defineProperty(baseObj, prop, desc);
+      return true;
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      if (prop in extObj) {
+        return Reflect.getOwnPropertyDescriptor(extObj, prop);
+      } else {
+        return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+      }
+    },
+    has(_target, prop) {
+      return prop in extObj || prop in baseObj;
+    },
+  }) as any;
+}

package/src/deps/jsr.io/@std/assert/1.0.6/assertion_error.ts

@@ -0,0 +1,31 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export class AssertionError extends Error {
+  /** Constructs a new instance.
+   *
+   * @param message The error message.
+   * @param options Additional options. This argument is still unstable. It may change in the future release.
+   */
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "AssertionError";
+  }
+}

package/src/deps/jsr.io/@std/assert/1.0.6/equal.ts

@@ -0,0 +1,152 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+type KeyedCollection = Set<unknown> | Map<unknown, unknown>;
+function isKeyedCollection(x: unknown): x is KeyedCollection {
+  return x instanceof Set || x instanceof Map;
+}
+
+function constructorsEqual(a: object, b: object) {
+  return a.constructor === b.constructor ||
+    a.constructor === Object && !b.constructor ||
+    !a.constructor && b.constructor === Object;
+}
+
+/**
+ * Deep equality comparison used in assertions.
+ *
+ * @param c The actual value
+ * @param d The expected value
+ * @returns `true` if the values are deeply equal, `false` otherwise
+ *
+ * @example Usage
+ * ```ts
+ * import { equal } from "@std/assert/equal";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false
+ * ```
+ */
+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 aTime === bTime;
+    }
+    if (typeof a === "number" && typeof b === "number") {
+      return Number.isNaN(a) && Number.isNaN(b) || a === b;
+    }
+    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 (a instanceof WeakRef || b instanceof WeakRef) {
+        if (!(a instanceof WeakRef && b instanceof WeakRef)) return false;
+        return compare(a.deref(), b.deref());
+      }
+      if (seen.get(a) === b) {
+        return true;
+      }
+      if (Object.keys(a).length !== Object.keys(b).length) {
+        return false;
+      }
+      seen.set(a, b);
+      if (isKeyedCollection(a) && isKeyedCollection(b)) {
+        if (a.size !== b.size) {
+          return false;
+        }
+
+        const aKeys = [...a.keys()];
+        const primitiveKeysFastPath = aKeys.every((k) => {
+          return typeof k === "string" ||
+            typeof k === "number" ||
+            typeof k === "boolean" ||
+            typeof k === "bigint" ||
+            typeof k === "symbol" ||
+            k == null;
+        });
+        if (primitiveKeysFastPath) {
+          if (a instanceof Set) {
+            return a.symmetricDifference(b).size === 0;
+          }
+
+          for (const key of aKeys) {
+            if (
+              !b.has(key) ||
+              !compare(a.get(key), (b as Map<unknown, unknown>).get(key))
+            ) {
+              return false;
+            }
+          }
+          return true;
+        }
+
+        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 (!compare(aKey, bKey)) continue;
+
+            if (
+              (aKey === aValue && bKey === bValue) ||
+              (compare(aValue, bValue))
+            ) {
+              unmatchedEntries--;
+              break;
+            }
+          }
+        }
+
+        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;
+        }
+      }
+      return true;
+    }
+    return false;
+  })(c, d);
+}

package/src/deps/jsr.io/@std/assert/1.0.6/equals.ts

@@ -0,0 +1,52 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { equal } from "./equal.js";
+import { buildMessage } from "../../internal/1.0.4/build_message.js";
+import { diff } from "../../internal/1.0.4/diff.js";
+import { diffStr } from "../../internal/1.0.4/diff_str.js";
+import { format } from "../../internal/1.0.4/format.js";
+
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * 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 Usage
+ * ```ts ignore
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals("world", "world"); // Doesn't throw
+ * assertEquals("hello", "world"); // Throws
+ * ```
+ *
+ * @typeParam T The type of the values to compare. This is usually inferred.
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertEquals<T>(
+  actual: T,
+  expected: T,
+  msg?: string,
+) {
+  if (equal(actual, expected)) {
+    return;
+  }
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  let message = `Values are not equal${msgSuffix}`;
+
+  const actualString = format(actual);
+  const expectedString = format(expected);
+  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 = `${message}\n${diffMsg}`;
+  throw new AssertionError(message);
+}

package/src/deps/jsr.io/@std/assert/1.0.6/false.ts

@@ -0,0 +1,26 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/** Assertion condition for {@linkcode assertFalse}. */
+export type Falsy = false | 0 | 0n | "" | null | undefined;
+
+/**
+ * Make an assertion, error will be thrown if `expr` have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertFalse } from "@std/assert";
+ *
+ * assertFalse(false); // Doesn't throw
+ * assertFalse(true); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertFalse(expr: unknown, msg = ""): asserts expr is Falsy {
+  if (expr) {
+    throw new AssertionError(msg);
+  }
+}

package/src/deps/jsr.io/@std/assert/1.0.6/instance_of.ts

@@ -0,0 +1,64 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/** Any constructor */
+// deno-lint-ignore no-explicit-any
+export type AnyConstructor = new (...args: any[]) => any;
+/** Gets constructor type */
+export type GetConstructorType<T extends AnyConstructor> = InstanceType<T>;
+
+/**
+ * Make an assertion that `obj` is an instance of `type`.
+ * If not then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertInstanceOf } from "@std/assert";
+ *
+ * assertInstanceOf(new Date(), Date); // Doesn't throw
+ * assertInstanceOf(new Date(), Number); // Throws
+ * ```
+ *
+ * @typeParam T The expected type of the object.
+ * @param actual The object to check.
+ * @param expectedType The expected class constructor.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertInstanceOf<
+  // deno-lint-ignore no-explicit-any
+  T extends abstract new (...args: any[]) => any,
+>(
+  actual: unknown,
+  expectedType: T,
+  msg = "",
+): asserts actual is InstanceType<T> {
+  if (actual instanceof expectedType) return;
+
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  const expectedTypeStr = expectedType.name;
+
+  let actualTypeStr = "";
+  if (actual === null) {
+    actualTypeStr = "null";
+  } else if (actual === undefined) {
+    actualTypeStr = "undefined";
+  } else if (typeof actual === "object") {
+    actualTypeStr = actual.constructor?.name ?? "Object";
+  } else {
+    actualTypeStr = typeof actual;
+  }
+
+  if (expectedTypeStr === actualTypeStr) {
+    msg =
+      `Expected object to be an instance of "${expectedTypeStr}"${msgSuffix}`;
+  } else if (actualTypeStr === "function") {
+    msg =
+      `Expected object to be an instance of "${expectedTypeStr}" but was not an instanced object${msgSuffix}`;
+  } else {
+    msg =
+      `Expected object to be an instance of "${expectedTypeStr}" but was "${actualTypeStr}"${msgSuffix}`;
+  }
+
+  throw new AssertionError(msg);
+}

package/src/deps/jsr.io/@std/assert/1.0.6/is_error.ts

@@ -0,0 +1,65 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+import { stripAnsiCode } from "../../internal/1.0.4/styles.js";
+
+/**
+ * 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.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertIsError } from "@std/assert";
+ *
+ * assertIsError(null); // Throws
+ * assertIsError(new RangeError("Out of range")); // Doesn't throw
+ * assertIsError(new RangeError("Out of range"), SyntaxError); // Throws
+ * assertIsError(new RangeError("Out of range"), SyntaxError, "Out of range"); // Doesn't throw
+ * assertIsError(new RangeError("Out of range"), SyntaxError, "Within range"); // Throws
+ * ```
+ *
+ * @typeParam E The type of the error to assert.
+ * @param error The error to assert.
+ * @param ErrorClass The optional error class to assert.
+ * @param msgMatches The optional string or RegExp to assert in the error message.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertIsError<E extends Error = Error>(
+  error: unknown,
+  // deno-lint-ignore no-explicit-any
+  ErrorClass?: abstract new (...args: any[]) => E,
+  msgMatches?: string | RegExp,
+  msg?: string,
+): asserts error is E {
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  if (!(error instanceof Error)) {
+    throw new AssertionError(
+      `Expected "error" to be an Error object${msgSuffix}}`,
+    );
+  }
+  if (ErrorClass && !(error instanceof ErrorClass)) {
+    msg =
+      `Expected error to be instance of "${ErrorClass.name}", but was "${error?.constructor?.name}"${msgSuffix}`;
+    throw new AssertionError(msg);
+  }
+  let msgCheck;
+  if (typeof msgMatches === "string") {
+    msgCheck = stripAnsiCode(error.message).includes(
+      stripAnsiCode(msgMatches),
+    );
+  }
+  if (msgMatches instanceof RegExp) {
+    msgCheck = msgMatches.test(stripAnsiCode(error.message));
+  }
+
+  if (msgMatches && !msgCheck) {
+    msg = `Expected error message to include ${
+      msgMatches instanceof RegExp
+        ? msgMatches.toString()
+        : JSON.stringify(msgMatches)
+    }, but got ${JSON.stringify(error?.message)}${msgSuffix}`;
+    throw new AssertionError(msg);
+  }
+}

package/src/deps/jsr.io/@std/assert/1.0.6/match.ts

@@ -0,0 +1,30 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Make an assertion that `actual` match RegExp `expected`. If not
+ * then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertMatch } from "@std/assert";
+ *
+ * assertMatch("Raptor", /Raptor/); // Doesn't throw
+ * assertMatch("Denosaurus", /Raptor/); // Throws
+ * ```
+ *
+ * @param actual The actual value to be matched.
+ * @param expected The expected pattern to match.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertMatch(
+  actual: string,
+  expected: RegExp,
+  msg?: string,
+) {
+  if (expected.test(actual)) return;
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  msg = `Expected actual: "${actual}" to match: "${expected}"${msgSuffix}`;
+  throw new AssertionError(msg);
+}