@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/@ark/schema/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@ark/schema",
+  "version": "0.56.0",
+  "license": "MIT",
+  "author": {
+    "name": "David Blass",
+    "email": "david@arktype.io",
+    "url": "https://arktype.io"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arktypeio/arktype.git",
+    "directory": "ark/schema"
+  },
+  "type": "module",
+  "main": "./out/index.js",
+  "types": "./out/index.d.ts",
+  "exports": {
+    ".": {
+      "ark-ts": "./index.ts",
+      "default": "./out/index.js"
+    },
+    "./config": {
+      "ark-ts": "./config.ts",
+      "default": "./out/config.js"
+    },
+    "./internal/*.ts": {
+      "ark-ts": "./*.ts",
+      "default": "./out/*.js"
+    },
+    "./internal/*.js": {
+      "ark-ts": "./*.ts",
+      "default": "./out/*.js"
+    }
+  },
+  "files": [
+    "out"
+  ],
+  "dependencies": {
+    "@ark/util": "0.56.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "ts ../repo/build.ts",
+    "bench": "ts ./__tests__/comparison.bench.ts",
+    "test": "ts ../repo/testPackage.ts",
+    "tnt": "ts ../repo/testPackage.ts --skipTypes"
+  }
+}

package/node_modules/@ark/util/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 ArkType
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/@ark/util/out/arrays.d.ts

