liminal 0.1.0-beta.25

package/src/core/signature.ts

@@ -0,0 +1,90 @@
+import { encodeBase32 } from "../deps/jsr.io/@std/encoding/1.0.6/mod.js"
+import { WeakMemo } from "../util/WeakMemo.js"
+import { IntrinsicName } from "./intrinsics_util.js"
+import type { PartialType } from "./Type.js"
+import { TypeVisitor } from "./TypeVisitor.js"
+
+export function signature(type: PartialType): string {
+  return signatureMemo.getOrInit(type)
+}
+const signatureMemo = new WeakMemo<PartialType, string>((type) => {
+  const ctx = new SignatureVisitorContext()
+  visit(ctx, type)
+  return `{\n  ${Object.entries(ctx.defs).map(([k, v]) => `${k}: ${v}`).join("\n  ")}\n}`
+})
+
+export function signatureHash(type: PartialType): Promise<string> {
+  return signatureHashMemo.getOrInit(type)
+}
+const signatureHashMemo = new WeakMemo<PartialType, Promise<string>>((type) =>
+  crypto.subtle
+    .digest("SHA-256", new TextEncoder().encode(signatureMemo.getOrInit(type)))
+    .then(encodeBase32)
+    .then((v) => v.slice(0, -4))
+)
+
+class SignatureVisitorContext {
+  ids: Map<PartialType, string> = new Map()
+  defs: Record<string, undefined | string> = {}
+}
+
+const visit = TypeVisitor<SignatureVisitorContext, string>({
+  hook(next, ctx, type): string {
+    const { ids, defs } = ctx
+    switch (IntrinsicName(type)) {
+      case "array":
+      case "object":
+      case "union": {
+        let id = ids.get(type)
+        if (id === undefined) {
+          id = ids.size.toString()
+          ids.set(type, id)
+        }
+        if (id in defs) {
+          return `i(${id})`
+        }
+        defs[id] = undefined
+        const signature = next(ctx, type)
+        defs[id] = signature
+        return `i(${id})`
+      }
+    }
+    return next(ctx, type)
+  },
+  const(_0, _1, _2, value): string {
+    if (typeof value === "string") {
+      return `"${escapeDoubleQuotes(value)}"`
+    }
+    return JSON.stringify(value)
+  },
+  array(ctx, _1, element): string {
+    return `array(${visit(ctx, element)})`
+  },
+  object(ctx, _1, fields): string {
+    return `object({ ${
+      Object
+        .entries(fields)
+        .map(([k, v]) => `${escapeDoubleQuotes(k)}: ${visit(ctx, v)}`)
+        .join(", ")
+    } })`
+  },
+  enum(_0, _1, ...values) {
+    return `enum("${values.map(escapeDoubleQuotes).join(`", "`)}")`
+  },
+  union(ctx, _1, ...members): string {
+    return `union(${members.map((member) => visit(ctx, member)).join(", ")})`
+  },
+  ref(ctx, _1, get): string {
+    return visit(ctx, get())
+  },
+  transform(ctx, _1, from): string {
+    return visit(ctx, from)
+  },
+  fallback(_0, type) {
+    return IntrinsicName(type)
+  },
+})
+
+function escapeDoubleQuotes(value: string): string {
+  return value.indexOf(`"`) !== -1 ? JSON.stringify(value) : value
+}

package/src/core/utility/Flatten.ts

@@ -0,0 +1,14 @@
+import * as I from "../intrinsics.js"
+import type { PartialType, Type } from "../Type.js"
+import { Tuple } from "./Tuple.js"
+
+export function Flattened<A extends Array<PartialType<Array<unknown>>>>(
+  ...sources: A
+): Type<NativeFlattened<A>, A[number]["D"]> {
+  return I.transform(Tuple(...sources), (value) => value.flat()) as never
+}
+
+type NativeFlattened<A extends Array<PartialType<Array<unknown>>>> = A extends
+  [infer E0 extends PartialType, ...infer ERest extends PartialType[]]
+  ? [...E0["T"], ...NativeFlattened<ERest>]
+  : []

package/src/core/utility/Intersection.ts

