@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/arktype/out/parser/shift/operator/bounds.d.ts

@@ -0,0 +1,24 @@
+import { type BaseRoot, type BoundKind } from "@ark/schema";
+import { type KeySet, type Scanner } from "@ark/util";
+import type { DateLiteral } from "../../../attributes.ts";
+import type { InferredAst } from "../../ast/infer.ts";
+import type { astToString } from "../../ast/utils.ts";
+import type { RootedRuntimeState, RuntimeState } from "../../reduce/dynamic.ts";
+import { writeUnpairableComparatorMessage, type Comparator, type InvertedComparators, type MaxComparator } from "../../reduce/shared.ts";
+import type { s, StaticState } from "../../reduce/static.ts";
+import type { parseOperand } from "../operand/operand.ts";
+export declare const parseBound: (s: RootedRuntimeState, start: ComparatorStartChar) => void;
+export type parseBound<s extends StaticState, start extends ComparatorStartChar, unscanned extends string, $, args> = shiftComparator<start, unscanned> extends infer shiftResultOrError ? shiftResultOrError extends (Scanner.shiftResult<infer comparator extends Comparator, infer nextUnscanned>) ? s["root"] extends (InferredAst<Date | number, `${infer limit extends number | DateLiteral}`>) ? s.reduceLeftBound<s, limit, comparator, nextUnscanned> : parseRightBound<s.scanTo<s, nextUnscanned>, comparator, $, args> : shiftResultOrError : never;
+type OneCharComparator = ">" | "<";
+export type ComparatorStartChar = Comparator extends `${infer char}${string}` ? char : never;
+export declare const comparatorStartChars: KeySet<ComparatorStartChar>;
+declare const shiftComparator: (s: RuntimeState, start: ComparatorStartChar) => Comparator;
+type shiftComparator<start extends ComparatorStartChar, unscanned extends string> = unscanned extends `=${infer nextUnscanned}` ? [`${start}=`, nextUnscanned] : [start & OneCharComparator, unscanned];
+export declare const writeIncompatibleRangeMessage: (l: BoundKind, r: BoundKind) => string;
+export declare const getBoundKinds: (comparator: Comparator, limit: number | DateLiteral, root: BaseRoot, boundKind: BoundExpressionKind) => BoundKind[];
+export declare const parseRightBound: (s: RootedRuntimeState, comparator: Comparator) => void;
+export type parseRightBound<s extends StaticState, comparator extends Comparator, $, args> = parseOperand<s, $, args> extends infer nextState extends StaticState ? nextState["root"] extends (InferredAst<unknown, `${infer limit extends number | DateLiteral}`>) ? s["branches"]["leftBound"] extends {} ? comparator extends MaxComparator ? s.reduceRange<s, s["branches"]["leftBound"]["limit"], s["branches"]["leftBound"]["comparator"], comparator, limit, nextState["unscanned"]> : s.error<writeUnpairableComparatorMessage<comparator>> : s.reduceSingleBound<s, comparator, limit, nextState["unscanned"]> : s.error<writeInvalidLimitMessage<comparator, astToString<nextState["root"]>, "right">> : never;
+export declare const writeInvalidLimitMessage: <comparator extends Comparator, limit extends string | number, boundKind extends BoundExpressionKind>(comparator: comparator, limit: limit, boundKind: boundKind) => writeInvalidLimitMessage<comparator, limit, boundKind>;
+export type writeInvalidLimitMessage<comparator extends Comparator, limit extends string | number, boundKind extends BoundExpressionKind> = `Comparator ${boundKind extends "left" ? InvertedComparators[comparator] : comparator} must be ${boundKind extends "left" ? "preceded" : "followed"} by a corresponding literal (was ${limit})`;
+export type BoundExpressionKind = "left" | "right";
+export {};

package/node_modules/arktype/out/parser/shift/operator/bounds.js

