@goast/core 0.4.1 → 0.4.2

package/script/tests/schema-factory.js

@@ -1,162 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOneOfSchema = createOneOfSchema;
-exports.createMultiTypeSchema = createMultiTypeSchema;
-exports.createStringSchema = createStringSchema;
-exports.createBooleanSchema = createBooleanSchema;
-exports.createNullSchema = createNullSchema;
-exports.createNumberSchema = createNumberSchema;
-exports.createIntegerSchema = createIntegerSchema;
-exports.createArraySchema = createArraySchema;
-exports.createObjectSchema = createObjectSchema;
-exports.createCombinedSchema = createCombinedSchema;
-exports.createUnknownSchema = createUnknownSchema;
-exports.createOneOfProperty = createOneOfProperty;
-exports.createMultiTypeProperty = createMultiTypeProperty;
-exports.createStringProperty = createStringProperty;
-exports.createBooleanProperty = createBooleanProperty;
-exports.createNullProperty = createNullProperty;
-exports.createNumberProperty = createNumberProperty;
-exports.createIntegerProperty = createIntegerProperty;
-exports.createArrayProperty = createArrayProperty;
-exports.createObjectProperty = createObjectProperty;
-exports.createCombinedProperty = createCombinedProperty;
-exports.createUnknownProperty = createUnknownProperty;
-let nextId = 0;
-function createSchemaBase(schema) {
-    var _a, _b, _c, _d, _e, _f;
-    const name = (_a = schema.name) !== null && _a !== void 0 ? _a : `schema-${nextId++}`;
-    return {
-        ...schema,
-        name,
-        $src: schema.$src,
-        id: (_b = schema.id) !== null && _b !== void 0 ? _b : name,
-        isNameGenerated: (_c = schema.isNameGenerated) !== null && _c !== void 0 ? _c : schema.id !== undefined,
-        deprecated: (_d = schema.deprecated) !== null && _d !== void 0 ? _d : false,
-        accessibility: (_e = schema.accessibility) !== null && _e !== void 0 ? _e : 'all',
-        required: new Set((_f = schema.required) !== null && _f !== void 0 ? _f : []),
-        custom: {},
-    };
-}
-function createOneOfSchema(schema = {}) {
-    var _a;
-    return {
-        ...createSchemaBase(schema),
-        kind: 'oneOf',
-        oneOf: (_a = schema.oneOf) !== null && _a !== void 0 ? _a : [],
-    };
-}
-function createMultiTypeSchema(schema = {}) {
-    var _a, _b, _c, _d;
-    return {
-        ...createSchemaBase(schema),
-        kind: 'multi-type',
-        type: (_a = schema.type) !== null && _a !== void 0 ? _a : [],
-        properties: new Map(((_b = schema.properties) !== null && _b !== void 0 ? _b : []).map((p) => [p.name, p])),
-        allOf: (_c = schema.allOf) !== null && _c !== void 0 ? _c : [],
-        anyOf: (_d = schema.anyOf) !== null && _d !== void 0 ? _d : [],
-    };
-}
-function createStringSchema(schema = {}) {
-    return {
-        ...createSchemaBase(schema),
-        kind: 'string',
-        type: 'string',
-    };
-}
-function createBooleanSchema(schema = {}) {
-    return {
-        ...createSchemaBase(schema),
-        kind: 'boolean',
-        type: 'boolean',
-    };
-}
-function createNullSchema(schema = {}) {
-    return {
-        ...createSchemaBase(schema),
-        kind: 'null',
-        type: 'null',
-    };
-}
-function createNumberSchema(schema = {}) {
-    return {
-        ...createSchemaBase(schema),
-        kind: 'number',
-        type: 'number',
-    };
-}
-function createIntegerSchema(schema = {}) {
-    return {
-        ...createSchemaBase(schema),
-        kind: 'integer',
-        type: 'integer',
-    };
-}
-function createArraySchema(schema = {}) {
-    var _a;
-    return {
-        ...createSchemaBase(schema),
-        kind: 'array',
-        type: 'array',
-        items: (_a = schema.items) !== null && _a !== void 0 ? _a : undefined,
-    };
-}
-function createObjectSchema(schema = {}) {
-    var _a, _b, _c;
-    return {
-        ...createSchemaBase(schema),
-        kind: 'object',
-        type: 'object',
-        properties: new Map(((_a = schema.properties) !== null && _a !== void 0 ? _a : []).map((p) => [p.name, p])),
-        allOf: (_b = schema.allOf) !== null && _b !== void 0 ? _b : [],
-        anyOf: (_c = schema.anyOf) !== null && _c !== void 0 ? _c : [],
-    };
-}
-function createCombinedSchema(schema = {}) {
-    var _a, _b;
-    return {
-        ...createSchemaBase(schema),
-        kind: 'combined',
-        allOf: (_a = schema.allOf) !== null && _a !== void 0 ? _a : [],
-        anyOf: (_b = schema.anyOf) !== null && _b !== void 0 ? _b : [],
-    };
-}
-function createUnknownSchema(schema = {}) {
-    return {
-        ...createSchemaBase(schema),
-        kind: 'unknown',
-    };
-}
-function createOneOfProperty(name, schema = {}) {
-    return { name, schema: createOneOfSchema(schema) };
-}
-function createMultiTypeProperty(name, schema = {}) {
-    return { name, schema: createMultiTypeSchema(schema) };
-}
-function createStringProperty(name, schema = {}) {
-    return { name, schema: createStringSchema(schema) };
-}
-function createBooleanProperty(name, schema = {}) {
-    return { name, schema: createBooleanSchema(schema) };
-}
-function createNullProperty(name, schema = {}) {
-    return { name, schema: createNullSchema(schema) };
-}
-function createNumberProperty(name, schema = {}) {
-    return { name, schema: createNumberSchema(schema) };
-}
-function createIntegerProperty(name, schema = {}) {
-    return { name, schema: createIntegerSchema(schema) };
-}
-function createArrayProperty(name, schema = {}) {
-    return { name, schema: createArraySchema(schema) };
-}
-function createObjectProperty(name, schema = {}) {
-    return { name, schema: createObjectSchema(schema) };
-}
-function createCombinedProperty(name, schema = {}) {
-    return { name, schema: createCombinedSchema(schema) };
-}
-function createUnknownProperty(name, schema = {}) {
-    return { name, schema: createUnknownSchema(schema) };
-}

