@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/arktype/out/parser/reduce/shared.d.ts

@@ -0,0 +1,39 @@
+import type { LimitLiteral } from "../../attributes.ts";
+export type StringifiablePrefixOperator = "keyof";
+export declare const minComparators: {
+    readonly ">": true;
+    readonly ">=": true;
+};
+export type MinComparator = keyof typeof minComparators;
+export declare const maxComparators: {
+    readonly "<": true;
+    readonly "<=": true;
+};
+export type MaxComparator = keyof typeof maxComparators;
+export declare const comparators: {
+    ">": boolean;
+    ">=": boolean;
+    "<": boolean;
+    "<=": boolean;
+    "==": boolean;
+};
+export type Comparator = keyof typeof comparators;
+export declare const invertedComparators: InvertedComparators;
+export type InvertedComparators = {
+    "<": ">";
+    ">": "<";
+    "<=": ">=";
+    ">=": "<=";
+    "==": "==";
+};
+export type BranchOperator = "&" | "|" | "|>";
+export type OpenLeftBound = {
+    limit: LimitLiteral;
+    comparator: MinComparator;
+};
+export declare const writeOpenRangeMessage: <min extends LimitLiteral, comparator extends MinComparator>(min: min, comparator: comparator) => writeOpenRangeMessage<min, comparator>;
+export type writeOpenRangeMessage<min extends LimitLiteral, comparator extends MinComparator> = `Left bounds are only valid when paired with right bounds (try ...${comparator}${min})`;
+export type writeUnpairableComparatorMessage<comparator extends Comparator> = `Left-bounded expressions must specify their limits using < or <= (was ${comparator})`;
+export declare const writeUnpairableComparatorMessage: <comparator extends Comparator>(comparator: comparator) => writeUnpairableComparatorMessage<comparator>;
+export declare const writeMultipleLeftBoundsMessage: <openLimit extends LimitLiteral, openComparator extends MinComparator, limit extends LimitLiteral, comparator extends MinComparator>(openLimit: openLimit, openComparator: openComparator, limit: limit, comparator: comparator) => writeMultipleLeftBoundsMessage<openLimit, openComparator, limit, comparator>;
+export type writeMultipleLeftBoundsMessage<openLimit extends LimitLiteral, openComparator extends MinComparator, limit extends LimitLiteral, comparator extends MinComparator> = `An expression may have at most one left bound (parsed ${openLimit}${InvertedComparators[openComparator]}, ${limit}${InvertedComparators[comparator]})`;

package/node_modules/arktype/out/parser/reduce/shared.js

@@ -0,0 +1,25 @@
+export const minComparators = {
+    ">": true,
+    ">=": true
+};
+export const maxComparators = {
+    "<": true,
+    "<=": true
+};
+export const comparators = {
+    ">": true,
+    ">=": true,
+    "<": true,
+    "<=": true,
+    "==": true
+};
+export const invertedComparators = {
+    "<": ">",
+    ">": "<",
+    "<=": ">=",
+    ">=": "<=",
+    "==": "=="
+};
+export const writeOpenRangeMessage = (min, comparator) => `Left bounds are only valid when paired with right bounds (try ...${comparator}${min})`;
+export const writeUnpairableComparatorMessage = (comparator) => `Left-bounded expressions must specify their limits using < or <= (was ${comparator})`;
+export const writeMultipleLeftBoundsMessage = (openLimit, openComparator, limit, comparator) => `An expression may have at most one left bound (parsed ${openLimit}${invertedComparators[openComparator]}, ${limit}${invertedComparators[comparator]})`;

package/node_modules/arktype/out/parser/reduce/static.d.ts