@@ -0,0 +1,24 @@
+import type { Expand, U2I } from "../../util/mod.js"
+import * as I from "../intrinsics.js"
+import type { PartialType, Type } from "../Type.js"
+
+export function Intersection<S extends Array<PartialType>>(
+  ...sources: Ensure<S>
+): Type<Expand<U2I<S[number]["T"]>>, S[number]["D"]> {
+  return I.object(
+    Object.fromEntries(
+      sources.flatMap((source) => Object.entries(source.declaration.args![0]!)),
+    ) as never,
+  )
+}
+
+type Ensure<S extends Array<PartialType>> = [ConflictingKey<S>] extends [never] ? S
+  : never
+
+type ConflictingKey<S extends Array<PartialType>, V extends string = never> = S extends [
+  infer E0 extends PartialType,
+  ...infer ERest extends Array<PartialType>,
+] ?
+    | keyof { [K in keyof E0["T"] as K extends V ? K : never]: true }
+    | ConflictingKey<ERest, V | Extract<keyof E0["T"], string>>
+  : never

package/src/core/utility/Option.ts

@@ -0,0 +1,6 @@
+import * as I from "../intrinsics.js"
+import type { Type } from "../Type.js"
+
+export function Option<V, P extends symbol>(some: Type<V, P>): Type<V | null, P> {
+  return I.union(I.null, some)
+}

package/src/core/utility/Record.ts

@@ -0,0 +1,7 @@
+import * as I from "../intrinsics.js"
+import type { Type } from "../Type.js"
+import { Tuple } from "./Tuple.js"
+
+export function Record<V, P extends symbol>(value: Type<V, P>): Type<Record<string, V>, P> {
+  return I.transform(I.array(Tuple(I.string, value)), Object.fromEntries)
+}

package/src/core/utility/Set.ts

@@ -0,0 +1,8 @@
+import * as I from "../intrinsics.js"
+import type { Type } from "../Type.js"
+
+export { Set_ as Set }
+function Set_<T extends number | string, P extends symbol>(element: Type<T, P>): Type<Set<T>, P> {
+  return I.transform(I.array(element), (value) => new Set(value))
+}
+Object.defineProperty(Set_, "name", { value: "Set" })

package/src/core/utility/TaggedUnion.ts

@@ -0,0 +1,23 @@
+import type { Falsy } from "../../deps/jsr.io/@std/assert/1.0.10/mod.js"
+import type { Expand } from "../../util/mod.js"
+import * as I from "../intrinsics.js"
+import type { PartialType, Type } from "../Type.js"
+
+export function TaggedUnion<M extends Record<string, Falsy | PartialType>>(members: M): Type<
+  {
+    [K in keyof M]: Expand<
+      & { type: K }
+      & (M[K] extends PartialType ? { value: M[K]["T"] } : { value?: never })
+    >
+  }[keyof M],
+  Extract<M[keyof M], PartialType>["D"]
+> {
+  return I.union(
+    ...Object.keys(members).toSorted().map((tag) =>
+      I.object({
+        type: I.const(I.string, tag),
+        value: members[tag] ? members[tag] : I.null,
+      } as never)
+    ),
+  )
+}

package/src/core/utility/Tuple.ts

@@ -0,0 +1,24 @@
+import type { ArrayOfLength } from "../../util/mod.js"
+import * as I from "../intrinsics.js"
+import type { PartialType, Type } from "../Type.js"
+
+export function Tuple<M extends Array<PartialType>>(
+  ...members: M
+): Type<{ [I in keyof M]: M[I]["T"] }, M[number]["D"]> {
+  return I.transform(
+    I.object(Object.fromEntries(members.map((type, i) => [i, type]))),
+    (value) => Object.values(value) as never,
+  )
+}
+
+export namespace Tuple {
+  export function N<T, P extends symbol, N extends number>(
+    member: Type<T, P>,
+    length: N,
+  ): Type<ArrayOfLength<T, N>, P> {
+    return I.transform(
+      I.object(Object.fromEntries(Array.from({ length }, (_0, i) => [i, member]))),
+      (value) => Object.values(value) as never,
+    )
+  }
+}

package/src/core/utility/mod.ts

@@ -0,0 +1,9 @@
+// moderate
+
+export * from "./Flatten.js"
+export * from "./Intersection.js"
+export * from "./Option.js"
+export * from "./Record.js"
+export * from "./Set.js"
+export * from "./TaggedUnion.js"
+export * from "./Tuple.js"

