veryfront 0.1.545 → 0.1.546

package/src/deps/jsr.io/@std/assert/1.0.19/rejects.ts

@@ -1,123 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-import { assertIsError } from "./is_error.js";
-
-/**
- * Executes a function which returns a promise, expecting it to reject.
- *
- * To assert that a synchronous function throws, use {@linkcode assertThrows}.
- *
- * @example Usage
- * ```ts ignore
- * import { assertRejects } from "@std/assert";
- *
- * await assertRejects(async () => Promise.reject(new Error())); // Doesn't throw
- * await assertRejects(async () => console.log("Hello world")); // Throws
- * ```
- *
- * @param fn The function to execute.
- * @param msg The optional message to display if the assertion fails.
- * @returns The promise which resolves to the thrown error.
- */
-export 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.
- *
- * To assert that a synchronous function throws, use {@linkcode assertThrows}.
- *
- * @example Usage
- * ```ts ignore
- * import { assertRejects } from "@std/assert";
- *
- * await assertRejects(async () => Promise.reject(new Error()), Error); // Doesn't throw
- * await assertRejects(async () => Promise.reject(new Error()), SyntaxError); // Throws
- * ```
- *
- * @typeParam E The error class to assert.
- * @param fn The function to execute.
- * @param ErrorClass The error class to assert.
- * @param msgIncludes The string that should be included in the error message.
- * @param msg The optional message to display if the assertion fails.
- * @returns The promise which resolves to the thrown error.
- */
-export function assertRejects<E extends Error = Error>(
-  fn: () => PromiseLike<unknown>,
-  // deno-lint-ignore no-explicit-any
-  ErrorClass: abstract new (...args: any[]) => E,
-  msgIncludes?: string,
-  msg?: string,
-): Promise<E>;
-export async function assertRejects<E extends Error = Error>(
-  fn: () => PromiseLike<unknown>,
-  errorClassOrMsg?:
-    // deno-lint-ignore no-explicit-any
-    | (abstract new (...args: any[]) => E)
-    | string,
-  msgIncludesOrMsg?: string,
-  msg?: string,
-): Promise<E | Error | unknown> {
-  // deno-lint-ignore no-explicit-any
-  let ErrorClass: (abstract new (...args: any[]) => E) | undefined;
-  let msgIncludes: string | undefined;
-  let err;
-
-  if (typeof errorClassOrMsg !== "string") {
-    if (
-      errorClassOrMsg === undefined ||
-      errorClassOrMsg.prototype instanceof Error ||
-      errorClassOrMsg.prototype === Error.prototype
-    ) {
-      ErrorClass = errorClassOrMsg;
-      msgIncludes = msgIncludesOrMsg;
-    }
-  } else {
-    msg = errorClassOrMsg;
-  }
-  let doesThrow = false;
-  let isPromiseReturned = false;
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  try {
-    const possiblePromise = fn();
-    if (
-      possiblePromise &&
-      typeof possiblePromise === "object" &&
-      typeof possiblePromise.then === "function"
-    ) {
-      isPromiseReturned = true;
-      await possiblePromise;
-    } else {
-      throw new Error();
-    }
-  } catch (error) {
-    if (!isPromiseReturned) {
-      throw new AssertionError(
-        `Function throws when expected to reject${msgSuffix}`,
-      );
-    }
-    if (ErrorClass) {
-      if (!(error instanceof Error)) {
-        throw new AssertionError(`A non-Error object was rejected${msgSuffix}`);
-      }
-      assertIsError(
-        error,
-        ErrorClass,
-        msgIncludes,
-        msg,
-      );
-    }
-    err = error;
-    doesThrow = true;
-  }
-  if (!doesThrow) {
-    throw new AssertionError(
-      `Expected function to reject${msgSuffix}`,
-    );
-  }
-  return err;
-}

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

@@ -1,68 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { buildMessage } from "../../internal/1.0.13/build_message.js";
-import { diff } from "../../internal/1.0.13/diff.js";
-import { diffStr } from "../../internal/1.0.13/diff_str.js";
-import { format } from "../../internal/1.0.13/format.js";
-import { red } from "../../internal/1.0.13/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 }, arguments[3])
-      .join("\n");
-    message = `Values are not strictly equal${msgSuffix}\n${diffMsg}`;
-  }
-
-  throw new AssertionError(message);
-}

package/src/deps/jsr.io/@std/assert/1.0.19/string_includes.ts