@@ -0,0 +1,186 @@
+import type { Completion, ErrorMessage, defined, writeUnclosedGroupMessage, writeUnmatchedGroupCloseMessage } from "@ark/util";
+import type { LimitLiteral } from "../../attributes.ts";
+import type { FinalizingLookahead } from "../shift/tokens.ts";
+import type { BranchOperator, Comparator, InvertedComparators, MaxComparator, MinComparator, OpenLeftBound, StringifiablePrefixOperator, writeMultipleLeftBoundsMessage, writeOpenRangeMessage, writeUnpairableComparatorMessage } from "./shared.ts";
+export type StaticState = {
+    root: unknown;
+    branches: BranchState;
+    groups: BranchState[];
+    finalizer: FinalizingLookahead | ErrorMessage | undefined;
+    scanned: string;
+    unscanned: string;
+};
+type BranchState = {
+    prefixes: StringifiablePrefixOperator[];
+    leftBound: OpenLeftBound | undefined;
+    intersection: unknown;
+    pipe: unknown;
+    union: unknown;
+};
+export type AutocompletePrefix = `${StringifiablePrefixOperator} `;
+export declare namespace s {
+    type initialize<def extends string> = from<{
+        root: undefined;
+        branches: initialBranches;
+        groups: [];
+        finalizer: undefined;
+        scanned: "";
+        unscanned: def;
+    }>;
+    type error<message extends string> = from<{
+        root: ErrorMessage<message>;
+        branches: initialBranches;
+        groups: [];
+        finalizer: ErrorMessage<message>;
+        scanned: "";
+        unscanned: "";
+    }>;
+    type completion<text extends string> = from<{
+        root: Completion<text>;
+        branches: initialBranches;
+        groups: [];
+        finalizer: Completion<text>;
+        scanned: "";
+        unscanned: "";
+    }>;
+    type initialBranches = branchesFrom<{
+        prefixes: [];
+        leftBound: undefined;
+        intersection: undefined;
+        pipe: undefined;
+        union: undefined;
+    }>;
+    type updateScanned<previousScanned extends string, previousUnscanned extends string, updatedUnscanned extends string> = previousUnscanned extends `${infer justScanned}${updatedUnscanned}` ? `${previousScanned}${justScanned}` : previousScanned;
+    type setRoot<s extends StaticState, root, unscanned extends string = s["unscanned"]> = from<{
+        root: root;
+        branches: s["branches"];
+        groups: s["groups"];
+        finalizer: s["finalizer"];
+        scanned: updateScanned<s["scanned"], s["unscanned"], unscanned>;
+        unscanned: unscanned;
+    }>;
+    type addPrefix<s extends StaticState, prefix extends StringifiablePrefixOperator, unscanned extends string = s["unscanned"]> = from<{
+        root: s["root"];
+        branches: {
+            prefixes: [...s["branches"]["prefixes"], prefix];
+            leftBound: s["branches"]["leftBound"];
+            intersection: s["branches"]["intersection"];
+            pipe: s["branches"]["pipe"];
+            union: s["branches"]["union"];
+        };
+        groups: s["groups"];
+        finalizer: s["finalizer"];
+        scanned: updateScanned<s["scanned"], s["unscanned"], unscanned>;
+        unscanned: unscanned;
+    }>;
+    type reduceBranch<s extends StaticState, token extends BranchOperator, unscanned extends string> = s["branches"]["leftBound"] extends {} ? openRangeError<s["branches"]["leftBound"]> : from<{
+        root: undefined;
+        branches: {
+            prefixes: [];
+            leftBound: undefined;
+            intersection: token extends "&" ? mergeToIntersection<s> : undefined;
+            union: token extends "|" ? mergeToUnion<s> : token extends "|>" ? undefined : s["branches"]["union"];
+            pipe: token extends "|>" ? mergeToPipe<s> : s["branches"]["pipe"];
+        };
+        groups: s["groups"];
+        finalizer: s["finalizer"];
+        scanned: updateScanned<s["scanned"], s["unscanned"], unscanned>;
+        unscanned: unscanned;
+    }>;
+    type reduceLeftBound<s extends StaticState, limit extends LimitLiteral, comparator extends Comparator, unscanned extends string> = comparator extends "<" | "<=" ? s["branches"]["leftBound"] extends {} ? s.error<writeMultipleLeftBoundsMessage<s["branches"]["leftBound"]["limit"], s["branches"]["leftBound"]["comparator"], limit, InvertedComparators[comparator]>> : from<{
+        root: undefined;
+        branches: {
+            prefixes: s["branches"]["prefixes"];
+            leftBound: {
+                limit: limit;
+                comparator: InvertedComparators[comparator];
+            };
+            intersection: s["branches"]["intersection"];
+            pipe: s["branches"]["pipe"];
+            union: s["branches"]["union"];
+        };
+        groups: s["groups"];
+        finalizer: s["finalizer"];
+        scanned: updateScanned<s["scanned"], s["unscanned"], unscanned>;
+        unscanned: unscanned;
+    }> : s.error<writeUnpairableComparatorMessage<comparator>>;
+    type reduceRange<s extends StaticState, minLimit extends LimitLiteral, minComparator extends MinComparator, maxComparator extends MaxComparator, maxLimit extends LimitLiteral, unscanned extends string> = s.from<{
+        root: [minLimit, minComparator, [s["root"], maxComparator, maxLimit]];
+        branches: {
+            prefixes: s["branches"]["prefixes"];
+            leftBound: undefined;
+            intersection: s["branches"]["intersection"];
+            pipe: s["branches"]["pipe"];
+            union: s["branches"]["union"];
+        };
+        groups: s["groups"];
+        finalizer: s["finalizer"];
+        scanned: updateScanned<s["scanned"], s["unscanned"], unscanned>;
+        unscanned: unscanned;
+    }>;
+    type reduceSingleBound<s extends StaticState, comparator extends Comparator, limit extends number | string, unscanned extends string> = s.from<{
+        root: [s["root"], comparator, limit];
+        branches: {
+            prefixes: s["branches"]["prefixes"];
+            leftBound: undefined;
+            intersection: s["branches"]["intersection"];
+            pipe: s["branches"]["pipe"];
+            union: s["branches"]["union"];
+        };
+        groups: s["groups"];
+        finalizer: s["finalizer"];
+        scanned: updateScanned<s["scanned"], s["unscanned"], unscanned>;
+        unscanned: unscanned;
+    }>;
+    type mergeToIntersection<s extends StaticState> = s["branches"]["intersection"] extends undefined ? mergePrefixes<s> : [s["branches"]["intersection"], "&", mergePrefixes<s>];
+    type mergeToUnion<s extends StaticState> = s["branches"]["union"] extends undefined ? mergeToIntersection<s> : [s["branches"]["union"], "|", mergeToIntersection<s>];
+    type mergeToPipe<s extends StaticState> = s["branches"]["pipe"] extends undefined ? mergeToUnion<s> : [s["branches"]["pipe"], "|>", mergeToUnion<s>];
+    type mergePrefixes<s extends StaticState, remaining extends unknown[] = s["branches"]["prefixes"]> = remaining extends [infer head, ...infer tail] ? [
+        head,
+        mergePrefixes<s, tail>
+    ] : s["root"];
+    type popGroup<stack extends BranchState[], top extends BranchState> = [
+        ...stack,
+        top
+    ];
+    type finalizeGroup<s extends StaticState, unscanned extends string> = s["branches"]["leftBound"] extends {} ? openRangeError<s["branches"]["leftBound"]> : s["groups"] extends popGroup<infer stack, infer top> ? from<{
+        groups: stack;
+        branches: top;
+        root: mergeToPipe<s>;
+        finalizer: s["finalizer"];
+        scanned: updateScanned<s["scanned"], s["unscanned"], unscanned>;
+        unscanned: unscanned;
+    }> : s.error<writeUnmatchedGroupCloseMessage<")", unscanned>>;
+    type reduceGroupOpen<s extends StaticState, unscanned extends string> = from<{
+        groups: [...s["groups"], s["branches"]];
+        branches: initialBranches;
+        root: undefined;
+        finalizer: s["finalizer"];
+        scanned: updateScanned<s["scanned"], s["unscanned"], unscanned>;
+        unscanned: unscanned;
+    }>;
+    type finalize<s extends StaticState, finalizer extends FinalizingLookahead> = s["groups"] extends [] ? s["branches"]["leftBound"] extends {} ? openRangeError<s["branches"]["leftBound"]> : from<{
+        root: mergeToPipe<s>;
+        groups: s["groups"];
+        branches: initialBranches;
+        finalizer: finalizer;
+        scanned: s["scanned"];
+        unscanned: s["unscanned"];
+    }> : s.error<writeUnclosedGroupMessage<")">>;
+    type openRangeError<range extends defined<BranchState["leftBound"]>> = s.error<writeOpenRangeMessage<range["limit"], range["comparator"]>>;
+    type previousOperator<s extends StaticState> = s["branches"]["leftBound"] extends {} ? s["branches"]["leftBound"]["comparator"] : s["branches"]["prefixes"] extends ([
+        ...unknown[],
+        infer tail extends string
+    ]) ? tail : s["branches"]["intersection"] extends {} ? "&" : s["branches"]["union"] extends {} ? "|" : undefined;
+    type scanTo<s extends StaticState, unscanned extends string> = from<{
+        root: s["root"];
+        branches: s["branches"];
+        groups: s["groups"];
+        finalizer: s["finalizer"];
+        scanned: updateScanned<s["scanned"], s["unscanned"], unscanned>;
+        unscanned: unscanned;
+    }>;
+    type from<s extends StaticState> = s;
+    type branchesFrom<b extends BranchState> = b;
+}
+export {};