@@ -0,0 +1,166 @@
+import type { GuardablePredicate } from "./functions.ts";
+import type { anyOrNever, conform } from "./generics.ts";
+import type { isDisjoint } from "./intersections.ts";
+import type { parseNonNegativeInteger } from "./numbers.ts";
+type DuplicateData<val = unknown> = {
+    element: val;
+    indices: number[];
+};
+/**
+ * Extracts duplicated elements and their indices from an array, returning them.
+ *
+ * Note that given `a === b && b === c`, then `c === a` must be `true` for this to give accurate results.
+ *
+ * @param arr The array to extract duplicate elements from.
+ */ export declare const getDuplicatesOf: <const arr extends array>(arr: arr, opts?: ComparisonOptions<arr[number]>) => DuplicateData<arr[number]>[];
+export type pathToString<segments extends string[], delimiter extends string = "/"> = segments extends [] ? "/" : join<segments, delimiter>;
+export declare const join: <segments extends array<string>, delimiter extends string>(segments: segments, delimiter: delimiter) => join<segments, delimiter>;
+export type join<segments extends array<string>, delimiter extends string, result extends string = ""> = segments extends (readonly [infer head extends string, ...infer tail extends string[]]) ? join<tail, delimiter, result extends "" ? head : `${result}${delimiter}${head}`> : result;
+export declare const getPath: (root: unknown, path: string[]) => unknown;
+export declare const intersectUniqueLists: <item>(l: readonly item[], r: readonly item[]) => item[];
+export type filter<t extends array, constraint, result extends unknown[] = []> = t extends readonly [infer head, ...infer tail] ? filter<tail, constraint, head extends constraint ? [...result, head] : result> : result;
+export type array<t = unknown> = readonly t[];
+export declare namespace array {
+    type multiply<t extends array, count extends number> = _multiply<t, [
+    ], count, [
+    ]>;
+    type _multiply<base extends array, result extends array, count extends number, i extends 1[]> = i["length"] extends count ? result : _multiply<base, [...result, ...base], count, [...i, 1]>;
+    type repeat<element, count extends number> = buildFromSegments<element, [
+    ], exponentials.max<count>, count>;
+    type buildFromSegments<element, result extends 1[], segments extends 1[][], count extends number, next extends 1[] = [...result, ...segments[0]]> = next["length"] extends count ? {
+        [i in keyof next]: element;
+    } : `${count}` extends keyof next ? buildFromSegments<element, result, nextSegments<segments>, count> : buildFromSegments<element, next, nextSegments<segments>, count>;
+    type nextSegments<segments extends 1[][]> = segments extends [unknown, ...infer nextSegments extends 1[][]] ? nextSegments : never;
+    type minLength<element, minLength extends number> = readonly [
+        ...multiply<[element], minLength>,
+        ...element[]
+    ];
+}
+export type listable<t> = t | readonly t[];
+export type flattenListable<t> = t extends array<infer element> ? element : t;
+export type longerThan<t extends array, n extends number> = `${n}` extends keyof t ? true : false;
+export type CollapsingList<t = unknown> = readonly [] | t | readonly [t, t, ...t[]];
+export type headOf<t extends array> = t[0];
+export type tailOf<t extends array> = t extends readonly [unknown, ...infer tail] ? tail : never;
+export type lastIndexOf<t extends array> = tailOf<t>["length"];
+export type lastOf<t extends array> = t[lastIndexOf<t>];
+export type initOf<t extends array> = t extends readonly [...infer init, unknown] ? init : never;
+export type numericStringKeyOf<t extends array> = Extract<keyof t, `${number}`>;
+export type arrayIndexOf<a extends array> = keyof a extends infer k ? parseNonNegativeInteger<k & string> : never;
+export type liftArray<t> = t extends array ? [
+    t
+] extends [anyOrNever] ? t[] : t : t[];
+export declare const liftArray: <t>(data: t) => liftArray<t>;
+/**
+ * Splits an array into two arrays based on the result of a predicate
+ *
+ * @param predicate - The guard function used to determine which items to include.
+ * @returns A tuple containing two arrays:
+ * 				- the first includes items for which `predicate` returns true
+ * 				- the second includes items for which `predicate` returns false
+ *
+ * @example
+ * const list = [1, "2", "3", 4, 5];
+ * const [numbers, strings] = spliterate(list, (x) => typeof x === "number");
+ * // Type: number[]
+ * // Output: [1, 4, 5]
+ * console.log(evens);
+ * // Type: string[]
+ * // Output: ["2", "3"]
+ * console.log(odds);
+ */
+export declare const spliterate: <item, included extends item>(arr: readonly item[], predicate: GuardablePredicate<item, included>) => [included: included[], excluded: [item] extends [included] ? item[] : Exclude<item, included>[]];
+export declare const ReadonlyArray: new <T>(...args: ConstructorParameters<typeof Array<T>>) => ReadonlyArray<T>;
+export declare const includes: <a extends array>(array: a, element: unknown) => element is a[number];
+export declare const range: (length: number, offset?: number) => number[];
+export type AppendOptions = {
+    /** If true, adds the element to the beginning of the array instead of the end */
+    prepend?: boolean;
+};
+/**
+ * Adds a value or array to an array, returning the concatenated result
+ */
+export declare const append: <to extends unknown[] | undefined, value extends appendableValue<to>>(to: to, value: value, opts?: AppendOptions) => to & {};
+export type appendableValue<to extends array | undefined> = to extends array<infer element> ? element extends array ? array<element> : listable<element> : never;
+/**
+ * Concatenates an element or list with a readonly list
+ */
+export declare const conflatenate: <element>(to: readonly element[] | undefined | null, elementOrList: appendableValue<readonly element[]> | undefined | null) => readonly element[];
+/**
+ * Concatenates a variadic list of elements or lists with a readonly list
+ */
+export declare const conflatenateAll: <element>(...elementsOrLists: (listable<element> | undefined | null)[]) => readonly element[];
+export interface ComparisonOptions<t = unknown> {
+    isEqual?: (l: t, r: t) => boolean;
+}
+/**
+ * Appends a value or concatenates an array to an array if it is not already included, returning the array
+ */
+export declare const appendUnique: <to extends unknown[]>(to: to | undefined, value: NoInfer<Readonly<to> | to[number]>, opts?: ComparisonOptions<to[number]>) => to;
+export type groupableKeyOf<o> = keyof o extends infer k ? k extends keyof o ? o[k] extends PropertyKey ? k : never : never : never;
+export type groupBy<element, discriminant extends groupableKeyOf<element>> = {
+    [k in element[discriminant] & PropertyKey]?: (element extends unknown ? isDisjoint<element[discriminant], k> extends true ? never : element : never)[];
+} & unknown;
+export declare const groupBy: <element, discriminant extends groupableKeyOf<element>>(array: readonly element[], discriminant: discriminant) => groupBy<element, discriminant>;
+export declare const arrayEquals: <element>(l: array<element>, r: array<element>, opts?: ComparisonOptions<element>) => boolean;
+export type validateExhaustiveKeys<keys extends readonly PropertyKey[], expectedKey extends PropertyKey> = keys extends readonly [infer head, ...infer tail extends PropertyKey[]] ? readonly [
+    conform<head, expectedKey>,
+    ...validateExhaustiveKeys<tail, Exclude<expectedKey, head>>
+] : [expectedKey] extends [never] ? [] : [expectedKey];
+export type applyElementLabels<t extends readonly unknown[], labels extends readonly unknown[]> = labels extends [unknown, ...infer labelsTail] ? t extends readonly [infer head, ...infer tail] ? readonly [
+    ...labelElement<head, labels>,
+    ...applyElementLabels<tail, labelsTail>
+] : applyOptionalElementLabels<Required<t>, labels> : t;
+type applyOptionalElementLabels<t extends readonly unknown[], labels extends readonly unknown[]> = labels extends readonly [unknown, ...infer labelsTail] ? t extends readonly [infer head, ...infer tail] ? [
+    ...labelOptionalElement<head, labels>,
+    ...applyOptionalElementLabels<tail, labelsTail>
+] : applyRestElementLabels<t, labels> : t;
+type applyRestElementLabels<t extends readonly unknown[], labels extends readonly unknown[]> = t extends readonly [] ? [] : labels extends readonly [unknown, ...infer tail] ? [
+    ...labelOptionalElement<t[0], labels>,
+    ...applyRestElementLabels<t, tail>
+] : t;
+type labelElement<element, labels extends readonly unknown[]> = labels extends readonly [unknown] ? {
+    [K in keyof labels]: element;
+} : labels extends readonly [...infer head, unknown] ? labelElement<element, head> : [_: element];
+type labelOptionalElement<element, label extends readonly unknown[]> = label extends readonly [unknown] ? {
+    [K in keyof label]?: element;
+} : label extends readonly [...infer head, unknown] ? labelOptionalElement<element, head> : [_?: element];
+export type setIndex<arr extends readonly unknown[], i extends number, to extends arr[number]> = arr extends arr[number][] ? _setIndex<arr, i, to, []> : Readonly<_setIndex<arr, i, to, []>>;
+type _setIndex<arr extends readonly unknown[], i extends number, to extends arr[number], result extends arr[number][]> = arr extends readonly [infer head, ...infer tail] ? _setIndex<tail, i, to, [...result, result["length"] extends i ? to : head]> : result;
+type zero = [];
+type one = [1];
+type two = [1, 1];
+type three = [...two, ...two];
+type four = [...three, ...three];
+type five = [...four, ...four];
+type six = [...five, ...five];
+type seven = [...six, ...six];
+type eight = [...seven, ...seven];
+type nine = [...eight, ...eight];
+type ten = [...nine, ...nine];
+type eleven = [...ten, ...ten];
+type twelve = [...eleven, ...eleven];
+type thirteen = [...twelve, ...twelve];
+type fourteen = [...thirteen, ...thirteen];
+type exponentials = [
+    fourteen,
+    thirteen,
+    twelve,
+    eleven,
+    ten,
+    nine,
+    eight,
+    seven,
+    six,
+    five,
+    four,
+    three,
+    two,
+    one,
+    zero
+];
+declare namespace exponentials {
+    type max<n extends number> = _max<n, exponentials>;
+    type _max<n extends number, filtered extends unknown[]> = `${n}` extends keyof filtered[0] ? _max<n, tailOf<filtered>> : filtered;
+}
+export {};