@@ -0,0 +1,91 @@
+import { $ark, writeUnboundableMessage } from "@ark/schema";
+import { isKeyOf, throwParseError } from "@ark/util";
+import { invertedComparators, maxComparators, writeUnpairableComparatorMessage } from "../../reduce/shared.js";
+import { extractDateLiteralSource, isDateLiteral } from "../operand/date.js";
+export const parseBound = (s, start) => {
+    const comparator = shiftComparator(s, start);
+    if (s.root.hasKind("unit")) {
+        if (typeof s.root.unit === "number") {
+            s.reduceLeftBound(s.root.unit, comparator);
+            s.unsetRoot();
+            return;
+        }
+        if (s.root.unit instanceof Date) {
+            const literal = `d'${s.root.description ?? s.root.unit.toISOString()}'`;
+            s.unsetRoot();
+            s.reduceLeftBound(literal, comparator);
+            return;
+        }
+    }
+    return parseRightBound(s, comparator);
+};
+export const comparatorStartChars = {
+    "<": 1,
+    ">": 1,
+    "=": 1
+};
+const shiftComparator = (s, start) => s.scanner.lookaheadIs("=") ?
+    `${start}${s.scanner.shift()}`
+    : start;
+export const writeIncompatibleRangeMessage = (l, r) => `Bound kinds ${l} and ${r} are incompatible`;
+export const getBoundKinds = (comparator, limit, root, boundKind) => {
+    if (root.extends($ark.intrinsic.number)) {
+        if (typeof limit !== "number") {
+            return throwParseError(writeInvalidLimitMessage(comparator, limit, boundKind));
+        }
+        return (comparator === "==" ? ["min", "max"]
+            : comparator[0] === ">" ? ["min"]
+                : ["max"]);
+    }
+    if (root.extends($ark.intrinsic.lengthBoundable)) {
+        if (typeof limit !== "number") {
+            return throwParseError(writeInvalidLimitMessage(comparator, limit, boundKind));
+        }
+        return (comparator === "==" ? ["exactLength"]
+            : comparator[0] === ">" ? ["minLength"]
+                : ["maxLength"]);
+    }
+    if (root.extends($ark.intrinsic.Date)) {
+        // allow either numeric or date limits
+        return (comparator === "==" ? ["after", "before"]
+            : comparator[0] === ">" ? ["after"]
+                : ["before"]);
+    }
+    return throwParseError(writeUnboundableMessage(root.expression));
+};
+const openLeftBoundToRoot = (leftBound) => ({
+    rule: isDateLiteral(leftBound.limit) ?
+        extractDateLiteralSource(leftBound.limit)
+        : leftBound.limit,
+    exclusive: leftBound.comparator.length === 1
+});
+export const parseRightBound = (s, comparator) => {
+    // store the node that will be bounded
+    const previousRoot = s.unsetRoot();
+    const previousScannerIndex = s.scanner.location;
+    s.parseOperand();
+    const limitNode = s.unsetRoot();
+    // after parsing the next operand, use the locations to get the
+    // token from which it was parsed
+    const limitToken = s.scanner.sliceChars(previousScannerIndex, s.scanner.location);
+    s.root = previousRoot;
+    if (!limitNode.hasKind("unit") ||
+        (typeof limitNode.unit !== "number" && !(limitNode.unit instanceof Date)))
+        return s.error(writeInvalidLimitMessage(comparator, limitToken, "right"));
+    const limit = limitNode.unit;
+    // apply the newly-parsed right bound
+    const exclusive = comparator.length === 1;
+    const boundKinds = getBoundKinds(comparator, typeof limit === "number" ? limit : limitToken, previousRoot, "right");
+    for (const kind of boundKinds) {
+        s.constrainRoot(kind, comparator === "==" ? { rule: limit } : { rule: limit, exclusive });
+    }
+    if (!s.branches.leftBound)
+        return;
+    // if there's an open left bound, perform additional validation and apply it
+    if (!isKeyOf(comparator, maxComparators))
+        return s.error(writeUnpairableComparatorMessage(comparator));
+    const lowerBoundKind = getBoundKinds(s.branches.leftBound.comparator, s.branches.leftBound.limit, previousRoot, "left");
+    s.constrainRoot(lowerBoundKind[0], openLeftBoundToRoot(s.branches.leftBound));
+    s.branches.leftBound = null;
+};
+export const writeInvalidLimitMessage = (comparator, limit, boundKind) => `Comparator ${boundKind === "left" ? invertedComparators[comparator] : comparator} must be ${boundKind === "left" ? "preceded" : "followed"} by a corresponding literal (was ${limit})`;

package/node_modules/arktype/out/parser/shift/operator/brand.d.ts

@@ -0,0 +1,7 @@
+import type { emptyBrandNameMessage } from "@ark/schema";
+import type { Scanner } from "@ark/util";
+import type { RootedRuntimeState } from "../../reduce/dynamic.ts";
+import type { StaticState, s } from "../../reduce/static.ts";
+import { type TerminatingChar } from "../tokens.ts";
+export declare const parseBrand: (s: RootedRuntimeState) => void;
+export type parseBrand<s extends StaticState, unscanned extends string> = Scanner.shiftUntil<Scanner.skipWhitespace<unscanned>, TerminatingChar> extends Scanner.shiftResult<`${infer brandName}`, infer nextUnscanned> ? brandName extends "" ? s.error<emptyBrandNameMessage> : s.setRoot<s, [s["root"], "#", brandName], nextUnscanned> : never;

package/node_modules/arktype/out/parser/shift/operator/brand.js

@@ -0,0 +1,6 @@
+import { terminatingChars } from "../tokens.js";
+export const parseBrand = (s) => {
+    s.scanner.shiftUntilNonWhitespace();
+    const brandName = s.scanner.shiftUntilLookahead(terminatingChars);
+    s.root = s.root.brand(brandName);
+};

package/node_modules/arktype/out/parser/shift/operator/default.d.ts

