structured-outputs 0.1.0-beta.2 → 0.1.0-beta.20

package/src/deps/jsr.io/@std/internal/1.0.5/styles.ts

@@ -0,0 +1,233 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+// A module to print ANSI terminal colors. Inspired by chalk, kleur, and colors
+// on npm.
+
+// This code is vendored from `fmt/colors.ts`.
+
+// deno-lint-ignore no-explicit-any
+import * as dntShim from "../../../../../_dnt.shims.js";
+
+const { Deno } = dntShim.dntGlobalThis as any;
+const noColor = typeof Deno?.noColor === "boolean"
+  ? Deno.noColor as boolean
+  : false;
+
+interface Code {
+  open: string;
+  close: string;
+  regexp: RegExp;
+}
+
+const enabled = !noColor;
+
+function code(open: number[], close: number): Code {
+  return {
+    open: `\x1b[${open.join(";")}m`,
+    close: `\x1b[${close}m`,
+    regexp: new RegExp(`\\x1b\\[${close}m`, "g"),
+  };
+}
+
+function run(str: string, code: Code): string {
+  return enabled
+    ? `${code.open}${str.replace(code.regexp, code.open)}${code.close}`
+    : str;
+}
+
+/**
+ * Sets the style of text to be printed to bold.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make bold
+ *
+ * @returns Bold text for printing
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bold } from "@std/internal/styles";
+ *
+ * console.log(bold("Hello, world!")); // Prints "Hello, world!" in bold
+ * ```
+ */
+export function bold(str: string): string {
+  return run(str, code([1], 22));
+}
+
+/**
+ * Sets the color of text to be printed to red.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make red
+ *
+ * @returns Red text for printing
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { red } from "@std/internal/styles";
+ *
+ * console.log(red("Hello, world!")); // Prints "Hello, world!" in red
+ * ```
+ */
+export function red(str: string): string {
+  return run(str, code([31], 39));
+}
+
+/**
+ * Sets the color of text to be printed to green.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make green
+ *
+ * @returns Green text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { green } from "@std/internal/styles";
+ *
+ * console.log(green("Hello, world!")); // Prints "Hello, world!" in green
+ * ```
+ */
+export function green(str: string): string {
+  return run(str, code([32], 39));
+}
+
+/**
+ * Sets the color of text to be printed to yellow.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make yellow
+ *
+ * @returns Yellow text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { yellow } from "@std/internal/styles";
+ *
+ * console.log(yellow("Hello, world!")); // Prints "Hello, world!" in yellow
+ * ```
+ */
+export function yellow(str: string): string {
+  return run(str, code([33], 39));
+}
+
+/**
+ * Sets the color of text to be printed to white.
+ *
+ * @param str Text to make white
+ *
+ * @returns White text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { white } from "@std/internal/styles";
+ *
+ * console.log(white("Hello, world!")); // Prints "Hello, world!" in white
+ * ```
+ */
+export function white(str: string): string {
+  return run(str, code([37], 39));
+}
+
+/**
+ * Sets the color of text to be printed to gray.
+ *
+ * @param str Text to make gray
+ *
+ * @returns Gray text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { gray } from "@std/internal/styles";
+ *
+ * console.log(gray("Hello, world!")); // Prints "Hello, world!" in gray
+ * ```
+ */
+export function gray(str: string): string {
+  return brightBlack(str);
+}
+
+/**
+ * Sets the color of text to be printed to bright-black.
+ *
+ * @param str Text to make bright-black
+ *
+ * @returns Bright-black text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { brightBlack } from "@std/internal/styles";
+ *
+ * console.log(brightBlack("Hello, world!")); // Prints "Hello, world!" in bright-black
+ * ```
+ */
+export function brightBlack(str: string): string {
+  return run(str, code([90], 39));
+}
+
+/**
+ * Sets the background color of text to be printed to red.
+ *
+ * @param str Text to make its background red
+ *
+ * @returns Red background text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bgRed } from "@std/internal/styles";
+ *
+ * console.log(bgRed("Hello, world!")); // Prints "Hello, world!" with red background
+ * ```
+ */
+export function bgRed(str: string): string {
+  return run(str, code([41], 49));
+}
+
+/**
+ * Sets the background color of text to be printed to green.
+ *
+ * @param str Text to make its background green
+ *
+ * @returns Green background text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bgGreen } from "@std/internal/styles";
+ *
+ * console.log(bgGreen("Hello, world!")); // Prints "Hello, world!" with green background
+ * ```
+ */
+export function bgGreen(str: string): string {
+  return run(str, code([42], 49));
+}
+
+// https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
+const ANSI_PATTERN = new RegExp(
+  [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))",
+  ].join("|"),
+  "g",
+);
+
+/**
+ * Remove ANSI escape codes from the string.
+ *
+ * @param string Text to remove ANSI escape codes from
+ *
+ * @returns Text without ANSI escape codes
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { red, stripAnsiCode } from "@std/internal/styles";
+ *
+ * console.log(stripAnsiCode(red("Hello, world!"))); // Prints "Hello, world!"
+ * ```
+ */
+export function stripAnsiCode(string: string): string {
+  return string.replace(ANSI_PATTERN, "");
+}