package/node_modules/@ark/util/out/arrays.js

@@ -0,0 +1,147 @@
+/**
+ * Extracts duplicated elements and their indices from an array, returning them.
+ *
+ * Note that given `a === b && b === c`, then `c === a` must be `true` for this to give accurate results.
+ *
+ * @param arr The array to extract duplicate elements from.
+ */ export const getDuplicatesOf = (arr, opts) => {
+    const isEqual = opts?.isEqual ?? ((l, r) => l === r);
+    const elementFirstSeenIndx = new Map();
+    const duplicates = [];
+    for (const [indx, element] of arr.entries()) {
+        const duplicatesIndx = duplicates.findIndex(duplicate => isEqual(duplicate.element, element));
+        if (duplicatesIndx !== -1) {
+            // This is at least the third occurrence of an item equal to `element`,
+            // so add this index to the list of indices where the element is duplicated.
+            duplicates[duplicatesIndx].indices.push(indx);
+            continue;
+        }
+        // At this point, we know this is either the first
+        // or second occurrence of an item equal to `element`...
+        let found = false;
+        for (const [existingElement, firstSeenIndx] of elementFirstSeenIndx) {
+            if (isEqual(element, existingElement)) {
+                // This is the second occurrence of an item equal to `element`,
+                // so store it as a duplicate.
+                found = true;
+                duplicates.push({
+                    element: existingElement,
+                    indices: [firstSeenIndx, indx]
+                });
+            }
+        }
+        if (!found) {
+            // We haven't seen this element before,
+            // so just store the index it was first seen
+            elementFirstSeenIndx.set(element, indx);
+        }
+    }
+    return duplicates;
+};
+export const join = (segments, delimiter) => segments.join(delimiter);
+export const getPath = (root, path) => {
+    let result = root;
+    for (const segment of path) {
+        if (typeof result !== "object" || result === null)
+            return undefined;
+        result = result[segment];
+    }
+    return result;
+};
+export const intersectUniqueLists = (l, r) => {
+    const intersection = [...l];
+    for (const item of r)
+        if (!l.includes(item))
+            intersection.push(item);
+    return intersection;
+};
+export const liftArray = (data) => (Array.isArray(data) ? data : [data]);
+/**
+ * Splits an array into two arrays based on the result of a predicate
+ *
+ * @param predicate - The guard function used to determine which items to include.
+ * @returns A tuple containing two arrays:
+ * 				- the first includes items for which `predicate` returns true
+ * 				- the second includes items for which `predicate` returns false
+ *
+ * @example
+ * const list = [1, "2", "3", 4, 5];
+ * const [numbers, strings] = spliterate(list, (x) => typeof x === "number");
+ * // Type: number[]
+ * // Output: [1, 4, 5]
+ * console.log(evens);
+ * // Type: string[]
+ * // Output: ["2", "3"]
+ * console.log(odds);
+ */
+export const spliterate = (arr, predicate) => {
+    const result = [[], []];
+    for (const item of arr) {
+        if (predicate(item))
+            result[0].push(item);
+        else
+            result[1].push(item);
+    }
+    return result;
+};
+export const ReadonlyArray = Array;
+export const includes = (array, element) => array.includes(element);
+export const range = (length, offset = 0) => [...new Array(length)].map((_, i) => i + offset);
+/**
+ * Adds a value or array to an array, returning the concatenated result
+ */
+export const append = (to, value, opts) => {
+    if (to === undefined) {
+        return (value === undefined ? []
+            : Array.isArray(value) ? value
+                : [value]);
+    }
+    if (opts?.prepend) {
+        if (Array.isArray(value))
+            to.unshift(...value);
+        else
+            to.unshift(value);
+    }
+    else {
+        if (Array.isArray(value))
+            to.push(...value);
+        else
+            to.push(value);
+    }
+    return to;
+};
+/**
+ * Concatenates an element or list with a readonly list
+ */
+export const conflatenate = (to, elementOrList) => {
+    if (elementOrList === undefined || elementOrList === null)
+        return to ?? [];
+    if (to === undefined || to === null)
+        return liftArray(elementOrList);
+    return to.concat(elementOrList);
+};
+/**
+ * Concatenates a variadic list of elements or lists with a readonly list
+ */
+export const conflatenateAll = (...elementsOrLists) => elementsOrLists.reduce(conflatenate, []);
+/**
+ * Appends a value or concatenates an array to an array if it is not already included, returning the array
+ */
+export const appendUnique = (to, value, opts) => {
+    if (to === undefined)
+        return Array.isArray(value) ? value : [value];
+    const isEqual = opts?.isEqual ?? ((l, r) => l === r);
+    for (const v of liftArray(value))
+        if (!to.some(existing => isEqual(existing, v)))
+            to.push(v);
+    return to;
+};
+export const groupBy = (array, discriminant) => array.reduce((result, item) => {
+    const key = item[discriminant];
+    result[key] = append(result[key], item);
+    return result;
+}, {});
+export const arrayEquals = (l, r, opts) => l.length === r.length &&
+    l.every(opts?.isEqual ?
+        (lItem, i) => opts.isEqual(lItem, r[i])
+        : (lItem, i) => lItem === r[i]);