package/node_modules/arktype/out/parser/reduce/static.js

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

package/node_modules/arktype/out/parser/shift/operand/date.d.ts

@@ -0,0 +1,11 @@
+import type { DateLiteral } from "../../../attributes.ts";
+export declare const isDateLiteral: (value: unknown) => value is DateLiteral;
+export declare const isValidDate: (d: Date) => boolean;
+export declare const extractDateLiteralSource: <literal extends DateLiteral>(literal: literal) => extractDateLiteralSource<literal>;
+type extractDateLiteralSource<literal extends DateLiteral> = literal extends DateLiteral<infer source> ? source : never;
+export declare const writeInvalidDateMessage: <source extends string>(source: source) => writeInvalidDateMessage<source>;
+export type writeInvalidDateMessage<source extends string> = `'${source}' could not be parsed by the Date constructor`;
+export type DateInput = ConstructorParameters<typeof Date>[0];
+export type DateParseResult<errorOnFail extends boolean | string = boolean | string> = Date | (errorOnFail extends true | string ? never : undefined);
+export declare const tryParseDate: <errorOnFail extends boolean | string>(source: string, errorOnFail?: errorOnFail) => DateParseResult<errorOnFail>;
+export {};

package/node_modules/arktype/out/parser/shift/operand/date.js