@@ -0,0 +1,24 @@
+import type { BaseRoot } from "@ark/schema";
+import type { BigintLiteral, ErrorMessage, NumberLiteral, Scanner, trim } from "@ark/util";
+import type { DateLiteral } from "../../../attributes.ts";
+import type { RootedRuntimeState } from "../../reduce/dynamic.ts";
+import type { EnclosingLiteralStartToken, EnclosingLiteralTokens, StringLiteral } from "../operand/enclosed.ts";
+type UnitLiteralKeyword = "null" | "undefined" | "true" | "false";
+export type UnitLiteral = UnenclosedUnitLiteral | EnclosedUnitLiteral;
+export type UnenclosedUnitLiteral = BigintLiteral | NumberLiteral | UnitLiteralKeyword;
+export type EnclosedUnitLiteral = StringLiteral | DateLiteral;
+export type ParsedDefaultableProperty = readonly [BaseRoot, "=", unknown];
+export declare const parseDefault: (s: RootedRuntimeState) => ParsedDefaultableProperty;
+export type parseDefault<root, unscanned extends string> = trim<unscanned> extends infer defaultExpression extends string ? defaultExpression extends UnenclosedUnitLiteral ? [
+    root,
+    "=",
+    defaultExpression
+] : defaultExpression extends (`${infer start extends EnclosingLiteralStartToken}${string}`) ? defaultExpression extends `${start}${infer nextUnscanned}` ? isValidEnclosedLiteral<start, nextUnscanned> extends true ? [
+    root,
+    "=",
+    defaultExpression
+] : ErrorMessage<writeNonLiteralDefaultMessage<defaultExpression>> : never : ErrorMessage<writeNonLiteralDefaultMessage<defaultExpression>> : never;
+export type isValidEnclosedLiteral<start extends EnclosingLiteralStartToken, unscanned extends string> = Scanner.shiftUntilEscapable<unscanned, EnclosingLiteralTokens[start], ""> extends Scanner.shiftResult<string, infer nextUnscanned> ? nextUnscanned extends EnclosingLiteralTokens[start] ? true : false : false;
+export declare const writeNonLiteralDefaultMessage: <defaultDef extends string>(defaultDef: defaultDef) => writeNonLiteralDefaultMessage<defaultDef>;
+export type writeNonLiteralDefaultMessage<defaultDef extends string> = `Default value '${defaultDef}' must be a literal value`;
+export {};

package/node_modules/arktype/out/parser/shift/operator/default.js

@@ -0,0 +1,15 @@
+export const parseDefault = (s) => {
+    // store the node that will be bounded
+    const baseNode = s.unsetRoot();
+    s.parseOperand();
+    const defaultNode = s.unsetRoot();
+    // after parsing the next operand, use the locations to get the
+    // token from which it was parsed
+    if (!defaultNode.hasKind("unit"))
+        return s.error(writeNonLiteralDefaultMessage(defaultNode.expression));
+    const defaultValue = defaultNode.unit instanceof Date ?
+        () => new Date(defaultNode.unit)
+        : defaultNode.unit;
+    return [baseNode, "=", defaultValue];
+};
+export const writeNonLiteralDefaultMessage = (defaultDef) => `Default value '${defaultDef}' must be a literal value`;

package/node_modules/arktype/out/parser/shift/operator/divisor.d.ts

@@ -0,0 +1,8 @@
+import { type Scanner } from "@ark/util";
+import type { RootedRuntimeState } from "../../reduce/dynamic.ts";
+import type { StaticState, s } from "../../reduce/static.ts";
+import { type TerminatingChar } from "../tokens.ts";
+export declare const parseDivisor: (s: RootedRuntimeState) => void;
+export type parseDivisor<s extends StaticState, unscanned extends string> = Scanner.shiftUntil<Scanner.skipWhitespace<unscanned>, TerminatingChar> extends Scanner.shiftResult<infer scanned, infer nextUnscanned> ? scanned extends `${infer divisor extends number}` ? divisor extends 0 ? s.error<writeInvalidDivisorMessage<0>> : s.setRoot<s, [s["root"], "%", divisor], nextUnscanned> : s.error<writeInvalidDivisorMessage<scanned>> : never;
+export declare const writeInvalidDivisorMessage: <divisor extends string | number>(divisor: divisor) => writeInvalidDivisorMessage<divisor>;
+export type writeInvalidDivisorMessage<divisor extends string | number> = `% operator must be followed by a non-zero integer literal (was ${divisor})`;

package/node_modules/arktype/out/parser/shift/operator/divisor.js

@@ -0,0 +1,13 @@
+import { tryParseInteger } from "@ark/util";
+import { terminatingChars } from "../tokens.js";
+export const parseDivisor = (s) => {
+    s.scanner.shiftUntilNonWhitespace();
+    const divisorToken = s.scanner.shiftUntilLookahead(terminatingChars);
+    const divisor = tryParseInteger(divisorToken, {
+        errorOnFail: writeInvalidDivisorMessage(divisorToken)
+    });
+    if (divisor === 0)
+        s.error(writeInvalidDivisorMessage(0));
+    s.root = s.root.constrain("divisor", divisor);
+};
+export const writeInvalidDivisorMessage = (divisor) => `% operator must be followed by a non-zero integer literal (was ${divisor})`;

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