package/node_modules/@ark/util/out/clone.d.ts

@@ -0,0 +1,4 @@
+/** Shallowly copy the properties of the object. */
+export declare const shallowClone: <input extends object>(input: input) => input;
+/** Deeply copy the properties of the a non-subclassed Object, Array or Date.*/
+export declare const deepClone: <input extends object>(input: input) => input;

package/node_modules/@ark/util/out/clone.js

@@ -0,0 +1,33 @@
+import { getBuiltinNameOfConstructor } from "./objectKinds.js";
+/** Shallowly copy the properties of the object. */
+export const shallowClone = input => _clone(input, null);
+/** Deeply copy the properties of the a non-subclassed Object, Array or Date.*/
+export const deepClone = (input) => _clone(input, new Map());
+const _clone = (input, seen) => {
+    if (typeof input !== "object" || input === null)
+        return input;
+    if (seen?.has(input))
+        return seen.get(input);
+    const builtinConstructorName = getBuiltinNameOfConstructor(input.constructor);
+    if (builtinConstructorName === "Date")
+        return new Date(input.getTime());
+    // we don't try and clone other prototypes here since this we can't guarantee arrow functions attached to the object
+    // are rebound in case they reference `this` (see https://x.com/colinhacks/status/1818422039210049985)
+    if (builtinConstructorName && builtinConstructorName !== "Array")
+        return input;
+    const cloned = Array.isArray(input) ?
+        input.slice()
+        : Object.create(Object.getPrototypeOf(input));
+    const propertyDescriptors = Object.getOwnPropertyDescriptors(input);
+    if (seen) {
+        seen.set(input, cloned);
+        for (const k in propertyDescriptors) {
+            const desc = propertyDescriptors[k];
+            if ("get" in desc || "set" in desc)
+                continue;
+            desc.value = _clone(desc.value, seen);
+        }
+    }
+    Object.defineProperties(cloned, propertyDescriptors);
+    return cloned;
+};