@@ -0,0 +1,23 @@
+import { throwParseError, tryParseNumber } from "@ark/util";
+export const isDateLiteral = (value) => typeof value === "string" &&
+    value[0] === "d" &&
+    (value[1] === "'" || value[1] === '"') &&
+    value[value.length - 1] === value[1];
+export const isValidDate = (d) => d.toString() !== "Invalid Date";
+export const extractDateLiteralSource = (literal) => literal.slice(2, -1);
+export const writeInvalidDateMessage = (source) => `'${source}' could not be parsed by the Date constructor`;
+export const tryParseDate = (source, errorOnFail) => maybeParseDate(source, errorOnFail);
+const maybeParseDate = (source, errorOnFail) => {
+    const stringParsedDate = new Date(source);
+    if (isValidDate(stringParsedDate))
+        return stringParsedDate;
+    const epochMillis = tryParseNumber(source);
+    if (epochMillis !== undefined) {
+        const numberParsedDate = new Date(epochMillis);
+        if (isValidDate(numberParsedDate))
+            return numberParsedDate;
+    }
+    return errorOnFail ?
+        throwParseError(errorOnFail === true ? writeInvalidDateMessage(source) : errorOnFail)
+        : undefined;
+};

package/node_modules/arktype/out/parser/shift/operand/enclosed.d.ts

@@ -0,0 +1,57 @@
+import { type ErrorMessage, type Scanner } from "@ark/util";
+import type { Regex, regex } from "arkregex";
+import type { Out } from "../../../attributes.ts";
+import type { InferredAst } from "../../ast/infer.ts";
+import type { RuntimeState } from "../../reduce/dynamic.ts";
+import type { StaticState, s } from "../../reduce/static.ts";
+export type StringLiteral<contents extends string = string> = DoubleQuotedStringLiteral<contents> | SingleQuotedStringLiteral<contents>;
+export type DoubleQuotedStringLiteral<contents extends string = string> = `"${contents}"`;
+export type SingleQuotedStringLiteral<contents extends string = string> = `'${contents}'`;
+export declare const parseEnclosed: (s: RuntimeState, enclosing: EnclosingStartToken) => void;
+export type parseEnclosed<s extends StaticState, enclosingStart extends EnclosingStartToken, unscanned extends string> = Scanner.shiftUntilEscapable<unscanned, EnclosingTokens[enclosingStart], ""> extends Scanner.shiftResult<infer scanned, infer nextUnscanned> ? _parseEnclosed<s, enclosingStart, scanned, nextUnscanned> : never;
+type _parseEnclosed<s extends StaticState, enclosingStart extends EnclosingStartToken, scanned extends string, nextUnscanned extends string, def extends string = `${enclosingStart}${scanned}${EnclosingTokens[enclosingStart]}`> = nextUnscanned extends "" ? s.error<writeUnterminatedEnclosedMessage<scanned, enclosingStart>> : enclosingStart extends EnclosingQuote ? s.setRoot<s, InferredAst<scanned, def>, nextUnscanned extends Scanner.shift<string, infer unscanned> ? unscanned : ""> : enclosingStart extends EnclosingRegexToken ? regex.parse<scanned> extends infer r ? r extends Regex ? s.setRoot<s, InferredAst<enclosingStart extends "/" ? r["infer"] : (In: r["infer"]) => Out<r["inferExecArray"]>, def>, nextUnscanned extends Scanner.shift<string, infer unscanned> ? unscanned : ""> : r extends ErrorMessage<infer e> ? s.error<e> : never : never : s.setRoot<s, InferredAst<Date, def>, nextUnscanned extends Scanner.shift<string, infer unscanned> ? unscanned : "">;
+export declare const enclosingQuote: {
+    readonly "'": 1;
+    readonly '"': 1;
+};
+export type EnclosingQuote = keyof typeof enclosingQuote;
+export declare const enclosingChar: {
+    readonly "/": 1;
+    readonly "'": 1;
+    readonly '"': 1;
+};
+export declare const enclosingLiteralTokens: {
+    readonly "d'": "'";
+    readonly 'd"': "\"";
+    readonly "'": "'";
+    readonly '"': "\"";
+};
+export type EnclosingLiteralTokens = typeof enclosingLiteralTokens;
+export type EnclosingLiteralStartToken = keyof EnclosingLiteralTokens;
+export declare const enclosingRegexTokens: {
+    readonly "/": "/";
+    readonly "x/": "/";
+};
+export type EnclosingRegexTokens = typeof enclosingRegexTokens;
+export type EnclosingRegexToken = keyof EnclosingRegexTokens;
+export declare const enclosingTokens: {
+    readonly "/": "/";
+    readonly "x/": "/";
+    readonly "d'": "'";
+    readonly 'd"': "\"";
+    readonly "'": "'";
+    readonly '"': "\"";
+};
+export type EnclosingTokens = typeof enclosingTokens;
+export type EnclosingStartToken = keyof EnclosingTokens;
+export type EnclosingEndToken = EnclosingTokens[keyof EnclosingTokens];
+export declare const untilLookaheadIsClosing: Record<EnclosingEndToken, Scanner.UntilCondition>;
+declare const enclosingCharDescriptions: {
+    readonly '"': "double-quote";
+    readonly "'": "single-quote";
+    readonly "/": "forward slash";
+};
+type enclosingCharDescriptions = typeof enclosingCharDescriptions;
+export declare const writeUnterminatedEnclosedMessage: <fragment extends string, enclosingStart extends EnclosingStartToken>(fragment: fragment, enclosingStart: enclosingStart) => writeUnterminatedEnclosedMessage<fragment, enclosingStart>;
+export type writeUnterminatedEnclosedMessage<fragment extends string, enclosingStart extends EnclosingStartToken> = `${enclosingStart}${fragment} requires a closing ${enclosingCharDescriptions[EnclosingTokens[enclosingStart]]}`;
+export {};