package/src/deps/jsr.io/@std/internal/1.0.5/types.ts

@@ -0,0 +1,18 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+/** Ways that lines in a diff can be different. */
+export type DiffType = "removed" | "common" | "added";
+
+/**
+ * Represents the result of a diff operation.
+ *
+ * @typeParam T The type of the value in the diff result.
+ */
+export interface DiffResult<T> {
+  /** The type of the diff. */
+  type: DiffType;
+  /** The value of the diff. */
+  value: T;
+  /** The details of the diff. */
+  details?: DiffResult<T>[];
+}

package/src/mod.ts

@@ -1,19 +1,4 @@
-import type { ArrayTy } from "./array.js"
-import type { NumberTy } from "./number.js"
-import type { ObjectTy } from "./object.js"
-import type { StringTy } from "./string.js"
-
-export type RootTy = NumberTy | StringTy | ObjectTy | ArrayTy
-
-// moderate --exclude _base.ts code_critique.ts
-
-export * from "./array.js"
-export * from "./common.js"
-export * from "./F.js"
-export * from "./literal.js"
-export * from "./number.js"
-export * from "./object.js"
+import "./_dnt.polyfills.js";
+export * as T from "./types/mod.js"
 export * from "./ResponseFormat.js"
-export * from "./schema.js"
-export * from "./string.js"
-export * from "./union.js"
+export * from "./Tool.js"

package/src/types/Ref.ts

@@ -0,0 +1,16 @@
+import type { Applied, Schema, Ty } from "./Ty.js"
+import { recombineTaggedTemplateArgs } from "../util/recombineTaggedTemplateArgs.js"
+
+export type Ref = (ty: Ty) => Schema
+
+export function Ref(applied: Applied): Ref {
+  return (ty) => {
+    applied = { ...applied, ...ty.applied }
+    const description = ty.descriptions
+      .map(({ template, placeheld }) =>
+        recombineTaggedTemplateArgs(template, placeheld.map((k) => applied[k]!))
+      )
+      .join(" ")
+    return ty.toSchema(description, Ref(applied))
+  }
+}

package/src/types/RootTy.ts

@@ -0,0 +1,40 @@
+import { phantoms } from "../util/phantoms.js"
+import { Ref } from "./Ref.js"
+import type { Applied, Description, Schema, ToSchema, Ty } from "./Ty.js"
+
+export function RootTy<T, P extends string = never>(
+  toSchema: ToSchema,
+  descriptions: Array<Description> = [],
+  applied: Applied = {},
+): RootTy<T, P> {
+  return Object.assign(
+    <P2 extends Array<string>>(template: TemplateStringsArray, ...placeheld: P2) =>
+      RootTy<T, P | P2[number]>(toSchema, [{ template, placeheld }, ...descriptions], applied),
+    phantoms<{ [Ty.T]: T; [Ty.P]: P }>(),
+    {
+      toSchema,
+      descriptions,
+      applied,
+      apply: <A extends Partial<Record<P, string | number>>>(values: A) => {
+        return RootTy<T, Exclude<P, keyof A>>(toSchema, descriptions, { ...applied, ...values })
+      },
+      schema(this: RootTy<T, never>) {
+        return Ref({})(this)
+      },
+      isRoot(): this is RootTy {
+        return true
+      },
+    },
+  )
+}
+
+export interface RootTy<T = any, P extends string = string> extends Ty<T, P> {
+  <P2 extends Array<string>>(
+    template: TemplateStringsArray,
+    ...placeheld: P2
+  ): RootTy<T, P | P2[number]>
+  apply: <A extends Partial<Record<P, number | string>>>(
+    values: A,
+  ) => RootTy<T, Exclude<P, keyof A>>
+  schema(this: RootTy<T, never>): Schema
+}