@@ -1,30 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Make an assertion that actual includes expected. If not
- * then throw.
- *
- * @example Usage
- * ```ts ignore
- * import { assertStringIncludes } from "@std/assert";
- *
- * assertStringIncludes("Hello", "ello"); // Doesn't throw
- * assertStringIncludes("Hello", "world"); // Throws
- * ```
- *
- * @param actual The actual string to check for inclusion.
- * @param expected The expected string to check for inclusion.
- * @param msg The optional message to display if the assertion fails.
- */
-export function assertStringIncludes(
-  actual: string,
-  expected: string,
-  msg?: string,
-) {
-  if (actual.includes(expected)) return;
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  msg = `Expected actual: "${actual}" to contain: "${expected}"${msgSuffix}`;
-  throw new AssertionError(msg);
-}

package/src/deps/jsr.io/@std/assert/1.0.19/throws.ts

@@ -1,111 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { assertIsError } from "./is_error.js";
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Executes a function, expecting it to throw. If it does not, then it
- * throws.
- *
- * To assert that an asynchronous function rejects, use
- * {@linkcode assertRejects}.
- *
- * @example Usage
- * ```ts ignore
- * import { assertThrows } from "@std/assert";
- *
- * assertThrows(() => { throw new TypeError("hello world!"); }); // Doesn't throw
- * assertThrows(() => console.log("hello world!")); // Throws
- * ```
- *
- * @param fn The function to execute.
- * @param msg The optional message to display if the assertion fails.
- * @returns The error that was thrown.
- */
-export 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.
- *
- * To assert that an asynchronous function rejects, use
- * {@linkcode assertRejects}.
- *
- * @example Usage
- * ```ts ignore
- * import { assertThrows } from "@std/assert";
- *
- * assertThrows(() => { throw new TypeError("hello world!"); }, TypeError); // Doesn't throw
- * assertThrows(() => { throw new TypeError("hello world!"); }, RangeError); // Throws
- * ```
- *
- * @typeParam E The error class to assert.
- * @param fn The function to execute.
- * @param ErrorClass The error class to assert.
- * @param msgIncludes The string that should be included in the error message.
- * @param msg The optional message to display if the assertion fails.
- * @returns The error that was thrown.
- */
-export function assertThrows<E extends Error = Error>(
-  fn: () => unknown,
-  // deno-lint-ignore no-explicit-any
-  ErrorClass: abstract new (...args: any[]) => E,
-  msgIncludes?: string,
-  msg?: string,
-): E;
-export function assertThrows<E extends Error = Error>(
-  fn: () => unknown,
-  errorClassOrMsg?:
-    // deno-lint-ignore no-explicit-any
-    | (abstract new (...args: any[]) => E)
-    | string,
-  msgIncludesOrMsg?: string,
-  msg?: string,
-): E | Error | unknown {
-  // deno-lint-ignore no-explicit-any
-  let ErrorClass: (abstract new (...args: any[]) => E) | undefined;
-  let msgIncludes: string | undefined;
-  let err;
-
-  if (typeof errorClassOrMsg !== "string") {
-    if (
-      errorClassOrMsg === undefined ||
-      errorClassOrMsg?.prototype instanceof Error ||
-      errorClassOrMsg?.prototype === Error.prototype
-    ) {
-      ErrorClass = errorClassOrMsg;
-      msgIncludes = msgIncludesOrMsg;
-    } else {
-      msg = msgIncludesOrMsg;
-    }
-  } else {
-    msg = errorClassOrMsg;
-  }
-  let doesThrow = false;
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  try {
-    fn();
-  } catch (error) {
-    if (ErrorClass) {
-      if (error instanceof Error === false) {
-        throw new AssertionError(`A non-Error object was thrown${msgSuffix}`);
-      }
-      assertIsError(
-        error,
-        ErrorClass,
-        msgIncludes,
-        msg,
-      );
-    }
-    err = error;
-    doesThrow = true;
-  }
-  if (!doesThrow) {
-    msg = `Expected function to throw${msgSuffix}`;
-    throw new AssertionError(msg);
-  }
-  return err;
-}

package/src/deps/jsr.io/@std/assert/1.0.19/unimplemented.ts

@@ -1,21 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Use this to stub out methods that will throw when invoked.
- *
- * @example Usage
- * ```ts ignore
- * import { unimplemented } from "@std/assert";
- *
- * unimplemented(); // Throws
- * ```
- *
- * @param msg Optional message to include in the error.
- * @returns Never returns, always throws.
- */
-export function unimplemented(msg?: string): never {
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  throw new AssertionError(`Unimplemented${msgSuffix}`);
-}

package/src/deps/jsr.io/@std/assert/1.0.19/unreachable.ts