package/node_modules/arktype/out/parser/shift/operand/enclosed.js

@@ -0,0 +1,78 @@
+import { rootSchema } from "@ark/schema";
+import { isKeyOf, throwParseError } from "@ark/util";
+import { tryParseDate, writeInvalidDateMessage } from "./date.js";
+const regexExecArray = rootSchema({
+    proto: "Array",
+    sequence: "string",
+    required: {
+        key: "groups",
+        value: ["object", { unit: undefined }]
+    }
+});
+export const parseEnclosed = (s, enclosing) => {
+    const enclosed = s.scanner.shiftUntilEscapable(untilLookaheadIsClosing[enclosingTokens[enclosing]]);
+    if (s.scanner.lookahead === "")
+        return s.error(writeUnterminatedEnclosedMessage(enclosed, enclosing));
+    // Shift the scanner one additional time for the second enclosing token
+    s.scanner.shift();
+    if (enclosing in enclosingRegexTokens) {
+        let regex;
+        try {
+            regex = new RegExp(enclosed);
+        }
+        catch (e) {
+            throwParseError(String(e));
+        }
+        s.root = s.ctx.$.node("intersection", {
+            domain: "string",
+            pattern: enclosed
+        }, { prereduced: true });
+        if (enclosing === "x/") {
+            s.root = s.ctx.$.node("morph", {
+                in: s.root,
+                morphs: (s) => regex.exec(s),
+                declaredOut: regexExecArray
+            });
+        }
+    }
+    else if (isKeyOf(enclosing, enclosingQuote))
+        s.root = s.ctx.$.node("unit", { unit: enclosed });
+    else {
+        const date = tryParseDate(enclosed, writeInvalidDateMessage(enclosed));
+        s.root = s.ctx.$.node("unit", { meta: enclosed, unit: date });
+    }
+};
+export const enclosingQuote = {
+    "'": 1,
+    '"': 1
+};
+export const enclosingChar = {
+    "/": 1,
+    "'": 1,
+    '"': 1
+};
+export const enclosingLiteralTokens = {
+    "d'": "'",
+    'd"': '"',
+    "'": "'",
+    '"': '"'
+};
+export const enclosingRegexTokens = {
+    "/": "/",
+    "x/": "/"
+};
+export const enclosingTokens = {
+    ...enclosingLiteralTokens,
+    ...enclosingRegexTokens
+};
+export const untilLookaheadIsClosing = {
+    "'": scanner => scanner.lookahead === `'`,
+    '"': scanner => scanner.lookahead === `"`,
+    "/": scanner => scanner.lookahead === `/`
+};
+const enclosingCharDescriptions = {
+    '"': "double-quote",
+    "'": "single-quote",
+    "/": "forward slash"
+};
+export const writeUnterminatedEnclosedMessage = (fragment, enclosingStart) => `${enclosingStart}${fragment} requires a closing ${enclosingCharDescriptions[enclosingTokens[enclosingStart]]}`;

package/node_modules/arktype/out/parser/shift/operand/genericArgs.d.ts

@@ -0,0 +1,27 @@
+import type { BaseRoot, GenericAst, genericParamNames, GenericRoot } from "@ark/schema";
+import { writeUnclosedGroupMessage, type array, type ErrorMessage, type join } from "@ark/util";
+import type { RuntimeState } from "../../reduce/dynamic.ts";
+import type { s, StaticState } from "../../reduce/static.ts";
+import type { parseUntilFinalizer } from "../../string.ts";
+export declare const parseGenericArgs: (name: string, g: GenericRoot, s: RuntimeState) => BaseRoot[];
+export type parseGenericArgs<name extends string, g extends GenericAst, unscanned extends string, $, args> = _parseGenericArgs<name, g, unscanned, $, args, [], []>;
+declare const _parseGenericArgs: (name: string, g: GenericRoot, s: RuntimeState, argNodes: BaseRoot[]) => BaseRoot[];
+export type ParsedArgs<result extends unknown[] = unknown[], unscanned extends string = string> = {
+    result: result;
+    unscanned: unscanned;
+};
+type _parseGenericArgs<name extends string, g extends GenericAst, unscanned extends string, $, args, argDefs extends string[], argAsts extends unknown[]> = parseUntilFinalizer<s.initialize<unscanned>, $, args> extends (infer finalArgState extends StaticState) ? {
+    defs: [
+        ...argDefs,
+        finalArgState["scanned"] extends `${infer def}${"," | ">"}` ? def : finalArgState["scanned"]
+    ];
+    asts: [...argAsts, finalArgState["root"]];
+    unscanned: finalArgState["unscanned"];
+} extends ({
+    defs: infer nextDefs extends string[];
+    asts: infer nextAsts extends unknown[];
+    unscanned: infer nextUnscanned extends string;
+}) ? finalArgState["finalizer"] extends ">" ? nextAsts["length"] extends g["paramsAst"]["length"] ? ParsedArgs<nextAsts, nextUnscanned> : s.error<writeInvalidGenericArgCountMessage<name, genericParamNames<g["paramsAst"]>, nextDefs>> : finalArgState["finalizer"] extends "," ? _parseGenericArgs<name, g, nextUnscanned, $, args, nextDefs, nextAsts> : finalArgState["finalizer"] extends ErrorMessage ? finalArgState : s.error<writeUnclosedGroupMessage<">">> : never : never;
+export declare const writeInvalidGenericArgCountMessage: <name extends string, params extends array<string>, argDefs extends array<string>>(name: name, params: params, argDefs: argDefs) => writeInvalidGenericArgCountMessage<name, params, argDefs>;
+export type writeInvalidGenericArgCountMessage<name extends string, params extends array<string>, argDefs extends array<string>> = `${name}<${join<params, ", ">}> requires exactly ${params["length"]} args (got ${argDefs["length"]}${argDefs["length"] extends (0) ? "" : `: ${join<argDefs, ",">}`})`;
+export {};