package/src/types/Ty.ts

@@ -0,0 +1,57 @@
+import type { Ref } from "./Ref.js"
+import { phantoms } from "../util/phantoms.js"
+import type { RootTy } from "./RootTy.js"
+
+export function Ty<T, P extends string = never>(
+  toSchema: ToSchema,
+  descriptions: Array<Description> = [],
+  applied: Applied = {},
+): Ty<T, P> {
+  return Object.assign(
+    <P2 extends Array<string>>(template: TemplateStringsArray, ...placeheld: P2) =>
+      Ty<T, P | P2[number]>(toSchema, [{ template, placeheld }, ...descriptions], applied),
+    phantoms<{ [Ty.T]: T; [Ty.P]: P }>(),
+    {
+      toSchema,
+      descriptions,
+      applied,
+      apply: <A extends Partial<Record<P, string | number>>>(values: A) => {
+        return Ty<T, Exclude<P, keyof A>>(toSchema, descriptions, { ...applied, ...values })
+      },
+      isRoot(): this is RootTy {
+        return false
+      },
+    },
+  )
+}
+
+export interface Ty<T = any, P extends string = string> {
+  <P2 extends Array<string>>(
+    template: TemplateStringsArray,
+    ...placeheld: P2
+  ): Ty<T, P | P2[number]>
+  [Ty.T]: T
+  [Ty.P]: P
+  toSchema: ToSchema
+  descriptions: Array<Description>
+  applied: Applied
+  apply: <A extends Partial<Record<P, number | string>>>(values: A) => Ty<T, Exclude<P, keyof A>>
+  isRoot(): this is RootTy
+}
+
+export namespace Ty {
+  export type T = typeof T
+  export declare const T: unique symbol
+  export type P = typeof P
+  export declare const P: unique symbol
+}
+
+export type ToSchema = (description: string | undefined, ref: Ref) => Schema
+export type Schema = Record<string, unknown>
+
+export interface Description {
+  template: TemplateStringsArray
+  placeheld: Array<string>
+}
+
+export type Applied = Record<string, number | string>

package/src/types/array.ts

@@ -0,0 +1,9 @@
+import { Ty } from "./Ty.js"
+
+export function array<E extends Ty>(element: E): Ty<Array<E[Ty.T]>, E[Ty.P]> {
+  return Ty((description, ref) => ({
+    type: "array",
+    description,
+    items: ref(element),
+  }))
+}

package/src/types/constant.ts

@@ -0,0 +1,8 @@
+import { Ty } from "./Ty.js"
+
+export function constant<V extends number | string>(value: V): Ty<V, never> {
+  return Ty((description) => ({
+    const: value,
+    description,
+  }))
+}

package/src/types/constantUnion.ts

@@ -0,0 +1,27 @@
+import { partition } from "../deps/jsr.io/@std/collections/1.0.9/mod.js"
+import { Ty } from "./Ty.js"
+
+export function constantUnion<M extends Array<number | string>>(
+  ...members: M
+): Ty<M[number], never> {
+  const [strings, numbers] = partition(members, (v) => typeof v === "string")
+  return Ty((description) => {
+    return {
+      anyOf: [
+        ...strings.length
+          ? [{
+            type: "string",
+            enum: strings,
+          }]
+          : [],
+        ...numbers.length
+          ? [{
+            type: "number",
+            enum: numbers,
+          }]
+          : [],
+      ],
+      description,
+    }
+  })
+}

package/src/types/leaves.ts

@@ -0,0 +1,21 @@
+import { Ty } from "./Ty.js"
+
+export const none: Ty<null, never> = Ty((description) => ({
+  type: "null",
+  description,
+}))
+
+export const boolean: Ty<boolean, never> = Ty((description) => ({
+  type: "boolean",
+  description,
+}))
+
+export const number: Ty<number, never> = Ty((description) => ({
+  type: "number",
+  description,
+}))
+
+export const string: Ty<string, never> = Ty((description) => ({
+  type: "string",
+  description,
+}))