package/node_modules/@ark/util/out/describe.d.ts

@@ -0,0 +1,25 @@
+import type { array } from "./arrays.ts";
+import type { describeDomainOf, domainOf, inferDomain } from "./domain.ts";
+import type { anyOrNever, satisfy, Stringifiable } from "./generics.ts";
+import type { describeObject } from "./objectKinds.ts";
+import type { stringifyUnion } from "./unionToTuple.ts";
+export type DescribeOptions = {
+    includeArticles?: boolean;
+    branchDelimiter?: string;
+};
+export type typeToString<t, opts extends DescribeOptions = {}> = stringifyUnion<[
+    t
+] extends [anyOrNever] ? unknown extends t ? "any" : "never" : unknown extends t ? "unknown" : boolean extends t ? "boolean" | ([t] extends [boolean] ? never : typeToString<Exclude<t, boolean>, opts>) : t extends array ? arrayTypeToString<t, opts> : t extends object ? describeObject<t, opts> : t extends Stringifiable ? stringifiableToString<t, opts> : describeDomainOf<t, opts>, opts["branchDelimiter"] extends string ? opts["branchDelimiter"] : describeDefaults["branchDelimiter"]>;
+type stringifiableToString<t extends Stringifiable, opts extends DescribeOptions> = inferDomain<domainOf<t>> extends t ? describeDomainOf<t, opts> : `${t}`;
+export type describe<t> = typeToString<t, {
+    includeArticles: true;
+    branchDelimiter: " or ";
+}>;
+type arrayTypeToString<t extends array, opts extends DescribeOptions> = typeToString<t[number], opts> extends infer element extends string ? opts["includeArticles"] extends true ? describeArrayOf<element> : includesDelimiter<element, opts> extends true ? `(${element})[]` : `${element}[]` : never;
+type describeArrayOf<element extends string> = element extends "unknown" ? "an array" : `an array of ${element}`;
+type includesDelimiter<s extends string, opts extends DescribeOptions> = s extends (`${string}${opts["branchDelimiter"] extends string ? opts["branchDelimiter"] : describeDefaults["branchDelimiter"]}${string}`) ? true : false;
+export type describeDefaults = satisfy<Required<DescribeOptions>, {
+    includeArticles: false;
+    branchDelimiter: " | ";
+}>;
+export {};