package/node_modules/arktype/out/parser/shift/operand/genericArgs.js

@@ -0,0 +1,16 @@
+import { writeUnclosedGroupMessage } from "@ark/util";
+export const parseGenericArgs = (name, g, s) => _parseGenericArgs(name, g, s, []);
+const _parseGenericArgs = (name, g, s, argNodes) => {
+    const argState = s.parseUntilFinalizer();
+    argNodes.push(argState.root);
+    if (argState.finalizer === ">") {
+        if (argNodes.length !== g.params.length) {
+            return s.error(writeInvalidGenericArgCountMessage(name, g.names, argNodes.map(arg => arg.expression)));
+        }
+        return argNodes;
+    }
+    if (argState.finalizer === ",")
+        return _parseGenericArgs(name, g, s, argNodes);
+    return argState.error(writeUnclosedGroupMessage(">"));
+};
+export const writeInvalidGenericArgCountMessage = (name, params, argDefs) => `${name}<${params.join(", ")}> requires exactly ${params.length} args (got ${argDefs.length}${argDefs.length === 0 ? "" : `: ${argDefs.join(", ")}`})`;

package/node_modules/arktype/out/parser/shift/operand/operand.d.ts

@@ -0,0 +1,8 @@
+import { type Scanner, type WhitespaceChar } from "@ark/util";
+import type { RuntimeState } from "../../reduce/dynamic.ts";
+import type { StaticState, s } from "../../reduce/static.ts";
+import type { BaseCompletions } from "../../string.ts";
+import { parseEnclosed, type EnclosingQuote, type EnclosingStartToken } from "./enclosed.ts";
+import { parseUnenclosed } from "./unenclosed.ts";
+export declare const parseOperand: (s: RuntimeState) => void;
+export type parseOperand<s extends StaticState, $, args> = s["unscanned"] extends Scanner.shift<infer lookahead, infer unscanned> ? lookahead extends "(" ? s.reduceGroupOpen<s, unscanned> : lookahead extends EnclosingStartToken ? parseEnclosed<s, lookahead, unscanned> : lookahead extends WhitespaceChar ? parseOperand<s.scanTo<s, unscanned>, $, args> : lookahead extends "d" ? unscanned extends (Scanner.shift<infer enclosing extends EnclosingQuote, infer nextUnscanned>) ? parseEnclosed<s, `d${enclosing}`, nextUnscanned> : parseUnenclosed<s, $, args> : lookahead extends "x" ? unscanned extends Scanner.shift<"/", infer nextUnscanned> ? parseEnclosed<s, "x/", nextUnscanned> : parseUnenclosed<s, $, args> : parseUnenclosed<s, $, args> : s.completion<`${s["scanned"]}${BaseCompletions<$, args>}`>;

package/node_modules/arktype/out/parser/shift/operand/operand.js

@@ -0,0 +1,16 @@
+import { whitespaceChars } from "@ark/util";
+import { enclosingChar, enclosingQuote, parseEnclosed } from "./enclosed.js";
+import { parseUnenclosed, writeMissingOperandMessage } from "./unenclosed.js";
+export const parseOperand = (s) => s.scanner.lookahead === "" ? s.error(writeMissingOperandMessage(s))
+    : s.scanner.lookahead === "(" ? s.shiftedBy(1).reduceGroupOpen()
+        : s.scanner.lookaheadIsIn(enclosingChar) ? parseEnclosed(s, s.scanner.shift())
+            : s.scanner.lookaheadIsIn(whitespaceChars) ? parseOperand(s.shiftedBy(1))
+                : s.scanner.lookahead === "d" ?
+                    s.scanner.nextLookahead in enclosingQuote ?
+                        parseEnclosed(s, `${s.scanner.shift()}${s.scanner.shift()}`)
+                        : parseUnenclosed(s)
+                    : s.scanner.lookahead === "x" ?
+                        s.scanner.nextLookahead === "/" ?
+                            s.shiftedBy(2) && parseEnclosed(s, "x/")
+                            : parseUnenclosed(s)
+                        : parseUnenclosed(s);