package/src/types/mod.ts

@@ -0,0 +1,10 @@
+export * from "./array.js"
+export * from "./leaves.js"
+export * from "./constant.js"
+export * from "./constantUnion.js"
+export * from "./std/mod.js"
+export * from "./object.js"
+export * from "./Ref.js"
+export * from "./taggedUnion.js"
+export * from "./Ty.js"
+export * from "./RootTy.js"

package/src/types/object.ts

@@ -0,0 +1,15 @@
+import { RootTy } from "./RootTy.js"
+import type { Ty } from "./Ty.js"
+
+export function object<F extends Record<string, Ty>>(fields: F): RootTy<
+  { [K in keyof F]: F[K][Ty.T] },
+  F[keyof F][Ty.P]
+> {
+  return RootTy((description, ref) => ({
+    type: "object",
+    description,
+    properties: Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, ref(v)])),
+    additionalProperties: false,
+    required: Object.keys(fields),
+  }))
+}

package/src/types/std/Option.ts

@@ -0,0 +1,15 @@
+import { none } from "../leaves.js"
+import { taggedUnion } from "../taggedUnion.js"
+import type { Ty } from "../Ty.js"
+
+export function option<S extends Ty>(Some: S): ReturnType<
+  typeof taggedUnion<{
+    Some: S
+    None: Ty<null, never>
+  }>
+> {
+  return taggedUnion({
+    Some,
+    None: none,
+  })`An option of specified \`some\` type.`
+}

package/src/types/std/Wrapper.ts

@@ -0,0 +1,8 @@
+import type { Ty } from "../mod.js"
+import { object } from "../object.js"
+
+export type Wrapper<X extends Ty = Ty> = ReturnType<typeof Wrapper<X>>
+
+export function Wrapper<X extends Ty>(value: X): ReturnType<typeof object<{ value: X }>> {
+  return object({ value })
+}

package/src/types/std/mod.ts

@@ -0,0 +1,2 @@
+export * from "./Option.js"
+export * from "./Wrapper.js"

package/src/types/taggedUnion.ts

@@ -0,0 +1,28 @@
+import { Ty } from "./Ty.js"
+
+export function taggedUnion<M extends Record<string, Ty>>(members: M): Ty<
+  {
+    [K in keyof M]: {
+      type: K
+      value: M[K][Ty.T]
+    }
+  }[keyof M],
+  M[keyof M][Ty.P]
+> {
+  return Ty((description, ref) => ({
+    description,
+    discriminator: "type",
+    anyOf: Object.entries(members).map(([k, v]) => ({
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          const: k,
+        },
+        value: ref(v),
+      },
+      required: ["type", "value"],
+      additionalProperties: false,
+    })),
+  }))
+}

package/src/util/phantoms.ts

@@ -0,0 +1,3 @@
+export function phantoms<T>(): T {
+  return {} as T
+}

package/src/util/recombineTaggedTemplateArgs.ts

@@ -0,0 +1,6 @@
+export function recombineTaggedTemplateArgs(
+  strings: TemplateStringsArray,
+  values: Array<number | string>,
+): string {
+  return strings.reduce((acc, cur, i) => `${acc}${cur}${values[i] ?? ""}`, "")
+}

package/types/ResponseFormat.d.ts

@@ -0,0 +1,26 @@
+import type Openai from "openai";
+import type { ResponseFormatJSONSchema } from "openai/resources/index.js";
+import type { RootTy } from "./types/mod.js";
+export declare function ResponseFormat<T>(name: string, ty: RootTy<T, never>): ResponseFormat<T>;
+export interface ResponseFormat<T> {
+    (template: TemplateStringsArray, ...quasis: Array<string>): ResponseFormat<T>;
+    type: "json_schema";
+    /** The desired return type in JSON Schema. */
+    json_schema: ResponseFormatJSONSchema.JSONSchema;
+    /** Parse inner responses into a typed object. */
+    parse(completion: ChatCompletion): TypedChatCompletion<T>;
+    /** Parse and return the first inner response into a typed object. */
+    parseFirstOrThrow(completion: ChatCompletion): T;
+}
+export type TypedChatCompletion<T> = Omit<ChatCompletion, "choices"> & {
+    choices: Array<Omit<ChatCompletionChoice, "message"> & {
+        message: Omit<ChatCompletionMessage, "content"> & {
+            content: T;
+        };
+    }>;
+};
+type ChatCompletion = Openai.Chat.ChatCompletion;
+type ChatCompletionChoice = Openai.Chat.ChatCompletion.Choice;
+type ChatCompletionMessage = Openai.Chat.Completions.ChatCompletionMessage;
+export {};
+//# sourceMappingURL=ResponseFormat.d.ts.map