@@ -0,0 +1,14 @@
+import { type Scanner, type WhitespaceChar } from "@ark/util";
+import type { RootedRuntimeState } from "../../reduce/dynamic.ts";
+import type { StaticState, s } from "../../reduce/static.ts";
+import { lookaheadIsFinalizing, type FinalizingLookahead } from "../tokens.ts";
+import { parseBound, type ComparatorStartChar } from "./bounds.ts";
+import { parseBrand } from "./brand.ts";
+import { parseDivisor } from "./divisor.ts";
+export declare const parseOperator: (s: RootedRuntimeState) => void;
+export type parseOperator<s extends StaticState, $, args> = s["unscanned"] extends Scanner.shift<infer lookahead, infer unscanned> ? lookahead extends "[" ? unscanned extends Scanner.shift<"]", infer nextUnscanned> ? s.setRoot<s, [s["root"], "[]"], nextUnscanned> : s.error<incompleteArrayTokenMessage> : lookahead extends "|" ? unscanned extends Scanner.shift<">", infer nextUnscanned> ? s.reduceBranch<s, "|>", nextUnscanned> : s.reduceBranch<s, lookahead, unscanned> : lookahead extends "&" ? s.reduceBranch<s, lookahead, unscanned> : lookahead extends ")" ? s.finalizeGroup<s, unscanned> : lookaheadIsFinalizing<lookahead, unscanned> extends true ? s.finalize<s.scanTo<s, unscanned>, lookahead & FinalizingLookahead> : lookahead extends ComparatorStartChar ? parseBound<s, lookahead, unscanned, $, args> : lookahead extends "%" ? parseDivisor<s, unscanned> : lookahead extends "#" ? parseBrand<s, unscanned> : lookahead extends WhitespaceChar ? parseOperator<s.scanTo<s, unscanned>, $, args> : s.error<writeUnexpectedCharacterMessage<lookahead>> : s.finalize<s, "">;
+export declare const writeUnexpectedCharacterMessage: <char extends string, shouldBe extends string>(char: char, shouldBe?: shouldBe) => writeUnexpectedCharacterMessage<char, shouldBe>;
+export type writeUnexpectedCharacterMessage<char extends string, shouldBe extends string = ""> = `'${char}' is not allowed here${shouldBe extends "" ? "" : ` (should be ${shouldBe})`}`;
+export declare const incompleteArrayTokenMessage = "Missing expected ']'";
+type incompleteArrayTokenMessage = typeof incompleteArrayTokenMessage;
+export {};

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

@@ -0,0 +1,28 @@
+import { isKeyOf, whitespaceChars } from "@ark/util";
+import { lookaheadIsFinalizing } from "../tokens.js";
+import { comparatorStartChars, parseBound } from "./bounds.js";
+import { parseBrand } from "./brand.js";
+import { parseDivisor } from "./divisor.js";
+export const parseOperator = (s) => {
+    const lookahead = s.scanner.shift();
+    return (lookahead === "" ? s.finalize("")
+        : lookahead === "[" ?
+            s.scanner.shift() === "]" ?
+                s.setRoot(s.root.array())
+                : s.error(incompleteArrayTokenMessage)
+            : lookahead === "|" ?
+                s.scanner.lookahead === ">" ?
+                    s.shiftedBy(1).pushRootToBranch("|>")
+                    : s.pushRootToBranch(lookahead)
+                : lookahead === "&" ? s.pushRootToBranch(lookahead)
+                    : lookahead === ")" ? s.finalizeGroup()
+                        : lookaheadIsFinalizing(lookahead, s.scanner.unscanned) ?
+                            s.finalize(lookahead)
+                            : isKeyOf(lookahead, comparatorStartChars) ? parseBound(s, lookahead)
+                                : lookahead === "%" ? parseDivisor(s)
+                                    : lookahead === "#" ? parseBrand(s)
+                                        : lookahead in whitespaceChars ? parseOperator(s)
+                                            : s.error(writeUnexpectedCharacterMessage(lookahead)));
+};
+export const writeUnexpectedCharacterMessage = (char, shouldBe = "") => `'${char}' is not allowed here${shouldBe && ` (should be ${shouldBe})`}`;
+export const incompleteArrayTokenMessage = `Missing expected ']'`;

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