package/node_modules/arktype/out/parser/shift/operand/unenclosed.d.ts

@@ -0,0 +1,43 @@
+import { writeUnresolvableMessage, type BaseRoot, type GenericAst, type GenericRoot, type arkKind, type genericParamNames, type resolvableReferenceIn, type writeNonSubmoduleDotMessage } from "@ark/schema";
+import { type BigintLiteral, type NumberLiteral, type Scanner, type join, type lastOf } from "@ark/util";
+import type { ArkAmbient } from "../../../config.ts";
+import type { resolutionToAst } from "../../../scope.ts";
+import type { GenericInstantiationAst } from "../../ast/generic.ts";
+import type { InferredAst } from "../../ast/infer.ts";
+import { writePrefixedPrivateReferenceMessage } from "../../ast/validate.ts";
+import type { RuntimeState } from "../../reduce/dynamic.ts";
+import type { StaticState, s } from "../../reduce/static.ts";
+import type { BaseCompletions } from "../../string.ts";
+import { type TerminatingChar } from "../tokens.ts";
+import { parseGenericArgs, writeInvalidGenericArgCountMessage, type ParsedArgs } from "./genericArgs.ts";
+export declare const parseUnenclosed: (s: RuntimeState) => void;
+export type parseUnenclosed<s extends StaticState, $, args> = Scanner.shiftUntil<s["unscanned"], TerminatingChar> extends (Scanner.shiftResult<infer token, infer unscanned>) ? tryResolve<s, unscanned, token, $, args> extends s.from<infer s> ? s : never : never;
+type parseResolution<s extends StaticState, unscanned extends string, alias extends string, resolution, $, args> = resolutionToAst<alias, resolution> extends infer ast ? ast extends GenericAst ? parseGenericInstantiation<alias, ast, s.scanTo<s, unscanned>, $, args> : s.setRoot<s, ast, unscanned> : never;
+export declare const parseGenericInstantiation: (name: string, g: GenericRoot, s: RuntimeState) => BaseRoot;
+export type parseGenericInstantiation<name extends string, g extends GenericAst, s extends StaticState, $, args> = Scanner.skipWhitespace<s["unscanned"]> extends `<${infer unscanned}` ? parseGenericArgs<name, g, unscanned, $, args> extends infer result ? result extends ParsedArgs<infer argAsts, infer nextUnscanned> ? s.setRoot<s, GenericInstantiationAst<g, argAsts>, nextUnscanned> : result : never : s.error<writeInvalidGenericArgCountMessage<name, genericParamNames<g["paramsAst"]>, [
+]>>;
+type tryResolve<s extends StaticState, unscanned extends string, token extends string, $, args> = token extends keyof args ? parseResolution<s, unscanned, token, args[token], $, args> : token extends keyof $ ? parseResolution<s, unscanned, token, $[token], $, args> : token extends keyof ArkAmbient.$ ? parseResolution<s, unscanned, token, ArkAmbient.$[token], $, args> : `#${token}` extends keyof $ ? parseResolution<s, unscanned, token, $[`#${token}`], $, args> : token extends NumberLiteral<infer n> ? s.setRoot<s, InferredAst<n, token>, unscanned> : token extends (`${infer submodule extends keyof $ & string}.${infer reference}`) ? tryResolveSubmodule<token, $[submodule], reference, s, unscanned, $, args, [
+    submodule
+]> : token extends (`${infer submodule extends keyof ArkAmbient.$ & string}.${infer reference}`) ? tryResolveSubmodule<token, ArkAmbient.$[submodule], reference, s, unscanned, $, args, [
+    submodule
+]> : token extends BigintLiteral<infer b> ? s.setRoot<s, InferredAst<b, token>, unscanned> : token extends "keyof" ? s.addPrefix<s, "keyof", unscanned> : unresolvableState<s, token, $, args, []>;
+type tryResolveSubmodule<token extends string, resolution, reference extends string, s extends StaticState, unscanned extends string, $, args, submodulePath extends string[]> = resolution extends {
+    [arkKind]: "module";
+} ? reference extends keyof resolution ? parseResolution<s, unscanned, token, resolution[reference], $, args> : reference extends (`${infer nestedSubmodule extends keyof resolution & string}.${infer nestedReference}`) ? tryResolveSubmodule<token, resolution[nestedSubmodule], nestedReference, s, unscanned, $, args, [
+    ...submodulePath,
+    nestedSubmodule
+]> : unresolvableState<s, reference, resolution, {}, submodulePath> : s.error<writeNonSubmoduleDotMessage<lastOf<submodulePath>>>;
+/** Provide valid completions for the current token, or fallback to an
+ * unresolvable error if there are none */
+export type unresolvableState<s extends StaticState, token extends string, resolutions, args, submodulePath extends string[]> = [
+    token,
+    s["unscanned"]
+] extends ["", Scanner.shift<"#", infer unscanned>] ? Scanner.shiftUntil<unscanned, TerminatingChar> extends (Scanner.shiftResult<infer name, string>) ? s.error<writePrefixedPrivateReferenceMessage<name>> : never : validReferenceFromToken<token, resolutions, args, submodulePath> extends (never) ? s.error<writeUnresolvableMessage<qualifiedReference<token, submodulePath>>> : s.completion<`${s["scanned"]}${qualifiedReference<validReferenceFromToken<token, resolutions, args, submodulePath>, submodulePath>}`>;
+type qualifiedReference<reference extends string, submodulePath extends string[]> = join<[...submodulePath, reference], ".">;
+type validReferenceFromToken<token extends string, $, args, submodulePath extends string[]> = Extract<submodulePath["length"] extends 0 ? BaseCompletions<$, args> : resolvableReferenceIn<$>, `${token}${string}`>;
+export declare const writeMissingOperandMessage: (s: RuntimeState) => string;
+export type writeMissingRightOperandMessage<token extends string, unscanned extends string = ""> = `Token '${token}' requires a right operand${unscanned extends "" ? "" : ` before '${unscanned}'`}`;
+export declare const writeMissingRightOperandMessage: <token extends string, unscanned extends string>(token: token, unscanned?: unscanned) => writeMissingRightOperandMessage<token, unscanned>;
+export declare const writeExpressionExpectedMessage: <unscanned extends string>(unscanned: unscanned) => writeExpressionExpectedMessage<unscanned>;
+export type writeExpressionExpectedMessage<unscanned extends string> = `Expected an expression${unscanned extends "" ? "" : ` before '${unscanned}'`}`;
+export {};