package/src/_dnt.test_polyfills.ts

@@ -1,70 +0,0 @@
-// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
-if (!Object.hasOwn) {
-  Object.defineProperty(Object, "hasOwn", {
-    value: function (object: any, property: any) {
-      if (object == null) {
-        throw new TypeError("Cannot convert undefined or null to object");
-      }
-      return Object.prototype.hasOwnProperty.call(Object(object), property);
-    },
-    configurable: true,
-    enumerable: false,
-    writable: true,
-  });
-}
-
-declare global {
-  interface Object {
-    /**
-     * Determines whether an object has a property with the specified name.
-     * @param o An object.
-     * @param v A property name.
-     */
-    hasOwn(o: object, v: PropertyKey): boolean;
-  }
-}
-
-export {};
-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

@@ -1,72 +0,0 @@
-import { Deno } from "@deno/shim-deno-test";
-export { Deno } from "@deno/shim-deno-test";
-import { fetch, File, FormData, Headers, Request, Response } from "undici";
-export { fetch, File, FormData, Headers, Request, Response, type BodyInit, type HeadersInit, type ReferrerPolicy, type RequestInit, type RequestCache, type RequestMode, type RequestRedirect, type ResponseInit } from "undici";
-
-const dntGlobals = {
-  Deno,
-  fetch,
-  File,
-  FormData,
-  Headers,
-  Request,
-  Response,
-};
-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.11/assertion_error.ts

@@ -1,31 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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.11/false.ts

@@ -1,26 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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.11/instance_of.ts

@@ -1,64 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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.11/match.ts

@@ -1,30 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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);
-}

package/src/deps/jsr.io/@std/assert/1.0.11/not_instance_of.ts