@@ -0,0 +1,33 @@
+import { type Scanner } from "@ark/util";
+import type { Comparator } from "../reduce/shared.ts";
+export declare const terminatingChars: {
+    readonly " ": 1;
+    readonly "\n": 1;
+    readonly "\t": 1;
+    readonly "<": 1;
+    readonly ">": 1;
+    readonly "=": 1;
+    readonly "|": 1;
+    readonly "&": 1;
+    readonly ")": 1;
+    readonly "[": 1;
+    readonly "%": 1;
+    readonly ",": 1;
+    readonly ":": 1;
+    readonly "?": 1;
+    readonly "#": 1;
+};
+export type TerminatingChar = keyof typeof terminatingChars;
+export declare const finalizingLookaheads: {
+    readonly ">": 1;
+    readonly ",": 1;
+    readonly "": 1;
+    readonly "=": 1;
+    readonly "?": 1;
+};
+export type FinalizingLookahead = keyof typeof finalizingLookaheads;
+export declare const lookaheadIsFinalizing: (lookahead: string, unscanned: string) => lookahead is ">" | "," | "=" | "?";
+export type lookaheadIsFinalizing<lookahead extends string, unscanned extends string> = lookahead extends ">" ? unscanned extends `=${infer nextUnscanned}` ? nextUnscanned extends `=${string}` ? true : false : Scanner.skipWhitespace<unscanned> extends ("" | `${TerminatingChar}${string}`) ? true : false : lookahead extends "=" ? unscanned extends `=${string}` ? false : true : lookahead extends "," | "?" ? true : false;
+export type InfixToken = Comparator | "|" | "&" | "%" | ":" | "=>" | "|>" | "#" | "@" | "=";
+export type PostfixToken = "[]" | "?";
+export type OperatorToken = InfixToken | PostfixToken;

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

@@ -0,0 +1,37 @@
+import { isKeyOf, whitespaceChars } from "@ark/util";
+export const terminatingChars = {
+    "<": 1,
+    ">": 1,
+    "=": 1,
+    "|": 1,
+    "&": 1,
+    ")": 1,
+    "[": 1,
+    "%": 1,
+    ",": 1,
+    ":": 1,
+    "?": 1,
+    "#": 1,
+    ...whitespaceChars
+};
+export const finalizingLookaheads = {
+    ">": 1,
+    ",": 1,
+    "": 1,
+    "=": 1,
+    "?": 1
+};
+export const lookaheadIsFinalizing = (lookahead, unscanned) => lookahead === ">" ?
+    unscanned[0] === "=" ?
+        // >== would only occur in an expression like Array<number>==5
+        // otherwise, >= would only occur as part of a bound like number>=5
+        unscanned[1] === "="
+        // if > is the end of a generic instantiation, the next token will be
+        // an operator or the end of the string
+        : unscanned.trimStart() === "" ||
+            isKeyOf(unscanned.trimStart()[0], terminatingChars)
+    // "=" is a finalizer on its own (representing a default value),
+    // but not with a second "=" (an equality comparator)
+    : lookahead === "=" ? unscanned[0] !== "="
+        // "," and "?" are unambiguously finalizers
+        : lookahead === "," || lookahead === "?";

package/node_modules/arktype/out/parser/string.d.ts

@@ -0,0 +1,30 @@
+import type { BaseParseContext, resolvableReferenceIn } from "@ark/schema";
+import { type ErrorMessage } from "@ark/util";
+import type { ArkAmbient } from "../config.ts";
+import type { InnerParseResult, resolutionToAst } from "../scope.ts";
+import type { inferAstRoot } from "./ast/infer.ts";
+import { RuntimeState, type RootedRuntimeState } from "./reduce/dynamic.ts";
+import type { StringifiablePrefixOperator } from "./reduce/shared.ts";
+import type { s, StaticState } from "./reduce/static.ts";
+import type { parseOperand } from "./shift/operand/operand.ts";
+import { parseDefault } from "./shift/operator/default.ts";
+import { writeUnexpectedCharacterMessage, type parseOperator } from "./shift/operator/operator.ts";
+export declare const parseString: (def: string, ctx: BaseParseContext) => InnerParseResult;
+/**
+ * Try to parse the definition from right to left using the most common syntax.
+ * This can be much more efficient for simple definitions.
+ */
+export type parseString<def extends string, $, args> = def extends keyof $ ? resolutionToAst<def, $[def]> : def extends `${infer child}[]` ? child extends keyof $ ? [
+    resolutionToAst<child, $[child]>,
+    "[]"
+] : fullStringParse<s.initialize<def>, $, args> : fullStringParse<s.initialize<def>, $, args>;
+export type inferString<def extends string, $, args> = inferAstRoot<parseString<def, $, args>, $, args>;
+export type BaseCompletions<$, args, otherSuggestions extends string = never> = resolvableReferenceIn<$> | resolvableReferenceIn<ArkAmbient.$> | (keyof args & string) | StringifiablePrefixOperator | otherSuggestions;
+export declare const fullStringParse: (s: RuntimeState) => InnerParseResult;
+type fullStringParse<s extends StaticState, $, args> = extractFinalizedResult<parseUntilFinalizer<s, $, args>>;
+export declare const parseUntilFinalizer: (s: RuntimeState) => RootedRuntimeState;
+export type parseUntilFinalizer<s extends StaticState, $, args> = s["finalizer"] extends undefined ? parseUntilFinalizer<next<s, $, args>, $, args> : s;
+declare const next: (s: RuntimeState) => void;
+type next<s extends StaticState, $, args> = s["root"] extends undefined ? parseOperand<s, $, args> : parseOperator<s, $, args>;
+export type extractFinalizedResult<s extends StaticState> = s["finalizer"] extends "" ? s["root"] : s["finalizer"] extends ErrorMessage ? s["finalizer"] : s["finalizer"] extends "?" ? [s["root"], "?"] : s["finalizer"] extends "=" ? parseDefault<s["root"], s["unscanned"]> : ErrorMessage<writeUnexpectedCharacterMessage<s["finalizer"] & string>>;
+export {};