package/node_modules/arktype/out/parser/shift/operand/unenclosed.js

@@ -0,0 +1,59 @@
+import { hasArkKind, writeUnresolvableMessage } from "@ark/schema";
+import { printable, throwParseError, tryParseWellFormedBigint, tryParseWellFormedNumber } from "@ark/util";
+import { writePrefixedPrivateReferenceMessage } from "../../ast/validate.js";
+import { terminatingChars } from "../tokens.js";
+import { parseGenericArgs, writeInvalidGenericArgCountMessage } from "./genericArgs.js";
+export const parseUnenclosed = (s) => {
+    const token = s.scanner.shiftUntilLookahead(terminatingChars);
+    if (token === "keyof")
+        s.addPrefix("keyof");
+    else
+        s.root = unenclosedToNode(s, token);
+};
+export const parseGenericInstantiation = (name, g, s) => {
+    s.scanner.shiftUntilNonWhitespace();
+    const lookahead = s.scanner.shift();
+    if (lookahead !== "<")
+        return s.error(writeInvalidGenericArgCountMessage(name, g.names, []));
+    const parsedArgs = parseGenericArgs(name, g, s);
+    return g(...parsedArgs);
+};
+const unenclosedToNode = (s, token) => maybeParseReference(s, token) ??
+    maybeParseUnenclosedLiteral(s, token) ??
+    s.error(token === "" ?
+        s.scanner.lookahead === "#" ?
+            writePrefixedPrivateReferenceMessage(s.shiftedBy(1).scanner.shiftUntilLookahead(terminatingChars))
+            : writeMissingOperandMessage(s)
+        : writeUnresolvableMessage(token));
+const maybeParseReference = (s, token) => {
+    if (s.ctx.args?.[token]) {
+        const arg = s.ctx.args[token];
+        if (typeof arg !== "string")
+            return arg;
+        return s.ctx.$.node("alias", { reference: arg }, { prereduced: true });
+    }
+    const resolution = s.ctx.$.maybeResolve(token);
+    if (hasArkKind(resolution, "root"))
+        return resolution;
+    if (resolution === undefined)
+        return;
+    if (hasArkKind(resolution, "generic"))
+        return parseGenericInstantiation(token, resolution, s);
+    return throwParseError(`Unexpected resolution ${printable(resolution)}`);
+};
+const maybeParseUnenclosedLiteral = (s, token) => {
+    const maybeNumber = tryParseWellFormedNumber(token);
+    if (maybeNumber !== undefined)
+        return s.ctx.$.node("unit", { unit: maybeNumber });
+    const maybeBigint = tryParseWellFormedBigint(token);
+    if (maybeBigint !== undefined)
+        return s.ctx.$.node("unit", { unit: maybeBigint });
+};
+export const writeMissingOperandMessage = (s) => {
+    const operator = s.previousOperator();
+    return operator ?
+        writeMissingRightOperandMessage(operator, s.scanner.unscanned)
+        : writeExpressionExpectedMessage(s.scanner.unscanned);
+};
+export const writeMissingRightOperandMessage = (token, unscanned = "") => `Token '${token}' requires a right operand${unscanned ? ` before '${unscanned}'` : ""}`;
+export const writeExpressionExpectedMessage = (unscanned) => `Expected an expression${unscanned ? ` before '${unscanned}'` : ""}`;