package/types/ResponseFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResponseFormat.d.ts","sourceRoot":"","sources":["../src/ResponseFormat.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAChC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAA;AACzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAG5C,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAEvF;AAkDD,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAA;IAC7E,IAAI,EAAE,aAAa,CAAA;IACnB,8CAA8C;IAC9C,WAAW,EAAE,wBAAwB,CAAC,UAAU,CAAA;IAChD,iDAAiD;IACjD,KAAK,CAAC,UAAU,EAAE,cAAc,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAA;IACzD,qEAAqE;IACrE,iBAAiB,CAAC,UAAU,EAAE,cAAc,GAAG,CAAC,CAAA;CACjD;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,GAAG;IACrE,OAAO,EAAE,KAAK,CACZ,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,GAAG;QACtC,OAAO,EAAE,IAAI,CAAC,qBAAqB,EAAE,SAAS,CAAC,GAAG;YAChD,OAAO,EAAE,CAAC,CAAA;SACX,CAAA;KACF,CACF,CAAA;CACF,CAAA;AAED,KAAK,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,cAAc,CAAA;AAChD,KAAK,oBAAoB,GAAG,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAA;AAC7D,KAAK,qBAAqB,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,qBAAqB,CAAA"}

package/types/Tool.d.ts

@@ -0,0 +1,13 @@
+import type { RootTy, Schema } from "./types/mod.js";
+export declare function Tool<T>(name: string, ty: RootTy<T, never>): Tool<T>;
+export interface Tool<T = any> {
+    (template: TemplateStringsArray, ...quasis: Array<string>): Tool<T>;
+    type: "function";
+    /** The name with which OpenAI recognizes the tool. */
+    name: string;
+    /** A description to inform the LLM of when/how to use the tool. */
+    description?: string;
+    /** The tool implementation's argument type in JSON Schema. */
+    parameters?: Schema;
+}
+//# sourceMappingURL=Tool.d.ts.map

package/types/Tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tool.d.ts","sourceRoot":"","sources":["../src/Tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAGpD,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAEnE;AAuBD,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG;IAC3B,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;IACnE,IAAI,EAAE,UAAU,CAAA;IAChB,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,8DAA8D;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB"}

package/types/_dnt.polyfills.d.ts

@@ -0,0 +1,12 @@
+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 {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/types/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAeA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd;;;;WAIG;QACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;KAC5C;CACF;AAED,OAAO,EAAE,CAAC"}

package/types/_dnt.shims.d.ts

@@ -0,0 +1,2 @@
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/types/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}

package/types/deps/jsr.io/@std/assert/1.0.8/almost_equals.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers
+ * through a given tolerance. It can be used to take into account IEEE-754
+ * double-precision floating-point representation limitations. If the values
+ * are not almost equal then throw.
+ *
+ * The default tolerance is one hundred thousandth of a percent of the
+ * expected value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertAlmostEquals } from "@std/assert";
+ *
+ * assertAlmostEquals(0.01, 0.02); // Throws
+ * assertAlmostEquals(1e-8, 1e-9); // Throws
+ * assertAlmostEquals(1.000000001e-8, 1.000000002e-8); // Doesn't throw
+ * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
+ * ```
+ *
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param tolerance The tolerance to consider the values almost equal. The
+ * default is one hundred thousandth of a percent of the expected value.
+ * @param msg The optional message to include in the error.
+ */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
+//# sourceMappingURL=almost_equals.d.ts.map

package/types/deps/jsr.io/@std/assert/1.0.8/almost_equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"almost_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.8/almost_equals.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,EAClB,GAAG,CAAC,EAAE,MAAM,QAmBb"}