package/src/deps/jsr.io/@std/assert/1.0.10/almost_equals.ts

@@ -0,0 +1,55 @@
+// 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` 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 function assertAlmostEquals(
+  actual: number,
+  expected: number,
+  tolerance?: number,
+  msg?: string,
+) {
+  if (Object.is(actual, expected)) {
+    return;
+  }
+  const delta = Math.abs(expected - actual);
+  if (tolerance === undefined) {
+    tolerance = isFinite(expected) ? Math.abs(expected * 1e-7) : 1e-7;
+  }
+  if (delta <= tolerance) {
+    return;
+  }
+
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  const f = (n: number) => Number.isInteger(n) ? n : n.toExponential();
+  throw new AssertionError(
+    `Expected actual: "${f(actual)}" to be close to "${f(expected)}": \
+delta "${f(delta)}" is greater than "${f(tolerance)}"${msgSuffix}`,
+  );
+}

package/src/deps/jsr.io/@std/assert/1.0.10/array_includes.ts

@@ -0,0 +1,57 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { equal } from "./equal.js";
+import { format } from "../../internal/1.0.5/format.js";
+import { AssertionError } from "./assertion_error.js";
+
+/** An array-like object (`Array`, `Uint8Array`, `NodeList`, etc.) that is not a string */
+export type ArrayLikeArg<T> = ArrayLike<T> & object;
+
+/**
+ * Make an assertion that `actual` includes the `expected` values. If not then
+ * an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertArrayIncludes } from "@std/assert";
+ *
+ * assertArrayIncludes([1, 2], [2]); // Doesn't throw
+ * assertArrayIncludes([1, 2], [3]); // Throws
+ * ```
+ *
+ * @typeParam T The type of the elements in the array to compare.
+ * @param actual The array-like object to check for.
+ * @param expected The array-like object to check for.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertArrayIncludes<T>(
+  actual: ArrayLikeArg<T>,
+  expected: ArrayLikeArg<T>,
+  msg?: string,
+) {
+  const missing: unknown[] = [];
+  for (let i = 0; i < expected.length; i++) {
+    let found = false;
+    for (let j = 0; j < actual.length; j++) {
+      if (equal(expected[i], actual[j])) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      missing.push(expected[i]);
+    }
+  }
+  if (missing.length === 0) {
+    return;
+  }
+
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  msg = `Expected actual: "${format(actual)}" to include: "${
+    format(expected)
+  }"${msgSuffix}\nmissing: ${format(missing)}`;
+  throw new AssertionError(msg);
+}

package/src/deps/jsr.io/@std/assert/1.0.10/assert.ts

@@ -0,0 +1,23 @@
+// 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, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assert } from "@std/assert";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assert(expr: unknown, msg = ""): asserts expr {
+  if (!expr) {
+    throw new AssertionError(msg);
+  }
+}

package/src/deps/jsr.io/@std/assert/1.0.10/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.10/equal.ts

@@ -0,0 +1,210 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import * as dntShim from "../../../../../_dnt.shims.js";
+
+
+type KeyedCollection = Set<unknown> | Map<unknown, unknown>;
+function isKeyedCollection(x: unknown): x is KeyedCollection {
+  return x instanceof Set || x instanceof Map;
+}
+
+function prototypesEqual(a: object, b: object) {
+  const pa = Object.getPrototypeOf(a);
+  const pb = Object.getPrototypeOf(b);
+  return pa === pb ||
+    pa === Object.prototype && pb === null ||
+    pa === null && pb === Object.prototype;
+}
+
+function isBasicObjectOrArray(obj: object) {
+  const proto = Object.getPrototypeOf(obj);
+  return proto === null || proto === Object.prototype ||
+    proto === Array.prototype;
+}
+
+// Slightly faster than Reflect.ownKeys in V8 as of 12.9.202.13-rusty (2024-10-28)
+function ownKeys(obj: object) {
+  return [
+    ...Object.getOwnPropertyNames(obj),
+    ...Object.getOwnPropertySymbols(obj),
+  ];
+}
+
+function getKeysDeep(obj: object) {
+  const keys = new Set<string | symbol>();
+
+  while (obj !== Object.prototype && obj !== Array.prototype && obj != null) {
+    for (const key of ownKeys(obj)) {
+      keys.add(key);
+    }
+    obj = Object.getPrototypeOf(obj);
+  }
+
+  return keys;
+}
+
+// deno-lint-ignore no-explicit-any
+const Temporal: any = (dntShim.dntGlobalThis as any).Temporal ??
+  new Proxy({}, { get: () => {} });
+
+/** A non-exhaustive list of prototypes that can be accurately fast-path compared with `String(instance)` */
+const stringComparablePrototypes = new Set<unknown>(
+  [
+    Intl.Locale,
+    RegExp,
+    Temporal.Duration,
+    Temporal.Instant,
+    Temporal.PlainDate,
+    Temporal.PlainDateTime,
+    Temporal.PlainTime,
+    Temporal.PlainYearMonth,
+    Temporal.PlainMonthDay,
+    Temporal.ZonedDateTime,
+    URL,
+    URLSearchParams,
+  ].filter((x) => x != null).map((x) => x.prototype),
+);
+
+function isPrimitive(x: unknown) {
+  return typeof x === "string" ||
+    typeof x === "number" ||
+    typeof x === "boolean" ||
+    typeof x === "bigint" ||
+    typeof x === "symbol" ||
+    x == null;
+}
+
+type TypedArray = Pick<Uint8Array | BigUint64Array, "length" | number>;
+const TypedArray = Object.getPrototypeOf(Uint8Array);
+function compareTypedArrays(a: TypedArray, b: TypedArray) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < b.length; i++) {
+    if (!sameValueZero(a[i], b[i])) return false;
+  }
+  return true;
+}
+
+/** Check both strict equality (`0 == -0`) and `Object.is` (`NaN == NaN`) */
+function sameValueZero(a: unknown, b: unknown) {
+  return a === b || Object.is(a, b);
+}
+
+/**
+ * Deep equality comparison used in assertions.
+ *
+ * @param a The actual value
+ * @param b 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(a: unknown, b: unknown): boolean {
+  const seen = new Map<unknown, unknown>();
+  return (function compare(a: unknown, b: unknown): boolean {
+    if (sameValueZero(a, b)) return true;
+    if (isPrimitive(a) || isPrimitive(b)) return false;
+
+    if (a instanceof Date && b instanceof Date) {
+      return Object.is(a.getTime(), b.getTime());
+    }
+    if (a && typeof a === "object" && b && typeof b === "object") {
+      if (!prototypesEqual(a, b)) {
+        return false;
+      }
+      if (a instanceof TypedArray) {
+        return compareTypedArrays(a as TypedArray, b as TypedArray);
+      }
+      if (a instanceof WeakMap) {
+        throw new TypeError("cannot compare WeakMap instances");
+      }
+      if (a instanceof WeakSet) {
+        throw new TypeError("cannot compare WeakSet instances");
+      }
+      if (a instanceof WeakRef) {
+        return compare(a.deref(), (b as WeakRef<WeakKey>).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(isPrimitive);
+        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;
+      }
+
+      let keys: Iterable<string | symbol>;
+
+      if (isBasicObjectOrArray(a)) {
+        // fast path
+        keys = ownKeys({ ...a, ...b });
+      } else if (stringComparablePrototypes.has(Object.getPrototypeOf(a))) {
+        // medium path
+        return String(a) === String(b);
+      } else {
+        // slow path
+        keys = getKeysDeep(a).union(getKeysDeep(b));
+      }
+
+      for (const key of keys) {
+        type Key = keyof typeof a;
+        if (!compare(a[key as Key], 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;
+  })(a, b);
+}

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

@@ -0,0 +1,65 @@
+// 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.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 { 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.
+ *
+ * Note: When comparing `Blob` objects, you should first convert them to
+ * `Uint8Array` using the `Blob.bytes()` method and then compare their
+ * contents.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals("world", "world"); // Doesn't throw
+ * assertEquals("hello", "world"); // Throws
+ * ```
+ * @example Compare `Blob` objects
+ * ```ts ignore
+ * import { assertEquals } from "@std/assert";
+ *
+ * const bytes1 = await new Blob(["foo"]).bytes();
+ * const bytes2 = await new Blob(["foo"]).bytes();
+ *
+ * assertEquals(bytes1, bytes2);
+ * ```
+ *
+ * @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);
+}