package/node_modules/arktype/out/parser/string.js

@@ -0,0 +1,42 @@
+import { Scanner, throwInternalError, throwParseError } from "@ark/util";
+import { RuntimeState } from "./reduce/dynamic.js";
+import { parseDefault } from "./shift/operator/default.js";
+import { writeUnexpectedCharacterMessage } from "./shift/operator/operator.js";
+export const parseString = (def, ctx) => {
+    const aliasResolution = ctx.$.maybeResolveRoot(def);
+    if (aliasResolution)
+        return aliasResolution;
+    if (def.endsWith("[]")) {
+        const possibleElementResolution = ctx.$.maybeResolveRoot(def.slice(0, -2));
+        if (possibleElementResolution)
+            return possibleElementResolution.array();
+    }
+    const s = new RuntimeState(new Scanner(def), ctx);
+    const node = fullStringParse(s);
+    if (s.finalizer === ">")
+        throwParseError(writeUnexpectedCharacterMessage(">"));
+    return node;
+};
+export const fullStringParse = (s) => {
+    s.parseOperand();
+    let result = parseUntilFinalizer(s).root;
+    if (!result) {
+        return throwInternalError(`Root was unexpectedly unset after parsing string '${s.scanner.scanned}'`);
+    }
+    if (s.finalizer === "=")
+        result = parseDefault(s);
+    else if (s.finalizer === "?")
+        result = [result, "?"];
+    s.scanner.shiftUntilNonWhitespace();
+    if (s.scanner.lookahead) {
+        // throw a parse error if non-whitespace characters made it here without being parsed
+        throwParseError(writeUnexpectedCharacterMessage(s.scanner.lookahead));
+    }
+    return result;
+};
+export const parseUntilFinalizer = (s) => {
+    while (s.finalizer === undefined)
+        next(s);
+    return s;
+};
+const next = (s) => s.hasRoot() ? s.parseOperator() : s.parseOperand();

package/node_modules/arktype/out/parser/tupleExpressions.d.ts