@@ -1,21 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { AssertionError } from "./assertion_error.js";
-
-/**
- * Use this to assert unreachable code.
- *
- * @example Usage
- * ```ts ignore
- * import { unreachable } from "@std/assert";
- *
- * unreachable(); // Throws
- * ```
- *
- * @param msg Optional message to include in the error.
- * @returns Never returns, always throws.
- */
-export function unreachable(msg?: string): never {
-  const msgSuffix = msg ? `: ${msg}` : ".";
-  throw new AssertionError(`Unreachable${msgSuffix}`);
-}

package/src/deps/jsr.io/@std/dotenv/0.225.6/mod.ts

@@ -1,251 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-
-/**
- * Parses and loads environment variables from a `.env` file into the current
- * process, or stringify data into a `.env` file format.
- *
- * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
- *
- * ```ts ignore
- * // Automatically load environment variables from a `.env` file
- * import "@std/dotenv/load";
- * ```
- *
- * ```ts
- * import { parse, stringify } from "@std/dotenv";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(parse("GREETING=hello world"), { GREETING: "hello world" });
- * assertEquals(stringify({ GREETING: "hello world" }), "GREETING='hello world'");
- * ```
- *
- * @module
- */
-import * as dntShim from "../../../../../_dnt.shims.js";
-
-
-import { parse } from "./parse.js";
-
-export * from "./stringify.js";
-export * from "./parse.js";
-
-/** Options for {@linkcode load} and {@linkcode loadSync}. */
-export interface LoadOptions {
-  /**
-   * Optional path to `.env` file. To prevent the default value from being
-   * used, set to `null`.
-   *
-   * @default {"./.env"}
-   */
-  envPath?: string | URL | null;
-
-  /**
-   * Set to `true` to export all `.env` variables to the current processes
-   * environment. Variables are then accessible via `Deno.env.get(<key>)`.
-   *
-   * @default {false}
-   */
-  export?: boolean;
-}
-
-/**
- * Works identically to {@linkcode load}, but synchronously.
- *
- * @example Usage
- * ```ts ignore
- * import { loadSync } from "@std/dotenv";
- *
- * const conf = loadSync();
- * ```
- *
- * @param options Options for loading the environment variables.
- * @returns The parsed environment variables.
- */
-export function loadSync(
-  options: LoadOptions = {},
-): Record<string, string> {
-  const {
-    envPath = ".env",
-    export: _export = false,
-  } = options;
-  const conf = envPath ? parseFileSync(envPath) : {};
-
-  if (_export) {
-    for (const [key, value] of Object.entries(conf)) {
-      if (dntShim.Deno.env.get(key) !== undefined) continue;
-      dntShim.Deno.env.set(key, value);
-    }
-  }
-
-  return conf;
-}
-
-/**
- * Load environment variables from a `.env` file.  Loaded variables are accessible
- * in a configuration object returned by the `load()` function, as well as optionally
- * exporting them to the process environment using the `export` option.
- *
- * Inspired by the node modules {@linkcode https://github.com/motdotla/dotenv | dotenv}
- * and {@linkcode https://github.com/motdotla/dotenv-expand | dotenv-expand}.
- *
- * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
- *
- * ## Basic usage
- * ```sh
- * # .env
- * GREETING=hello world
- * ```
- *
- * Then import the environment variables using the `load` function.
- *
- * @example Basic usage
- * ```ts ignore
- * // app.ts
- * import { load } from "@std/dotenv";
- *
- * console.log(await load({ export: true })); // { GREETING: "hello world" }
- * console.log(Deno.env.get("GREETING")); // hello world
- * ```
- *
- * Run this with `deno run --allow-read --allow-env app.ts`.
- *
- * .env files support blank lines, comments, multi-line values and more.
- * See Parsing Rules below for more detail.
- *
- * ## Auto loading
- * Import the `load.ts` module to auto-import from the `.env` file and into
- * the process environment.
- *
- * @example Auto-loading
- * ```ts ignore
- * // app.ts
- * import "@std/dotenv/load";
- *
- * console.log(Deno.env.get("GREETING")); // hello world
- * ```
- *
- * Run this with `deno run --allow-read --allow-env app.ts`.
- *
- * ## Files
- * Dotenv supports a number of different files, all of which are optional.
- * File names and paths are configurable.
- *
- * |File|Purpose|
- * |----|-------|
- * |.env|primary file for storing key-value environment entries
- *
- * ## Configuration
- *
- * Loading environment files comes with a number of options passed into
- * the `load()` function, all of which are optional.
- *
- * |Option|Default|Description
- * |------|-------|-----------
- * |envPath|./.env|Path and filename of the `.env` file.  Use null to prevent the .env file from being loaded.
- * |export|false|When true, this will export all environment variables in the `.env` file to the process environment (e.g. for use by `Deno.env.get()`) but only if they are not already set.  If a variable is already in the process, the `.env` value is ignored.
- *
- * ### Example configuration
- *
- * @example Using with options
- * ```ts ignore
- * import { load } from "@std/dotenv";
- *
- * const conf = await load({
- *   envPath: "./.env_prod", // Uses .env_prod instead of .env
- *   export: true, // Exports all variables to the environment
- * });
- * ```
- *
- * ## Permissions
- *
- * At a minimum, loading the `.env` related files requires the `--allow-read` permission.  Additionally, if
- * you access the process environment, either through exporting your configuration or expanding variables
- * in your `.env` file, you will need the `--allow-env` permission.  E.g.
- *
- * ```sh
- * deno run --allow-read=.env --allow-env=ENV1,ENV2 app.ts
- * ```
- *
- * ## Parsing Rules
- *
- * The parsing engine currently supports the following rules:
- *
- * - Variables that already exist in the environment are not overridden with
- *   `export: true`
- * - `BASIC=basic` becomes `{ BASIC: "basic" }`
- * - empty lines are skipped
- * - lines beginning with `#` are treated as comments
- * - empty values become empty strings (`EMPTY=` becomes `{ EMPTY: "" }`)
- * - single and double quoted values are escaped (`SINGLE_QUOTE='quoted'` becomes
- *   `{ SINGLE_QUOTE: "quoted" }`)
- * - new lines are expanded in double quoted values (`MULTILINE="new\nline"`
- *   becomes
- *
- * ```
- * { MULTILINE: "new\nline" }
- * ```
- *
- * - inner quotes are maintained (think JSON) (`JSON={"foo": "bar"}` becomes
- *   `{ JSON: "{\"foo\": \"bar\"}" }`)
- * - whitespace is removed from both ends of unquoted values (see more on
- *   {@linkcode https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim | trim})
- *   (`FOO= some value` becomes `{ FOO: "some value" }`)
- * - whitespace is preserved on both ends of quoted values (`FOO=" some value "`
- *   becomes `{ FOO: " some value " }`)
- * - dollar sign with an environment key in or without curly braces in unquoted
- *   values will expand the environment key (`KEY=$KEY` or `KEY=${KEY}` becomes
- *   `{ KEY: "<KEY_VALUE_FROM_ENV>" }`)
- * - escaped dollar sign with an environment key in unquoted values will escape the
- *   environment key rather than expand (`KEY=\$KEY` becomes `{ KEY: "\\$KEY" }`)
- * - colon and a minus sign with a default value(which can also be another expand
- *   value) in expanding construction in unquoted values will first attempt to
- *   expand the environment key. If it’s not found, then it will return the default
- *   value (`KEY=${KEY:-default}` If KEY exists it becomes
- *   `{ KEY: "<KEY_VALUE_FROM_ENV>" }` If not, then it becomes
- *   `{ KEY: "default" }`. Also there is possible to do this case
- *   `KEY=${NO_SUCH_KEY:-${EXISTING_KEY:-default}}` which becomes
- *   `{ KEY: "<EXISTING_KEY_VALUE_FROM_ENV>" }`)
- *
- * @param options The options
- * @returns The parsed environment variables
- */
-export async function load(
-  options: LoadOptions = {},
-): Promise<Record<string, string>> {
-  const {
-    envPath = ".env",
-    export: _export = false,
-  } = options;
-  const conf = envPath ? await parseFile(envPath) : {};
-
-  if (_export) {
-    for (const [key, value] of Object.entries(conf)) {
-      if (dntShim.Deno.env.get(key) !== undefined) continue;
-      dntShim.Deno.env.set(key, value);
-    }
-  }
-
-  return conf;
-}
-
-function parseFileSync(
-  filepath: string | URL,
-): Record<string, string> {
-  try {
-    return parse(dntShim.Deno.readTextFileSync(filepath));
-  } catch (e) {
-    if (e instanceof dntShim.Deno.errors.NotFound) return {};
-    throw e;
-  }
-}
-
-async function parseFile(
-  filepath: string | URL,
-): Promise<Record<string, string>> {
-  try {
-    return parse(await dntShim.Deno.readTextFile(filepath));
-  } catch (e) {
-    if (e instanceof dntShim.Deno.errors.NotFound) return {};
-    throw e;
-  }
-}