package/node_modules/@ark/util/out/describe.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@ark/util/out/domain.d.ts

@@ -0,0 +1,48 @@
+import type { describeDefaults, DescribeOptions } from "./describe.ts";
+import type { show } from "./generics.ts";
+import type { stringifyUnion } from "./unionToTuple.ts";
+export type JsTypeOf = "object" | "function" | "number" | "bigint" | "boolean" | "string" | "symbol" | "undefined" | "null";
+export declare const hasDomain: <data, domain extends Domain>(data: data, kind: domain) => data is data & inferDomain<domain>;
+type TypesByDomain = {
+    bigint: bigint;
+    boolean: boolean;
+    number: number;
+    object: object;
+    string: string;
+    symbol: symbol;
+    undefined: undefined;
+    null: null;
+};
+export type inferDomain<kind extends Domain> = Domain extends kind ? unknown : TypesByDomain[kind];
+export type Domain = show<keyof TypesByDomain>;
+export type NullishDomain = "undefined" | "null";
+export type NonNullishDomain = Exclude<Domain, NullishDomain>;
+export type PrimitiveDomain = Exclude<Domain, "object">;
+export type Primitive = inferDomain<PrimitiveDomain>;
+export type domainOf<data> = unknown extends data ? Domain : data extends object ? "object" : data extends string ? "string" : data extends number ? "number" : data extends boolean ? "boolean" : data extends undefined ? "undefined" : data extends null ? "null" : data extends bigint ? "bigint" : data extends symbol ? "symbol" : never;
+export declare const domainOf: <data>(data: data) => domainOf<data>;
+/** Each domain's completion for the phrase "must be _____" */
+export declare const domainDescriptions: {
+    readonly boolean: "boolean";
+    readonly null: "null";
+    readonly undefined: "undefined";
+    readonly bigint: "a bigint";
+    readonly number: "a number";
+    readonly object: "an object";
+    readonly string: "a string";
+    readonly symbol: "a symbol";
+};
+export declare const jsTypeOfDescriptions: {
+    readonly function: "a function";
+    readonly boolean: "boolean";
+    readonly null: "null";
+    readonly undefined: "undefined";
+    readonly bigint: "a bigint";
+    readonly number: "a number";
+    readonly object: "an object";
+    readonly string: "a string";
+    readonly symbol: "a symbol";
+};
+export type domainDescriptions = typeof domainDescriptions;
+export type describeDomainOf<t, opts extends DescribeOptions = {}> = stringifyUnion<opts["includeArticles"] extends true ? domainDescriptions[domainOf<t>] : domainOf<t>, opts["branchDelimiter"] extends string ? opts["branchDelimiter"] : describeDefaults["branchDelimiter"]>;
+export {};