@@ -0,0 +1,79 @@
+import { type BaseParseContext, type BaseRoot, type Morph, type NodeSelector, type Predicate, type TypeMeta, type unwrapDefault } from "@ark/schema";
+import { type array, type BuiltinObjectKind, type Constructor, type Domain, type show } from "@ark/util";
+import type { defaultFor, distill, inferIntersection, inferMorphOut, inferPipe, inferPredicate, Out, withDefault } from "../attributes.ts";
+import type { type } from "../keywords/keywords.ts";
+import type { inferDefinition, validateDefinition } from "./definition.ts";
+import { writeMissingRightOperandMessage } from "./shift/operand/unenclosed.ts";
+import type { InfixToken } from "./shift/tokens.ts";
+import type { BaseCompletions } from "./string.ts";
+export declare const maybeParseTupleExpression: (def: array, ctx: BaseParseContext) => BaseRoot | null;
+export type maybeValidateTupleExpression<def extends array, $, args> = def extends IndexZeroExpression ? validatePrefixExpression<def, $, args> : def extends IndexOneExpression ? validateIndexOneExpression<def, $, args> : def extends (readonly ["", ...unknown[]] | readonly [unknown, "", ...unknown[]]) ? readonly [
+    def[0] extends "" ? BaseCompletions<$, args, IndexZeroOperator | "..."> : def[0],
+    def[1] extends "" ? BaseCompletions<$, args, IndexOneOperator | "..."> : def[1]
+] : null;
+export type inferTupleExpression<def extends TupleExpression, $, args> = def[1] extends "[]" ? inferDefinition<def[0], $, args>[] : def[1] extends "?" ? inferDefinition<def[0], $, args> : def[1] extends "&" ? inferIntersection<inferDefinition<def[0], $, args>, inferDefinition<def[2], $, args>> : def[1] extends "|" ? inferDefinition<def[0], $, args> | inferDefinition<def[2], $, args> : def[1] extends ":" ? inferPredicate<inferDefinition<def[0], $, args>, def[2]> : def[1] extends "=>" ? parseMorph<def[0], def[2], $, args> : def[1] extends "|>" ? parseTo<def[0], def[2], $, args> : def[1] extends "=" ? withDefault<inferDefinition<def[0], $, args>, unwrapDefault<def[2]>> : def[1] extends "@" ? inferDefinition<def[0], $, args> : def extends readonly ["===", ...infer values] ? values[number] : def extends (readonly ["instanceof", ...infer constructors extends Constructor[]]) ? InstanceType<constructors[number]> : def[0] extends "keyof" ? inferKeyOfExpression<def[1], $, args> : never;
+export type validatePrefixExpression<def extends IndexZeroExpression, $, args> = def["length"] extends 1 ? readonly [writeMissingRightOperandMessage<def[0]>] : def[0] extends "keyof" ? readonly [def[0], validateDefinition<def[1], $, args>] : def[0] extends "===" ? readonly [def[0], ...unknown[]] : def[0] extends "instanceof" ? readonly [def[0], ...Constructor[]] : never;
+export type validateIndexOneExpression<def extends IndexOneExpression, $, args> = def[1] extends TuplePostfixOperator ? readonly [validateDefinition<def[0], $, args>, def[1]] : readonly [
+    validateDefinition<def[0], $, args>,
+    def["length"] extends 2 ? writeMissingRightOperandMessage<def[1]> : def[1],
+    def[1] extends "|" ? validateDefinition<def[2], $, args> : def[1] extends "&" ? validateDefinition<def[2], $, args> : def[1] extends ":" ? Predicate<type.infer.Out<def[0], $, args>> : def[1] extends "=>" ? Morph<type.infer.Out<def[0], $, args>> : def[1] extends "|>" ? validateDefinition<def[2], $, args> : def[1] extends "=" ? defaultFor<type.infer.In<def[0], $, args>> : def[1] extends "@" ? TypeMeta.MappableInput : validateDefinition<def[2], $, args>,
+    ...(def[1] extends "@" ? [NodeSelector?] : [])
+];
+export type UnparsedTupleExpressionInput = {
+    instanceof: Constructor;
+    "===": unknown;
+};
+export type UnparsedTupleOperator = show<keyof UnparsedTupleExpressionInput>;
+export declare const parseKeyOfTuple: IndexZeroParser<"keyof">;
+export type inferKeyOfExpression<operandDef, $, args> = show<keyof inferDefinition<operandDef, $, args>>;
+export type TupleExpression = IndexZeroExpression | IndexOneExpression;
+export type TupleExpressionOperator = IndexZeroOperator | IndexOneOperator;
+export type ArgTwoOperator = Exclude<IndexOneOperator, "?" | "=">;
+export declare const parseMorphTuple: IndexOneParser<"=>">;
+export declare const writeMalformedFunctionalExpressionMessage: (operator: ":" | "=>", value: unknown) => string;
+export type parseTo<inDef, outDef, $, args> = inferPipe<inferDefinition<inDef, $, args>, inferDefinition<outDef, $, args>>;
+export type parseMorph<inDef, morph, $, args> = morph extends Morph ? inferMorphOut<morph> extends infer out ? (In: distill.In<inferDefinition<inDef, $, args>>) => Out<out> : never : never;
+export declare const parseNarrowTuple: IndexOneParser<":">;
+export type IndexOneExpression<token extends string = IndexOneOperator> = readonly [unknown, token, ...unknown[]];
+type IndexOneParser<token extends string> = (def: IndexOneExpression<token>, ctx: BaseParseContext) => BaseRoot;
+declare const postfixParsers: {
+    "?": IndexOneParser<"?">;
+    "[]": IndexOneParser<"[]">;
+};
+export type TuplePostfixOperator = keyof typeof postfixParsers;
+declare const infixParsers: {
+    "&": IndexOneParser<"&">;
+    "|": IndexOneParser<"|">;
+    "|>": IndexOneParser<"|>">;
+    "=": IndexOneParser<"=">;
+    ":": IndexOneParser<":">;
+    "=>": IndexOneParser<"=>">;
+    "@": IndexOneParser<"@">;
+};
+export type TupleInfixOperator = keyof typeof infixParsers;
+declare const indexOneParsers: {
+    "&": IndexOneParser<"&">;
+    "|": IndexOneParser<"|">;
+    "|>": IndexOneParser<"|>">;
+    "=": IndexOneParser<"=">;
+    ":": IndexOneParser<":">;
+    "=>": IndexOneParser<"=>">;
+    "@": IndexOneParser<"@">;
+    "?": IndexOneParser<"?">;
+    "[]": IndexOneParser<"[]">;
+};
+export type IndexOneOperator = keyof typeof indexOneParsers;
+export type InfixExpression = readonly [unknown, InfixToken, ...unknown[]];
+type IndexZeroParser<token extends string> = (def: IndexZeroExpression<token>, ctx: BaseParseContext) => BaseRoot;
+type IndexZeroExpression<token extends string = IndexZeroOperator> = readonly [
+    token,
+    ...unknown[]
+];
+declare const indexZeroParsers: {
+    keyof: IndexZeroParser<"keyof">;
+    instanceof: IndexZeroParser<"instanceof">;
+    "===": IndexZeroParser<"===">;
+};
+export type IndexZeroOperator = keyof typeof indexZeroParsers;
+export declare const writeInvalidConstructorMessage: <actual extends Domain | BuiltinObjectKind>(actual: actual) => string;
+export {};