@@ -1,33 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { assertFalse } from "./false.js";
-
-/**
- * Make an assertion that `obj` is not an instance of `type`.
- * If so, then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertNotInstanceOf } from "@std/assert";
- *
- * assertNotInstanceOf(new Date(), Number); // Doesn't throw
- * assertNotInstanceOf(new Date(), Date); // Throws
- * ```
- *
- * @typeParam A The type of the object to check.
- * @typeParam T The type of the class to check against.
- * @param actual The object to check.
- * @param unexpectedType The class constructor to check against.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertNotInstanceOf<A, T>(
-  actual: A,
-  // deno-lint-ignore no-explicit-any
-  unexpectedType: abstract new (...args: any[]) => T,
-  msg?: string,
-): asserts actual is Exclude<A, T> {
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  msg =
-    `Expected object to not be an instance of "${typeof unexpectedType}"${msgSuffix}`;
-  assertFalse(actual instanceof unexpectedType, msg);
-}

package/src/deps/jsr.io/@std/assert/1.0.11/not_match.ts

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

package/src/deps/jsr.io/@std/assert/1.0.11/not_strict_equals.ts

@@ -1,42 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-import { format } from "../../internal/1.0.5/format.js";
-
-/**
- * Make an assertion that `actual` and `expected` are not strictly equal, using
- * {@linkcode Object.is} for equality comparison. If the values are strictly
- * equal then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertNotStrictEquals } from "@std/assert";
- *
- * assertNotStrictEquals(1, 1); // Throws
- * assertNotStrictEquals(1, 2); // Doesn't throw
- *
- * assertNotStrictEquals(0, 0); // Throws
- * assertNotStrictEquals(0, -0); // Doesn't throw
- * ```
- *
- * @typeParam T The type of the values to compare.
- * @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 assertNotStrictEquals<T>(
-  actual: T,
-  expected: T,
-  msg?: string,
-) {
-  if (!Object.is(actual, expected)) {
-    return;
-  }
-
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  throw new AssertionError(
-    `Expected "actual" to not be strictly equal to: ${
-      format(actual)
-    }${msgSuffix}\n`,
-  );
-}

package/src/deps/jsr.io/@std/assert/1.0.11/strict_equals.ts

@@ -1,67 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { buildMessage } from "../../internal/1.0.5/build_message.js";
-import { diff } from "../../internal/1.0.5/diff.js";
-import { diffStr } from "../../internal/1.0.5/diff_str.js";
-import { format } from "../../internal/1.0.5/format.js";
-import { red } from "../../internal/1.0.5/styles.js";
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that `actual` and `expected` are strictly equal, using
- * {@linkcode Object.is} for equality comparison. If not, then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertStrictEquals } from "@std/assert";
- *
- * const a = {};
- * const b = a;
- * assertStrictEquals(a, b); // Doesn't throw
- *
- * const c = {};
- * const d = {};
- * assertStrictEquals(c, d); // Throws
- * ```
- *
- * @typeParam T The type of the expected value.
- * @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 assertStrictEquals<T>(
-  actual: unknown,
-  expected: T,
-  msg?: string,
-): asserts actual is T {
-  if (Object.is(actual, expected)) {
-    return;
-  }
-
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  let message: string;
-
-  const actualString = format(actual);
-  const expectedString = format(expected);
-
-  if (actualString === expectedString) {
-    const withOffset = actualString
-      .split("\n")
-      .map((l) => `    ${l}`)
-      .join("\n");
-    message =
-      `Values have the same structure but are not reference-equal${msgSuffix}\n\n${
-        red(withOffset)
-      }\n`;
-  } else {
-    const stringDiff = (typeof actual === "string") &&
-      (typeof expected === "string");
-    const diffResult = stringDiff
-      ? diffStr(actual as string, expected as string)
-      : diff(actualString.split("\n"), expectedString.split("\n"));
-    const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n");
-    message = `Values are not strictly equal${msgSuffix}\n${diffMsg}`;
-  }
-
-  throw new AssertionError(message);
-}

package/src/deps/jsr.io/@std/expect/1.0.12/_assert_equals.ts

@@ -1,38 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-
-// This file is copied from `std/assert`.
-
-import { AssertionError } from "../../assert/1.0.11/assertion_error.js";
-import { buildEqualErrorMessage } from "./_build_message.js";
-import { equal } from "./_equal.js";
-import type { EqualOptions } from "./_types.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
- * ```ts ignore
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals("world", "world"); // Doesn't throw
- * assertEquals("hello", "world"); // Throws
- * ```
- *
- * Note: formatter option is experimental and may be removed in the future.
- */
-export function assertEquals<T>(
-  actual: T,
-  expected: T,
-  options?: EqualOptions,
-) {
-  if (equal(actual, expected, options)) {
-    return;
-  }
-
-  const message = buildEqualErrorMessage(actual, expected, options ?? {});
-  throw new AssertionError(message);
-}