package/node_modules/@ark/util/out/domain.js

@@ -0,0 +1,25 @@
+export const hasDomain = (data, kind) => domainOf(data) === kind;
+export const domainOf = (data) => {
+    const builtinType = typeof data;
+    return (builtinType === "object" ?
+        data === null ?
+            "null"
+            : "object"
+        : builtinType === "function" ? "object"
+            : builtinType);
+};
+/** Each domain's completion for the phrase "must be _____" */
+export const domainDescriptions = {
+    boolean: "boolean",
+    null: "null",
+    undefined: "undefined",
+    bigint: "a bigint",
+    number: "a number",
+    object: "an object",
+    string: "a string",
+    symbol: "a symbol"
+};
+export const jsTypeOfDescriptions = {
+    ...domainDescriptions,
+    function: "a function"
+};

package/node_modules/@ark/util/out/errors.d.ts

@@ -0,0 +1,29 @@
+import type { brand } from "./generics.ts";
+import type { CastableBase } from "./records.ts";
+export declare class InternalArktypeError extends Error {
+}
+export declare const throwInternalError: (message: string) => never;
+export declare const throwError: (message: string, ctor?: new (message: string) => Error) => never;
+export declare class ParseError extends Error {
+    readonly name = "ParseError";
+}
+export declare const throwParseError: (message: string) => never;
+/**
+ *  TypeScript won't suggest strings beginning with a space as properties.
+ *  Useful for symbol-like string properties.
+ */
+export declare const noSuggest: <s extends string>(s: s) => noSuggest<s>;
+/**
+ *  TypeScript won't suggest strings beginning with a space as properties.
+ *  Useful for symbol-like string properties.
+ */
+export type noSuggest<s extends string = string> = ` ${s}`;
+/** Unrendered character (U+200B) used to mark a string type */
+export declare const ZeroWidthSpace = "\u200B";
+/** Unrendered character (U+200B) used to mark a string type */
+export type ZeroWidthSpace = typeof ZeroWidthSpace;
+export type ErrorMessage<message extends string = string> = `${message}${ZeroWidthSpace}`;
+export interface ErrorType<ctx extends {} = {}> extends CastableBase<ctx> {
+    [brand]: "ErrorType";
+}
+export type Completion<text extends string = string> = `${text}${ZeroWidthSpace}${ZeroWidthSpace}`;

package/node_modules/@ark/util/out/errors.js

@@ -0,0 +1,17 @@
+export class InternalArktypeError extends Error {
+}
+export const throwInternalError = message => throwError(message, InternalArktypeError);
+export const throwError = (message, ctor = Error) => {
+    throw new ctor(message);
+};
+export class ParseError extends Error {
+    name = "ParseError";
+}
+export const throwParseError = message => throwError(message, ParseError);
+/**
+ *  TypeScript won't suggest strings beginning with a space as properties.
+ *  Useful for symbol-like string properties.
+ */
+export const noSuggest = (s) => ` ${s}`;
+/** Unrendered character (U+200B) used to mark a string type */
+export const ZeroWidthSpace = "\u{200B}";

package/node_modules/@ark/util/out/flatMorph.d.ts