package/node_modules/arktype/out/parser/tupleExpressions.js

@@ -0,0 +1,75 @@
+import { Disjoint, intersectNodesRoot, pipeNodesRoot } from "@ark/schema";
+import { objectKindOrDomainOf, throwParseError } from "@ark/util";
+import { shallowDefaultableMessage, shallowOptionalMessage } from "./ast/validate.js";
+import { writeMissingRightOperandMessage } from "./shift/operand/unenclosed.js";
+export const maybeParseTupleExpression = (def, ctx) => isIndexZeroExpression(def) ? indexZeroParsers[def[0]](def, ctx)
+    : isIndexOneExpression(def) ? indexOneParsers[def[1]](def, ctx)
+        : null;
+export const parseKeyOfTuple = (def, ctx) => ctx.$.parseOwnDefinitionFormat(def[1], ctx).keyof();
+const parseBranchTuple = (def, ctx) => {
+    if (def[2] === undefined)
+        return throwParseError(writeMissingRightOperandMessage(def[1], ""));
+    const l = ctx.$.parseOwnDefinitionFormat(def[0], ctx);
+    const r = ctx.$.parseOwnDefinitionFormat(def[2], ctx);
+    if (def[1] === "|")
+        return ctx.$.node("union", { branches: [l, r] });
+    const result = def[1] === "&" ?
+        intersectNodesRoot(l, r, ctx.$)
+        : pipeNodesRoot(l, r, ctx.$);
+    if (result instanceof Disjoint)
+        return result.throw();
+    return result;
+};
+const parseArrayTuple = (def, ctx) => ctx.$.parseOwnDefinitionFormat(def[0], ctx).array();
+export const parseMorphTuple = (def, ctx) => {
+    if (typeof def[2] !== "function") {
+        return throwParseError(writeMalformedFunctionalExpressionMessage("=>", def[2]));
+    }
+    return ctx.$.parseOwnDefinitionFormat(def[0], ctx).pipe(def[2]);
+};
+export const writeMalformedFunctionalExpressionMessage = (operator, value) => `${operator === ":" ? "Narrow" : "Morph"} expression requires a function following '${operator}' (was ${typeof value})`;
+export const parseNarrowTuple = (def, ctx) => {
+    if (typeof def[2] !== "function") {
+        return throwParseError(writeMalformedFunctionalExpressionMessage(":", def[2]));
+    }
+    return ctx.$.parseOwnDefinitionFormat(def[0], ctx).constrain("predicate", def[2]);
+};
+const parseMetaTuple = (def, ctx) => ctx.$.parseOwnDefinitionFormat(def[0], ctx).configure(def[2], def[3]);
+const defineIndexOneParsers = (parsers) => parsers;
+const postfixParsers = defineIndexOneParsers({
+    "[]": parseArrayTuple,
+    "?": () => throwParseError(shallowOptionalMessage)
+});
+const infixParsers = defineIndexOneParsers({
+    "|": parseBranchTuple,
+    "&": parseBranchTuple,
+    ":": parseNarrowTuple,
+    "=>": parseMorphTuple,
+    "|>": parseBranchTuple,
+    "@": parseMetaTuple,
+    // since object and tuple literals parse there via `parseProperty`,
+    // they must be shallow if parsed directly as a tuple expression
+    "=": () => throwParseError(shallowDefaultableMessage)
+});
+const indexOneParsers = { ...postfixParsers, ...infixParsers };
+const isIndexOneExpression = (def) => indexOneParsers[def[1]] !== undefined;
+const defineIndexZeroParsers = (parsers) => parsers;
+const indexZeroParsers = defineIndexZeroParsers({
+    keyof: parseKeyOfTuple,
+    instanceof: (def, ctx) => {
+        if (typeof def[1] !== "function") {
+            return throwParseError(writeInvalidConstructorMessage(objectKindOrDomainOf(def[1])));
+        }
+        const branches = def
+            .slice(1)
+            .map(ctor => typeof ctor === "function" ?
+            ctx.$.node("proto", { proto: ctor })
+            : throwParseError(writeInvalidConstructorMessage(objectKindOrDomainOf(ctor))));
+        return branches.length === 1 ?
+            branches[0]
+            : ctx.$.node("union", { branches });
+    },
+    "===": (def, ctx) => ctx.$.units(def.slice(1))
+});
+const isIndexZeroExpression = (def) => indexZeroParsers[def[0]] !== undefined;
+export const writeInvalidConstructorMessage = (actual) => `Expected a constructor following 'instanceof' operator (was ${actual})`;