@@ -0,0 +1,41 @@
+import { type array, type listable } from "./arrays.ts";
+import type { conform, show } from "./generics.ts";
+import type { Key } from "./keys.ts";
+import type { Entry, entryOf } from "./records.ts";
+import type { intersectUnion } from "./unionToTuple.ts";
+type objectFromListableEntries<transformed extends readonly GroupableEntry[]> = show<intersectUnion<fromGroupableEntries<transformed>>>;
+type fromGroupableEntries<entries extends readonly GroupableEntry[]> = {
+    [entry in entries[number] as entry extends GroupedEntry ? entry[0]["group"] : conform<entry[0], PropertyKey>]: entry extends GroupedEntry ? entry[1][] : entry[1];
+};
+type arrayFromListableEntries<transformed extends Entry> = Entry<number, never> extends transformed ? transformed[1][] : _arrayFromListableEntries<transformed, []>;
+type _arrayFromListableEntries<transformed extends Entry, result extends unknown[]> = [
+    transformed
+] extends [never] ? result : Extract<transformed, Entry<result["length"]>> extends (infer next extends Entry) ? Exclude<transformed, next> extends infer remaining extends Entry ? [
+    transformed
+] extends [remaining] ? [
+    ...result,
+    ...transformed[1][]
+] : _arrayFromListableEntries<remaining, [...result, next[1]]> : never : [...result, ...transformed[1][]];
+type extractEntrySets<e extends listable<GroupableEntry>> = e extends readonly GroupableEntry[] ? e : [e];
+type extractEntries<e extends listable<Entry>> = e extends readonly Entry[] ? e[number] : e;
+type entryArgsWithIndex<o> = {
+    [k in keyof o]-?: [k: k, v: Exclude<o[k], undefined>, i: number];
+}[keyof o];
+type numericArrayEntry<a extends array> = number extends a["length"] ? [number, a[number]] : {
+    [i in keyof a]: i extends `${infer n extends number}` ? [n, a[i]] : never;
+}[number];
+export type GroupedEntry = readonly [key: {
+    group: Key;
+}, value: unknown];
+export type GroupableEntry = Entry<Key> | Entry<number> | GroupedEntry;
+export type ListableEntry = listable<GroupableEntry>;
+export type fromMappedEntries<transformed extends ListableEntry> = [
+    transformed
+] extends [listable<Entry<number>>] ? arrayFromListableEntries<extractEntries<transformed>> : objectFromListableEntries<extractEntrySets<transformed>>;
+export type FlatMorph = {
+    <const o extends array, transformed extends ListableEntry>(o: o, flatMapEntry: (...args: numericArrayEntry<o>) => transformed): fromMappedEntries<transformed>;
+    <const o extends object, transformed extends ListableEntry>(o: o, flatMapEntry: (...args: entryOf<o>) => transformed): fromMappedEntries<transformed>;
+    <const o extends object, transformed extends ListableEntry>(o: o, flatMapEntry: (...args: entryArgsWithIndex<o>) => transformed): fromMappedEntries<transformed>;
+};
+export declare const flatMorph: FlatMorph;
+export {};

package/node_modules/@ark/util/out/flatMorph.js

@@ -0,0 +1,24 @@
+import { append } from "./arrays.js";
+export const flatMorph = (o, flatMapEntry) => {
+    const result = {};
+    const inputIsArray = Array.isArray(o);
+    let outputShouldBeArray = false;
+    for (const [i, entry] of Object.entries(o).entries()) {
+        const mapped = inputIsArray ? flatMapEntry(i, entry[1]) : flatMapEntry(...entry, i);
+        outputShouldBeArray ||= typeof mapped[0] === "number";
+        const flattenedEntries = Array.isArray(mapped[0]) || mapped.length === 0 ?
+            // if we have an empty array (for filtering) or an array with
+            // another array as its first element, treat it as a list
+            mapped
+            // otherwise, it should be a single entry, so nest it in a tuple
+            // so it doesn't get spread when the result is flattened
+            : [mapped];
+        for (const [k, v] of flattenedEntries) {
+            if (typeof k === "object")
+                result[k.group] = append(result[k.group], v);
+            else
+                result[k] = v;
+        }
+    }
+    return outputShouldBeArray ? Object.values(result) : result;
+};