@r0cksolid/emerald-cli 0.0.0-stage → 0.1.0

package/dist/main.mjs

@@ -0,0 +1,4609 @@
+#!/usr/bin/env node
+import { $ as IsLiteralString, $t as IsMultipleOf$1, A as Instantiate, At as IsSet, B as Tuple, Bt as IsBoolean$1, Ct as Assign, Dt as Get$3, E as isLevelStyle, Et as Unreachable, F as IsRecord, Ft as Every$1, G as String$1, Gt as IsFunction$1, H as IsUnion, Ht as IsConstructor$1, I as Record, It as EveryAll, J as IsNull$2, Jt as IsInteger$1, K as IsSymbol$2, Kt as IsGreaterEqualThan$1, L as RecordPattern, Lt as HasPropertyKey$1, M as IsTemplateLiteral, Mt as Counted$1, N as IsVoid, Nt as Entries$1, O as Priority, Ot as IsMap, P as IsUndefined$2, Pt as EntriesRegExp, Q as IsLiteralNumber, Qt as IsMinLength$2, R as RecordValue, Rt as IsArray$1, S as createItemCatalog, St as IsSchema$1, T as LevelStyleSchema, Tt as hash_exports, U as Union, Ut as IsDeepEqual$1, V as TemplateLiteralDecode, Vt as IsClassInstance, W as IsString$2, Wt as IsEqual$1, X as IsLiteralBigInt, Xt as IsLessThan$1, Y as IsLiteral, Yt as IsLessEqualThan$1, Z as IsLiteralBoolean, Zt as IsMaxLength$2, _t as IsFunction$2, a as formatWays, an as IsSymbol$1, at as Intersect, b as SnapshotSchema, bt as IsArray$2, c as tagsText, cn as IsValueLike, ct as IsCyclic, d as heading, dn as SomeAll$1, dt as _Object_, en as IsNull$1, et as Literal, f as title, fn as Symbols, ft as IsOptional, gt as Ref$1, h as itemWays, ht as IsRef$1, i as durationText, in as IsString$1, it as IsCodec, j as With, jt as IsTypeArray, k as Evaluate$1, kt as IsRegExp, l as waySections, ln as Keys$1, lt as Unknown, m as isListedWay, mt as IsNever, n as NO_WAY, nn as IsObject$1, nt as IsBoolean$2, on as IsUndefined$1, ot as IsIntersect, p as itemPlan, pn as guard_exports, pt as Optional, q as IsNumber$2, qt as IsGreaterThan$1, rn as IsObjectNotArray$1, rt as IsBigInt$2, s as number, sn as IsUnsafePropertyKey, st as IsEnum$1, t as METHOD_NAMES, tn as IsNumber$1, tt as IsInteger$2, u as dim, un as Some$1, ut as IsObject$2, vt as IsConstructor$2, w as LEVEL_STYLES, wt as Hash, x as checkStatGlyphs, xt as _Array_, y as MetaSchema, yt as ArrayOptions, z as IsTuple, zt as IsBigInt$1 } from "./format-ways-CBqYIK0Q.mjs";
+import { lstat, mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { homedir } from "node:os";
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/system/arguments/arguments.mjs
+/**
+* Match arguments for overloaded functions that use the `...args: unknown[]` pattern. Arguments
+* are parsed using argument length only.
+*/
+function Match$1(args, match) {
+	return match[args.length]?.(...args) ?? (() => {
+		throw Error("Invalid Arguments");
+	})();
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/guard/emit.mjs
+const identifierRegExp = /^[\p{ID_Start}_$][\p{ID_Continue}_$\u200C\u200D]*$/u;
+/** Returns true if this value is a valid JavaScript identifier */
+function IsIdentifier(value) {
+	return identifierRegExp.test(value);
+}
+function And(left, right) {
+	return `(${left} && ${right})`;
+}
+function Or(left, right) {
+	return `(${left} || ${right})`;
+}
+function Not(expr) {
+	return `!(${expr})`;
+}
+/** Returns true if this value is an array */
+function IsArray(value) {
+	return `Array.isArray(${value})`;
+}
+/** Returns true if this value is bigint */
+function IsBigInt(value) {
+	return `typeof ${value} === "bigint"`;
+}
+/** Returns true if this value is a boolean */
+function IsBoolean(value) {
+	return `typeof ${value} === "boolean"`;
+}
+/** Returns true if this value is integer */
+function IsInteger(value) {
+	return `Number.isInteger(${value})`;
+}
+/** Returns true if this value is null */
+function IsNull(value) {
+	return `${value} === null`;
+}
+/** Returns true if this value is number */
+function IsNumber(value) {
+	return `Number.isFinite(${value})`;
+}
+/** Returns true if this value is an object but not an array */
+function IsObjectNotArray(value) {
+	return And(IsObject(value), Not(IsArray(value)));
+}
+/** Returns true if this value is an object */
+function IsObject(value) {
+	return `typeof ${value} === "object" && ${value} !== null`;
+}
+/** Returns true if this value is string */
+function IsString(value) {
+	return `typeof ${value} === "string"`;
+}
+/** Returns true if this value is symbol */
+function IsSymbol(value) {
+	return `typeof ${value} === "symbol"`;
+}
+/** Returns true if this value is undefined */
+function IsUndefined(value) {
+	return `${value} === undefined`;
+}
+function IsFunction(value) {
+	return `typeof ${value} === "function"`;
+}
+function IsConstructor(value) {
+	return `Guard.IsConstructor(${value})`;
+}
+function IsEqual(left, right) {
+	return `${left} === ${right}`;
+}
+function IsGreaterThan(left, right) {
+	return `${left} > ${right}`;
+}
+function IsLessThan(left, right) {
+	return `${left} < ${right}`;
+}
+function IsLessEqualThan(left, right) {
+	return `${left} <= ${right}`;
+}
+function IsGreaterEqualThan(left, right) {
+	return `${left} >= ${right}`;
+}
+function IsMinLength$1(value, length) {
+	return `(${value}.length >= ${+length << 1} || (${value}.length >= ${length} && Guard.CodePointCount(${value}) >= ${length}))`;
+}
+function IsMaxLength$1(value, length) {
+	return `(${value}.length <= ${length} || (${value}.length <= ${+length << 1} && Guard.CodePointCount(${value}) <= ${length}))`;
+}
+function Every(value, offset, params, expression) {
+	return IsEqual$1(offset, "0") ? `${value}.every((${params[0]}, ${params[1]}) => (${expression}))` : `${value}.every((${params[0]}, ${params[1]}) => (${params[1]} < ${offset}) || (${expression}))`;
+}
+function Some(value, params, expression) {
+	return `${value}.some((${params[0]}, ${params[1]}) => ${expression})`;
+}
+function SomeAll(value, params, expression) {
+	return `((value) => { let result = false; value.forEach((${params[0]}, ${params[1]}) => { if (${expression}) result = true }); return result })(${value})`;
+}
+function Counted(value, params, expression) {
+	return `${value}.reduce((result, ${params[0]}, ${params[1]}) => (${expression}) ? ++result : result, 0)`;
+}
+function Entries(value) {
+	return `Object.entries(${value})`;
+}
+function Keys(value) {
+	return `Object.getOwnPropertyNames(${value})`;
+}
+function HasPropertyKey(value, key) {
+	return IsEqual$1(key, "\"__proto__\"") || IsEqual$1(key, "\"constructor\"") ? `Object.prototype.hasOwnProperty.call(${value}, ${key})` : `${key} in ${value}`;
+}
+function IsDeepEqual(left, right) {
+	return `Guard.IsDeepEqual(${left}, ${right})`;
+}
+function ArrayLiteral(elements) {
+	return `[${elements.join(", ")}]`;
+}
+function ArrowFunction(parameters, body) {
+	return `((${parameters.join(", ")}) => ${body})`;
+}
+function Call(value, arguments_) {
+	return `${value}(${arguments_.join(", ")})`;
+}
+function New(value, arguments_) {
+	return `new ${value}(${arguments_.join(", ")})`;
+}
+function Member(left, right) {
+	return `${left}${IsIdentifier(right) ? `.${right}` : `[${Constant(right)}]`}`;
+}
+function Constant(value) {
+	if (!IsValueLike(value)) throw Error("Unsupported Constant");
+	return IsString$1(value) ? JSON.stringify(value) : `${value}`;
+}
+function Ternary(condition, true_, false_) {
+	return `(${condition} ? ${true_} : ${false_})`;
+}
+function Statements(statements) {
+	return `{ ${statements.join("; ")}; }`;
+}
+function ConstDeclaration(identifier, expression) {
+	return `const ${identifier} = ${expression}`;
+}
+function If(condition, then) {
+	return `if(${condition}) { ${then} }`;
+}
+function Return(expression) {
+	return `return ${expression}`;
+}
+function ReduceAnd(operands) {
+	return IsEqual$1(operands.length, 0) ? "true" : operands.reduce((left, right) => And(left, right));
+}
+function ReduceOr(operands) {
+	return IsEqual$1(operands.length, 0) ? "false" : operands.reduce((left, right) => Or(left, right));
+}
+function MultipleOf(dividend, divisor) {
+	return `Guard.IsMultipleOf(${dividend}, ${divisor})`;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/guard/index.mjs
+var guard_default = guard_exports;
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/_refine.mjs
+/**
+* Returns true if the schema contains an '~refine` keyword
+* @specification None
+*/
+function IsRefine(value) {
+	return HasPropertyKey$1(value, "~refine") && IsArray$1(value["~refine"]) && Every$1(value["~refine"], 0, (value) => IsObject$1(value) && HasPropertyKey$1(value, "check") && HasPropertyKey$1(value, "error") && IsFunction$1(value.check) && IsFunction$1(value.error));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/schema.mjs
+/** Returns true if this value is object like */
+function IsSchemaObject$1(value) {
+	return IsObject$1(value) && !IsArray$1(value);
+}
+/** Returns true if this value is a boolean */
+function IsSchemaBoolean(value) {
+	return IsBoolean$1(value);
+}
+/** Returns true if this value is schema like */
+function IsSchema(value) {
+	return IsSchemaObject$1(value) || IsSchemaBoolean(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/additionalItems.mjs
+/**
+* Returns true if the schema contains a valid additionalItems property
+* @specification Json Schema 7
+*/
+function IsAdditionalItems(schema) {
+	return HasPropertyKey$1(schema, "additionalItems") && IsSchema(schema.additionalItems);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/additionalProperties.mjs
+/**
+* Returns true if the schema contains a valid additionalProperties property
+* @specification Json Schema 7
+*/
+function IsAdditionalProperties(schema) {
+	return HasPropertyKey$1(schema, "additionalProperties") && IsSchema(schema.additionalProperties);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/allOf.mjs
+/**
+* Returns true if the schema contains a valid allOf property
+* @specification Json Schema 7
+*/
+function IsAllOf(schema) {
+	return HasPropertyKey$1(schema, "allOf") && IsArray$1(schema.allOf) && schema.allOf.every((value) => IsSchema(value));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/anchor.mjs
+/**
+* Returns true if the schema contains a valid $anchor property
+*/
+function IsAnchor(schema) {
+	return HasPropertyKey$1(schema, "$anchor") && IsString$1(schema.$anchor);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/anyOf.mjs
+/**
+* Returns true if the schema contains a valid anyOf property
+* @specification Json Schema 7
+*/
+function IsAnyOf(schema) {
+	return HasPropertyKey$1(schema, "anyOf") && IsArray$1(schema.anyOf) && schema.anyOf.every((value) => IsSchema(value));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/const.mjs
+/**
+* Returns true if the schema contains a valid const property
+* @specification Json Schema 7
+*/
+function IsConst(value) {
+	return HasPropertyKey$1(value, "const");
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/contains.mjs
+/**
+* Returns true if the schema contains a valid contains property
+* @specification Json Schema 7
+*/
+function IsContains(schema) {
+	return HasPropertyKey$1(schema, "contains") && IsSchema(schema.contains);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/default.mjs
+/**
+* Returns true if the schema contains a valid contentMediaType property
+* @specification Json Schema 7
+*/
+function IsDefault(schema) {
+	return HasPropertyKey$1(schema, "default");
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/dependencies.mjs
+/**
+* Returns true if the schema contains a valid dependencies property
+* @specification Json Schema 7
+*/
+function IsDependencies(schema) {
+	return HasPropertyKey$1(schema, "dependencies") && IsObject$1(schema.dependencies) && Object.values(schema.dependencies).every((value) => IsSchema(value) || IsArray$1(value) && value.every((value) => IsString$1(value)));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/dependentRequired.mjs
+/**
+* Returns true if the schema contains a valid dependentRequired property
+* @specification Json Schema 2019-09
+*/
+function IsDependentRequired(schema) {
+	return HasPropertyKey$1(schema, "dependentRequired") && IsObject$1(schema.dependentRequired) && Object.values(schema.dependentRequired).every((value) => IsArray$1(value) && value.every((value) => IsString$1(value)));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/dependentSchemas.mjs
+/**
+* Returns true if the schema contains a valid dependentRequired property
+* @specification Json Schema 2019-09
+*/
+function IsDependentSchemas(schema) {
+	return HasPropertyKey$1(schema, "dependentSchemas") && IsObject$1(schema.dependentSchemas) && Object.values(schema.dependentSchemas).every((value) => IsSchema(value));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/dynamicAnchor.mjs
+/**
+* Returns true if the schema contains a valid $dynamicAnchor property
+*/
+function IsDynamicAnchor(schema) {
+	return HasPropertyKey$1(schema, "$dynamicAnchor") && IsString$1(schema.$dynamicAnchor);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/dynamicRef.mjs
+/**
+* Returns true if the schema contains a valid $dynamicRef property
+*/
+function IsDynamicRef(schema) {
+	return HasPropertyKey$1(schema, "$dynamicRef") && IsString$1(schema.$dynamicRef);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/else.mjs
+/**
+* Returns true if the schema contains a valid else property
+* @specification Json Schema 7
+*/
+function IsElse(schema) {
+	return HasPropertyKey$1(schema, "else") && IsSchema(schema.else);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/enum.mjs
+/**
+* Returns true if the schema contains a valid enum property
+* @specification Json Schema 7
+*/
+function IsEnum(schema) {
+	return HasPropertyKey$1(schema, "enum") && IsArray$1(schema.enum);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/exclusiveMaximum.mjs
+/**
+* Returns true if the schema contains a valid exclusiveMaximum property
+* @specification Json Schema 7
+*/
+function IsExclusiveMaximum(schema) {
+	return HasPropertyKey$1(schema, "exclusiveMaximum") && (IsNumber$1(schema.exclusiveMaximum) || IsBigInt$1(schema.exclusiveMaximum));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/exclusiveMinimum.mjs
+/**
+* Returns true if the schema contains a valid exclusiveMinimum property
+* @specification Json Schema 7
+*/
+function IsExclusiveMinimum(schema) {
+	return HasPropertyKey$1(schema, "exclusiveMinimum") && (IsNumber$1(schema.exclusiveMinimum) || IsBigInt$1(schema.exclusiveMinimum));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/format.mjs
+/**
+* Returns true if the schema contains a valid format property
+* @specification Json Schema 7
+*/
+function IsFormat(schema) {
+	return HasPropertyKey$1(schema, "format") && IsString$1(schema.format);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/id.mjs
+/**
+* Returns true if the schema contains a valid $id property
+* @specification Json Schema 7
+*/
+function IsId(schema) {
+	return HasPropertyKey$1(schema, "$id") && IsString$1(schema.$id);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/if.mjs
+/**
+* Returns true if the schema contains a valid $id property
+* @specification Json Schema 7
+*/
+function IsIf(schema) {
+	return HasPropertyKey$1(schema, "if") && IsSchema(schema.if);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/items.mjs
+/**
+* Returns true if the schema contains a valid items property
+* @specification Json Schema 7
+*/
+function IsItems(schema) {
+	return HasPropertyKey$1(schema, "items") && (IsSchema(schema.items) || IsArray$1(schema.items) && schema.items.every((value) => {
+		return IsSchema(value);
+	}));
+}
+/** Returns true if this schema is a sized items variant */
+function IsItemsSized(schema) {
+	return IsItems(schema) && IsArray$1(schema.items);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/maximum.mjs
+/**
+* Returns true if the schema contains a valid maximum property
+* @specification Json Schema 7
+*/
+function IsMaximum(schema) {
+	return HasPropertyKey$1(schema, "maximum") && (IsNumber$1(schema.maximum) || IsBigInt$1(schema.maximum));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/maxContains.mjs
+/**
+* Returns true if the schema contains a valid maxContains property
+* @specification Json Schema 2019-09
+*/
+function IsMaxContains(schema) {
+	return HasPropertyKey$1(schema, "maxContains") && IsNumber$1(schema.maxContains);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/maxItems.mjs
+/**
+* Returns true if the schema contains a valid maxItems property
+* @specification Json Schema 7
+*/
+function IsMaxItems(schema) {
+	return HasPropertyKey$1(schema, "maxItems") && IsNumber$1(schema.maxItems);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/maxLength.mjs
+/**
+* Returns true if the schema contains a valid maxLength property
+* @specification Json Schema 7
+*/
+function IsMaxLength(schema) {
+	return HasPropertyKey$1(schema, "maxLength") && IsNumber$1(schema.maxLength);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/maxProperties.mjs
+/**
+* Returns true if the schema contains a valid maxProperties property
+* @specification Json Schema 7
+*/
+function IsMaxProperties(schema) {
+	return HasPropertyKey$1(schema, "maxProperties") && IsNumber$1(schema.maxProperties);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/minimum.mjs
+/**
+* Returns true if the schema contains a valid minimum property
+* @specification Json Schema 7
+*/
+function IsMinimum(schema) {
+	return HasPropertyKey$1(schema, "minimum") && (IsNumber$1(schema.minimum) || IsBigInt$1(schema.minimum));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/minContains.mjs
+/**
+* Returns true if the schema contains a valid maxContains property
+* @specification Json Schema 2019-09
+*/
+function IsMinContains(schema) {
+	return HasPropertyKey$1(schema, "minContains") && IsNumber$1(schema.minContains);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/minItems.mjs
+/**
+* Returns true if the schema contains a valid minItems property
+* @specification Json Schema 7
+*/
+function IsMinItems(schema) {
+	return HasPropertyKey$1(schema, "minItems") && IsNumber$1(schema.minItems);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/minLength.mjs
+/**
+* Returns true if the schema contains a valid minLength property
+* @specification Json Schema 7
+*/
+function IsMinLength(schema) {
+	return HasPropertyKey$1(schema, "minLength") && IsNumber$1(schema.minLength);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/minProperties.mjs
+/**
+* Returns true if the schema contains a valid minProperties property
+* @specification Json Schema 7
+*/
+function IsMinProperties(schema) {
+	return HasPropertyKey$1(schema, "minProperties") && IsNumber$1(schema.minProperties);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/multipleOf.mjs
+/**
+* Returns true if the schema contains a valid multipleOf property
+* @specification Json Schema 7
+*/
+function IsMultipleOf(schema) {
+	return HasPropertyKey$1(schema, "multipleOf") && (IsNumber$1(schema.multipleOf) || IsBigInt$1(schema.multipleOf));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/not.mjs
+/**
+* Returns true if the schema contains a valid not property
+* @specification Json Schema 7
+*/
+function IsNot(schema) {
+	return HasPropertyKey$1(schema, "not") && IsSchema(schema.not);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/oneOf.mjs
+/**
+* Returns true if the schema contains a valid oneOf property
+* @specification Json Schema 7
+*/
+function IsOneOf(schema) {
+	return HasPropertyKey$1(schema, "oneOf") && IsArray$1(schema.oneOf) && schema.oneOf.every((value) => IsSchema(value));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/pattern.mjs
+/**
+* Returns true if the schema contains a valid pattern property
+* @specification Json Schema 7
+*/
+function IsPattern(schema) {
+	return HasPropertyKey$1(schema, "pattern") && (IsString$1(schema.pattern) || schema.pattern instanceof RegExp);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/patternProperties.mjs
+/**
+* Returns true if the schema contains a valid patternProperties property
+* @specification Json Schema 7
+*/
+function IsPatternProperties(schema) {
+	return HasPropertyKey$1(schema, "patternProperties") && IsObject$1(schema.patternProperties) && Object.values(schema.patternProperties).every((value) => IsSchema(value));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/prefixItems.mjs
+/**
+* Returns true if the schema contains a valid prefixItems property
+*/
+function IsPrefixItems(schema) {
+	return HasPropertyKey$1(schema, "prefixItems") && IsArray$1(schema.prefixItems) && schema.prefixItems.every((schema) => IsSchema(schema));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/properties.mjs
+/**
+* Returns true if the schema contains a valid properties property
+* @specification Json Schema 7
+*/
+function IsProperties(schema) {
+	return HasPropertyKey$1(schema, "properties") && IsObject$1(schema.properties) && Object.values(schema.properties).every((value) => IsSchema(value));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/propertyNames.mjs
+/**
+* Returns true if the schema contains a valid propertyNames property
+* @specification Json Schema 7
+*/
+function IsPropertyNames(schema) {
+	return HasPropertyKey$1(schema, "propertyNames") && (IsObject$1(schema.propertyNames) || IsSchema(schema.propertyNames));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/recursiveAnchor.mjs
+/**
+* Returns true if the schema contains a valid $recursiveAnchor property
+*/
+function IsRecursiveAnchor(schema) {
+	return HasPropertyKey$1(schema, "$recursiveAnchor") && IsBoolean$1(schema.$recursiveAnchor);
+}
+/**
+* Returns true if the schema contains a valid $recursiveAnchor property that is true
+*/
+function IsRecursiveAnchorTrue(schema) {
+	return IsRecursiveAnchor(schema) && IsEqual$1(schema.$recursiveAnchor, true);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/recursiveRef.mjs
+/**
+* Returns true if the schema contains a valid $recursiveRef property
+*/
+function IsRecursiveRef(schema) {
+	return HasPropertyKey$1(schema, "$recursiveRef") && IsString$1(schema.$recursiveRef);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/ref.mjs
+/**
+* Returns true if the schema contains a valid $ref property
+* @specification Json Schema 7
+*/
+function IsRef(schema) {
+	return HasPropertyKey$1(schema, "$ref") && IsString$1(schema.$ref);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/required.mjs
+/**
+* Returns true if the schema contains a valid required property
+* @specification Json Schema 7
+*/
+function IsRequired(schema) {
+	return HasPropertyKey$1(schema, "required") && IsArray$1(schema.required) && schema.required.every((value) => IsString$1(value));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/then.mjs
+/**
+* Returns true if the schema contains a valid then property
+* @specification Json Schema 7
+*/
+function IsThen(schema) {
+	return HasPropertyKey$1(schema, "then") && IsSchema(schema.then);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/type.mjs
+/**
+* Returns true if the schema contains a valid type property
+* @specification Json Schema 7
+*/
+function IsType(schema) {
+	return HasPropertyKey$1(schema, "type") && (IsString$1(schema.type) || IsArray$1(schema.type) && schema.type.every((value) => IsString$1(value)));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/uniqueItems.mjs
+/**
+* Returns true if the schema contains a valid uniqueItems property
+* @specification Json Schema 7
+*/
+function IsUniqueItems(schema) {
+	return HasPropertyKey$1(schema, "uniqueItems") && IsBoolean$1(schema.uniqueItems);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/unevaluatedItems.mjs
+/**
+* Returns true if the schema contains a valid unevaluatedItems property
+* @specification Json Schema 2019-09
+*/
+function IsUnevaluatedItems(schema) {
+	return HasPropertyKey$1(schema, "unevaluatedItems") && IsSchema(schema.unevaluatedItems);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/types/unevaluatedProperties.mjs
+/**
+* Returns true if the schema contains a valid unevaluatedProperties property
+* @specification Json Schema 2019-09
+*/
+function IsUnevaluatedProperties(schema) {
+	return HasPropertyKey$1(schema, "unevaluatedProperties") && IsSchema(schema.unevaluatedProperties);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/_context.mjs
+function HasUnevaluatedFromObject(value) {
+	return IsUnevaluatedItems(value) || IsUnevaluatedProperties(value) || Some$1(Keys$1(value), (key) => HasUnevaluatedFromUnknown(value[key]));
+}
+function HasUnevaluatedFromArray(value) {
+	return Some$1(value, (value) => HasUnevaluatedFromUnknown(value));
+}
+function HasUnevaluatedFromUnknown(value) {
+	return IsArray$1(value) ? HasUnevaluatedFromArray(value) : IsObject$1(value) ? HasUnevaluatedFromObject(value) : false;
+}
+function HasUnevaluated(context, schema) {
+	return HasUnevaluatedFromUnknown(schema) || Some$1(Keys$1(context), (key) => HasUnevaluatedFromUnknown(context[key]));
+}
+var BuildContext = class {
+	constructor(hasUnevaluated) {
+		this.hasUnevaluated = hasUnevaluated;
+	}
+	UseUnevaluated() {
+		return this.hasUnevaluated;
+	}
+	Push() {
+		return Call(Member("context", "Push"), []);
+	}
+	Pop() {
+		return Call(Member("context", "Pop"), []);
+	}
+	AddIndex(index) {
+		return Call(Member("context", "AddIndex"), [index]);
+	}
+	AddKey(key) {
+		return Call(Member("context", "AddKey"), [key]);
+	}
+	Merge(results) {
+		return Call(Member("context", "Merge"), [results]);
+	}
+};
+var CheckContext = class {
+	constructor() {
+		const indices = /* @__PURE__ */ new Set();
+		const keys = /* @__PURE__ */ new Set();
+		this.stack = [{
+			indices,
+			keys
+		}];
+	}
+	Push() {
+		const indices = /* @__PURE__ */ new Set();
+		const keys = /* @__PURE__ */ new Set();
+		this.stack.push({
+			indices,
+			keys
+		});
+		return true;
+	}
+	Pop() {
+		this.stack.pop();
+		return true;
+	}
+	AddIndex(index) {
+		this.GetIndices().add(index);
+		return true;
+	}
+	AddKey(key) {
+		this.GetKeys().add(key);
+		return true;
+	}
+	GetIndices() {
+		return this.stack[this.stack.length - 1].indices;
+	}
+	GetKeys() {
+		return this.stack[this.stack.length - 1].keys;
+	}
+	Merge(results) {
+		for (const context of results) {
+			context.GetIndices().forEach((value) => this.GetIndices().add(value));
+			context.GetKeys().forEach((value) => this.GetKeys().add(value));
+		}
+		return true;
+	}
+};
+var ErrorContext = class extends CheckContext {
+	constructor() {
+		super();
+		this.errors = [];
+	}
+	AtCapacity() {
+		return this.errors.length >= Get$3().maxErrors;
+	}
+	AddError(keyword, schemaPath, instancePath, params) {
+		return this.AddErrorObject({
+			keyword,
+			schemaPath,
+			instancePath,
+			params
+		});
+	}
+	AddErrors(error) {
+		error.forEach((error) => this.AddErrorObject(error));
+		return false;
+	}
+	GetErrors() {
+		return this.errors;
+	}
+	AddErrorObject(error) {
+		if (!this.AtCapacity()) this.errors.push(error);
+		return false;
+	}
+};
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/_externals.mjs
+const state = {
+	identifier: "External",
+	variables: []
+};
+function CreateVariable(value) {
+	const call = `External[${state.variables.length}]`;
+	state.variables.push(value);
+	return call;
+}
+function ResetExternal() {
+	state.variables = [];
+}
+function GetExternal() {
+	return { ...state };
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/_refine.mjs
+function BuildRefineMultiple(_stack, _context, schema, value) {
+	return Every(CreateVariable(schema["~refine"]), Constant(0), ["refinement", "_"], Call(Member("refinement", "check"), [value]));
+}
+function BuildRefineSingle(_stack, _context, schema, value) {
+	return Call(Member(CreateVariable(schema["~refine"][0]), "check"), [value]);
+}
+function BuildRefine(_stack, _context, schema, value) {
+	return IsEqual$1(schema["~refine"].length, 1) ? BuildRefineSingle(_stack, _context, schema, value) : BuildRefineMultiple(_stack, _context, schema, value);
+}
+function CheckRefine(_stack, _context, schema, value) {
+	return Every$1(schema["~refine"], 0, (refinement, _) => refinement.check(value));
+}
+function ErrorRefine(_stack, context, schemaPath, instancePath, schema, value) {
+	return EveryAll(schema["~refine"], 0, (refinement, index) => {
+		return refinement.check(value) || context.AddError("~refine", schemaPath, instancePath, {
+			index,
+			message: refinement.error(value)
+		});
+	});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/_stack.mjs
+const DefaultUri = "urn:typebox:root";
+function NextUri(ref, base) {
+	return URL.canParse(ref, base) ? new URL(ref, base) : IsEqual$1(base, "urn:typebox:root") ? new URL(`${base}:${ref}`) : new URL(`${base.slice(0, base.lastIndexOf(":"))}:${ref}`);
+}
+function Stack(context, schema) {
+	const base = IsSchemaObject$1(schema) && IsId(schema) ? NextUri(schema.$id, DefaultUri).href : DefaultUri;
+	return {
+		context,
+		schema,
+		lexicalSchema: schema,
+		lexicalBase: base,
+		resourceBase: base,
+		referenceBase: base,
+		ids: [],
+		useResourceBaseForReference: true,
+		recursiveAnchor: void 0,
+		dynamicAnchors: [],
+		resourceEntries: /* @__PURE__ */ new Map(),
+		pendingResource: true,
+		enteredResource: false
+	};
+}
+function RegisterResourceAnchors(anchors, schema, isRoot = true) {
+	if (IsSchemaBoolean(schema)) return anchors;
+	if (Array.isArray(schema)) return schema.reduce((result, item) => RegisterResourceAnchors(result, item, false), anchors);
+	if (!IsSchemaObject$1(schema)) return anchors;
+	if (!isRoot && IsId(schema)) return anchors;
+	const next = !isRoot && IsDynamicAnchor(schema) ? [...anchors, schema] : anchors;
+	return Object.keys(schema).reduce((result, key) => RegisterResourceAnchors(result, schema[key], false), next);
+}
+function ResourceEntry(stack, schema) {
+	return stack.resourceEntries.get(schema);
+}
+function NextEnteredResource(stack, schema) {
+	return stack.enteredResource || ResourceEntry(stack, schema) !== void 0;
+}
+function IsRelativeId(schema) {
+	return !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(schema.$id);
+}
+function NextIds(stack, schema) {
+	return IsId(schema) ? [...stack.ids, schema] : stack.ids;
+}
+function NextRecursiveAnchor(stack, schema) {
+	return stack.recursiveAnchor ?? (IsRecursiveAnchorTrue(schema) ? schema : void 0);
+}
+function NextDynamicAnchors(stack, schema) {
+	const registered = IsId(schema) ? RegisterResourceAnchors(stack.dynamicAnchors, schema) : stack.dynamicAnchors;
+	return IsDynamicAnchor(schema) ? [...registered, schema] : registered;
+}
+function NextPendingResource(stack, schema) {
+	return IsId(schema) ? false : stack.pendingResource;
+}
+function NextLexicalBase(stack, schema) {
+	const entry = ResourceEntry(stack, schema);
+	if (entry) return entry.base;
+	return IsId(schema) ? NextUri(schema.$id, stack.lexicalBase).href : stack.lexicalBase;
+}
+function NextResourceBase(stack, schema) {
+	const entry = ResourceEntry(stack, schema);
+	if (entry) return entry.base;
+	return IsId(schema) && stack.pendingResource ? NextUri(schema.$id, stack.resourceBase).href : stack.resourceBase;
+}
+function NextUseResourceBaseForReference(stack, schema) {
+	return IsId(schema) ? !IsRelativeId(schema) : stack.useResourceBaseForReference;
+}
+function NextReferenceBase(stack, schema) {
+	const isRetrieved = NextEnteredResource(stack, schema);
+	const useResourceBaseForReference = NextUseResourceBaseForReference(stack, schema);
+	return isRetrieved || useResourceBaseForReference ? NextResourceBase(stack, schema) : NextLexicalBase(stack, schema);
+}
+function NextLexicalSchema(stack, schema) {
+	const entry = ResourceEntry(stack, schema);
+	if (entry) return entry.root;
+	return IsId(schema) ? schema : stack.lexicalSchema;
+}
+function HasStackKeywords(stack, schema) {
+	return IsSchemaObject$1(schema) && (IsId(schema) || IsDynamicAnchor(schema) || IsUndefined$1(stack.recursiveAnchor) && IsRecursiveAnchorTrue(schema) || !IsUndefined$1(ResourceEntry(stack, schema)));
+}
+function NextStack(stack, schema) {
+	return HasStackKeywords(stack, schema) ? {
+		...stack,
+		ids: NextIds(stack, schema),
+		dynamicAnchors: NextDynamicAnchors(stack, schema),
+		recursiveAnchor: NextRecursiveAnchor(stack, schema),
+		pendingResource: NextPendingResource(stack, schema),
+		lexicalBase: NextLexicalBase(stack, schema),
+		resourceBase: NextResourceBase(stack, schema),
+		useResourceBaseForReference: NextUseResourceBaseForReference(stack, schema),
+		referenceBase: NextReferenceBase(stack, schema),
+		lexicalSchema: NextLexicalSchema(stack, schema),
+		enteredResource: NextEnteredResource(stack, schema)
+	} : stack;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/_unique.mjs
+let index$1 = 0;
+/** Creates a unique variable name */
+function CreateUnique() {
+	return `unique_${index$1++}`;
+}
+/** Resets the unique variable name counter */
+function ResetUnique() {
+	index$1 = 0;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/additionalItems.mjs
+function IsValid$4(schema) {
+	return IsItems(schema) && IsArray$1(schema.items);
+}
+function BuildAdditionalItemsStandard(stack, context, schema, value) {
+	const [item, index] = [CreateUnique(), CreateUnique()];
+	const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
+	const isLength = IsLessThan(index, Constant(schema.items.length));
+	const addIndex = context.AddIndex(index);
+	return Every(value, Constant(0), [item, index], Or(isLength, And(isSchema, addIndex)));
+}
+function BuildAdditionalItemsFast(stack, context, schema, value) {
+	const [item, index] = [CreateUnique(), CreateUnique()];
+	const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
+	const isLength = IsLessThan(index, Constant(schema.items.length));
+	return Every(value, Constant(0), [item, index], Or(isLength, isSchema));
+}
+function BuildAdditionalItems(stack, context, schema, value) {
+	if (!IsValid$4(schema)) return Constant(true);
+	return context.UseUnevaluated() ? BuildAdditionalItemsStandard(stack, context, schema, value) : BuildAdditionalItemsFast(stack, context, schema, value);
+}
+function CheckAdditionalItems(stack, context, schema, value) {
+	if (!IsValid$4(schema)) return true;
+	return Every$1(value, 0, (item, index) => {
+		return IsLessThan$1(index, schema.items.length) || CheckSchemaPushStack(stack, context, schema.additionalItems, item) && context.AddIndex(index);
+	});
+}
+function ErrorAdditionalItems(stack, context, schemaPath, instancePath, schema, value) {
+	if (!IsValid$4(schema)) return true;
+	return Every$1(value, 0, (item, index) => {
+		const nextSchemaPath = `${schemaPath}/additionalItems`;
+		const nextInstancePath = `${instancePath}/${index}`;
+		return IsLessThan$1(index, schema.items.length) || ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalItems, item) && context.AddIndex(index);
+	});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/_pathing.mjs
+function EncodeFragment(fragment) {
+	return fragment.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/_regexp.mjs
+/** Standard RegExp with Unicode */
+function UnicodeRegExp(pattern) {
+	return new RegExp(pattern, "u");
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/additionalProperties.mjs
+function IsAdditionalPropertiesIgnored(context, additionalProperties) {
+	return !context.UseUnevaluated() && (IsEqual$1(additionalProperties, true) || IsObject$1(additionalProperties) && IsEqual$1(Keys$1(additionalProperties).length, 0));
+}
+function GetPropertyKeyAsPattern(key) {
+	return `^${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`;
+}
+function GetPropertiesPattern(schema) {
+	const patterns = [];
+	if (IsPatternProperties(schema)) patterns.push(...Keys$1(schema.patternProperties));
+	if (IsProperties(schema)) patterns.push(...Keys$1(schema.properties).map(GetPropertyKeyAsPattern));
+	return IsEqual$1(patterns.length, 0) ? "(?!)" : `(${patterns.join("|")})`;
+}
+function HasExactRequiredProperties(schema) {
+	const keys = Keys$1(schema.properties);
+	return IsEqual$1(keys.length, schema.required.length) && Every$1(keys, 0, (key) => schema.required.includes(key));
+}
+function CanAdditionalPropertiesFast(_context, schema, _value) {
+	return IsRequired(schema) && IsProperties(schema) && !IsPatternProperties(schema) && IsEqual$1(schema.additionalProperties, false) && HasExactRequiredProperties(schema);
+}
+function BuildAdditionalPropertiesFast(_context, schema, value) {
+	return IsEqual(Member(Call(Member("Object", "getOwnPropertyNames"), [value]), "length"), Constant(schema.required.length));
+}
+function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
+	const [key, _index] = [CreateUnique(), CreateUnique()];
+	const regexp = CreateVariable(UnicodeRegExp(GetPropertiesPattern(schema)));
+	const isSchema = BuildSchemaPushStack(stack, context, schema.additionalProperties, `${value}[${key}]`);
+	const isKey = Call(Member(regexp, "test"), [key]);
+	const addKey = context.AddKey(key);
+	const guarded = context.UseUnevaluated() ? Or(isKey, And(isSchema, addKey)) : Or(isKey, isSchema);
+	return Every(Keys(value), Constant(0), [key, _index], guarded);
+}
+function BuildAdditionalProperties(stack, context, schema, value) {
+	if (IsAdditionalPropertiesIgnored(context, schema.additionalProperties)) return Constant(true);
+	return CanAdditionalPropertiesFast(context, schema, value) ? BuildAdditionalPropertiesFast(context, schema, value) : BuildAdditionalPropertiesStandard(stack, context, schema, value);
+}
+function CheckAdditionalProperties(stack, context, schema, value) {
+	const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
+	return Every$1(Keys$1(value), 0, (key, _index) => {
+		return regexp.test(key) || CheckSchemaPushStack(stack, context, schema.additionalProperties, value[key]) && context.AddKey(key);
+	});
+}
+function ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value) {
+	const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
+	const additionalProperties = [];
+	return EveryAll(Keys$1(value), 0, (key, _index) => {
+		const nextSchemaPath = `${schemaPath}/additionalProperties`;
+		const nextInstancePath = `${instancePath}/${EncodeFragment(key)}`;
+		const isAdditionalProperty = regexp.test(key) || ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key);
+		if (!isAdditionalProperty) additionalProperties.push(key);
+		return isAdditionalProperty;
+	}) || context.AddError("additionalProperties", schemaPath, instancePath, { additionalProperties });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/_reducer.mjs
+function Reducer(stack, context, schemas, value, check) {
+	const results = ConstDeclaration("results", "[]");
+	const context_n = schemas.map((_schema, index) => ConstDeclaration(`context_${index}`, New("CheckContext", [])));
+	const condition_n = schemas.map((schema, index) => ConstDeclaration(`condition_${index}`, Call(ArrowFunction(["context"], BuildSchema(stack, context, schema, value)), [`context_${index}`])));
+	const checks = schemas.map((_schema, index) => If(`condition_${index}`, Call(Member("results", "push"), [`context_${index}`])));
+	const returns = Return(And(check, context.Merge("results")));
+	return Call(ArrowFunction([], Statements([
+		results,
+		...context_n,
+		...condition_n,
+		...checks,
+		returns
+	])), []);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/allOf.mjs
+function BuildAllOfStandard(stack, context, schema, value) {
+	return Reducer(stack, context, schema.allOf, value, IsEqual(Member("results", "length"), Constant(schema.allOf.length)));
+}
+function BuildAllOfFast(stack, context, schema, value) {
+	return ReduceAnd(schema.allOf.map((schema) => BuildSchema(stack, context, schema, value)));
+}
+function BuildAllOf(stack, context, schema, value) {
+	return context.UseUnevaluated() ? BuildAllOfStandard(stack, context, schema, value) : BuildAllOfFast(stack, context, schema, value);
+}
+function CheckAllOf(stack, context, schema, value) {
+	const results = schema.allOf.reduce((result, schema) => {
+		const nextContext = new CheckContext();
+		return CheckSchema(stack, nextContext, schema, value) ? [...result, nextContext] : result;
+	}, []);
+	return IsEqual$1(results.length, schema.allOf.length) && context.Merge(results);
+}
+function ErrorAllOf(stack, context, schemaPath, instancePath, schema, value) {
+	const failedContexts = [];
+	const results = schema.allOf.reduce((result, schema, index) => {
+		const nextSchemaPath = `${schemaPath}/allOf/${index}`;
+		const nextContext = new ErrorContext();
+		const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
+		if (!isSchema) failedContexts.push(nextContext);
+		return isSchema ? [...result, nextContext] : result;
+	}, []);
+	const isAllOf = IsEqual$1(results.length, schema.allOf.length) && context.Merge(results);
+	if (!isAllOf) failedContexts.forEach((failed) => context.AddErrors(failed.GetErrors()));
+	return isAllOf;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/anyOf.mjs
+function BuildAnyOfStandard(stack, context, schema, value) {
+	return Reducer(stack, context, schema.anyOf, value, IsGreaterThan(Member("results", "length"), Constant(0)));
+}
+function BuildAnyOfFast(stack, context, schema, value) {
+	return ReduceOr(schema.anyOf.map((schema) => BuildSchema(stack, context, schema, value)));
+}
+function BuildAnyOf(stack, context, schema, value) {
+	return context.UseUnevaluated() ? BuildAnyOfStandard(stack, context, schema, value) : BuildAnyOfFast(stack, context, schema, value);
+}
+function CheckAnyOf(stack, context, schema, value) {
+	const results = schema.anyOf.reduce((result, schema) => {
+		const nextContext = new CheckContext();
+		return CheckSchema(stack, nextContext, schema, value) ? [...result, nextContext] : result;
+	}, []);
+	return IsGreaterThan$1(results.length, 0) && context.Merge(results);
+}
+function ErrorAnyOf(stack, context, schemaPath, instancePath, schema, value) {
+	const failedContexts = [];
+	const results = schema.anyOf.reduce((result, schema, index) => {
+		const nextContext = new ErrorContext();
+		const isSchema = ErrorSchema(stack, nextContext, `${schemaPath}/anyOf/${index}`, instancePath, schema, value);
+		if (!isSchema) failedContexts.push(nextContext);
+		return isSchema ? [...result, nextContext] : result;
+	}, []);
+	const isAnyOf = IsGreaterThan$1(results.length, 0) && context.Merge(results);
+	if (!isAnyOf) failedContexts.forEach((failed) => context.AddErrors(failed.GetErrors()));
+	return isAnyOf || context.AddError("anyOf", schemaPath, instancePath, {});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/boolean.mjs
+function BuildSchemaBoolean(_stack, _context, schema, _value) {
+	return schema ? Constant(true) : Constant(false);
+}
+function CheckSchemaBoolean(_stack, _context, schema, _value) {
+	return schema;
+}
+function ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckSchemaBoolean(stack, context, schema, value) || context.AddError("boolean", schemaPath, instancePath, {});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/const.mjs
+function BuildConst(_stack, _context, schema, value) {
+	return IsValueLike(schema.const) ? IsEqual(value, Constant(schema.const)) : IsDeepEqual(value, CreateVariable(schema.const));
+}
+function CheckConst(_stack, _context, schema, value) {
+	return IsValueLike(schema.const) ? IsEqual$1(value, schema.const) : IsDeepEqual$1(value, schema.const);
+}
+function ErrorConst(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckConst(stack, context, schema, value) || context.AddError("const", schemaPath, instancePath, { allowedValue: schema.const });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/contains.mjs
+function IsValid$3(schema) {
+	return !(IsMinContains(schema) && IsEqual$1(schema.minContains, 0));
+}
+function BuildContainsStandard(stack, context, schema, value) {
+	const [item, index] = [CreateUnique(), CreateUnique()];
+	return And(Not(IsEqual(Member(value, "length"), Constant(0))), SomeAll(value, [item, index], And(BuildSchema(stack, context, schema.contains, item), context.AddIndex(index))));
+}
+function BuildContainsFast(stack, context, schema, value) {
+	const [item] = [CreateUnique()];
+	return And(Not(IsEqual(Member(value, "length"), Constant(0))), Some(value, [item, "_"], BuildSchema(stack, context, schema.contains, item)));
+}
+function BuildContains(stack, context, schema, value) {
+	if (!IsValid$3(schema)) return Constant(true);
+	return context.UseUnevaluated() ? BuildContainsStandard(stack, context, schema, value) : BuildContainsFast(stack, context, schema, value);
+}
+function CheckContains(stack, context, schema, value) {
+	if (!IsValid$3(schema)) return true;
+	return !IsEqual$1(value.length, 0) && SomeAll$1(value, (item, index) => {
+		return CheckSchema(stack, context, schema.contains, item) && context.AddIndex(index);
+	});
+}
+function ErrorContains(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckContains(stack, context, schema, value) || context.AddError("contains", schemaPath, instancePath, { minContains: 1 });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/dependencies.mjs
+function BuildDependencies(stack, context, schema, value) {
+	return Or(IsEqual(Member(Keys(value), "length"), Constant(0)), ReduceAnd(Entries$1(schema.dependencies).map(([key, schema]) => {
+		const notKey = Not(HasPropertyKey(value, Constant(key)));
+		const isSchema = BuildSchema(stack, context, schema, value);
+		const isEveryKey = (schema) => ReduceAnd(schema.map((key) => HasPropertyKey(value, Constant(key))));
+		return Or(notKey, IsArray$1(schema) ? isEveryKey(schema) : isSchema);
+	})));
+}
+function CheckDependencies(stack, context, schema, value) {
+	const isLength = IsEqual$1(Keys$1(value).length, 0);
+	const isEvery = Every$1(Entries$1(schema.dependencies), 0, ([key, schema]) => {
+		return !HasPropertyKey$1(value, key) || (IsArray$1(schema) ? schema.every((key) => HasPropertyKey$1(value, key)) : CheckSchema(stack, context, schema, value));
+	});
+	return isLength || isEvery;
+}
+function ErrorDependencies(stack, context, schemaPath, instancePath, schema, value) {
+	const isLength = IsEqual$1(Keys$1(value).length, 0);
+	const isEvery = EveryAll(Entries$1(schema.dependencies), 0, ([key, schema]) => {
+		const nextSchemaPath = `${schemaPath}/dependencies/${EncodeFragment(key)}`;
+		return !HasPropertyKey$1(value, key) || (IsArray$1(schema) ? schema.every((dependency) => HasPropertyKey$1(value, dependency) || context.AddError("dependencies", schemaPath, instancePath, {
+			property: key,
+			dependencies: schema
+		})) : ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value));
+	});
+	return isLength || isEvery;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/dependentRequired.mjs
+function BuildDependentRequired(_stack, _context, schema, value) {
+	return Or(IsEqual(Member(Keys(value), "length"), Constant(0)), ReduceAnd(Entries$1(schema.dependentRequired).map(([key, keys]) => {
+		return Or(Not(HasPropertyKey(value, Constant(key))), ReduceAnd(keys.map((key) => HasPropertyKey(value, Constant(key)))));
+	})));
+}
+function CheckDependentRequired(_stack, _context, schema, value) {
+	const isLength = IsEqual$1(Keys$1(value).length, 0);
+	const isEvery = Every$1(Entries$1(schema.dependentRequired), 0, ([key, keys]) => {
+		return !HasPropertyKey$1(value, key) || keys.every((key) => HasPropertyKey$1(value, key));
+	});
+	return isLength || isEvery;
+}
+function ErrorDependentRequired(_stack, context, schemaPath, instancePath, schema, value) {
+	const isLength = IsEqual$1(Keys$1(value).length, 0);
+	const isEveryEntry = EveryAll(Entries$1(schema.dependentRequired), 0, ([key, keys]) => {
+		return !HasPropertyKey$1(value, key) || EveryAll(keys, 0, (dependency) => HasPropertyKey$1(value, dependency) || context.AddError("dependentRequired", schemaPath, instancePath, {
+			property: key,
+			dependencies: keys
+		}));
+	});
+	return isLength || isEveryEntry;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/dependentSchemas.mjs
+function BuildDependentSchemas(stack, context, schema, value) {
+	return Or(IsEqual(Member(Keys(value), "length"), Constant(0)), ReduceAnd(Entries$1(schema.dependentSchemas).map(([key, schema]) => {
+		return Or(Not(HasPropertyKey(value, Constant(key))), BuildSchema(stack, context, schema, value));
+	})));
+}
+function CheckDependentSchemas(stack, context, schema, value) {
+	const isLength = IsEqual$1(Keys$1(value).length, 0);
+	const isEvery = Every$1(Entries$1(schema.dependentSchemas), 0, ([key, schema]) => {
+		return !HasPropertyKey$1(value, key) || CheckSchema(stack, context, schema, value);
+	});
+	return isLength || isEvery;
+}
+function ErrorDependentSchemas(stack, context, schemaPath, instancePath, schema, value) {
+	const isLength = IsEqual$1(Keys$1(value).length, 0);
+	const isEvery = EveryAll(Entries$1(schema.dependentSchemas), 0, ([key, schema]) => {
+		const nextSchemaPath = `${schemaPath}/dependentSchemas/${EncodeFragment(key)}`;
+		return !HasPropertyKey$1(value, key) || ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value);
+	});
+	return isLength || isEvery;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/pointer/pointer.mjs
+function Indices(pointer) {
+	const indices = pointer.split("/").map((index) => index.replace(/~1/g, "/").replace(/~0/g, "~"));
+	return indices[0] === "" ? indices.slice(1) : indices;
+}
+function Get$2(value, pointer) {
+	let current = value;
+	for (const index of Indices(pointer)) {
+		if (!IsObject$1(current) || IsUnsafePropertyKey(index)) return void 0;
+		current = current[index];
+	}
+	return current;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/resolve/resolve.mjs
+function RelativeBase(schema, base) {
+	return IsSchemaObject$1(schema) && IsId(schema) ? NextUri(schema.$id, base.href) : base;
+}
+function AbsoluteBase(base) {
+	return NextUri(base, DefaultUri);
+}
+function CanonicalHref(url) {
+	return url.href.split("#")[0];
+}
+function Base(schema, base, target) {
+	return SearchBase(schema, AbsoluteBase(base), target);
+}
+function RefRoot(stack, ref) {
+	return ref.$ref.startsWith("#") || stack.enteredResource ? stack.lexicalSchema : stack.schema;
+}
+function IsPointerFragment(fragment) {
+	return fragment.startsWith("#/");
+}
+function SearchDynamicAnchor(schema, name) {
+	if (IsObject$1(schema) && IsDynamicAnchor(schema) && IsEqual$1(schema.$dynamicAnchor, name)) return schema;
+	if (IsObject$1(schema)) for (const key of Keys$1(schema)) {
+		const result = SearchDynamicAnchor(schema[key], name);
+		if (result) return result;
+	}
+}
+function SearchBase(schema, base, target) {
+	if (IsEqual$1(schema, target)) return base.href;
+	const nextBase = RelativeBase(schema, base);
+	if (IsArray$1(schema)) for (const item of schema) {
+		const result = SearchBase(item, nextBase, target);
+		if (!IsUndefined$1(result)) return result;
+	}
+	else if (IsObject$1(schema)) for (const key of Keys$1(schema)) {
+		const result = SearchBase(schema[key], nextBase, target);
+		if (!IsUndefined$1(result)) return result;
+	}
+}
+function MatchWithHash(schema, ref) {
+	if (ref.href.endsWith("#")) return schema;
+	if (!ref.hash.startsWith("#")) return void 0;
+	const fragment = decodeURIComponent(ref.hash.slice(1));
+	if (!fragment.startsWith("/")) return void 0;
+	return Get$2(schema, fragment);
+}
+function MatchWithId(schema, base, ref) {
+	if (!IsId(schema)) return void 0;
+	if (IsEqual$1(schema.$id, ref.hash)) return schema;
+	const absoluteRef = new URL(ref.href, base.href);
+	if (IsEqual$1(base.pathname, absoluteRef.pathname)) return ref.hash.startsWith("#") ? MatchWithHash(schema, ref) : schema;
+}
+function MatchWithAnchor(schema, base, ref) {
+	if (!IsAnchor(schema)) return void 0;
+	const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
+	const absoluteRef = new URL(ref.href, base.href);
+	return IsEqual$1(absoluteAnchor.href, absoluteRef.href) ? schema : void 0;
+}
+function MatchWithDynamicAnchor(schema, base, ref) {
+	if (!IsDynamicAnchor(schema)) return void 0;
+	const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
+	const absoluteRef = new URL(ref.href, base.href);
+	return IsEqual$1(absoluteAnchor.href, absoluteRef.href) ? schema : void 0;
+}
+function MatchSchemaObject(schema, base, ref) {
+	if (!IsSchemaObject$1(schema)) return void 0;
+	return MatchWithId(schema, base, ref) ?? MatchWithAnchor(schema, base, ref) ?? MatchWithDynamicAnchor(schema, base, ref) ?? MatchWithHash(schema, ref);
+}
+function MatchFromArray(schema, base, ref) {
+	if (!IsArray$1(schema)) return void 0;
+	return schema.reduce((result, item) => {
+		const match = Match(item, base, ref);
+		return !IsUndefined$1(match) ? match : result;
+	}, void 0);
+}
+function MatchFromObject(schema, base, ref) {
+	if (!IsObject$1(schema)) return void 0;
+	return Keys$1(schema).reduce((result, key) => {
+		if (IsEqual$1(key, "const") || IsEqual$1(key, "enum")) return result;
+		const match = Match(schema[key], base, ref);
+		return !IsUndefined$1(match) ? match : result;
+	}, void 0);
+}
+function Match(schema, base, ref) {
+	const relativeBase = RelativeBase(schema, base);
+	return MatchSchemaObject(schema, relativeBase, ref) ?? MatchFromArray(schema, relativeBase, ref) ?? MatchFromObject(schema, relativeBase, ref);
+}
+function Resource(context, schema, base, ref) {
+	const result = RefInternal(context, schema, base, ref);
+	return IsSchemaObject$1(result) && IsId(result) ? result : void 0;
+}
+function FindDeferredResourceLegacy(stack, ref, schema) {
+	if (!ref.$ref.startsWith("#")) return void 0;
+	if (!IsSchemaObject$1(stack.schema) || HasPropertyKey$1(stack.schema, "$schema")) return void 0;
+	const targetBase = Base(stack.lexicalSchema, stack.referenceBase, schema);
+	if (IsUndefined$1(targetBase) || IsEqual$1(targetBase, stack.referenceBase)) return void 0;
+	return {
+		target: schema,
+		base: targetBase,
+		root: stack.lexicalSchema
+	};
+}
+function FindDeferredResourceModern(stack, canonical, schema) {
+	const remoteRoot = stack.context[canonical];
+	if (!IsSchemaObject$1(remoteRoot)) return void 0;
+	return {
+		target: schema,
+		base: canonical,
+		root: remoteRoot
+	};
+}
+function FindDeferredResource(stack, ref, schema, canonical, isRemote) {
+	const remote = isRemote ? FindDeferredResourceModern(stack, canonical, schema) : void 0;
+	return IsUndefined$1(remote) ? FindDeferredResourceLegacy(stack, ref, schema) : remote;
+}
+function FindResolvedResource(stack, canonical, schema) {
+	if (IsId(schema)) return void 0;
+	const resource = Resource(stack.context, stack.schema, stack.referenceBase, canonical);
+	if (!resource || stack.ids.includes(resource)) return void 0;
+	return { resource };
+}
+function RefInternalWithContext(context, ref) {
+	return HasPropertyKey$1(context, ref) ? context[ref] : void 0;
+}
+function RefInternalWithLocal(schema, base, ref) {
+	return Match(schema, base, ref);
+}
+function RefInternalWithRemote(context, base, ref) {
+	const canonicalHref = CanonicalHref(ref);
+	if (!HasPropertyKey$1(context, canonicalHref) || IsEqual$1(canonicalHref, CanonicalHref(base))) return void 0;
+	const remoteSchema = context[canonicalHref];
+	const remoteBase = RelativeBase(remoteSchema, new URL(canonicalHref));
+	return IsEqual$1(ref.hash, "") ? remoteSchema : Match(remoteSchema, remoteBase, ref);
+}
+function RefInternal(context, schema, base, ref) {
+	const absoluteBase = AbsoluteBase(base);
+	const target = NextUri(ref, absoluteBase.href);
+	return RefInternalWithContext(context, ref) ?? RefInternalWithLocal(schema, absoluteBase, target) ?? RefInternalWithRemote(context, absoluteBase, target);
+}
+function RefNextStackDeferred(stack, deferredResource) {
+	if (!deferredResource) return stack;
+	const resourceEntries = new Map(stack.resourceEntries);
+	resourceEntries.set(deferredResource.target, {
+		base: deferredResource.base,
+		root: deferredResource.root
+	});
+	return {
+		...stack,
+		resourceEntries
+	};
+}
+function RefNextStackResolved(stack, resolvedResource) {
+	return resolvedResource ? NextStack(stack, resolvedResource.resource) : stack;
+}
+function RefNextStack(stack, pendingResource, deferredResource, resolvedResource) {
+	return RefNextStackResolved(RefNextStackDeferred({
+		...stack,
+		pendingResource
+	}, deferredResource), resolvedResource);
+}
+function RefResultFound(stack, ref, schema) {
+	const canonical = CanonicalHref(NextUri(ref.$ref, stack.referenceBase));
+	const isRemote = !IsEqual$1(canonical, stack.resourceBase);
+	return {
+		schema,
+		stack: RefNextStack(stack, true, FindDeferredResource(stack, ref, schema, canonical, isRemote), isRemote ? FindResolvedResource(stack, canonical, schema) : void 0)
+	};
+}
+function RefResultNotFound(stack, schema) {
+	return {
+		schema,
+		stack: RefNextStack(stack, !IsUndefined$1(schema))
+	};
+}
+function Ref(stack, ref) {
+	const schema = RefInternal(stack.context, RefRoot(stack, ref), stack.referenceBase, ref.$ref);
+	return IsSchemaObject$1(schema) ? RefResultFound(stack, ref, schema) : RefResultNotFound(stack, schema);
+}
+function IsRecursiveAnchorInScope(stack) {
+	return IsSchemaObject$1(stack.lexicalSchema) && IsRecursiveAnchorTrue(stack.lexicalSchema);
+}
+function RecursiveRef(stack, recursiveRef) {
+	const schema = IsRecursiveAnchorInScope(stack) ? stack.recursiveAnchor : stack.lexicalSchema;
+	return RefInternal(stack.context, schema, stack.lexicalBase, recursiveRef.$recursiveRef);
+}
+function DynamicRefFragment(stack, dynamicRef) {
+	return NextUri(dynamicRef.$dynamicRef, AbsoluteBase(stack.lexicalBase).href).hash;
+}
+function FindScopedDynamicAnchor(stack, name) {
+	return stack.dynamicAnchors.find((anchor) => IsEqual$1(anchor.$dynamicAnchor, name)) ?? SearchDynamicAnchor(stack.schema, name);
+}
+function DynamicRefWhenFound(stack, dynamicRef, fragmentTarget) {
+	if (!IsSchemaObject$1(fragmentTarget) || !IsDynamicAnchor(fragmentTarget)) return fragmentTarget;
+	return IsPointerFragment(DynamicRefFragment(stack, dynamicRef)) ? fragmentTarget : FindScopedDynamicAnchor(stack, fragmentTarget.$dynamicAnchor);
+}
+function DynamicRefWhenNotFound(stack, dynamicRef) {
+	const fragment = DynamicRefFragment(stack, dynamicRef);
+	return FindScopedDynamicAnchor(stack, decodeURIComponent(fragment.slice(1)));
+}
+function DynamicRef(stack, dynamicRef) {
+	const fragmentRoot = dynamicRef.$dynamicRef.startsWith("#") ? stack.lexicalSchema : stack.schema;
+	const fragmentTarget = RefInternal(stack.context, fragmentRoot, stack.lexicalBase, dynamicRef.$dynamicRef);
+	return IsUndefined$1(fragmentTarget) ? DynamicRefWhenNotFound(stack, dynamicRef) : DynamicRefWhenFound(stack, dynamicRef, fragmentTarget);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/dynamicRef.mjs
+function BuildDynamicRef(stack, context, schema, value) {
+	const target = DynamicRef(stack, schema) ?? false;
+	return CreateFunction(target ? {
+		...stack,
+		pendingResource: true
+	} : stack, context, target, value);
+}
+function CheckDynamicRef(stack, context, schema, value) {
+	const target = DynamicRef(stack, schema) ?? false;
+	const nextStack = target ? {
+		...stack,
+		pendingResource: true
+	} : stack;
+	return IsSchema(target) && CheckSchema(nextStack, context, target, value);
+}
+function ErrorDynamicRef(stack, context, schemaPath, instancePath, schema, value) {
+	const target = DynamicRef(stack, schema) ?? false;
+	const nextStack = target ? {
+		...stack,
+		pendingResource: true
+	} : stack;
+	return IsSchema(target) && ErrorSchema(nextStack, context, schemaPath, instancePath, target, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/enum.mjs
+function BuildEnum(_stack, _context, schema, value) {
+	return ReduceOr(schema.enum.map((option) => {
+		if (IsValueLike(option)) return IsEqual(value, Constant(option));
+		return IsDeepEqual(value, CreateVariable(option));
+	}));
+}
+function CheckEnum(_stack, _context, schema, value) {
+	return Some$1(schema.enum, (option) => IsValueLike(option) ? IsEqual$1(value, option) : IsDeepEqual$1(value, option));
+}
+function ErrorEnum(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckEnum(stack, context, schema, value) || context.AddError("enum", schemaPath, instancePath, { allowedValues: schema.enum });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/exclusiveMaximum.mjs
+function BuildExclusiveMaximum(_stack, _context, schema, value) {
+	return IsLessThan(value, Constant(schema.exclusiveMaximum));
+}
+function CheckExclusiveMaximum(_stack, _context, schema, value) {
+	return IsLessThan$1(value, schema.exclusiveMaximum);
+}
+function ErrorExclusiveMaximum(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckExclusiveMaximum(stack, context, schema, value) || context.AddError("exclusiveMaximum", schemaPath, instancePath, {
+		comparison: "<",
+		limit: schema.exclusiveMaximum
+	});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/exclusiveMinimum.mjs
+function BuildExclusiveMinimum(_stack, _context, schema, value) {
+	return IsGreaterThan(value, Constant(schema.exclusiveMinimum));
+}
+function CheckExclusiveMinimum(_stack, _context, schema, value) {
+	return IsGreaterThan$1(value, schema.exclusiveMinimum);
+}
+function ErrorExclusiveMinimum(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckExclusiveMinimum(stack, context, schema, value) || context.AddError("exclusiveMinimum", schemaPath, instancePath, {
+		comparison: ">",
+		limit: schema.exclusiveMinimum
+	});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/date.mjs
+const DAYS = [
+	0,
+	31,
+	28,
+	31,
+	30,
+	31,
+	30,
+	31,
+	31,
+	30,
+	31,
+	30,
+	31
+];
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+function IsLeapYear(year) {
+	return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+/**
+* Returns true if the value is a ISO8601 Date component string
+* @description https://datatracker.ietf.org/doc/html/rfc3339
+* @example `2020-12-12`
+*/
+function IsDate(value) {
+	const matches = DATE.exec(value);
+	if (!matches) return false;
+	const year = +matches[1];
+	const month = +matches[2];
+	const day = +matches[3];
+	return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && IsLeapYear(year) ? 29 : DAYS[month]);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/time.mjs
+const TIME = /^(\d\d):(\d\d):(\d\d)(?:\.\d+)?(?:([Zz])|([+-])(\d\d):(\d\d))?$/;
+/**
+* Returns true if the value is an ISO time string
+* @specification https://datatracker.ietf.org/doc/html/rfc3339
+*/
+function IsTime(value, strictTimeZone = true) {
+	const matches = TIME.exec(value);
+	if (!matches) return false;
+	if (strictTimeZone && !matches[4] && !matches[5]) return false;
+	const hr = +matches[1];
+	const min = +matches[2];
+	const sec = +matches[3];
+	if (hr > 23 || min > 59 || sec > 60) return false;
+	if (matches[5]) {
+		const tzH = +matches[6];
+		const tzM = +matches[7];
+		if (tzH > 23 || tzM > 59) return false;
+	}
+	if (sec < 60) return true;
+	const tzSign = matches[5] === "-" ? -1 : 1;
+	const tzH = +(matches[6] || 0);
+	const tzM = +(matches[7] || 0);
+	return ((hr * 60 + min - tzSign * (tzH * 60 + tzM)) % 1440 + 1440) % 1440 === 1439;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/date_time.mjs
+const DATE_TIME_SUFFIX = /^(?:\[!?(?:(?!\.{1,2}[/\]])[A-Za-z._][A-Za-z._0-9+-]{0,13}(?:\/(?!\.{1,2}[/\]])[A-Za-z._][A-Za-z._0-9+-]{0,13})*|[+-](?:[01][0-9]|2[0-3]):[0-5][0-9])\](?:\[!?[a-z_][a-z_0-9-]*=[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*\])*|(?:\[!?[a-z_][a-z_0-9-]*=[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*\])*)$/;
+/**
+* Returns true if the string is an [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339) date-time with optional [RFC 9557](https://datatracker.ietf.org/doc/html/rfc9557) suffix.
+* @specification https://datatracker.ietf.org/doc/html/rfc3339
+* @specification https://datatracker.ietf.org/doc/html/rfc9557
+* @example `2020-12-12T20:20:40+00:00`
+*/
+function IsDateTime(value) {
+	const index = value.indexOf("[");
+	const datetime = index === -1 ? value : value.slice(0, index);
+	if (index !== -1 && !DATE_TIME_SUFFIX.test(value.slice(index))) return false;
+	const split = datetime.split(/T/i);
+	return split.length === 2 && IsDate(split[0]) && IsTime(split[1]);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/duration.mjs
+const Duration = /^P((\d+Y(\d+M(\d+D)?)?|\d+M(\d+D)?|\d+D)(T(\d+H(\d+M(\d+S)?)?|\d+M(\d+S)?|\d+S))?|T(\d+H(\d+M(\d+S)?)?|\d+M(\d+S)?|\d+S)|\d+W)$/;
+/**
+* Returns true if the value is a valid duration.
+* @specification https://www.rfc-editor.org/rfc/rfc3339.html#appendix-A
+*/
+function IsDuration(value) {
+	return Duration.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/email.mjs
+const Email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\[\x20-\x7e])*")@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[(?:IPv6:[a-f0-9:]+|(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})\])$/i;
+/**
+* Returns true if the value is an Email
+* @specification https://datatracker.ietf.org/doc/html/rfc5322
+*/
+function IsEmail(value) {
+	return Email.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/idna/pattern/pattern.mjs
+const RE_RULE_HYPHEN_PLACEMENT = /^(?!-).*(?<!-)$/;
+const RE_RULE_NOT_RESERVED_ACE = /^(?!..--)/;
+const RE_ASCII_LDH = /^[a-zA-Z0-9-]*$/;
+const RE_NON_ASCII = /[^\p{ASCII}]/u;
+const RE_ASCII_DIGIT = /[0-9]/;
+const RE_ARABIC_INDIC_DIGIT = /[\u{0660}-\u{0669}]/u;
+const RE_EXT_ARABIC_INDIC_DIGIT = /[\u{06f0}-\u{06f9}]/u;
+const RE_COMMON_SEPARATOR = /[\u{002e}\u{002c}\u{003a}\u{002f}]/u;
+const RE_EUROPEAN_SEPARATOR = /[\u{002d}\u{002b}]/u;
+const RE_MARK_NONSPACING = /\p{Mn}/u;
+const RE_MARK_SPACING_COMBINING = /\p{Mc}/u;
+const RE_COMBINING_MARK = /[\p{Mn}\p{Mc}\p{Me}]/u;
+const RE_LETTER = /\p{L}/u;
+const RE_NUMBER_DECIMAL = /\p{Nd}/u;
+const RE_SCRIPT_GREEK = /\p{Script=Greek}/u;
+const RE_SCRIPT_HEBREW = /\p{Script=Hebrew}/u;
+const RE_SCRIPT_JAPANESE = /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/u;
+const RE_SCRIPT_ARABIC_LETTER = /[\p{Script=Arabic}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Mandaic}]/u;
+const RE_VIRAMA = /[\u{094d}\u{09cd}\u{0a4d}\u{0acd}\u{0b4d}\u{0bcd}\u{0c4d}\u{0ccd}\u{0d3b}\u{0d3c}\u{0d4d}\u{0dca}\u{1b44}\u{1baa}\u{1bab}\u{a9c0}\u{11046}\u{1107f}\u{110b9}\u{11133}\u{11134}\u{111c0}\u{11235}\u{1134d}\u{11442}\u{114c2}\u{115bf}\u{1163f}\u{116b6}\u{11c3f}\u{11d44}\u{11d45}]/u;
+const RE_RFC5892_DISALLOWED = /[\u{0640}\u{07fa}\u{302e}\u{302f}\u{3031}\u{3032}\u{3033}\u{3034}\u{3035}\u{303b}]/u;
+const RE_CONTEXTO_EXCEPTIONS = /[\u{00b7}\u{0375}\u{05f3}\u{05f4}\u{200c}\u{200d}\u{30fb}]/u;
+const RE_PVALID_EXCEPTIONS = /[\u{00df}\u{03c2}\u{06fd}\u{06fe}\u{0f0b}\u{3007}]/u;
+const RE_EUROPEAN_NUMBER = new RegExp([RE_ASCII_DIGIT, RE_EXT_ARABIC_INDIC_DIGIT].map((regexp) => regexp.source).join("|"), "u");
+const RE_PERMITTED_CATEGORY = new RegExp([
+	RE_LETTER,
+	RE_EUROPEAN_SEPARATOR,
+	RE_COMMON_SEPARATOR,
+	RE_NUMBER_DECIMAL,
+	RE_MARK_NONSPACING,
+	RE_MARK_SPACING_COMBINING,
+	RE_CONTEXTO_EXCEPTIONS,
+	RE_PVALID_EXCEPTIONS
+].map((regexp) => regexp.source).join("|"), "u");
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/idna/label/ascii.mjs
+function IsAsciiLabel(value) {
+	return RE_RULE_HYPHEN_PLACEMENT.test(value) && RE_RULE_NOT_RESERVED_ACE.test(value) && RE_ASCII_LDH.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/idna/format/puny.mjs
+const PUNYCODE_BASE = 36;
+const PUNYCODE_TMIN = 1;
+const PUNYCODE_TMAX = 26;
+const PUNYCODE_SKEW = 38;
+const PUNYCODE_DAMP = 700;
+const PUNYCODE_INITIAL_BIAS = 72;
+const PUNYCODE_INITIAL_N = 128;
+function ThrowDontCare() {
+	throw null;
+}
+function IsAcePrefixed(value) {
+	return value.toLowerCase().startsWith("xn--");
+}
+function Adapt(delta, numPoints, firstTime) {
+	delta = firstTime ? Math.floor(delta / PUNYCODE_DAMP) : delta >> 1;
+	delta += Math.floor(delta / numPoints);
+	let k = 0;
+	while (delta > 455) {
+		delta = Math.floor(delta / 35);
+		k += PUNYCODE_BASE;
+	}
+	return k + Math.floor(36 * delta / (delta + PUNYCODE_SKEW));
+}
+function Decode$8(value) {
+	const output = [];
+	let n = PUNYCODE_INITIAL_N;
+	let i = 0;
+	let bias = PUNYCODE_INITIAL_BIAS;
+	const delimIdx = value.lastIndexOf("-");
+	if (delimIdx > 0) for (let j = 0; j < delimIdx; j++) {
+		const cp = value.charCodeAt(j);
+		if (cp >= 128) ThrowDontCare();
+		output.push(cp);
+	}
+	let inIdx = delimIdx < 0 ? 0 : delimIdx + 1;
+	while (inIdx < value.length) {
+		const oldi = i;
+		let w = 1;
+		let k = PUNYCODE_BASE;
+		while (true) {
+			if (inIdx >= value.length) ThrowDontCare();
+			const ch = value.charCodeAt(inIdx++);
+			let digit;
+			if (ch >= 97 && ch <= 122) digit = ch - 97;
+			else if (ch >= 48 && ch <= 57) digit = ch - 48 + 26;
+			else ThrowDontCare();
+			i += digit * w;
+			const t = k <= bias ? PUNYCODE_TMIN : k >= bias + PUNYCODE_TMAX ? PUNYCODE_TMAX : k - bias;
+			if (digit < t) break;
+			w *= PUNYCODE_BASE - t;
+			k += PUNYCODE_BASE;
+		}
+		const outLen = output.length + 1;
+		bias = Adapt(i - oldi, outLen, oldi === 0);
+		n += Math.floor(i / outLen);
+		i %= outLen;
+		output.splice(i, 0, n);
+		i++;
+	}
+	return String.fromCodePoint(...output);
+}
+function DigitToChar(digit) {
+	return digit < 26 ? String.fromCharCode(digit + 97) : String.fromCharCode(digit - 26 + 48);
+}
+const RE_REPLACE_NON_ASCII = new RegExp(RE_NON_ASCII.source, "gu");
+function Encode$8(input) {
+	const basic = input.replace(RE_REPLACE_NON_ASCII, "");
+	const basicLength = basic.length;
+	const result = basicLength > 0 ? [basic, "-"] : [];
+	const codePoints = Array.from(input, (char) => char.codePointAt(0));
+	let n = PUNYCODE_INITIAL_N;
+	let delta = 0;
+	let bias = PUNYCODE_INITIAL_BIAS;
+	let handledCPCount = basicLength;
+	while (handledCPCount < codePoints.length) {
+		let m = Infinity;
+		for (const cp of codePoints) if (cp >= n && cp < m) m = cp;
+		delta += (m - n) * (handledCPCount + 1);
+		n = m;
+		for (const cp of codePoints) {
+			if (cp < n) delta++;
+			if (cp === n) {
+				let q = delta;
+				for (let k = PUNYCODE_BASE;; k += PUNYCODE_BASE) {
+					const t = k <= bias ? PUNYCODE_TMIN : k >= bias + PUNYCODE_TMAX ? PUNYCODE_TMAX : k - bias;
+					if (q < t) break;
+					const digit = t + (q - t) % (PUNYCODE_BASE - t);
+					result.push(DigitToChar(digit));
+					q = Math.floor((q - t) / (PUNYCODE_BASE - t));
+				}
+				result.push(DigitToChar(q));
+				bias = Adapt(delta, handledCPCount + 1, handledCPCount === basicLength);
+				delta = 0;
+				handledCPCount++;
+			}
+		}
+		delta++;
+		n++;
+	}
+	return result.join("");
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/idna/format/bidi.mjs
+const RE_RTL_ALLOWED = /^(?:R|AL|AN|EN|ES|CS|ET|ON|BN|NSM)$/;
+const RE_LTR_ALLOWED = /^(?:L|EN|ES|CS|ET|ON|BN|NSM)$/;
+const RE_RTL_CLASSES = /^(?:R|AL|AN)$/;
+function HasBidiChars(value) {
+	if (IsAcePrefixed(value)) try {
+		return HasRightToLeftCharacters(Decode$8(value.slice(4).toLowerCase()));
+	} catch {
+		return false;
+	}
+	return HasRightToLeftCharacters(value);
+}
+function GetBidiClass(codePoint) {
+	const char = String.fromCodePoint(codePoint);
+	return RE_EUROPEAN_NUMBER.test(char) ? "EN" : RE_ARABIC_INDIC_DIGIT.test(char) ? "AN" : RE_MARK_NONSPACING.test(char) ? "NSM" : RE_SCRIPT_HEBREW.test(char) ? "R" : RE_SCRIPT_ARABIC_LETTER.test(char) ? "AL" : RE_LETTER.test(char) ? "L" : "ON";
+}
+function HasRightToLeftCharacters(value) {
+	for (const ch of value) if (RE_RTL_CLASSES.test(GetBidiClass(ch.codePointAt(0)))) return true;
+	return false;
+}
+function SatisfiesBidiRule(value) {
+	let isRtl = false;
+	let allowed = RE_LTR_ALLOWED;
+	let sawEN = false;
+	let sawAN = false;
+	let isFirst = true;
+	for (const ch of value) {
+		const bidiClass = GetBidiClass(ch.codePointAt(0));
+		if (isFirst) {
+			if (bidiClass !== "L" && bidiClass !== "R" && bidiClass !== "AL") return false;
+			isRtl = bidiClass === "R" || bidiClass === "AL";
+			allowed = isRtl ? RE_RTL_ALLOWED : RE_LTR_ALLOWED;
+			isFirst = false;
+		}
+		if (!allowed.test(bidiClass)) return false;
+		if (bidiClass === "EN") sawEN = true;
+		else if (bidiClass === "AN") sawAN = true;
+	}
+	if (isRtl && sawEN && sawAN) return false;
+	return true;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/idna/label/unicode.mjs
+function ExceedsMaxALabelLength(value) {
+	return RE_NON_ASCII.test(value) && Encode$8(value).length + 4 > 63;
+}
+function HasInvalidHyphens(chars) {
+	if (chars[0] === "-" || chars[chars.length - 1] === "-") return true;
+	return chars.slice(2).join("").startsWith("--");
+}
+function IsUnicodeLabel(value) {
+	if (ExceedsMaxALabelLength(value)) return false;
+	if (HasRightToLeftCharacters(value) && !SatisfiesBidiRule(value)) return false;
+	const chars = [...value];
+	const codePoints = chars.map((c) => c.codePointAt(0));
+	const length = codePoints.length;
+	if (HasInvalidHyphens(chars)) return false;
+	if (RE_COMBINING_MARK.test(chars[0])) return false;
+	let hasJapanese = false;
+	for (let i = 0; i < length; i++) {
+		const codePoint = codePoints[i];
+		const char = chars[i];
+		if (RE_RFC5892_DISALLOWED.test(char)) return false;
+		if (!RE_PERMITTED_CATEGORY.test(char)) return false;
+		if (RE_SCRIPT_JAPANESE.test(char)) hasJapanese = true;
+		const prev = codePoints[i - 1], next = codePoints[i + 1];
+		switch (codePoint) {
+			case 183:
+				if (prev !== 108 || next !== 108) return false;
+				break;
+			case 885:
+				if (!next || !RE_SCRIPT_GREEK.test(chars[i + 1])) return false;
+				break;
+			case 1523:
+			case 1524:
+				if (!prev || !RE_SCRIPT_HEBREW.test(chars[i - 1])) return false;
+				break;
+			case 8204:
+				if (!prev || prev < 128 && !RE_VIRAMA.test(chars[i - 1])) return false;
+				break;
+			case 8205: if (!prev || !RE_VIRAMA.test(chars[i - 1])) return false;
+		}
+	}
+	if (value.includes("・") && !hasJapanese) return false;
+	return true;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/idna/label/puny.mjs
+function IsPunyLabel(value) {
+	if (!IsAcePrefixed(value)) return false;
+	try {
+		const body = value.slice(4).toLowerCase();
+		if (body.lastIndexOf("-") === 0) return false;
+		const decoded = Decode$8(body);
+		if (!RE_NON_ASCII.test(decoded)) return false;
+		return IsUnicodeLabel(decoded);
+	} catch {
+		return false;
+	}
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/idna/hostname.mjs
+function IsValidLabelLength$1(value) {
+	return value.length > 0 && value.length <= 63;
+}
+function IsLabel$1(value) {
+	return IsValidLabelLength$1(value) && (IsPunyLabel(value) || IsAsciiLabel(value));
+}
+function IsHostname$1(value) {
+	if (value.length === 0 || value.length > 253) return false;
+	if (value.charCodeAt(value.length - 1) === 46) return false;
+	return value.split(".").every((label) => IsLabel$1(label));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/idna/idn-hostname.mjs
+function IsValidLabelLength(value) {
+	return value.length > 0 && value.length <= 63;
+}
+function IsLabel(value) {
+	return IsValidLabelLength(value) && (IsPunyLabel(value) || IsUnicodeLabel(value));
+}
+function NormalizeHostname(value) {
+	return value.replace(/[\uff01-\uff5e]/g, (char) => String.fromCharCode(char.charCodeAt(0) - 65248)).normalize("NFC").replace(/[\u00ad\u034f\u180b-\u180d\u200b\ufe00-\ufe0f\u{e0100}-\u{e01ef}]/gu, "").replace(/[\u002E\u3002\uFF0E\uFF61]/g, ".");
+}
+function IsIdnHostname$1(value) {
+	if (value.length === 0 || value.includes(" ")) return false;
+	const normalized = NormalizeHostname(value);
+	if (normalized.length > 253) return false;
+	const labels = normalized.split(".");
+	const hasBidiChars = labels.some((label) => HasBidiChars(label));
+	return labels.every((label) => IsLabel(label) && (!hasBidiChars || SatisfiesBidiRule(label)));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/hostname.mjs
+/**
+* Returns true if the value is a valid hostname.
+* @specification https://tools.ietf.org/html/rfc1123
+* @specification https://tools.ietf.org/html/rfc5891
+* @specification https://tools.ietf.org/html/rfc5892
+*/
+function IsHostname(value) {
+	return IsHostname$1(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/idn_email.mjs
+const IdnEmail = /^(?:[A-Za-z0-9!#$%&'*+\/=?^_`{|}~\u{0080}-\u{10FFFF}-]+(?:\.[A-Za-z0-9!#$%&'*+\/=?^_`{|}~\u{0080}-\u{10FFFF}-]+)*|"(?:[^"\\]|\\.)*")@[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,62})(?<!-)(?:\.[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,62})(?<!-))*$/iu;
+/**
+* Returns true if the value is an IdnEmail
+* @specification https://datatracker.ietf.org/doc/html/rfc4952
+* @specification https://datatracker.ietf.org/doc/html/rfc6531
+*/
+function IsIdnEmail(value) {
+	return IdnEmail.test(value.normalize("NFC"));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/idn_hostname.mjs
+/**
+* Returns true if the value is a valid internationalized (IDN) hostname.
+* @specification https://datatracker.ietf.org/doc/html/rfc5890
+* @specification https://tools.ietf.org/html/rfc5891
+* @specification https://tools.ietf.org/html/rfc5892
+* @specification https://tools.ietf.org/html/rfc5893
+*/
+function IsIdnHostname(value) {
+	return IsIdnHostname$1(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/ipv4.mjs
+const IPv4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+/**
+* Returns true if the value is an IPv4 address
+* @specification https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.2
+*/
+function IsIPv4(value) {
+	return IPv4.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/ipv6.mjs
+const IPv6 = /^(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:)?[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)$/i;
+/**
+* Returns true if the value is an IPv6 address
+* @specification https://datatracker.ietf.org/doc/html/rfc4291#section-2.2
+*/
+function IsIPv6(value) {
+	return IPv6.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/iri_reference.mjs
+const InvalidIriChars$1 = /[\x00-\x20\x7F\\]|%(?![0-9a-fA-F]{2})/;
+const MalformedScheme = /^[a-zA-Z][a-zA-Z0-9+\-.]*\/\//;
+/**
+* Returns true if the value is an IRI reference
+* @specification https://tools.ietf.org/html/rfc3987
+*/
+function IsIriReference(value) {
+	return !InvalidIriChars$1.test(value) && !MalformedScheme.test(value) && URL.canParse(value, "http://example.com");
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/iri.mjs
+const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
+const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
+/**
+* Returns true if the value is a valid Internationalized Resource Identifier.
+* @specification https://datatracker.ietf.org/doc/html/rfc3987
+*/
+function IsIri(value) {
+	if (InvalidIriChars.test(value)) return false;
+	if (InvalidPercentEncoding.test(value)) return false;
+	return URL.canParse(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/json_pointer_uri_fragment.mjs
+const JsonPointerUriFragment = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
+/**
+* Returns true if the value is a json pointer uri fragment
+* @specification https://datatracker.ietf.org/doc/html/rfc6901
+* @source https://github.com/ajv-validator/ajv-formats
+*/
+function IsJsonPointerUriFragment(value) {
+	return JsonPointerUriFragment.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/json_pointer.mjs
+const JsonPointer = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
+/**
+* Returns true if the value is a json pointer
+* @specification https://datatracker.ietf.org/doc/html/rfc6901
+* @source https://github.com/ajv-validator/ajv-formats
+*/
+function IsJsonPointer(value) {
+	return JsonPointer.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/regex.mjs
+/**
+* Returns true if the value is a regular expression string pattern
+* @specification https://ecma-international.org/ecma-262
+*/
+function IsRegex(value) {
+	try {
+		new RegExp(value, "u");
+		return true;
+	} catch {
+		return false;
+	}
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/relative_json_pointer.mjs
+const RelativeJsonPointer = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
+/**
+* Returns true if the value is a relative JSON Pointer
+* @specification https://datatracker.ietf.org/doc/html/draft-handrews-relative-json-pointer/
+* @source https://github.com/ajv-validator/ajv-formats
+*/
+function IsRelativeJsonPointer(value) {
+	return RelativeJsonPointer.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/uri_reference.mjs
+const UriReference = /^(?:[a-z][a-z0-9+\-.]*:(?:\/\/(?:(?:[-a-z0-9._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:[\da-f]{1,4}:){6}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|::(?:[\da-f]{1,4}:){5}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:[\da-f]{1,4})?::(?:[\da-f]{1,4}:){4}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,1}[\da-f]{1,4})?::(?:[\da-f]{1,4}:){3}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,2}[\da-f]{1,4})?::(?:[\da-f]{1,4}:){2}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,3}[\da-f]{1,4})?::[\da-f]{1,4}:(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,4}[\da-f]{1,4})?::(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,5}[\da-f]{1,4})?::[\da-f]{1,4}|(?:(?:[\da-f]{1,4}:){0,6}[\da-f]{1,4})?::)|v[0-9a-f]+\.[-a-z0-9._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)|(?:[-a-z0-9._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:\/\/(?:(?:[-a-z0-9._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:[\da-f]{1,4}:){6}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|::(?:[\da-f]{1,4}:){5}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:[\da-f]{1,4})?::(?:[\da-f]{1,4}:){4}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,1}[\da-f]{1,4})?::(?:[\da-f]{1,4}:){3}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,2}[\da-f]{1,4})?::(?:[\da-f]{1,4}:){2}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,3}[\da-f]{1,4})?::[\da-f]{1,4}:(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,4}[\da-f]{1,4})?::(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,5}[\da-f]{1,4})?::[\da-f]{1,4}|(?:(?:[\da-f]{1,4}:){0,6}[\da-f]{1,4})?::)|v[0-9a-f]+\.[-a-z0-9._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)|(?:[-a-z0-9._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[-a-z0-9._~!$&'()*+,;=@]|%[0-9a-f]{2})+(?:\/(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?)(?:\?(?:[-a-z0-9._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[-a-z0-9._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+/**
+* Returns true if the value is a valid Uri Reference.
+* @specification https://tools.ietf.org/html/rfc3986
+*/
+function IsUriReference(value) {
+	return UriReference.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/uri_template.mjs
+const UriTemplate = /^(?:(?:[^\x00-\x20"<>%\\^`{|}\x7f]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?:\.(?:[a-z0-9_]|%[0-9a-f]{2})+)*(?::[1-9]\d{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?:\.(?:[a-z0-9_]|%[0-9a-f]{2})+)*(?::[1-9]\d{0,3}|\*)?)*\})*$/i;
+/**
+* Returns true if the value is a valid Uri Template
+* @specification https://datatracker.ietf.org/doc/html/rfc6570
+*/
+function IsUriTemplate(value) {
+	return UriTemplate.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/uri.mjs
+const Uri = /^[a-z][a-z0-9+\-.]*:(?:\/\/(?:(?:[-a-z0-9._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:[\da-f]{1,4}:){6}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|::(?:[\da-f]{1,4}:){5}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:[\da-f]{1,4})?::(?:[\da-f]{1,4}:){4}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,1}[\da-f]{1,4})?::(?:[\da-f]{1,4}:){3}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,2}[\da-f]{1,4})?::(?:[\da-f]{1,4}:){2}(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,3}[\da-f]{1,4})?::[\da-f]{1,4}:(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,4}[\da-f]{1,4})?::(?:[\da-f]{1,4}:[\da-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[\da-f]{1,4}:){0,5}[\da-f]{1,4})?::[\da-f]{1,4}|(?:(?:[\da-f]{1,4}:){0,6}[\da-f]{1,4})?::)|v[0-9a-f]+\.[-a-z0-9._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)|(?:[-a-z0-9._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[-a-z0-9._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[-a-z0-9._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[-a-z0-9._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+/**
+* Returns true if the value is a valid Uniform Resource Identifier.
+* @specification https://tools.ietf.org/html/rfc3986
+*/
+function IsUri(value) {
+	return Uri.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/url.mjs
+/**
+* Returns true if the value is a valid Uniform Resource Locator
+* @specification https://datatracker.ietf.org/doc/html/rfc3986
+* @specification https://datatracker.ietf.org/doc/html/rfc3987
+*/
+function IsUrl(value) {
+	return URL.canParse(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/uuid.mjs
+const Uuid = /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
+/**
+* Returns true if the value is a uuid
+* @specification https://www.rfc-editor.org/info/rfc4122/
+* @specification https://www.rfc-editor.org/info/rfc9562/
+*/
+function IsUuid(value) {
+	return Uuid.test(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/format/_registry.mjs
+const formats = /* @__PURE__ */ new Map();
+/** Clears all entries */
+function Clear() {
+	formats.clear();
+}
+/** Returns true if the registry has this format */
+function Has(format) {
+	return formats.has(format);
+}
+/** Gets a format or undefined if not exists */
+function Get$1(format) {
+	return formats.get(format);
+}
+/** Tests a value against a format, if the format is not registered, true */
+function Test(format, value) {
+	return formats.get(format)?.(value) ?? true;
+}
+/** Resets all formats to defaults */
+function Reset() {
+	Clear();
+	formats.set("date-time", IsDateTime);
+	formats.set("date", IsDate);
+	formats.set("duration", IsDuration);
+	formats.set("email", IsEmail);
+	formats.set("hostname", IsHostname);
+	formats.set("idn-email", IsIdnEmail);
+	formats.set("idn-hostname", IsIdnHostname);
+	formats.set("ipv4", IsIPv4);
+	formats.set("ipv6", IsIPv6);
+	formats.set("iri-reference", IsIriReference);
+	formats.set("iri", IsIri);
+	formats.set("json-pointer-uri-fragment", IsJsonPointerUriFragment);
+	formats.set("json-pointer", IsJsonPointer);
+	formats.set("regex", IsRegex);
+	formats.set("relative-json-pointer", IsRelativeJsonPointer);
+	formats.set("time", IsTime);
+	formats.set("uri-reference", IsUriReference);
+	formats.set("uri-template", IsUriTemplate);
+	formats.set("uri", IsUri);
+	formats.set("url", IsUrl);
+	formats.set("uuid", IsUuid);
+}
+Reset();
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/format.mjs
+function BuildFormat(_stack, _context, schema, value) {
+	return Has(schema.format) ? Call(CreateVariable(Get$1(schema.format)), [value]) : Constant(true);
+}
+function CheckFormat(_stack, _context, schema, value) {
+	return Test(schema.format, value);
+}
+function ErrorFormat(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckFormat(stack, context, schema, value) || context.AddError("format", schemaPath, instancePath, { format: schema.format });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/if.mjs
+function BuildIf(stack, context, schema, value) {
+	const thenSchema = IsThen(schema) ? schema.then : true;
+	const elseSchema = IsElse(schema) ? schema.else : true;
+	return Ternary(BuildSchema(stack, context, schema.if, value), BuildSchema(stack, context, thenSchema, value), BuildSchema(stack, context, elseSchema, value));
+}
+function CheckIf(stack, context, schema, value) {
+	const thenSchema = IsThen(schema) ? schema.then : true;
+	const elseSchema = IsElse(schema) ? schema.else : true;
+	return CheckSchema(stack, context, schema.if, value) ? CheckSchema(stack, context, thenSchema, value) : CheckSchema(stack, context, elseSchema, value);
+}
+function ErrorIf(stack, context, schemaPath, instancePath, schema, value) {
+	const thenSchema = IsThen(schema) ? schema.then : true;
+	const elseSchema = IsElse(schema) ? schema.else : true;
+	const trueContext = new ErrorContext();
+	const isIf = ErrorSchema(stack, trueContext, `${schemaPath}/if`, instancePath, schema.if, value) ? ErrorSchema(stack, trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) || context.AddError("if", schemaPath, instancePath, { failingKeyword: "then" }) : ErrorSchema(stack, context, `${schemaPath}/else`, instancePath, elseSchema, value) || context.AddError("if", schemaPath, instancePath, { failingKeyword: "else" });
+	if (isIf) context.Merge([trueContext]);
+	return isIf;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/items.mjs
+function BuildItemsSizedStandard(stack, context, schema, value) {
+	return ReduceAnd(schema.items.map((schema, index) => {
+		return Or(IsLessEqualThan(Member(value, "length"), Constant(index)), And(BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`), context.AddIndex(Constant(index))));
+	}));
+}
+function BuildItemsSizedFast(stack, context, schema, value) {
+	return ReduceAnd(schema.items.map((schema, index) => {
+		return Or(IsLessEqualThan(Member(value, "length"), Constant(index)), BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`));
+	}));
+}
+function BuildItemsSized(stack, context, schema, value) {
+	return context.UseUnevaluated() ? BuildItemsSizedStandard(stack, context, schema, value) : BuildItemsSizedFast(stack, context, schema, value);
+}
+function CheckItemsSized(stack, context, schema, value) {
+	return Every$1(schema.items, 0, (schema, index) => {
+		return IsLessEqualThan$1(value.length, index) || CheckSchemaPushStack(stack, context, schema, value[index]) && context.AddIndex(index);
+	});
+}
+function ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value) {
+	return EveryAll(schema.items, 0, (schema, index) => {
+		const nextSchemaPath = `${schemaPath}/items/${index}`;
+		const nextInstancePath = `${instancePath}/${index}`;
+		return IsLessEqualThan$1(value.length, index) || ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index);
+	});
+}
+function BuildItemsUnsizedStandard(stack, context, schema, value) {
+	const offset = IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+	const [item] = [CreateUnique()];
+	const isSchema = BuildSchemaPushStack(stack, context, schema.items, item);
+	const addIndex = context.AddIndex("index");
+	return Every(value, Constant(offset), [item, "index"], And(isSchema, addIndex));
+}
+function BuildItemsUnsizedFast(stack, context, schema, value) {
+	const offset = IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+	const [item] = [CreateUnique()];
+	const isSchema = BuildSchemaPushStack(stack, context, schema.items, item);
+	return Every(value, Constant(offset), [item, "index"], isSchema);
+}
+function BuildItemsUnsized(stack, context, schema, value) {
+	return context.UseUnevaluated() ? BuildItemsUnsizedStandard(stack, context, schema, value) : BuildItemsUnsizedFast(stack, context, schema, value);
+}
+function CheckItemsUnsized(stack, context, schema, value) {
+	const offset = IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+	return Every$1(value, offset, (element, index) => {
+		return CheckSchemaPushStack(stack, context, schema.items, element) && context.AddIndex(index);
+	});
+}
+function ErrorItemsUnsized(stack, context, schemaPath, instancePath, schema, value) {
+	const offset = IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+	return EveryAll(value, offset, (element, index) => {
+		return ErrorSchemaPushStack(stack, context, `${schemaPath}/items`, `${instancePath}/${index}`, schema.items, element) && context.AddIndex(index);
+	});
+}
+function BuildItems(stack, context, schema, value) {
+	return IsItemsSized(schema) ? BuildItemsSized(stack, context, schema, value) : BuildItemsUnsized(stack, context, schema, value);
+}
+function CheckItems(stack, context, schema, value) {
+	return IsItemsSized(schema) ? CheckItemsSized(stack, context, schema, value) : CheckItemsUnsized(stack, context, schema, value);
+}
+function ErrorItems(stack, context, schemaPath, instancePath, schema, value) {
+	return IsItemsSized(schema) ? ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value) : ErrorItemsUnsized(stack, context, schemaPath, instancePath, schema, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/maxContains.mjs
+function IsValid$2(schema) {
+	return IsContains(schema);
+}
+function BuildMaxContains(stack, context, schema, value) {
+	if (!IsValid$2(schema)) return Constant(true);
+	const [item] = [CreateUnique()];
+	return IsLessEqualThan(Counted(value, [item, "_"], BuildSchema(stack, context, schema.contains, item)), Constant(schema.maxContains));
+}
+function CheckMaxContains(stack, context, schema, value) {
+	if (!IsValid$2(schema)) return true;
+	const count = Counted$1(value, (item) => CheckSchema(stack, context, schema.contains, item));
+	return IsLessEqualThan$1(count, schema.maxContains);
+}
+function ErrorMaxContains(stack, context, schemaPath, instancePath, schema, value) {
+	const minContains = IsMinContains(schema) ? schema.minContains : 1;
+	return CheckMaxContains(stack, context, schema, value) || context.AddError("contains", schemaPath, instancePath, {
+		minContains,
+		maxContains: schema.maxContains
+	});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/maximum.mjs
+function BuildMaximum(_stack, _context, schema, value) {
+	return IsLessEqualThan(value, Constant(schema.maximum));
+}
+function CheckMaximum(_stack, _context, schema, value) {
+	return IsLessEqualThan$1(value, schema.maximum);
+}
+function ErrorMaximum(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckMaximum(stack, context, schema, value) || context.AddError("maximum", schemaPath, instancePath, {
+		comparison: "<=",
+		limit: schema.maximum
+	});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/maxItems.mjs
+function BuildMaxItems(_stack, _context, schema, value) {
+	return IsLessEqualThan(Member(value, "length"), Constant(schema.maxItems));
+}
+function CheckMaxItems(_stack, _context, schema, value) {
+	return IsLessEqualThan$1(value.length, schema.maxItems);
+}
+function ErrorMaxItems(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckMaxItems(stack, context, schema, value) || context.AddError("maxItems", schemaPath, instancePath, { limit: schema.maxItems });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/maxLength.mjs
+function BuildMaxLength(_stack, _context, schema, value) {
+	return IsMaxLength$1(value, Constant(schema.maxLength));
+}
+function CheckMaxLength(_stack, _context, schema, value) {
+	return IsMaxLength$2(value, schema.maxLength);
+}
+function ErrorMaxLength(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckMaxLength(stack, context, schema, value) || context.AddError("maxLength", schemaPath, instancePath, { limit: schema.maxLength });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/maxProperties.mjs
+function BuildMaxProperties(_stack, _context, schema, value) {
+	return IsLessEqualThan(Member(Keys(value), "length"), Constant(schema.maxProperties));
+}
+function CheckMaxProperties(_stack, _context, schema, value) {
+	return IsLessEqualThan$1(Keys$1(value).length, schema.maxProperties);
+}
+function ErrorMaxProperties(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckMaxProperties(stack, context, schema, value) || context.AddError("maxProperties", schemaPath, instancePath, { limit: schema.maxProperties });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/minContains.mjs
+function IsValid$1(schema) {
+	return IsContains(schema);
+}
+function BuildMinContainsStandard(stack, context, schema, value) {
+	const [item, index] = [CreateUnique(), CreateUnique()];
+	return IsGreaterEqualThan(Counted(value, [item, index], And(BuildSchema(stack, context, schema.contains, item), context.AddIndex(index))), Constant(schema.minContains));
+}
+function BuildMinContainsFast(stack, context, schema, value) {
+	const [item] = [CreateUnique()];
+	return IsGreaterEqualThan(Counted(value, [item, "_"], BuildSchema(stack, context, schema.contains, item)), Constant(schema.minContains));
+}
+function BuildMinContains(stack, context, schema, value) {
+	if (!IsValid$1(schema)) return Constant(true);
+	return context.UseUnevaluated() ? BuildMinContainsStandard(stack, context, schema, value) : BuildMinContainsFast(stack, context, schema, value);
+}
+function CheckMinContains(stack, context, schema, value) {
+	if (!IsValid$1(schema)) return true;
+	const count = Counted$1(value, (item, index) => CheckSchema(stack, context, schema.contains, item) && context.AddIndex(index));
+	return IsGreaterEqualThan$1(count, schema.minContains);
+}
+function ErrorMinContains(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckMinContains(stack, context, schema, value) || context.AddError("contains", schemaPath, instancePath, { minContains: schema.minContains });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/minimum.mjs
+function BuildMinimum(_stack, _context, schema, value) {
+	return IsGreaterEqualThan(value, Constant(schema.minimum));
+}
+function CheckMinimum(_stack, _context, schema, value) {
+	return IsGreaterEqualThan$1(value, schema.minimum);
+}
+function ErrorMinimum(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckMinimum(stack, context, schema, value) || context.AddError("minimum", schemaPath, instancePath, {
+		comparison: ">=",
+		limit: schema.minimum
+	});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/minItems.mjs
+function BuildMinItems(_stack, _context, schema, value) {
+	return IsGreaterEqualThan(Member(value, "length"), Constant(schema.minItems));
+}
+function CheckMinItems(_stack, _context, schema, value) {
+	return IsGreaterEqualThan$1(value.length, schema.minItems);
+}
+function ErrorMinItems(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckMinItems(stack, context, schema, value) || context.AddError("minItems", schemaPath, instancePath, { limit: schema.minItems });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/minLength.mjs
+function BuildMinLength(_stack, _context, schema, value) {
+	return IsMinLength$1(value, Constant(schema.minLength));
+}
+function CheckMinLength(_stack, _context, schema, value) {
+	return IsMinLength$2(value, schema.minLength);
+}
+function ErrorMinLength(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckMinLength(stack, context, schema, value) || context.AddError("minLength", schemaPath, instancePath, { limit: schema.minLength });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/minProperties.mjs
+function BuildMinProperties(_stack, _context, schema, value) {
+	return IsGreaterEqualThan(Member(Keys(value), "length"), Constant(schema.minProperties));
+}
+function CheckMinProperties(_stack, _context, schema, value) {
+	return IsGreaterEqualThan$1(Keys$1(value).length, schema.minProperties);
+}
+function ErrorMinProperties(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckMinProperties(stack, context, schema, value) || context.AddError("minProperties", schemaPath, instancePath, { limit: schema.minProperties });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/multipleOf.mjs
+function BuildMultipleOf(_stack, _context, schema, value) {
+	return MultipleOf(value, Constant(schema.multipleOf));
+}
+function CheckMultipleOf(_stack, _context, schema, value) {
+	return IsMultipleOf$1(value, schema.multipleOf);
+}
+function ErrorMultipleOf(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckMultipleOf(stack, context, schema, value) || context.AddError("multipleOf", schemaPath, instancePath, { multipleOf: schema.multipleOf });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/not.mjs
+function BuildNotStandard(stack, context, schema, value) {
+	return Reducer(stack, context, [schema.not], value, Not(IsEqual(Member("results", "length"), Constant(1))));
+}
+function BuildNotFast(stack, context, schema, value) {
+	return Not(BuildSchema(stack, context, schema.not, value));
+}
+function BuildNot(stack, context, schema, value) {
+	return context.UseUnevaluated() ? BuildNotStandard(stack, context, schema, value) : BuildNotFast(stack, context, schema, value);
+}
+function CheckNot(stack, context, schema, value) {
+	const nextContext = new CheckContext();
+	return !CheckSchema(stack, nextContext, schema.not, value) && context.Merge([nextContext]);
+}
+function ErrorNot(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckNot(stack, context, schema, value) || context.AddError("not", schemaPath, instancePath, {});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/oneOf.mjs
+function BuildOneOfStandard(stack, context, schema, value) {
+	return Reducer(stack, context, schema.oneOf, value, IsEqual(Member("results", "length"), Constant(1)));
+}
+function BuildOneOfFast(stack, context, schema, value) {
+	const [result] = [CreateUnique()];
+	return IsEqual(Counted(ArrayLiteral(schema.oneOf.map((schema) => BuildSchema(stack, context, schema, value))), [result, "_"], IsEqual(result, Constant(true))), Constant(1));
+}
+function BuildOneOf(stack, context, schema, value) {
+	return context.UseUnevaluated() ? BuildOneOfStandard(stack, context, schema, value) : BuildOneOfFast(stack, context, schema, value);
+}
+function CheckOneOf(stack, context, schema, value) {
+	const passedContexts = schema.oneOf.reduce((result, schema) => {
+		const nextContext = new CheckContext();
+		return CheckSchema(stack, nextContext, schema, value) ? [...result, nextContext] : result;
+	}, []);
+	return IsEqual$1(passedContexts.length, 1) && context.Merge(passedContexts);
+}
+function ErrorOneOf(stack, context, schemaPath, instancePath, schema, value) {
+	const failedContexts = [];
+	const passingSchemas = [];
+	const passedContexts = schema.oneOf.reduce((result, schema, index) => {
+		const nextContext = new ErrorContext();
+		const isSchema = ErrorSchema(stack, nextContext, `${schemaPath}/oneOf/${index}`, instancePath, schema, value);
+		if (isSchema) passingSchemas.push(index);
+		if (!isSchema) failedContexts.push(nextContext);
+		return isSchema ? [...result, nextContext] : result;
+	}, []);
+	const isOneOf = IsEqual$1(passedContexts.length, 1) && context.Merge(passedContexts);
+	if (!isOneOf && IsEqual$1(passingSchemas.length, 0)) failedContexts.forEach((failed) => context.AddErrors(failed.GetErrors()));
+	return isOneOf || context.AddError("oneOf", schemaPath, instancePath, { passingSchemas });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/pattern.mjs
+function BuildPattern(_stack, _context, schema, value) {
+	return Call(Member(CreateVariable(IsString$1(schema.pattern) ? UnicodeRegExp(schema.pattern) : schema.pattern), "test"), [value]);
+}
+function CheckPattern(_stack, _context, schema, value) {
+	return (IsString$1(schema.pattern) ? UnicodeRegExp(schema.pattern) : schema.pattern).test(value);
+}
+function ErrorPattern(stack, context, schemaPath, instancePath, schema, value) {
+	return CheckPattern(stack, context, schema, value) || context.AddError("pattern", schemaPath, instancePath, { pattern: schema.pattern });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/patternProperties.mjs
+function BuildPatternProperties(stack, context, schema, value) {
+	return ReduceAnd(Entries$1(schema.patternProperties).map(([pattern, schema]) => {
+		const [key, prop] = [CreateUnique(), CreateUnique()];
+		const notKey = Not(Call(Member(CreateVariable(UnicodeRegExp(pattern)), "test"), [key]));
+		const isSchema = BuildSchemaPushStack(stack, context, schema, prop);
+		const addKey = context.AddKey(key);
+		const guarded = context.UseUnevaluated() ? Or(notKey, And(isSchema, addKey)) : Or(notKey, isSchema);
+		return Every(Entries(value), Constant(0), [`[${key}, ${prop}]`, "_"], guarded);
+	}));
+}
+function CheckPatternProperties(stack, context, schema, value) {
+	return Every$1(Entries$1(schema.patternProperties), 0, ([pattern, schema]) => {
+		const regexp = UnicodeRegExp(pattern);
+		return Every$1(Entries$1(value), 0, ([key, prop]) => {
+			return !regexp.test(key) || CheckSchemaPushStack(stack, context, schema, prop) && context.AddKey(key);
+		});
+	});
+}
+function ErrorPatternProperties(stack, context, schemaPath, instancePath, schema, value) {
+	return EveryAll(Entries$1(schema.patternProperties), 0, ([pattern, schema]) => {
+		const nextSchemaPath = `${schemaPath}/patternProperties/${EncodeFragment(pattern)}`;
+		const regexp = UnicodeRegExp(pattern);
+		return EveryAll(Entries$1(value), 0, ([key, value]) => {
+			const nextInstancePath = `${instancePath}/${EncodeFragment(key)}`;
+			return !regexp.test(key) || ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value) && context.AddKey(key);
+		});
+	});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/prefixItems.mjs
+function BuildPrefixItems(stack, context, schema, value) {
+	return ReduceAnd(schema.prefixItems.map((schema, index) => {
+		const isLength = IsLessEqualThan(Member(value, "length"), Constant(index));
+		const isSchema = BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`);
+		const addIndex = context.AddIndex(Constant(index));
+		return Or(isLength, context.UseUnevaluated() ? And(isSchema, addIndex) : isSchema);
+	}));
+}
+function CheckPrefixItems(stack, context, schema, value) {
+	return IsEqual$1(value.length, 0) || Every$1(schema.prefixItems, 0, (schema, index) => {
+		return IsLessEqualThan$1(value.length, index) || CheckSchemaPushStack(stack, context, schema, value[index]) && context.AddIndex(index);
+	});
+}
+function ErrorPrefixItems(stack, context, schemaPath, instancePath, schema, value) {
+	return IsEqual$1(value.length, 0) || EveryAll(schema.prefixItems, 0, (schema, index) => {
+		const nextSchemaPath = `${schemaPath}/prefixItems/${index}`;
+		const nextInstancePath = `${instancePath}/${index}`;
+		return IsLessEqualThan$1(value.length, index) || ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index);
+	});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/_exact_optional.mjs
+function IsExactOptional(required, key) {
+	return required.includes(key) || Get$3().exactOptionalPropertyTypes;
+}
+function InexactOptionalBuild(value, key) {
+	return IsUndefined(Member(value, key));
+}
+function InexactOptionalCheck(value, key) {
+	return IsUndefined$1(value[key]);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/properties.mjs
+function BuildProperties(stack, context, schema, value) {
+	const required = IsRequired(schema) ? schema.required : [];
+	return ReduceAnd(Entries$1(schema.properties).map(([key, schema]) => {
+		const notKey = Not(HasPropertyKey(value, Constant(key)));
+		const isSchema = BuildSchemaPushStack(stack, context, schema, Member(value, key));
+		const addKey = context.AddKey(Constant(key));
+		const guarded = context.UseUnevaluated() ? And(isSchema, addKey) : isSchema;
+		const isProperty = required.includes(key) ? guarded : Or(notKey, guarded);
+		return IsExactOptional(required, key) ? isProperty : Or(InexactOptionalBuild(value, key), isProperty);
+	}));
+}
+function CheckProperties(stack, context, schema, value) {
+	const required = IsRequired(schema) ? schema.required : [];
+	return Every$1(Entries$1(schema.properties), 0, ([key, schema]) => {
+		const isProperty = !HasPropertyKey$1(value, key) || CheckSchemaPushStack(stack, context, schema, value[key]) && context.AddKey(key);
+		return IsExactOptional(required, key) ? isProperty : InexactOptionalCheck(value, key) || isProperty;
+	});
+}
+function ErrorProperties(stack, context, schemaPath, instancePath, schema, value) {
+	const required = IsRequired(schema) ? schema.required : [];
+	return EveryAll(Entries$1(schema.properties), 0, ([key, schema]) => {
+		const nextSchemaPath = `${schemaPath}/properties/${EncodeFragment(key)}`;
+		const nextInstancePath = `${instancePath}/${EncodeFragment(key)}`;
+		const isProperty = () => !HasPropertyKey$1(value, key) || ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[key]) && context.AddKey(key);
+		return IsExactOptional(required, key) ? isProperty() : InexactOptionalCheck(value, key) || isProperty();
+	});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/propertyNames.mjs
+function BuildPropertyNames(stack, context, schema, value) {
+	const [key, _index] = [CreateUnique(), CreateUnique()];
+	return Every(Keys(value), Constant(0), [key, _index], BuildSchema(stack, context, schema.propertyNames, key));
+}
+function CheckPropertyNames(stack, context, schema, value) {
+	return Every$1(Keys$1(value), 0, (key, _index) => CheckSchema(stack, context, schema.propertyNames, key));
+}
+function ErrorPropertyNames(stack, context, schemaPath, instancePath, schema, value) {
+	const propertyNames = [];
+	return EveryAll(Keys$1(value), 0, (key, _index) => {
+		const nextInstancePath = `${instancePath}/${EncodeFragment(key)}`;
+		const isPropertyName = ErrorSchema(stack, context, `${schemaPath}/propertyNames`, nextInstancePath, schema.propertyNames, key);
+		if (!isPropertyName) propertyNames.push(key);
+		return isPropertyName;
+	}) || context.AddError("propertyNames", schemaPath, instancePath, { propertyNames });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/recursiveRef.mjs
+function BuildRecursiveRef(stack, context, schema, value) {
+	const target = RecursiveRef(stack, schema) ?? false;
+	return CreateFunction(target ? {
+		...stack,
+		pendingResource: true
+	} : stack, context, target, value);
+}
+function CheckRecursiveRef(stack, context, schema, value) {
+	const target = RecursiveRef(stack, schema) ?? false;
+	const nextStack = target ? {
+		...stack,
+		pendingResource: true
+	} : stack;
+	return IsSchema(target) && CheckSchema(nextStack, context, target, value);
+}
+function ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema, value) {
+	const target = RecursiveRef(stack, schema) ?? false;
+	const nextStack = target ? {
+		...stack,
+		pendingResource: true
+	} : stack;
+	return IsSchema(target) && ErrorSchema(nextStack, context, schemaPath, instancePath, target, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/ref.mjs
+function BuildRefStandard(stack, context, target, value) {
+	const interior = ArrowFunction(["context", "value"], CreateFunction(stack, context, target, "value"));
+	return Call(ArrowFunction(["context", "value"], Statements([
+		ConstDeclaration("nextContext", New("CheckContext", [])),
+		ConstDeclaration("result", Call(interior, ["nextContext", "value"])),
+		If("result", context.Merge("[nextContext]")),
+		Return("result")
+	])), ["context", value]);
+}
+function BuildRefFast(stack, context, target, value) {
+	return CreateFunction(stack, context, target, value);
+}
+function BuildRef(stack, context, schema, value) {
+	const result = Ref(stack, schema);
+	const target = result.schema ?? false;
+	return context.UseUnevaluated() ? BuildRefStandard(result.stack, context, target, value) : BuildRefFast(result.stack, context, target, value);
+}
+function CheckRef(stack, context, schema, value) {
+	const result = Ref(stack, schema);
+	const target = result.schema ?? false;
+	const nextContext = new CheckContext();
+	const valid = IsSchema(target) && CheckSchema(result.stack, nextContext, target, value);
+	if (valid) context.Merge([nextContext]);
+	return valid;
+}
+function ErrorRef(stack, context, schemaPath, instancePath, schema, value) {
+	const result = Ref(stack, schema);
+	const target = result.schema ?? false;
+	const nextContext = new ErrorContext();
+	const valid = IsSchema(target) && ErrorSchema(result.stack, nextContext, schemaPath, instancePath, target, value);
+	if (valid) context.Merge([nextContext]);
+	if (!valid) context.AddErrors(nextContext.GetErrors());
+	return valid;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/required.mjs
+function BuildRequired(_stack, _context, schema, value) {
+	return ReduceAnd(schema.required.map((key) => HasPropertyKey(value, Constant(key))));
+}
+function CheckRequired(_stack, _context, schema, value) {
+	return Every$1(schema.required, 0, (key) => HasPropertyKey$1(value, key));
+}
+function ErrorRequired(_stack, context, schemaPath, instancePath, schema, value) {
+	const requiredProperties = [];
+	return EveryAll(schema.required, 0, (key) => {
+		const hasKey = HasPropertyKey$1(value, key);
+		if (!hasKey) requiredProperties.push(key);
+		return hasKey;
+	}) || context.AddError("required", schemaPath, instancePath, { requiredProperties });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/type.mjs
+function BuildTypeName(_stack, _context, type, value) {
+	return IsEqual$1(type, "object") ? IsObjectNotArray(value) : IsEqual$1(type, "array") ? IsArray(value) : IsEqual$1(type, "boolean") ? IsBoolean(value) : IsEqual$1(type, "integer") ? IsInteger(value) : IsEqual$1(type, "number") ? IsNumber(value) : IsEqual$1(type, "null") ? IsNull(value) : IsEqual$1(type, "string") ? IsString(value) : IsEqual$1(type, "bigint") ? IsBigInt(value) : IsEqual$1(type, "constructor") ? IsConstructor(value) : IsEqual$1(type, "function") ? IsFunction(value) : IsEqual$1(type, "symbol") ? IsSymbol(value) : IsEqual$1(type, "undefined") ? IsUndefined(value) : IsEqual$1(type, "void") ? IsUndefined(value) : Constant(true);
+}
+function CheckTypeName(_stack, _context, type, _schema, value) {
+	return IsEqual$1(type, "object") ? IsObjectNotArray$1(value) : IsEqual$1(type, "array") ? IsArray$1(value) : IsEqual$1(type, "boolean") ? IsBoolean$1(value) : IsEqual$1(type, "integer") ? IsInteger$1(value) : IsEqual$1(type, "number") ? IsNumber$1(value) : IsEqual$1(type, "null") ? IsNull$1(value) : IsEqual$1(type, "string") ? IsString$1(value) : IsEqual$1(type, "bigint") ? IsBigInt$1(value) : IsEqual$1(type, "constructor") ? IsConstructor$1(value) : IsEqual$1(type, "function") ? IsFunction$1(value) : IsEqual$1(type, "symbol") ? IsSymbol$1(value) : IsEqual$1(type, "undefined") ? IsUndefined$1(value) : IsEqual$1(type, "void") ? IsUndefined$1(value) : true;
+}
+function BuildTypeNames(stack, context, typenames, value) {
+	return ReduceOr(typenames.map((type) => BuildTypeName(stack, context, type, value)));
+}
+function CheckTypeNames(stack, context, types, schema, value) {
+	return Some$1(types, (type) => CheckTypeName(stack, context, type, schema, value));
+}
+function BuildType(stack, context, schema, value) {
+	return IsArray$1(schema.type) ? BuildTypeNames(stack, context, schema.type, value) : BuildTypeName(stack, context, schema.type, value);
+}
+function CheckType(stack, context, schema, value) {
+	return IsArray$1(schema.type) ? CheckTypeNames(stack, context, schema.type, schema, value) : CheckTypeName(stack, context, schema.type, schema, value);
+}
+function ErrorType(stack, context, schemaPath, instancePath, schema, value) {
+	return (IsArray$1(schema.type) ? CheckTypeNames(stack, context, schema.type, schema, value) : CheckTypeName(stack, context, schema.type, schema, value)) || context.AddError("type", schemaPath, instancePath, { type: schema.type });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/unevaluatedItems.mjs
+function BuildUnevaluatedItems(stack, context, schema, value) {
+	const [index, item] = [CreateUnique(), CreateUnique()];
+	const indices = Call(Member("context", "GetIndices"), []);
+	const hasIndex = Call(Member("indices", "has"), [index]);
+	const isSchema = BuildSchema(stack, context, schema.unevaluatedItems, item);
+	const addIndex = Call(Member("context", "AddIndex"), [index]);
+	const isEvery = Every(value, Constant(0), [item, index], And(Or(hasIndex, isSchema), addIndex));
+	return Call(ArrowFunction(["context"], Statements([ConstDeclaration("indices", indices), Return(isEvery)])), ["context"]);
+}
+function CheckUnevaluatedItems(stack, context, schema, value) {
+	const indices = context.GetIndices();
+	return Every$1(value, 0, (item, index) => {
+		return (indices.has(index) || CheckSchema(stack, context, schema.unevaluatedItems, item)) && context.AddIndex(index);
+	});
+}
+function ErrorUnevaluatedItems(stack, context, schemaPath, instancePath, schema, value) {
+	const indices = context.GetIndices();
+	const unevaluatedItems = [];
+	return EveryAll(value, 0, (item, index) => {
+		const nextContext = new ErrorContext();
+		const isEvaluatedItem = (indices.has(index) || ErrorSchema(stack, nextContext, schemaPath, instancePath, schema.unevaluatedItems, item)) && context.AddIndex(index);
+		if (!isEvaluatedItem) unevaluatedItems.push(index);
+		return isEvaluatedItem;
+	}) || context.AddError("unevaluatedItems", schemaPath, instancePath, { unevaluatedItems });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/unevaluatedProperties.mjs
+function BuildUnevaluatedProperties(stack, context, schema, value) {
+	const [key, prop] = [CreateUnique(), CreateUnique()];
+	const keys = Call(Member("context", "GetKeys"), []);
+	const hasKey = Call(Member("keys", "has"), [key]);
+	const addKey = Call(Member("context", "AddKey"), [key]);
+	const isSchema = BuildSchema(stack, context, schema.unevaluatedProperties, prop);
+	const isEvery = Every(Entries(value), Constant(0), [`[${key}, ${prop}]`, "_"], Or(hasKey, And(isSchema, addKey)));
+	return Call(ArrowFunction(["context"], Statements([ConstDeclaration("keys", keys), Return(isEvery)])), ["context"]);
+}
+function CheckUnevaluatedProperties(stack, context, schema, value) {
+	const keys = context.GetKeys();
+	return Every$1(Entries$1(value), 0, ([key, prop]) => {
+		return keys.has(key) || CheckSchema(stack, context, schema.unevaluatedProperties, prop) && context.AddKey(key);
+	});
+}
+function ErrorUnevaluatedProperties(stack, context, schemaPath, instancePath, schema, value) {
+	const keys = context.GetKeys();
+	const unevaluatedProperties = [];
+	return EveryAll(Entries$1(value), 0, ([key, prop]) => {
+		const nextContext = new ErrorContext();
+		const isEvaluatedProperty = keys.has(key) || ErrorSchema(stack, nextContext, schemaPath, instancePath, schema.unevaluatedProperties, prop) && context.AddKey(key);
+		if (!isEvaluatedProperty) unevaluatedProperties.push(key);
+		return isEvaluatedProperty;
+	}) || context.AddError("unevaluatedProperties", schemaPath, instancePath, { unevaluatedProperties });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/uniqueItems.mjs
+function IsValid(schema) {
+	return !IsEqual$1(schema.uniqueItems, false);
+}
+function BuildUniqueItems(_stack, _context, schema, value) {
+	if (!IsValid(schema)) return Constant(true);
+	return IsEqual(Member(New("Set", [Call(Member(value, "map"), [Member("Hashing", "Hash")])]), "size"), Member(value, "length"));
+}
+function CheckUniqueItems(_stack, _context, schema, value) {
+	if (!IsValid(schema)) return true;
+	const set = new Set(value.map(Hash)).size;
+	const isLength = value.length;
+	return IsEqual$1(set, isLength);
+}
+function ErrorUniqueItems(_stack, context, schemaPath, instancePath, schema, value) {
+	if (!IsValid(schema)) return true;
+	const set = /* @__PURE__ */ new Set();
+	const duplicateItems = value.reduce((result, value, index) => {
+		const hash = Hash(value);
+		if (set.has(hash)) return [...result, index];
+		set.add(hash);
+		return result;
+	}, []);
+	return IsEqual$1(duplicateItems.length, 0) || context.AddError("uniqueItems", schemaPath, instancePath, { duplicateItems });
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/schema.mjs
+function HasTypeName(schema, typename) {
+	return IsType(schema) && (IsArray$1(schema.type) && IsGreaterThan$1(schema.type.length, 0) && Every$1(schema.type, 0, (type) => IsEqual$1(type, typename)) || IsEqual$1(schema.type, typename));
+}
+function HasObjectType(schema) {
+	return HasTypeName(schema, "object");
+}
+function HasObjectKeywords(schema) {
+	return IsSchemaObject$1(schema) && (IsAdditionalProperties(schema) || IsDependencies(schema) || IsDependentRequired(schema) || IsDependentSchemas(schema) || IsProperties(schema) || IsPatternProperties(schema) || IsPropertyNames(schema) || IsMinProperties(schema) || IsMaxProperties(schema) || IsRequired(schema) || IsUnevaluatedProperties(schema));
+}
+function HasArrayType(schema) {
+	return HasTypeName(schema, "array");
+}
+function HasArrayKeywords(schema) {
+	return IsSchemaObject$1(schema) && (IsAdditionalItems(schema) || IsItems(schema) || IsContains(schema) || IsMaxContains(schema) || IsMaxItems(schema) || IsMinContains(schema) || IsMinItems(schema) || IsPrefixItems(schema) || IsUnevaluatedItems(schema) || IsUniqueItems(schema));
+}
+function HasStringType(schema) {
+	return HasTypeName(schema, "string");
+}
+function HasStringKeywords(schema) {
+	return IsSchemaObject$1(schema) && (IsMinLength(schema) || IsMaxLength(schema) || IsFormat(schema) || IsPattern(schema));
+}
+function HasNumberType(schema) {
+	return HasTypeName(schema, "number") || HasTypeName(schema, "bigint");
+}
+function HasNumberKeywords(schema) {
+	return IsSchemaObject$1(schema) && (IsMinimum(schema) || IsMaximum(schema) || IsExclusiveMaximum(schema) || IsExclusiveMinimum(schema) || IsMultipleOf(schema));
+}
+function BuildSchemaPushStack(stack, context, schema, value) {
+	return context.UseUnevaluated() ? And(And(context.Push(), BuildSchema(stack, context, schema, value)), context.Pop()) : BuildSchema(stack, context, schema, value);
+}
+function BuildSchema(stack, context, schema, value) {
+	const current = NextStack(stack, schema);
+	const conditions = [];
+	if (IsSchemaBoolean(schema)) return BuildSchemaBoolean(current, context, schema, value);
+	if (IsType(schema)) conditions.push(BuildType(current, context, schema, value));
+	if (HasObjectKeywords(schema)) {
+		const constraints = [];
+		if (IsRequired(schema)) constraints.push(BuildRequired(current, context, schema, value));
+		if (IsAdditionalProperties(schema)) constraints.push(BuildAdditionalProperties(current, context, schema, value));
+		if (IsDependencies(schema)) constraints.push(BuildDependencies(current, context, schema, value));
+		if (IsDependentRequired(schema)) constraints.push(BuildDependentRequired(current, context, schema, value));
+		if (IsDependentSchemas(schema)) constraints.push(BuildDependentSchemas(current, context, schema, value));
+		if (IsPatternProperties(schema)) constraints.push(BuildPatternProperties(current, context, schema, value));
+		if (IsProperties(schema)) constraints.push(BuildProperties(current, context, schema, value));
+		if (IsPropertyNames(schema)) constraints.push(BuildPropertyNames(current, context, schema, value));
+		if (IsMinProperties(schema)) constraints.push(BuildMinProperties(current, context, schema, value));
+		if (IsMaxProperties(schema)) constraints.push(BuildMaxProperties(current, context, schema, value));
+		const reduced = ReduceAnd(constraints);
+		const guarded = Or(Not(IsObjectNotArray(value)), reduced);
+		conditions.push(HasObjectType(schema) ? reduced : guarded);
+	}
+	if (HasArrayKeywords(schema)) {
+		const constraints = [];
+		if (IsAdditionalItems(schema)) constraints.push(BuildAdditionalItems(current, context, schema, value));
+		if (IsContains(schema)) constraints.push(BuildContains(current, context, schema, value));
+		if (IsItems(schema)) constraints.push(BuildItems(current, context, schema, value));
+		if (IsMinContains(schema)) constraints.push(BuildMinContains(current, context, schema, value));
+		if (IsMaxContains(schema)) constraints.push(BuildMaxContains(current, context, schema, value));
+		if (IsMinItems(schema)) constraints.push(BuildMinItems(current, context, schema, value));
+		if (IsMaxItems(schema)) constraints.push(BuildMaxItems(current, context, schema, value));
+		if (IsPrefixItems(schema)) constraints.push(BuildPrefixItems(current, context, schema, value));
+		if (IsUniqueItems(schema)) constraints.push(BuildUniqueItems(current, context, schema, value));
+		const reduced = ReduceAnd(constraints);
+		const guarded = Or(Not(IsArray(value)), reduced);
+		conditions.push(HasArrayType(schema) ? reduced : guarded);
+	}
+	if (HasStringKeywords(schema)) {
+		const constraints = [];
+		if (IsMinLength(schema)) constraints.push(BuildMinLength(current, context, schema, value));
+		if (IsMaxLength(schema)) constraints.push(BuildMaxLength(current, context, schema, value));
+		if (IsFormat(schema)) constraints.push(BuildFormat(current, context, schema, value));
+		if (IsPattern(schema)) constraints.push(BuildPattern(current, context, schema, value));
+		const reduced = ReduceAnd(constraints);
+		const guarded = Or(Not(IsString(value)), reduced);
+		conditions.push(HasStringType(schema) ? reduced : guarded);
+	}
+	if (HasNumberKeywords(schema)) {
+		const constraints = [];
+		if (IsExclusiveMinimum(schema)) constraints.push(BuildExclusiveMinimum(current, context, schema, value));
+		if (IsExclusiveMaximum(schema)) constraints.push(BuildExclusiveMaximum(current, context, schema, value));
+		if (IsMinimum(schema)) constraints.push(BuildMinimum(current, context, schema, value));
+		if (IsMaximum(schema)) constraints.push(BuildMaximum(current, context, schema, value));
+		if (IsMultipleOf(schema)) constraints.push(BuildMultipleOf(current, context, schema, value));
+		const reduced = ReduceAnd(constraints);
+		const guarded = Or(Not(Or(IsNumber(value), IsBigInt(value))), reduced);
+		conditions.push(HasNumberType(schema) ? reduced : guarded);
+	}
+	if (IsRef(schema)) conditions.push(BuildRef(current, context, schema, value));
+	if (IsRecursiveRef(schema)) conditions.push(BuildRecursiveRef(current, context, schema, value));
+	if (IsDynamicRef(schema)) conditions.push(BuildDynamicRef(current, context, schema, value));
+	if (IsConst(schema)) conditions.push(BuildConst(current, context, schema, value));
+	if (IsEnum(schema)) conditions.push(BuildEnum(current, context, schema, value));
+	if (IsIf(schema)) conditions.push(BuildIf(current, context, schema, value));
+	if (IsNot(schema)) conditions.push(BuildNot(current, context, schema, value));
+	if (IsAllOf(schema)) conditions.push(BuildAllOf(current, context, schema, value));
+	if (IsAnyOf(schema)) conditions.push(BuildAnyOf(current, context, schema, value));
+	if (IsOneOf(schema)) conditions.push(BuildOneOf(current, context, schema, value));
+	if (IsUnevaluatedItems(schema)) conditions.push(Or(Not(IsArray(value)), BuildUnevaluatedItems(current, context, schema, value)));
+	if (IsUnevaluatedProperties(schema)) conditions.push(Or(Not(IsObject(value)), BuildUnevaluatedProperties(current, context, schema, value)));
+	if (IsRefine(schema)) conditions.push(BuildRefine(current, context, schema, value));
+	return ReduceAnd(conditions);
+}
+function CheckSchemaPushStack(stack, context, schema, value) {
+	return context.Push() && CheckSchema(stack, context, schema, value) && context.Pop();
+}
+function CheckSchema(stack, context, schema, value) {
+	const current = NextStack(stack, schema);
+	return IsSchemaBoolean(schema) ? CheckSchemaBoolean(current, context, schema, value) : (!IsType(schema) || CheckType(current, context, schema, value)) && (!(IsObject$1(value) && !IsArray$1(value)) || (!IsRequired(schema) || CheckRequired(current, context, schema, value)) && (!IsAdditionalProperties(schema) || CheckAdditionalProperties(current, context, schema, value)) && (!IsDependencies(schema) || CheckDependencies(current, context, schema, value)) && (!IsDependentRequired(schema) || CheckDependentRequired(current, context, schema, value)) && (!IsDependentSchemas(schema) || CheckDependentSchemas(current, context, schema, value)) && (!IsPatternProperties(schema) || CheckPatternProperties(current, context, schema, value)) && (!IsProperties(schema) || CheckProperties(current, context, schema, value)) && (!IsPropertyNames(schema) || CheckPropertyNames(current, context, schema, value)) && (!IsMinProperties(schema) || CheckMinProperties(current, context, schema, value)) && (!IsMaxProperties(schema) || CheckMaxProperties(current, context, schema, value))) && (!IsArray$1(value) || (!IsAdditionalItems(schema) || CheckAdditionalItems(current, context, schema, value)) && (!IsContains(schema) || CheckContains(current, context, schema, value)) && (!IsItems(schema) || CheckItems(current, context, schema, value)) && (!IsMinContains(schema) || CheckMinContains(current, context, schema, value)) && (!IsMaxContains(schema) || CheckMaxContains(current, context, schema, value)) && (!IsMinItems(schema) || CheckMinItems(current, context, schema, value)) && (!IsMaxItems(schema) || CheckMaxItems(current, context, schema, value)) && (!IsPrefixItems(schema) || CheckPrefixItems(current, context, schema, value)) && (!IsUniqueItems(schema) || CheckUniqueItems(current, context, schema, value))) && (!IsString$1(value) || (!IsMinLength(schema) || CheckMinLength(current, context, schema, value)) && (!IsMaxLength(schema) || CheckMaxLength(current, context, schema, value)) && (!IsFormat(schema) || CheckFormat(current, context, schema, value)) && (!IsPattern(schema) || CheckPattern(current, context, schema, value))) && (!(IsNumber$1(value) || IsBigInt$1(value)) || (!IsExclusiveMinimum(schema) || CheckExclusiveMinimum(current, context, schema, value)) && (!IsExclusiveMaximum(schema) || CheckExclusiveMaximum(current, context, schema, value)) && (!IsMinimum(schema) || CheckMinimum(current, context, schema, value)) && (!IsMaximum(schema) || CheckMaximum(current, context, schema, value)) && (!IsMultipleOf(schema) || CheckMultipleOf(current, context, schema, value))) && (!IsRef(schema) || CheckRef(current, context, schema, value)) && (!IsRecursiveRef(schema) || CheckRecursiveRef(current, context, schema, value)) && (!IsDynamicRef(schema) || CheckDynamicRef(current, context, schema, value)) && (!IsConst(schema) || CheckConst(current, context, schema, value)) && (!IsEnum(schema) || CheckEnum(current, context, schema, value)) && (!IsIf(schema) || CheckIf(current, context, schema, value)) && (!IsNot(schema) || CheckNot(current, context, schema, value)) && (!IsAllOf(schema) || CheckAllOf(current, context, schema, value)) && (!IsAnyOf(schema) || CheckAnyOf(current, context, schema, value)) && (!IsOneOf(schema) || CheckOneOf(current, context, schema, value)) && (!IsUnevaluatedItems(schema) || !IsArray$1(value) || CheckUnevaluatedItems(current, context, schema, value)) && (!IsUnevaluatedProperties(schema) || !IsObject$1(value) || CheckUnevaluatedProperties(current, context, schema, value)) && (!IsRefine(schema) || CheckRefine(current, context, schema, value));
+}
+function ErrorSchemaPushStack(stack, context, schemaPath, instancePath, schema, value) {
+	return context.Push() && ErrorSchema(stack, context, schemaPath, instancePath, schema, value) && context.Pop();
+}
+function ErrorSchema(stack, context, schemaPath, instancePath, schema, value) {
+	if (context.AtCapacity()) return false;
+	const current = NextStack(stack, schema);
+	return IsSchemaBoolean(schema) ? ErrorSchemaBoolean(current, context, schemaPath, instancePath, schema, value) : !!(+(!IsType(schema) || ErrorType(current, context, schemaPath, instancePath, schema, value)) & +(!(IsObject$1(value) && !IsArray$1(value)) || !!(+(!IsRequired(schema) || ErrorRequired(current, context, schemaPath, instancePath, schema, value)) & +(!IsAdditionalProperties(schema) || ErrorAdditionalProperties(current, context, schemaPath, instancePath, schema, value)) & +(!IsDependencies(schema) || ErrorDependencies(current, context, schemaPath, instancePath, schema, value)) & +(!IsDependentRequired(schema) || ErrorDependentRequired(current, context, schemaPath, instancePath, schema, value)) & +(!IsDependentSchemas(schema) || ErrorDependentSchemas(current, context, schemaPath, instancePath, schema, value)) & +(!IsPatternProperties(schema) || ErrorPatternProperties(current, context, schemaPath, instancePath, schema, value)) & +(!IsProperties(schema) || ErrorProperties(current, context, schemaPath, instancePath, schema, value)) & +(!IsPropertyNames(schema) || ErrorPropertyNames(current, context, schemaPath, instancePath, schema, value)) & +(!IsMinProperties(schema) || ErrorMinProperties(current, context, schemaPath, instancePath, schema, value)) & +(!IsMaxProperties(schema) || ErrorMaxProperties(current, context, schemaPath, instancePath, schema, value)))) & +(!IsArray$1(value) || !!(+(!IsAdditionalItems(schema) || ErrorAdditionalItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsContains(schema) || ErrorContains(current, context, schemaPath, instancePath, schema, value)) & +(!IsItems(schema) || ErrorItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsMinContains(schema) || ErrorMinContains(current, context, schemaPath, instancePath, schema, value)) & +(!IsMaxContains(schema) || ErrorMaxContains(current, context, schemaPath, instancePath, schema, value)) & +(!IsMinItems(schema) || ErrorMinItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsMaxItems(schema) || ErrorMaxItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsPrefixItems(schema) || ErrorPrefixItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsUniqueItems(schema) || ErrorUniqueItems(current, context, schemaPath, instancePath, schema, value)))) & +(!IsString$1(value) || !!(+(!IsMinLength(schema) || ErrorMinLength(current, context, schemaPath, instancePath, schema, value)) & +(!IsMaxLength(schema) || ErrorMaxLength(current, context, schemaPath, instancePath, schema, value)) & +(!IsFormat(schema) || ErrorFormat(current, context, schemaPath, instancePath, schema, value)) & +(!IsPattern(schema) || ErrorPattern(current, context, schemaPath, instancePath, schema, value)))) & +(!(IsNumber$1(value) || IsBigInt$1(value)) || !!(+(!IsExclusiveMinimum(schema) || ErrorExclusiveMinimum(current, context, schemaPath, instancePath, schema, value)) & +(!IsExclusiveMaximum(schema) || ErrorExclusiveMaximum(current, context, schemaPath, instancePath, schema, value)) & +(!IsMinimum(schema) || ErrorMinimum(current, context, schemaPath, instancePath, schema, value)) & +(!IsMaximum(schema) || ErrorMaximum(current, context, schemaPath, instancePath, schema, value)) & +(!IsMultipleOf(schema) || ErrorMultipleOf(current, context, schemaPath, instancePath, schema, value)))) & +(!IsRef(schema) || ErrorRef(current, context, schemaPath, instancePath, schema, value)) & +(!IsRecursiveRef(schema) || ErrorRecursiveRef(current, context, schemaPath, instancePath, schema, value)) & +(!IsDynamicRef(schema) || ErrorDynamicRef(current, context, schemaPath, instancePath, schema, value)) & +(!IsConst(schema) || ErrorConst(current, context, schemaPath, instancePath, schema, value)) & +(!IsEnum(schema) || ErrorEnum(current, context, schemaPath, instancePath, schema, value)) & +(!IsIf(schema) || ErrorIf(current, context, schemaPath, instancePath, schema, value)) & +(!IsNot(schema) || ErrorNot(current, context, schemaPath, instancePath, schema, value)) & +(!IsAllOf(schema) || ErrorAllOf(current, context, schemaPath, instancePath, schema, value)) & +(!IsAnyOf(schema) || ErrorAnyOf(current, context, schemaPath, instancePath, schema, value)) & +(!IsOneOf(schema) || ErrorOneOf(current, context, schemaPath, instancePath, schema, value)) & +(!IsUnevaluatedItems(schema) || !IsArray$1(value) || ErrorUnevaluatedItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsUnevaluatedProperties(schema) || !IsObject$1(value) || ErrorUnevaluatedProperties(current, context, schemaPath, instancePath, schema, value))) && (!IsRefine(schema) || ErrorRefine(current, context, schemaPath, instancePath, schema, value));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/engine/_functions.mjs
+const index = [0];
+const names = /* @__PURE__ */ new Map();
+const funcs = /* @__PURE__ */ new Map();
+function NextName() {
+	return `${index[0]++}`;
+}
+function CreateName(schema, href) {
+	if (!names.has(schema)) names.set(schema, /* @__PURE__ */ new Map());
+	const hrefs = names.get(schema);
+	if (hrefs.has(href)) return hrefs.get(href);
+	const name = NextName();
+	hrefs.set(href, name);
+	return name;
+}
+function CreateCallExpression(context, _schema, name, value) {
+	return context.UseUnevaluated() ? Call(`check_${name}`, ["context", value]) : Call(`check_${name}`, [value]);
+}
+function CreateFunctionExpression(stack, context, schema, name) {
+	const expression = BuildSchema(stack, context, schema, "value");
+	return context.UseUnevaluated() ? ConstDeclaration(`check_${name}`, ArrowFunction(["context", "value"], expression)) : ConstDeclaration(`check_${name}`, ArrowFunction(["value"], expression));
+}
+function ResetFunctions() {
+	index[0] = 0;
+	names.clear();
+	funcs.clear();
+}
+function GetFunctions() {
+	return [...funcs.values()];
+}
+function CreateFunction(stack, context, schema, value) {
+	const name = CreateName(schema, stack.lexicalBase);
+	const call = CreateCallExpression(context, schema, name, value);
+	if (funcs.has(name)) return call;
+	funcs.set(name, "");
+	funcs.set(name, CreateFunctionExpression(stack, context, schema, name));
+	return call;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/system/environment/evaluate.mjs
+let supported = void 0;
+function TryEvaluate() {
+	try {
+		Evaluate("null")();
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Returns true if the environment supports dynamic JavaScript evaluation */
+function CanEvaluate() {
+	if (IsUndefined$1(supported)) supported = TryEvaluate();
+	return supported && Get$3().useAcceleration;
+}
+/**
+* Evaluates code in the current environment. This function will throw if the
+* environment Content-Security-Policy does not support `unsafe-eval`. Use the
+* Environment.CanEvaluate() to determine if the environment supports Evaluate
+* before calling this function.
+*/
+function Evaluate(...args) {
+	return new globalThis.Function(...args);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/system/locale/en_US.mjs
+/** en_US: English (United States) - ISO 639-1 language code 'en' with ISO 3166-1 alpha-2 country code 'US' for United States. */
+function en_US(error) {
+	switch (error.keyword) {
+		case "additionalProperties": return "must not have additional properties";
+		case "anyOf": return "must match a schema in anyOf";
+		case "boolean": return "schema is false";
+		case "const": return "must be equal to constant";
+		case "contains": return "must contain at least 1 valid item";
+		case "dependencies": return `must have properties ${error.params.dependencies.join(", ")} when property ${error.params.property} is present`;
+		case "dependentRequired": return `must have properties ${error.params.dependencies.join(", ")} when property ${error.params.property} is present`;
+		case "enum": return "must be equal to one of the allowed values";
+		case "exclusiveMaximum": return `must be ${error.params.comparison} ${error.params.limit}`;
+		case "exclusiveMinimum": return `must be ${error.params.comparison} ${error.params.limit}`;
+		case "format": return `must match format "${error.params.format}"`;
+		case "if": return `must match "${error.params.failingKeyword}" schema`;
+		case "maxItems": return `must not have more than ${error.params.limit} items`;
+		case "maxLength": return `must not have more than ${error.params.limit} characters`;
+		case "maxProperties": return `must not have more than ${error.params.limit} properties`;
+		case "maximum": return `must be ${error.params.comparison} ${error.params.limit}`;
+		case "minItems": return `must not have fewer than ${error.params.limit} items`;
+		case "minLength": return `must not have fewer than ${error.params.limit} characters`;
+		case "minProperties": return `must not have fewer than ${error.params.limit} properties`;
+		case "minimum": return `must be ${error.params.comparison} ${error.params.limit}`;
+		case "multipleOf": return `must be multiple of ${error.params.multipleOf}`;
+		case "not": return "must not be valid";
+		case "oneOf": return "must match exactly one schema in oneOf";
+		case "pattern": return `must match pattern "${error.params.pattern}"`;
+		case "propertyNames": return `property names ${error.params.propertyNames.join(", ")} are invalid`;
+		case "required": return `must have required properties ${error.params.requiredProperties.join(", ")}`;
+		case "type": return typeof error.params.type === "string" ? `must be ${error.params.type}` : `must be either ${error.params.type.join(" or ")}`;
+		case "unevaluatedItems": return "must not have unevaluated items";
+		case "unevaluatedProperties": return "must not have unevaluated properties";
+		case "uniqueItems": return `must not have duplicate items`;
+		case "~refine": return error.params.message;
+		default: return "an unknown validation error occurred";
+	}
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/system/locale/_config.mjs
+let locale = en_US;
+/** Gets the locale */
+function Get() {
+	return locale;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/build.mjs
+function CreateCode(build) {
+	return `${build.Functions().join(";\n")}; return (value) => { ${(build.UseUnevaluated() ? ["const context = new CheckContext({}, {})", `return ${build.Entry()}`] : [`return ${build.Entry()}`]).join("; ")} }`;
+}
+function CreateEvaluatedCheck(build, code) {
+	return Evaluate("CheckContext", "Guard", "Hashing", build.External().identifier, code)(CheckContext, guard_exports, hash_exports, build.External().variables);
+}
+function CreateDynamicCheck(build) {
+	const stack = Stack(build.Context(), build.Schema());
+	const context = new CheckContext();
+	return (value) => CheckSchema(stack, context, build.Schema(), value);
+}
+function CreateCheck(build, code) {
+	return CanEvaluate() ? CreateEvaluatedCheck(build, code) : CreateDynamicCheck(build);
+}
+var EvaluateResult = class {
+	constructor(isAccelerated, code, check) {
+		this.isAccelerated = isAccelerated;
+		this.code = code;
+		this.check = check;
+	}
+	IsAccelerated() {
+		return this.isAccelerated;
+	}
+	Code() {
+		return this.code;
+	}
+	Check(value) {
+		return this.check(value);
+	}
+};
+var BuildResult = class {
+	constructor(context, schema, external, functions, entry, useUnevaluated) {
+		this.context = context;
+		this.schema = schema;
+		this.external = external;
+		this.functions = functions;
+		this.entry = entry;
+		this.useUnevaluated = useUnevaluated;
+	}
+	/** Returns the Context used for this build */
+	Context() {
+		return this.context;
+	}
+	/** Returns the Schema used for this build */
+	Schema() {
+		return this.schema;
+	}
+	/** Returns true if this build requires a Unevaluated context */
+	UseUnevaluated() {
+		return this.useUnevaluated;
+	}
+	/** Returns external variables */
+	External() {
+		return this.external;
+	}
+	/** Returns check functions */
+	Functions() {
+		return this.functions;
+	}
+	/** Return entry function call. */
+	Entry() {
+		return this.entry;
+	}
+	/** Evaluates the build into a validation function */
+	Evaluate() {
+		const code = CreateCode(this);
+		const check = CreateCheck(this, code);
+		return new EvaluateResult(CanEvaluate(), code, check);
+	}
+};
+/** Builds a schema into a optimized runtime validator */
+function Build(...args) {
+	const [context, schema] = Match$1(args, {
+		2: (context, schema) => [context, schema],
+		1: (schema) => [{}, schema]
+	});
+	ResetUnique();
+	ResetExternal();
+	ResetFunctions();
+	const stack = Stack(context, schema);
+	const build = new BuildContext(HasUnevaluated(context, schema));
+	const call = CreateFunction(stack, build, schema, "value");
+	const functions = GetFunctions();
+	return new BuildResult(context, schema, GetExternal(), functions, call, build.UseUnevaluated());
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/errors.mjs
+/** Returns an array of validation errors for the given value. */
+function Errors$1(...args) {
+	const [context, schema, value] = Match$1(args, {
+		3: (context, schema, value) => [
+			context,
+			schema,
+			value
+		],
+		2: (schema, value) => [
+			{},
+			schema,
+			value
+		]
+	});
+	const stack = Stack(context, schema);
+	const errorContext = new ErrorContext();
+	const result = ErrorSchema(stack, errorContext, "#", "", schema, value);
+	const errors = errorContext.GetErrors();
+	const locale = Get();
+	return [result, errors.map((error) => ({
+		...error,
+		message: locale(error)
+	}))];
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/system/settings/internal.mjs
+let TempMaxErrors = 0;
+function EnableParseErrors() {
+	const settings = Get$3();
+	TempMaxErrors = settings.maxErrors;
+	settings.maxErrors = settings.maxParseErrors;
+}
+function DisableParseErrors() {
+	const settings = Get$3();
+	settings.maxErrors = TempMaxErrors;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/schema/check.mjs
+/** Checks a value against the provided schema */
+function Check$1(...args) {
+	const [context, schema, value] = Match$1(args, {
+		3: (context, schema, value) => [
+			context,
+			schema,
+			value
+		],
+		2: (schema, value) => [
+			{},
+			schema,
+			value
+		]
+	});
+	return CheckSchema(Stack(context, schema), new CheckContext(), schema, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/check/check.mjs
+/** Checks a value matches the provided type. */
+function Check(...args) {
+	const [context, type, value] = Match$1(args, {
+		3: (context, type, value) => [
+			context,
+			type,
+			value
+		],
+		2: (type, value) => [
+			{},
+			type,
+			value
+		]
+	});
+	return Check$1(context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/errors/errors.mjs
+/** Returns an array of validation errors for the given value. */
+function Errors(...args) {
+	const [context, type, value] = Match$1(args, {
+		3: (context, type, value) => [
+			context,
+			type,
+			value
+		],
+		2: (type, value) => [
+			{},
+			type,
+			value
+		]
+	});
+	const [_, errors] = Errors$1(context, type, value);
+	return errors;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/assert/assert.mjs
+var AssertError = class extends Error {
+	constructor(source, value, errors) {
+		super(source);
+		Object.defineProperty(this, "cause", {
+			value: {
+				source,
+				errors,
+				value
+			},
+			writable: false,
+			configurable: false,
+			enumerable: false
+		});
+	}
+};
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clean/from_array.mjs
+function FromArray$6(context, type, value) {
+	if (!IsArray$1(value)) return value;
+	return value.map((value) => FromType$6(context, type.items, value));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clean/from_cyclic.mjs
+function FromCyclic$5(context, type, value) {
+	return FromType$6({
+		...context,
+		...type.$defs
+	}, Ref$1(type.$ref), value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clean/from_intersect.mjs
+function EvaluateIntersection(context, type) {
+	const additionalProperties = HasPropertyKey$1(type, "unevaluatedProperties") ? { additionalProperties: type.unevaluatedProperties } : {};
+	const instantiated = Instantiate(context, type);
+	const evaluated = Evaluate$1(instantiated);
+	return IsObject$2(evaluated) ? With(evaluated, additionalProperties) : evaluated;
+}
+function FromIntersect$5(context, type, value) {
+	return FromType$6(context, EvaluateIntersection(context, type), value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clean/additional.mjs
+function GetAdditionalProperties(type) {
+	return HasPropertyKey$1(type, "additionalProperties") ? type.additionalProperties : void 0;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clean/from_object.mjs
+function FromObject$6(context, type, value) {
+	if (!IsObject$1(value) || IsArray$1(value)) return value;
+	const additionalProperties = GetAdditionalProperties(type);
+	for (const key of Keys$1(value)) {
+		if (HasPropertyKey$1(type.properties, key) && IsSchema$1(type.properties[key])) {
+			value[key] = FromType$6(context, type.properties[key], value[key]);
+			continue;
+		}
+		if (IsBoolean$1(additionalProperties) && IsEqual$1(additionalProperties, true) || IsSchema$1(additionalProperties) && Check(context, additionalProperties, value[key])) {
+			value[key] = FromType$6(context, additionalProperties, value[key]);
+			continue;
+		}
+		delete value[key];
+	}
+	return value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clean/from_record.mjs
+function FromRecord$5(context, type, value) {
+	if (!IsObject$1(value)) return value;
+	const additionalProperties = GetAdditionalProperties(type);
+	const [recordPattern, recordValue] = [new RegExp(RecordPattern(type)), RecordValue(type)];
+	for (const key of Keys$1(value)) {
+		if (recordPattern.test(key)) {
+			value[key] = FromType$6(context, recordValue, value[key]);
+			continue;
+		}
+		if (IsBoolean$1(additionalProperties) && IsEqual$1(additionalProperties, true) || IsSchema$1(additionalProperties) && Check(context, additionalProperties, value[key])) {
+			value[key] = FromType$6(context, additionalProperties, value[key]);
+			continue;
+		}
+		delete value[key];
+	}
+	return value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clean/from_ref.mjs
+function FromRef$5(context, type, value) {
+	return HasPropertyKey$1(context, type.$ref) ? FromType$6(context, context[type.$ref], value) : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clean/from_tuple.mjs
+function FromTuple$5(context, schema, value) {
+	if (!IsArray$1(value)) return value;
+	const length = Math.min(value.length, schema.items.length);
+	for (let index = 0; index < length; index++) value[index] = FromType$6(context, schema.items[index], value[index]);
+	return IsGreaterThan$1(value.length, length) ? value.slice(0, length) : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/system/memory/deep.mjs
+function FromClassInstance(value) {
+	return value;
+}
+function IsSchemaObject(value) {
+	return HasPropertyKey$1(value, "~kind") || HasPropertyKey$1(value, "~unsafe");
+}
+function FromSchemaObject(value) {
+	const result = {};
+	for (const key of Keys$1(value)) {
+		if (IsUnsafePropertyKey(key)) continue;
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		descriptor.value = FromValue(descriptor.value);
+		if (IsEqual$1(descriptor.enumerable, true)) result[key] = descriptor.value;
+		else Object.defineProperty(result, key, descriptor);
+	}
+	return result;
+}
+function FromPlainObject(value) {
+	const result = {};
+	for (const key of Keys$1(value)) {
+		if (IsUnsafePropertyKey(key)) continue;
+		result[key] = FromValue(value[key]);
+	}
+	for (const key of Symbols(value)) result[key] = FromValue(value[key]);
+	return result;
+}
+function FromObject$5(value) {
+	return IsClassInstance(value) ? FromClassInstance(value) : IsSchemaObject(value) ? FromSchemaObject(value) : FromPlainObject(value);
+}
+function FromArray$5(value) {
+	return value.map((element) => FromValue(element));
+}
+function FromTypedArray(value) {
+	return value.slice();
+}
+function FromRegExp(value) {
+	return new RegExp(value.source, value.flags);
+}
+function FromMap(value) {
+	return new Map(FromValue([...value.entries()]));
+}
+function FromSet(value) {
+	return new Set(FromValue([...value.values()]));
+}
+function FromValue(value) {
+	return IsTypeArray(value) ? FromTypedArray(value) : IsRegExp(value) ? FromRegExp(value) : IsMap(value) ? FromMap(value) : IsSet(value) ? FromSet(value) : IsArray$1(value) ? FromArray$5(value) : IsObject$1(value) ? FromObject$5(value) : value;
+}
+/** Returns a deep Clone of the given value. This function is similar to structuredClone() but also supports deep cloning instances of Map, Set and TypeArray. */
+function Deep(value) {
+	return FromValue(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clone/clone.mjs
+/**
+* Returns a deep Clone of the given value. This function is similar to `structuredClone()`,
+* but also supports deep cloning `Map`, `Set`, and `TypeArray` instances. This function can also be used
+* to clone TypeBox types while retaining their enumerable and non-enumerable properties.
+*/
+function Clone(value) {
+	return Deep(value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clean/from_union.mjs
+function FromUnion$5(context, type, value) {
+	for (const schema of type.anyOf) {
+		const clean = FromType$6(context, schema, Clone(value));
+		if (Check(context, schema, clean)) return clean;
+	}
+	return value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clean/from_type.mjs
+function FromType$6(context, type, value) {
+	return IsArray$2(type) ? FromArray$6(context, type, value) : IsCyclic(type) ? FromCyclic$5(context, type, value) : IsIntersect(type) ? FromIntersect$5(context, type, value) : IsObject$2(type) ? FromObject$6(context, type, value) : IsRecord(type) ? FromRecord$5(context, type, value) : IsRef$1(type) ? FromRef$5(context, type, value) : IsTuple(type) ? FromTuple$5(context, type, value) : IsUnion(type) ? FromUnion$5(context, type, value) : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/shared/union_priority_sort.mjs
+function Modifiers(type, next) {
+	return Assign(type, next);
+}
+function FromProperties$1(properties) {
+	const result = {};
+	for (const key of guard_default.Keys(properties)) result[key] = FromType$5(properties[key]);
+	return result;
+}
+function FromRecordKey(type) {
+	return String$1({ pattern: RecordPattern(type) });
+}
+function FromPriorityTypes(types) {
+	return FromTypes(Priority(types));
+}
+function FromTypes(types) {
+	return types.map((type) => FromType$5(type));
+}
+function FromType$5(type) {
+	return Modifiers(type, IsArray$2(type) ? _Array_(FromType$5(type.items), ArrayOptions(type)) : IsIntersect(type) ? Intersect(FromTypes(type.allOf)) : IsUnion(type) ? Union(FromPriorityTypes(type.anyOf)) : IsObject$2(type) ? _Object_(FromProperties$1(type.properties)) : IsRecord(type) ? Record(FromRecordKey(type), FromType$5(RecordValue(type))) : IsTuple(type) ? Tuple(FromTypes(type.items)) : type);
+}
+/**
+* (Type-Preprocessor) Recursively reorders Union variants from narrowest to broadest, ensuring
+* more specific types (e.g. Literal) are evaluated before broader types (e.g. String). Used
+* prior to Clean, Decode, and Encode operations.
+*/
+function UnionPrioritySort(type) {
+	return FromType$5(type);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/clean/clean.mjs
+/**
+* Cleans a value by removing non-evaluated properties and elements as derived from the provided type.
+* This function returns unknown so callers should Check the return value before use. This function
+* mutates the provided value. If mutation is not wanted, you should Clone the value before passing
+* to this function.
+*/
+function Clean(...args) {
+	const [context, type, value] = Match$1(args, {
+		3: (context, type, value) => [
+			context,
+			type,
+			value
+		],
+		2: (type, value) => [
+			{},
+			type,
+			value
+		]
+	});
+	return FromType$6(context, Get$3().unionPrioritySort ? UnionPrioritySort(type) : type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/try/try_result.mjs
+function IsOk(value) {
+	return IsObject$1(value) && HasPropertyKey$1(value, "value");
+}
+function Ok(value) {
+	return { value };
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/try/try_array.mjs
+function TryArray(value) {
+	return IsArray$1(value) ? Ok(value) : Ok([value]);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/try/try_bigint.mjs
+function FromBoolean$5(value) {
+	return IsEqual$1(value, true) ? Ok(BigInt(1)) : Ok(BigInt(0));
+}
+const bigintPattern = /^-?(0|[1-9]\d*)n$/;
+const decimalPattern = /^-?(0|[1-9]\d*)\.\d+$/;
+const integerPattern = /^-?(0|[1-9]\d*)$/;
+function IsStringBigIntLike(value) {
+	return bigintPattern.test(value);
+}
+function IsStringDecimalLike(value) {
+	return decimalPattern.test(value);
+}
+function IsStringIntegerLike(value) {
+	return integerPattern.test(value);
+}
+function FromString$6(value) {
+	const lowercase = value.toLowerCase();
+	return IsStringBigIntLike(value) ? Ok(BigInt(value.slice(0, value.length - 1))) : IsStringDecimalLike(value) ? Ok(BigInt(value.split(".")[0])) : IsStringIntegerLike(value) ? Ok(BigInt(value)) : IsEqual$1(lowercase, "false") ? Ok(BigInt(0)) : IsEqual$1(lowercase, "true") ? Ok(BigInt(1)) : void 0;
+}
+function TryBigInt(value) {
+	return IsBigInt$1(value) ? Ok(value) : IsBoolean$1(value) ? FromBoolean$5(value) : IsNumber$1(value) ? Ok(BigInt(Math.trunc(value))) : IsNull$1(value) ? Ok(BigInt(0)) : IsString$1(value) ? FromString$6(value) : IsUndefined$1(value) ? Ok(BigInt(0)) : void 0;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/try/try_boolean.mjs
+function FromBigInt$5(value) {
+	return IsEqual$1(value, BigInt(0)) ? Ok(false) : IsEqual$1(value, BigInt(1)) ? Ok(true) : void 0;
+}
+function FromNumber$4(value) {
+	return IsEqual$1(value, 0) ? Ok(false) : IsEqual$1(value, 1) ? Ok(true) : void 0;
+}
+function FromString$5(value) {
+	return IsEqual$1(value.toLowerCase(), "false") ? Ok(false) : IsEqual$1(value.toLowerCase(), "true") ? Ok(true) : IsEqual$1(value, "0") ? Ok(false) : IsEqual$1(value, "1") ? Ok(true) : void 0;
+}
+function TryBoolean(value) {
+	return IsBigInt$1(value) ? FromBigInt$5(value) : IsBoolean$1(value) ? Ok(value) : IsNumber$1(value) ? FromNumber$4(value) : IsNull$1(value) ? Ok(false) : IsString$1(value) ? FromString$5(value) : IsUndefined$1(value) ? Ok(false) : void 0;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/try/try_null.mjs
+function FromBigInt$4(value) {
+	return IsEqual$1(value, BigInt(0)) ? Ok(null) : void 0;
+}
+function FromBoolean$4(value) {
+	return IsEqual$1(value, false) ? Ok(null) : void 0;
+}
+function FromNumber$3(value) {
+	return IsEqual$1(value, 0) ? Ok(null) : void 0;
+}
+function FromString$4(value) {
+	const lowercase = value.toLowerCase();
+	return IsEqual$1(lowercase, "undefined") || IsEqual$1(lowercase, "null") || IsEqual$1(value, "") || IsEqual$1(value, "0") ? Ok(null) : void 0;
+}
+function TryNull(value) {
+	return IsBigInt$1(value) ? FromBigInt$4(value) : IsBoolean$1(value) ? FromBoolean$4(value) : IsNumber$1(value) ? FromNumber$3(value) : IsNull$1(value) ? Ok(null) : IsString$1(value) ? FromString$4(value) : IsUndefined$1(value) ? Ok(null) : void 0;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/try/try_number.mjs
+const maxBigInt = BigInt(Number.MAX_SAFE_INTEGER);
+const minBigInt = BigInt(Number.MIN_SAFE_INTEGER);
+function FromBigInt$3(value) {
+	return value <= maxBigInt && value >= minBigInt ? Ok(Number(value)) : void 0;
+}
+function FromBoolean$3(value) {
+	return Ok(value ? 1 : 0);
+}
+function FromString$3(value) {
+	const coerced = +value;
+	if (IsNumber$1(coerced)) return Ok(coerced);
+	const lowercase = value.toLowerCase();
+	if (IsEqual$1(lowercase, "false")) return Ok(0);
+	if (IsEqual$1(lowercase, "true")) return Ok(1);
+	const result = TryBigInt(value);
+	if (IsOk(result)) return result.value <= maxBigInt && result.value >= minBigInt ? Ok(Number(result.value)) : void 0;
+}
+function TryNumber(value) {
+	return IsBigInt$1(value) ? FromBigInt$3(value) : IsBoolean$1(value) ? FromBoolean$3(value) : IsNumber$1(value) ? Ok(value) : IsNull$1(value) ? Ok(0) : IsString$1(value) ? FromString$3(value) : IsUndefined$1(value) ? Ok(0) : void 0;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/try/try_string.mjs
+function TryString(value) {
+	return IsBigInt$1(value) ? Ok(value.toString()) : IsBoolean$1(value) ? Ok(value.toString()) : IsNumber$1(value) ? Ok(value.toString()) : IsNull$1(value) ? Ok("null") : IsString$1(value) ? Ok(value) : IsUndefined$1(value) ? Ok("") : void 0;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/try/try_undefined.mjs
+function FromBigInt$2(value) {
+	return IsEqual$1(value, BigInt(0)) ? Ok(void 0) : void 0;
+}
+function FromBoolean$2(value) {
+	return IsEqual$1(value, false) ? Ok(void 0) : void 0;
+}
+function FromNumber$2(value) {
+	return IsEqual$1(value, 0) ? Ok(void 0) : void 0;
+}
+function FromString$2(value) {
+	const lowercase = value.toLowerCase();
+	return IsEqual$1(lowercase, "undefined") || IsEqual$1(lowercase, "null") || IsEqual$1(value, "") || IsEqual$1(value, "0") ? Ok(void 0) : void 0;
+}
+function TryUndefined(value) {
+	return IsBigInt$1(value) ? FromBigInt$2(value) : IsBoolean$1(value) ? FromBoolean$2(value) : IsNumber$1(value) ? FromNumber$2(value) : IsNull$1(value) ? Ok(void 0) : IsString$1(value) ? FromString$2(value) : IsUndefined$1(value) ? Ok(value) : void 0;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_array.mjs
+function FromArray$4(context, type, value) {
+	return TryArray(value).value.map((value) => FromType$4(context, type.items, value));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_bigint.mjs
+function FromBigInt$1(_context, _type, value) {
+	const result = TryBigInt(value);
+	return IsOk(result) ? result.value : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_boolean.mjs
+function FromBoolean$1(_context, _type, value) {
+	const result = TryBoolean(value);
+	return IsOk(result) ? result.value : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_cyclic.mjs
+function FromCyclic$4(context, type, value) {
+	return FromType$4({
+		...context,
+		...type.$defs
+	}, Ref$1(type.$ref), value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_enum.mjs
+function FromEnum$1(context, type, value) {
+	return FromType$4(context, Evaluate$1(type), value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_integer.mjs
+function FromInteger$1(_context, _type, value) {
+	const result = TryNumber(value);
+	return IsOk(result) ? Math.trunc(result.value) : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_intersect.mjs
+function FromIntersect$4(context, type, value) {
+	const instantiated = Instantiate(context, type);
+	return FromType$4(context, Evaluate$1(instantiated), value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_literal.mjs
+function FromLiteralBigInt(_context, type, value) {
+	const result = TryBigInt(value);
+	return IsOk(result) && IsEqual$1(type.const, result.value) ? result.value : value;
+}
+function FromLiteralBoolean(_context, type, value) {
+	const result = TryBoolean(value);
+	return IsOk(result) && IsEqual$1(type.const, result.value) ? result.value : value;
+}
+function FromLiteralNumber(_context, type, value) {
+	const result = TryNumber(value);
+	return IsOk(result) && IsEqual$1(type.const, result.value) ? result.value : value;
+}
+function FromLiteralString(_context, type, value) {
+	const result = TryString(value);
+	return IsOk(result) && IsEqual$1(type.const, result.value) ? result.value : value;
+}
+function FromLiteral$1(context, type, value) {
+	if (IsEqual$1(type.const, value)) return value;
+	return IsLiteralBigInt(type) ? FromLiteralBigInt(context, type, value) : IsLiteralBoolean(type) ? FromLiteralBoolean(context, type, value) : IsLiteralNumber(type) ? FromLiteralNumber(context, type, value) : IsLiteralString(type) ? FromLiteralString(context, type, value) : Unreachable();
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_null.mjs
+function FromNull$1(_context, _type, value) {
+	const result = TryNull(value);
+	return IsOk(result) ? result.value : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_number.mjs
+function FromNumber$1(_context, _type, value) {
+	const result = TryNumber(value);
+	return IsOk(result) ? result.value : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_additional.mjs
+/**
+* Used by Object and Record Types. The entries are derived from the known
+* properties obtained from 'properties' and 'patternProperties' respectively.
+*/
+function FromAdditionalProperties(context, entries, additionalProperties, value) {
+	const keys = Keys$1(value);
+	for (const [regexp, _] of entries) for (const key of keys) if (!regexp.test(key)) value[key] = FromType$4(context, additionalProperties, value[key]);
+	return value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/shared/optional_undefined.mjs
+function IsOptionalUndefined(property, key, value) {
+	return IsOptional(property) && IsUndefined$1(value[key]);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_object.mjs
+function FromProperties(context, type, value) {
+	const entries = EntriesRegExp(type.properties);
+	const keys = Keys$1(value);
+	for (const [regexp, property] of entries) for (const key of keys) {
+		if (!regexp.test(key) || IsOptionalUndefined(property, key, value)) continue;
+		value[key] = FromType$4(context, property, value[key]);
+	}
+	return HasPropertyKey$1(type, "additionalProperties") && IsObject$1(type.additionalProperties) ? FromAdditionalProperties(context, entries, type.additionalProperties, value) : value;
+}
+function FromObject$4(context, type, value) {
+	return IsObjectNotArray$1(value) ? FromProperties(context, type, value) : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_record.mjs
+function FromPatternProperties(context, type, value) {
+	const entries = EntriesRegExp(type.patternProperties);
+	const keys = Keys$1(value);
+	for (const [regexp, schema] of entries) for (const key of keys) if (regexp.test(key)) value[key] = FromType$4(context, schema, value[key]);
+	return HasPropertyKey$1(type, "additionalProperties") && IsObject$1(type.additionalProperties) ? FromAdditionalProperties(context, entries, type.additionalProperties, value) : value;
+}
+function FromRecord$4(context, type, value) {
+	return IsObjectNotArray$1(value) ? FromPatternProperties(context, type, value) : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_ref.mjs
+function FromRef$4(context, type, value) {
+	return HasPropertyKey$1(context, type.$ref) ? FromType$4(context, context[type.$ref], value) : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_string.mjs
+function FromString$1(_context, _type, value) {
+	const result = TryString(value);
+	return IsOk(result) ? result.value : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_template_literal.mjs
+function FromTemplateLiteral$1(context, type, value) {
+	return FromType$4(context, Evaluate$1(type), value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_tuple.mjs
+function FromTuple$4(context, type, value) {
+	if (!IsArray$1(value)) return value;
+	for (let index = 0; index < Math.min(type.items.length, value.length); index++) value[index] = FromType$4(context, type.items[index], value[index]);
+	return value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_undefined.mjs
+function FromUndefined$1(_context, _type, value) {
+	const result = TryUndefined(value);
+	return IsOk(result) ? result.value : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_union.mjs
+function FromUnion$4(context, type, value) {
+	if (type.anyOf.some((type) => Check(context, type, value))) return value;
+	const selected = type.anyOf.map((type) => FromType$4(context, type, Clone(value))).find((value) => Check(context, type, value));
+	return IsUndefined$1(selected) ? value : selected;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_void.mjs
+function FromVoid$1(_context, _type, value) {
+	return IsOk(TryUndefined(value)) ? void 0 : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/from_type.mjs
+function FromType$4(context, type, value) {
+	return IsArray$2(type) ? FromArray$4(context, type, value) : IsBigInt$2(type) ? FromBigInt$1(context, type, value) : IsBoolean$2(type) ? FromBoolean$1(context, type, value) : IsCyclic(type) ? FromCyclic$4(context, type, value) : IsEnum$1(type) ? FromEnum$1(context, type, value) : IsInteger$2(type) ? FromInteger$1(context, type, value) : IsIntersect(type) ? FromIntersect$4(context, type, value) : IsLiteral(type) ? FromLiteral$1(context, type, value) : IsNull$2(type) ? FromNull$1(context, type, value) : IsNumber$2(type) ? FromNumber$1(context, type, value) : IsObject$2(type) ? FromObject$4(context, type, value) : IsRecord(type) ? FromRecord$4(context, type, value) : IsRef$1(type) ? FromRef$4(context, type, value) : IsString$2(type) ? FromString$1(context, type, value) : IsTemplateLiteral(type) ? FromTemplateLiteral$1(context, type, value) : IsTuple(type) ? FromTuple$4(context, type, value) : IsUndefined$2(type) ? FromUndefined$1(context, type, value) : IsUnion(type) ? FromUnion$4(context, type, value) : IsVoid(type) ? FromVoid$1(context, type, value) : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/convert/convert.mjs
+/**
+* Converts a value to the given type, coercing interior values if a reasonable conversion is possible. This
+* function returns unknown so callers should Check the return value before use. This function mutates the
+* provided value. If mutation is not wanted, you should Clone the value before passing to this function.
+*/
+function Convert(...args) {
+	const [context, type, value] = Match$1(args, {
+		3: (context, type, value) => [
+			context,
+			type,
+			value
+		],
+		2: (type, value) => [
+			{},
+			type,
+			value
+		]
+	});
+	return FromType$4(context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/default/from_array.mjs
+function FromArray$3(context, type, value) {
+	if (!IsArray$1(value)) return value;
+	for (let i = 0; i < value.length; i++) value[i] = FromType$3(context, type.items, value[i]);
+	return value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/default/from_cyclic.mjs
+function FromCyclic$3(context, type, value) {
+	return FromType$3({
+		...context,
+		...type.$defs
+	}, Ref$1(type.$ref), value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/default/from_default.mjs
+function FromDefault$1(type, value) {
+	if (!IsUndefined$1(value)) return value;
+	return IsFunction$1(type.default) ? type.default() : Clone(type.default);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/default/from_intersect.mjs
+function FromIntersect$3(context, type, value) {
+	const instantiated = Instantiate(context, type);
+	return FromType$3(context, Evaluate$1(instantiated), value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/default/from_object.mjs
+function FromObject$3(context, type, value) {
+	if (!IsObject$1(value)) return value;
+	const knownPropertyKeys = Keys$1(type.properties);
+	for (const key of knownPropertyKeys) {
+		const propertyValue = FromType$3(context, type.properties[key], value[key]);
+		if (IsUndefined$1(propertyValue) && (IsOptional(type.properties[key]) || !HasPropertyKey$1(type.properties[key], "default"))) continue;
+		value[key] = propertyValue;
+	}
+	if (!IsAdditionalProperties(type) || IsBoolean$1(type.additionalProperties)) return value;
+	for (const key of Keys$1(value)) {
+		if (knownPropertyKeys.includes(key)) continue;
+		value[key] = FromType$3(context, type.additionalProperties, value[key]);
+	}
+	return value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/default/from_record.mjs
+function FromRecord$3(context, type, value) {
+	if (!IsObject$1(value)) return value;
+	const [recordKey, recordValue] = [new RegExp(RecordPattern(type)), RecordValue(type)];
+	for (const key of Keys$1(value)) {
+		if (!(recordKey.test(key) && IsDefault(recordValue))) continue;
+		value[key] = FromType$3(context, recordValue, value[key]);
+	}
+	if (!IsAdditionalProperties(type)) return value;
+	for (const key of Keys$1(value)) {
+		if (recordKey.test(key)) continue;
+		value[key] = FromType$3(context, type.additionalProperties, value[key]);
+	}
+	return value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/default/from_ref.mjs
+function FromRef$3(context, type, value) {
+	return HasPropertyKey$1(context, type.$ref) ? FromType$3(context, context[type.$ref], value) : value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/default/from_tuple.mjs
+function FromTuple$3(context, schema, value) {
+	if (!IsArray$1(value)) return value;
+	const [items, max] = [schema.items, Math.max(schema.items.length, value.length)];
+	for (let i = 0; i < max; i++) if (i < items.length) value[i] = FromType$3(context, items[i], value[i]);
+	return value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/default/from_union.mjs
+function FromUnion$3(context, schema, value) {
+	for (const inner of schema.anyOf) {
+		const result = FromType$3(context, inner, Clone(value));
+		if (Check(context, inner, result)) return result;
+	}
+	return value;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/default/from_type.mjs
+function FromType$3(context, type, value) {
+	const defaulted = IsDefault(type) ? FromDefault$1(type, value) : value;
+	return IsArray$2(type) ? FromArray$3(context, type, defaulted) : IsCyclic(type) ? FromCyclic$3(context, type, defaulted) : IsIntersect(type) ? FromIntersect$3(context, type, defaulted) : IsObject$2(type) ? FromObject$3(context, type, defaulted) : IsRecord(type) ? FromRecord$3(context, type, defaulted) : IsRef$1(type) ? FromRef$3(context, type, defaulted) : IsTuple(type) ? FromTuple$3(context, type, defaulted) : IsUnion(type) ? FromUnion$3(context, type, defaulted) : defaulted;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/default/default.mjs
+/**
+* Patches missing properties on the value using default annotations specified on the provided type. This
+* function returns unknown so callers should Check the return value before use. This function mutates the
+* provided value. If mutation is not wanted, you should Clone the value before passing to this function.
+*/
+function Default(...args) {
+	const [context, type, value] = Match$1(args, {
+		3: (context, type, value) => [
+			context,
+			type,
+			value
+		],
+		2: (type, value) => [
+			{},
+			type,
+			value
+		]
+	});
+	return FromType$3(context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/pipeline/pipeline.mjs
+/** Creates a value processing pipeline. */
+function Pipeline(pipeline) {
+	return (...args) => {
+		const [context, type, value] = Match$1(args, {
+			3: (context, type, value) => [
+				context,
+				type,
+				value
+			],
+			2: (type, value) => [
+				{},
+				type,
+				value
+			]
+		});
+		return pipeline.reduce((result, func) => func(context, type, result), value);
+	};
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/callback.mjs
+function Decode$7(_context, type, value) {
+	return type["~codec"].decode(value);
+}
+function Encode$7(_context, type, value) {
+	return type["~codec"].encode(value);
+}
+function Callback(direction, context, type, value) {
+	if (!IsCodec(type)) return value;
+	return IsEqual$1(direction, "Decode") ? Decode$7(context, type, value) : Encode$7(context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/from_array.mjs
+function Decode$6(direction, context, type, value) {
+	if (!IsArray$1(value)) return value;
+	for (let i = 0; i < value.length; i++) value[i] = FromType$2(direction, context, type.items, value[i]);
+	return Callback(direction, context, type, value);
+}
+function Encode$6(direction, context, type, value) {
+	const exterior = Callback(direction, context, type, value);
+	if (!IsArray$1(exterior)) return exterior;
+	for (let i = 0; i < exterior.length; i++) exterior[i] = FromType$2(direction, context, type.items, exterior[i]);
+	return exterior;
+}
+function FromArray$2(direction, context, type, value) {
+	return IsEqual$1(direction, "Decode") ? Decode$6(direction, context, type, value) : Encode$6(direction, context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/from_cyclic.mjs
+function FromCyclic$2(direction, context, type, value) {
+	value = FromType$2(direction, {
+		...context,
+		...type.$defs
+	}, Ref$1(type.$ref), value);
+	return Callback(direction, context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/from_intersect.mjs
+function MergeInteriors(interiors) {
+	return interiors.reduce((results, interior) => ({
+		...results,
+		...interior
+	}), {});
+}
+function NonMatchingInterior(value, interiors) {
+	for (const interior of interiors) if (!IsDeepEqual$1(value, interior)) return interior;
+	return value;
+}
+function Decode$5(direction, context, type, value) {
+	if (IsEqual$1(type.allOf.length, 0)) return Callback(direction, context, type, value);
+	const interiors = type.allOf.map((schema) => FromType$2(direction, context, schema, Clean(schema, Clone(value))));
+	return Callback(direction, context, type, interiors.every((result) => IsObject$1(result)) ? MergeInteriors(interiors) : NonMatchingInterior(value, interiors));
+}
+function Encode$5(direction, context, type, value) {
+	if (IsEqual$1(type.allOf.length, 0)) return Callback(direction, context, type, value);
+	const exterior = Callback(direction, context, type, value);
+	const interiors = type.allOf.map((schema) => FromType$2(direction, context, schema, Clean(schema, Clone(exterior))));
+	if (interiors.every((result) => IsObject$1(result))) return MergeInteriors(interiors);
+	return NonMatchingInterior(exterior, interiors);
+}
+function FromIntersect$2(direction, context, type, value) {
+	return IsEqual$1(direction, "Decode") ? Decode$5(direction, context, type, value) : Encode$5(direction, context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/from_object.mjs
+function Decode$4(direction, context, type, value) {
+	if (!IsObjectNotArray$1(value)) return value;
+	for (const key of Keys$1(type.properties)) {
+		if (!HasPropertyKey$1(value, key) || IsOptionalUndefined(type.properties[key], key, value)) continue;
+		value[key] = FromType$2(direction, context, type.properties[key], value[key]);
+	}
+	return Callback(direction, context, type, value);
+}
+function Encode$4(direction, context, type, value) {
+	const exterior = Callback(direction, context, type, value);
+	if (!IsObjectNotArray$1(exterior)) return exterior;
+	for (const key of Keys$1(type.properties)) {
+		if (!HasPropertyKey$1(exterior, key) || IsOptionalUndefined(type.properties[key], key, exterior)) continue;
+		exterior[key] = FromType$2(direction, context, type.properties[key], exterior[key]);
+	}
+	return exterior;
+}
+function FromObject$2(direction, context, type, value) {
+	return IsEqual$1(direction, "Decode") ? Decode$4(direction, context, type, value) : Encode$4(direction, context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/from_record.mjs
+function Decode$3(direction, context, type, value) {
+	if (!IsObjectNotArray$1(value)) return value;
+	const regexp = new RegExp(RecordPattern(type));
+	for (const key of Keys$1(value)) {
+		if (!regexp.test(key)) continue;
+		value[key] = FromType$2(direction, context, RecordValue(type), value[key]);
+	}
+	return Callback(direction, context, type, value);
+}
+function Encode$3(direction, context, type, value) {
+	const exterior = Callback(direction, context, type, value);
+	if (!IsObjectNotArray$1(exterior)) return exterior;
+	const regexp = new RegExp(RecordPattern(type));
+	for (const key of Keys$1(exterior)) {
+		if (!regexp.test(key)) continue;
+		exterior[key] = FromType$2(direction, context, RecordValue(type), exterior[key]);
+	}
+	return exterior;
+}
+function FromRecord$2(direction, context, type, value) {
+	return IsEqual$1(direction, "Decode") ? Decode$3(direction, context, type, value) : Encode$3(direction, context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/from_ref.mjs
+function ResolveRef(direction, context, type, value) {
+	return HasPropertyKey$1(context, type.$ref) ? FromType$2(direction, context, context[type.$ref], value) : value;
+}
+function FromRef$2(direction, context, type, value) {
+	return IsEqual$1(direction, "Decode") ? Callback(direction, context, type, ResolveRef(direction, context, type, value)) : ResolveRef(direction, context, type, Callback(direction, context, type, value));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/from_tuple.mjs
+function Decode$2(direction, context, type, value) {
+	if (!IsArray$1(value)) return value;
+	for (let i = 0; i < Math.min(type.items.length, value.length); i++) value[i] = FromType$2(direction, context, type.items[i], value[i]);
+	return Callback(direction, context, type, value);
+}
+function Encode$2(direction, context, type, value) {
+	const exterior = Callback(direction, context, type, value);
+	if (!IsArray$1(exterior)) return value;
+	for (let i = 0; i < Math.min(type.items.length, exterior.length); i++) exterior[i] = FromType$2(direction, context, type.items[i], exterior[i]);
+	return exterior;
+}
+function FromTuple$2(direction, context, type, value) {
+	return IsEqual$1(direction, "Decode") ? Decode$2(direction, context, type, value) : Encode$2(direction, context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/from_union.mjs
+function Decode$1(direction, context, type, value) {
+	for (const schema of type.anyOf) {
+		if (!Check(context, schema, value)) continue;
+		return Callback(direction, context, type, FromType$2(direction, context, schema, value));
+	}
+	return value;
+}
+function Encode$1(direction, context, type, value) {
+	const exterior = Callback(direction, context, type, value);
+	for (const schema of type.anyOf) {
+		const variant = FromType$2(direction, context, schema, Clone(exterior));
+		if (!Check(context, schema, variant)) continue;
+		return variant;
+	}
+	return exterior;
+}
+function FromUnion$2(direction, context, type, value) {
+	return IsEqual$1(direction, "Decode") ? Decode$1(direction, context, type, value) : Encode$1(direction, context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/from_type.mjs
+function FromType$2(direction, context, type, value) {
+	return IsArray$2(type) ? FromArray$2(direction, context, type, value) : IsCyclic(type) ? FromCyclic$2(direction, context, type, value) : IsIntersect(type) ? FromIntersect$2(direction, context, type, value) : IsObject$2(type) ? FromObject$2(direction, context, type, value) : IsRecord(type) ? FromRecord$2(direction, context, type, value) : IsRef$1(type) ? FromRef$2(direction, context, type, value) : IsTuple(type) ? FromTuple$2(direction, context, type, value) : IsUnion(type) ? FromUnion$2(direction, context, type, value) : Callback(direction, context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/decode.mjs
+var DecodeError = class extends AssertError {
+	constructor(value, errors) {
+		super("Decode", value, errors);
+	}
+};
+function Assert$2(context, type, value) {
+	if (!Check(context, type, value)) throw new DecodeError(value, Errors(context, type, value));
+	return value;
+}
+/** Executes Decode callbacks only */
+function DecodeUnsafe(context, type, value) {
+	return FromType$2("Decode", context, Get$3().unionPrioritySort ? UnionPrioritySort(type) : type, value);
+}
+const Decoder = Pipeline([
+	(_context, _type, value) => Clone(value),
+	(context, type, value) => Default(context, type, value),
+	(context, type, value) => Convert(context, type, value),
+	(context, type, value) => Clean(context, type, value),
+	(context, type, value) => Assert$2(context, type, value),
+	(context, type, value) => DecodeUnsafe(context, type, value)
+]);
+/** Decodes a value with the given type. */
+function Decode(...args) {
+	const [context, type, value] = Match$1(args, {
+		3: (context, type, value) => [
+			context,
+			type,
+			value
+		],
+		2: (type, value) => [
+			{},
+			type,
+			value
+		]
+	});
+	return Decoder(context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/encode.mjs
+var EncodeError = class extends AssertError {
+	constructor(value, errors) {
+		super("Encode", value, errors);
+	}
+};
+function Assert$1(context, type, value) {
+	if (!Check(context, type, value)) throw new EncodeError(value, Errors(context, type, value));
+	return value;
+}
+/** Executes Encode callbacks only */
+function EncodeUnsafe(context, type, value) {
+	return FromType$2("Encode", context, Get$3().unionPrioritySort ? UnionPrioritySort(type) : type, value);
+}
+const Encoder = Pipeline([
+	(_context, _type, value) => Clone(value),
+	(context, type, value) => EncodeUnsafe(context, type, value),
+	(context, type, value) => Default(context, type, value),
+	(context, type, value) => Convert(context, type, value),
+	(context, type, value) => Clean(context, type, value),
+	(context, type, value) => Assert$1(context, type, value)
+]);
+/** Encodes a value with the given type. */
+function Encode(...args) {
+	const [context, type, value] = Match$1(args, {
+		3: (context, type, value) => [
+			context,
+			type,
+			value
+		],
+		2: (type, value) => [
+			{},
+			type,
+			value
+		]
+	});
+	return Encoder(context, type, value);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/codec/has.mjs
+function FromArray$1(context, type) {
+	return IsCodec(type) || FromType$1(context, type.items);
+}
+function FromCyclic$1(context, type) {
+	return IsCodec(type) || FromRef$1({
+		...context,
+		...type.$defs
+	}, Ref$1(type.$ref));
+}
+function FromIntersect$1(context, type) {
+	return IsCodec(type) || type.allOf.some((type) => FromType$1(context, type));
+}
+function FromObject$1(context, type) {
+	return IsCodec(type) || Keys$1(type.properties).some((key) => {
+		return FromType$1(context, type.properties[key]);
+	});
+}
+function FromRecord$1(context, type) {
+	return IsCodec(type) || FromType$1(context, RecordValue(type));
+}
+function FromRef$1(context, type) {
+	if (visited.has(type.$ref)) return false;
+	visited.add(type.$ref);
+	return IsCodec(type) || HasPropertyKey$1(context, type.$ref) && FromType$1(context, context[type.$ref]);
+}
+function FromTuple$1(context, type) {
+	return IsCodec(type) || type.items.some((type) => FromType$1(context, type));
+}
+function FromUnion$1(context, type) {
+	return IsCodec(type) || type.anyOf.some((type) => FromType$1(context, type));
+}
+function FromType$1(context, type) {
+	return IsArray$2(type) ? FromArray$1(context, type) : IsCyclic(type) ? FromCyclic$1(context, type) : IsIntersect(type) ? FromIntersect$1(context, type) : IsObject$2(type) ? FromObject$1(context, type) : IsRecord(type) ? FromRecord$1(context, type) : IsRef$1(type) ? FromRef$1(context, type) : IsTuple(type) ? FromTuple$1(context, type) : IsUnion(type) ? FromUnion$1(context, type) : IsCodec(type);
+}
+const visited = /* @__PURE__ */ new Set();
+/** Returns true if this type contains a Codec */
+function HasCodec(...args) {
+	const [context, type] = Match$1(args, {
+		2: (context, type) => [context, type],
+		1: (type) => [{}, type]
+	});
+	visited.clear();
+	return FromType$1(context, type);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/error.mjs
+var CreateError = class extends Error {
+	constructor(type, message) {
+		super(message);
+		this.type = type;
+	}
+};
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_default.mjs
+function FromDefault(_context, schema) {
+	return IsFunction$1(schema.default) ? schema.default(schema) : IsObject$1(schema.default) ? Clone(schema.default) : schema.default;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_array.mjs
+function FromArray(context, type) {
+	if (IsUniqueItems(type) && !IsDefault(type)) throw new CreateError(type, "Arrays with uniqueItems constraints must specify a default annotation");
+	const length = IsMinItems(type) ? type.minItems : 0;
+	return Array.from({ length }, () => FromType(context, type.items));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_bigint.mjs
+function FromBigInt(_context, type) {
+	return IsExclusiveMinimum(type) ? BigInt(type.exclusiveMinimum) + BigInt(1) : IsMinimum(type) ? BigInt(type.minimum) : BigInt(0);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_boolean.mjs
+function FromBoolean(_context, _type) {
+	return false;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_constructor.mjs
+function FromConstructor(context, type) {
+	const instanceType = FromType(context, type.instanceType);
+	return class {
+		constructor() {
+			Object.assign(this, instanceType);
+		}
+	};
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_cyclic.mjs
+function FromCyclic(context, type) {
+	return FromType({
+		...context,
+		...type.$defs
+	}, Ref$1(type.$ref));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_enum.mjs
+function FromEnum(context, type) {
+	return FromType(context, Evaluate$1(type));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_function.mjs
+function FromFunction(context, type) {
+	const returnType = FromType(context, type.returnType);
+	return () => returnType;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_integer.mjs
+function FromInteger(_context, type) {
+	return IsExclusiveMinimum(type) && IsNumber$1(type.exclusiveMinimum) ? type.exclusiveMinimum + 1 : IsMinimum(type) ? type.minimum : 0;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_intersect.mjs
+function FromIntersect(context, type) {
+	const instantiated = Instantiate(context, type);
+	return FromType(context, Evaluate$1(instantiated));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_literal.mjs
+function FromLiteral(_context, type) {
+	return type.const;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_never.mjs
+function FromNever(_context, type) {
+	throw new CreateError(type, "Cannot create TNever types");
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_null.mjs
+function FromNull(_context, _type) {
+	return null;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_number.mjs
+function FromNumber(_context, type) {
+	return IsExclusiveMinimum(type) && IsNumber$1(type.exclusiveMinimum) ? type.exclusiveMinimum + 1 : IsMinimum(type) ? type.minimum : 0;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_object.mjs
+function FromObject(context, type) {
+	return (IsUndefined$1(type.required) ? [] : type.required).reduce((result, key) => {
+		return {
+			...result,
+			[key]: FromType(context, type.properties[key])
+		};
+	}, {});
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_record.mjs
+function FromRecord(_context, type) {
+	if (IsMinProperties(type) && !IsDefault(type)) throw new CreateError(type, "Record with the minProperties constraint must have a default annotation");
+	return {};
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_ref.mjs
+function FromRef(context, type) {
+	return HasPropertyKey$1(context, type.$ref) ? FromType(context, context[type.$ref]) : (() => {
+		throw new CreateError(type, "Unable to deref Ref");
+	})();
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_string.mjs
+function FromString(_context, type) {
+	if ((IsPattern(type) || IsFormat(type)) && !IsDefault(type)) throw Error("Strings with format or pattern constraints must specify default");
+	const minLength = IsMinLength(type) ? type.minLength : 0;
+	return "".padEnd(minLength);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_symbol.mjs
+function FromSymbol(_context, _type) {
+	return Symbol();
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_template_literal.mjs
+function FromTemplateLiteral(context, type) {
+	const decoded = TemplateLiteralDecode(type.pattern);
+	if (IsString$2(decoded)) throw new CreateError(type, "Unable to create TemplateLiteral due to infinite type expansion");
+	return FromType(context, decoded);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_tuple.mjs
+function FromTuple(context, type) {
+	return Array.from({ length: type.minItems }, (_, i) => FromType(context, type.items[i]));
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_union.mjs
+function FromUnion(context, type) {
+	if (IsEqual$1(type.anyOf.length, 0)) throw Error("Unable to create Union with no variants");
+	return FromType(context, type.anyOf[0]);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/from_type.mjs
+function FromType(context, type) {
+	return IsDefault(type) ? FromDefault(context, type) : IsArray$2(type) ? FromArray(context, type) : IsBigInt$2(type) ? FromBigInt(context, type) : IsBoolean$2(type) ? FromBoolean(context, type) : IsConstructor$2(type) ? FromConstructor(context, type) : IsCyclic(type) ? FromCyclic(context, type) : IsEnum$1(type) ? FromEnum(context, type) : IsFunction$2(type) ? FromFunction(context, type) : IsInteger$2(type) ? FromInteger(context, type) : IsIntersect(type) ? FromIntersect(context, type) : IsLiteral(type) ? FromLiteral(context, type) : IsNever(type) ? FromNever(context, type) : IsNull$2(type) ? FromNull(context, type) : IsNumber$2(type) ? FromNumber(context, type) : IsObject$2(type) ? FromObject(context, type) : IsRecord(type) ? FromRecord(context, type) : IsRef$1(type) ? FromRef(context, type) : IsString$2(type) ? FromString(context, type) : IsSymbol$2(type) ? FromSymbol(context, type) : IsTemplateLiteral(type) ? FromTemplateLiteral(context, type) : IsTuple(type) ? FromTuple(context, type) : IsUndefined$2(type) ? void 0 : IsUnion(type) ? FromUnion(context, type) : IsVoid(type) ? void 0 : void 0;
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/create/create.mjs
+/** Creates a value from the provided type. This function will use `default` annotations if present. */
+function Create(...args) {
+	const [context, type] = Match$1(args, {
+		2: (context, type) => [context, type],
+		1: (type) => [{}, type]
+	});
+	return FromType(context, type);
+}
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/parse/parse.mjs
+var ParseError = class extends AssertError {
+	constructor(value, errors) {
+		super("Parse", value, errors);
+	}
+};
+function Assert(context, type, value) {
+	EnableParseErrors();
+	const errors = Errors(context, type, value);
+	DisableParseErrors();
+	if (!Check(context, type, value)) throw new ParseError(value, errors);
+	return value;
+}
+const Parser = Pipeline([
+	(_context, _type, value) => Clone(value),
+	(context, type, value) => Default(context, type, value),
+	(context, type, value) => Convert(context, type, value),
+	(context, type, value) => Clean(context, type, value),
+	(context, type, value) => Assert(context, type, value)
+]);
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/value/delta/edit.mjs
+const Insert = _Object_({
+	type: Literal("insert"),
+	path: String$1(),
+	value: Unknown()
+});
+const Update = Object({
+	type: Literal("update"),
+	path: String$1(),
+	value: Unknown()
+});
+const Delete = _Object_({
+	type: Literal("delete"),
+	path: String$1()
+});
+Union([
+	Insert,
+	Update,
+	Delete
+]);
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/compile/validator.mjs
+var Validator = class {
+	/** Constructs a Validator. */
+	constructor(context, type) {
+		this.hasCodec = HasCodec(context, type);
+		this.buildResult = Build(context, type);
+		this.evaluateResult = this.buildResult.Evaluate();
+	}
+	/** Returns true if this Validator is using JIT acceleration. */
+	IsAccelerated() {
+		return this.evaluateResult.IsAccelerated();
+	}
+	/** Returns the Context for this validator. */
+	Context() {
+		return this.buildResult.Context();
+	}
+	/** Returns the underlying Type used to construct this Validator. */
+	Type() {
+		return this.buildResult.Schema();
+	}
+	/** Returns the generated code for this validator. */
+	Code() {
+		return this.evaluateResult.Code();
+	}
+	/** Performs a type-guard check on the provided value. */
+	Check(value) {
+		return this.evaluateResult.Check(value);
+	}
+	/** Validates a value and returns it. Will throw if invalid. */
+	Parse(value) {
+		if (this.Check(value)) return value;
+		if (Get$3().correctiveParse) return Parser(this.Context(), this.Type(), value);
+		EnableParseErrors();
+		const errors = this.Errors(value);
+		DisableParseErrors();
+		throw new ParseError(value, errors);
+	}
+	/** Returns an array of validation errors for the given value. */
+	Errors(value) {
+		if (this.IsAccelerated() && this.Check(value)) return [];
+		return Errors(this.Context(), this.Type(), value);
+	}
+	/** Cleans a value using the Validator type. */
+	Clean(value) {
+		return Clean(this.Context(), this.Type(), value);
+	}
+	/** Converts a value using the Validator type. */
+	Convert(value) {
+		return Convert(this.Context(), this.Type(), value);
+	}
+	/** Creates a value using the Validator type. */
+	Create() {
+		return Create(this.Context(), this.Type());
+	}
+	/** Creates defaults using the Validator type. */
+	Default(value) {
+		return Default(this.Context(), this.Type(), value);
+	}
+	/** Decodes a value */
+	Decode(value) {
+		return this.hasCodec ? Decode(this.Context(), this.Type(), value) : this.Parse(value);
+	}
+	/** Encodes a value */
+	Encode(value) {
+		return this.hasCodec ? Encode(this.Context(), this.Type(), value) : this.Parse(value);
+	}
+};
+// ../../node_modules/.pnpm/typebox@1.4.3/node_modules/typebox/build/compile/compile.mjs
+/** Compiles a type into a high performance Validator */
+function Compile(...args) {
+	const [context, type] = Match$1(args, {
+		2: (context, type) => [context, type],
+		1: (type) => [{}, type]
+	});
+	return new Validator(context, type);
+}
+// ../../packages/core/src/icon-path.ts
+/** Selects a finished PNG for either supported tile picture size. */
+function generatedIconFile(icon, size) {
+	return `${icon.assetId}-${icon.variant === "native" ? "native" : size}.png`;
+}
+/**
+* Names the finished PNG of one game-font glyph.
+*
+* @param assetId - The glyph's asset id, from the snapshot's glyph table.
+* @returns Its filename under `generated-icons/`.
+*/
+function generatedGlyphFile(assetId) {
+	return `${assetId}-glyph.png`;
+}
+// ../../packages/core/src/loader.ts
+/**
+* Finds the committed snapshot's directory, `data/` in the `@r0cksolid/emerald-core`
+* package, for a caller that loads it with {@link loadItemCatalog}. An app reaches it only
+* through this entry, never by path. It is found through the package's name rather than
+* this file's location, so it stays right from the sources, from the built package, and
+* from a bundle that inlines this entry but installs the package beside it. It resolves
+* only when called, so a bundle that loads a snapshot of its own runs without the package
+* installed.
+*
+* @returns The directory's absolute path.
+* @throws Error when `@r0cksolid/emerald-core` is not installed where the caller runs.
+*/
+function committedDataDirectory() {
+	return fileURLToPath(new URL("data/", import.meta.resolve("@r0cksolid/emerald-core/package.json")));
+}
+const snapshotCheck = Compile(SnapshotSchema);
+const metaCheck = Compile(MetaSchema);
+/**
+* Parses one snapshot file and checks its schema version. Nothing else is checked.
+*
+* @param directory - The snapshot directory.
+* @param name - The file to read from it.
+* @returns The parsed content, known only to carry this build's schema version.
+* @throws Error naming the file when it cannot be parsed, or when its `schemaVersion` is not
+* {@link SCHEMA_VERSION}.
+*/
+async function readVersioned(directory, name) {
+	const text = await readFile(join(directory, name), "utf8");
+	let content;
+	try {
+		content = JSON.parse(text);
+	} catch (error) {
+		throw new Error(`Item-catalog file ${name} could not be parsed: ${String(error)}`, { cause: error });
+	}
+	const version = typeof content === "object" && content !== null && "schemaVersion" in content ? content.schemaVersion : void 0;
+	if (version !== 9) throw new Error(`Unsupported item-catalog schema version ${String(version)} in ${name}; this build reads version 9.`);
+	return content;
+}
+/** The eight bytes every PNG starts with. */
+const PNG_SIGNATURE = Buffer.from("89504e470d0a1a0a", "hex");
+/**
+* Reads a glyph PNG's size from its header: the width and height of its `IHDR` chunk,
+* which every PNG holds first, at bytes 16 to 23.
+*
+* @param directory - The trusted directory holding the PNG, already checked.
+* @param file - The PNG's file name.
+* @returns Its width and height in pixels.
+* @throws Error naming the file when it is not a PNG.
+*/
+async function glyphSize(directory, file) {
+	const bytes = await readFile(join(directory, file));
+	const width = bytes.length >= 24 ? bytes.readUInt32BE(16) : 0;
+	const height = bytes.length >= 24 ? bytes.readUInt32BE(20) : 0;
+	if (!bytes.subarray(0, 8).equals(PNG_SIGNATURE) || bytes.toString("latin1", 12, 16) !== "IHDR" || width === 0 || height === 0) throw new Error(`Generated glyph ${file} is not a PNG.`);
+	return {
+		width,
+		height
+	};
+}
+/**
+* Reads `snapshot.json` and `snapshot.meta.json` and indexes them once.
+*
+* @remarks
+* Records, including each stat glyph's entry in the glyph table, are always checked
+* before any image is read and before indexing. With a generated-image directory, every
+* unique generated PNG reference, icons and glyphs alike, is checked too, and each glyph's
+* size is read from its PNG's header, so a page can lay it out before the image loads.
+* Without one, no image is read and the catalog's glyph table is empty, so item answers
+* carry no glyphs; generated icon references are returned unchecked.
+*
+* @param directory - The directory holding both files.
+* @param generatedDirectory - The trusted directory containing their finished PNGs, or
+* `null` to load without images. It is never optional, so a missing setting cannot skip
+* the image checks unnoticed.
+* @param options - How to write levels; see `CatalogOptions`. Glyph sizes come from the
+* generated images.
+* @returns Lookups backed by maps built during this call.
+* @throws Error when either file is missing, cannot be parsed, or has an unsupported schema
+* version, malformed records, a stat glyph that the glyph table lacks, or a family whose
+* members fall in different categories. A parse failure names the file. With a
+* generated-image directory, also on a missing/redirected PNG or a glyph file that is not
+* a PNG.
+*/
+async function loadItemCatalog(directory, generatedDirectory, options = {}) {
+	const snapshot = await readVersioned(directory, "snapshot.json");
+	const meta = await readVersioned(directory, "snapshot.meta.json");
+	if (!snapshotCheck.Check(snapshot)) throw new Error("Invalid item-catalog records in snapshot.json.");
+	if (!metaCheck.Check(meta)) throw new Error("Invalid item-catalog records in snapshot.meta.json.");
+	checkStatGlyphs(snapshot);
+	if (generatedDirectory === null) return createItemCatalog(snapshot, meta, options);
+	const files = /* @__PURE__ */ new Set([...snapshot.items.flatMap(({ icon }) => icon.kind === "generated" ? [generatedIconFile(icon, 32), generatedIconFile(icon, 48)] : []), ...Object.values(snapshot.glyphs).map(generatedGlyphFile)]);
+	if (files.size) try {
+		const root = await lstat(generatedDirectory);
+		if (!root.isDirectory() || root.isSymbolicLink()) throw new Error("Generated image directory is redirected or not a directory.");
+		const physicalRoot = await realpath(generatedDirectory);
+		if (physicalRoot !== resolve(generatedDirectory)) throw new Error("Generated image directory has a redirected ancestor.");
+		for (const file of files) {
+			const path = join(generatedDirectory, file);
+			const stat = await lstat(path);
+			if (!stat.isFile() || stat.isSymbolicLink() || await realpath(path) !== join(physicalRoot, file)) throw new Error(`Invalid generated image ${file}.`);
+		}
+	} catch (cause) {
+		throw new Error("A required generated image is missing or redirected.", { cause });
+	}
+	const glyphSizes = new Map(await Promise.all([...new Set(Object.values(snapshot.glyphs))].map(async (assetId) => [assetId, await glyphSize(generatedDirectory, generatedGlyphFile(assetId))])));
+	return createItemCatalog(snapshot, meta, {
+		...options,
+		glyphSizes
+	});
+}
+// src/settings.ts
+const SettingsSchema = _Object_({ levels: Optional(LevelStyleSchema) }, { additionalProperties: false });
+/**
+* Where the settings live: the platform's per-user configuration directory. A relative
+* `XDG_CONFIG_HOME` is ignored, as the XDG spec says, so the path never depends on the
+* directory a command runs in.
+*/
+function settingsPath() {
+	const { XDG_CONFIG_HOME: xdg, APPDATA: appData } = process.env;
+	const base = xdg && isAbsolute(xdg) && xdg || process.platform === "win32" && appData || join(homedir(), ".config");
+	return join(base, "emerald", "settings.json");
+}
+/** Whether an error says a file doesn't exist. */
+const isMissing = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+/**
+* Reads the saved settings.
+*
+* @returns The settings, empty when none have been saved.
+* @throws Error naming the file when it can't be read as settings.
+*/
+async function readSettings() {
+	const path = settingsPath();
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch (error) {
+		if (isMissing(error)) return {};
+		throw error;
+	}
+	let settings;
+	try {
+		settings = JSON.parse(text.replace(/^\uFEFF/, ""));
+	} catch {
+		settings = void 0;
+	}
+	if (!Check(SettingsSchema, settings)) throw new Error(`${path} holds no valid settings. Fix or delete it.`);
+	return settings;
+}
+/**
+* Saves settings over any saved before, creating the directory they live in.
+*
+* @param settings - Every setting to keep.
+*/
+async function saveSettings(settings) {
+	const path = settingsPath();
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${JSON.stringify(settings, null, 2)}\n`);
+}
+// src/command.ts
+/** The exit codes every command uses, as `--help` lists them. */
+const EXIT_CODES = [
+	"0  success",
+	"1  the request can't be answered, such as an unknown id or an unreadable snapshot",
+	"2  a usage error"
+];
+/** The options every command takes. */
+const SHARED_OPTIONS = {
+	snapshot: {
+		type: "string",
+		value: "dir",
+		description: "Load this snapshot directory instead of the committed one."
+	},
+	levels: {
+		type: "string",
+		value: "style",
+		description: `Write levels as ${LEVEL_STYLES.join(" or ")}, over the saved setting.`
+	},
+	help: {
+		type: "boolean",
+		short: "h",
+		description: "Show this help."
+	}
+};
+/** A usage error: emerald prints it with a pointer to the command's `--help` and exits 2. */
+var UsageError = class extends Error {};
+/**
+* Parses a whole number of at least `min`, for an option such as `--limit`. A number
+* too large to hold exactly is rejected too.
+*
+* @param min - The smallest value allowed.
+* @returns The option's `parse` step.
+*/
+const wholeNumber = (min) => (text) => {
+	const value = Number(text);
+	if (!/^[0-9]+$/.test(text) || value < min) throw new UsageError(`must be a whole number of at least ${min}, not "${text}".`);
+	if (!Number.isSafeInteger(value)) throw new UsageError(`must be at most ${Number.MAX_SAFE_INTEGER.toLocaleString("en")}, not "${text}".`);
+	return value;
+};
+/**
+* Declares a subcommand. The returned command parses its arguments, prints `--help`,
+* loads the catalog from `--snapshot` or the committed snapshot, in the level style of
+* `--levels` or the saved setting, and then calls `run`.
+*
+* @param spec - The command's name, summary, its one argument (several words when
+* `variadic`), its own options, and what it does with them.
+*/
+function defineCommand(spec) {
+	const options = {
+		...spec.options,
+		...SHARED_OPTIONS
+	};
+	const help = [
+		`Usage: emerald ${spec.name} <${spec.argument.name}>${spec.argument.variadic ? "..." : ""} [options]`,
+		"",
+		spec.summary,
+		"",
+		"Options:",
+		...Object.entries(options).map(([name, option]) => {
+			const flag = [..."short" in option ? [`-${option.short},`] : [], `--${name}${"value" in option ? ` <${option.value}>` : ""}`].join(" ");
+			const fallback = "default" in option ? ` (default: ${String(option.default)})` : "";
+			return `  ${flag.padEnd(20)}${option.description}${fallback}`;
+		}),
+		"",
+		"Exit codes:",
+		...EXIT_CODES.map((line) => `  ${line}`)
+	].join("\n");
+	return {
+		name: spec.name,
+		summary: spec.summary,
+		async run(args) {
+			let parsed;
+			try {
+				parsed = parseArgs({
+					args: [...args],
+					options,
+					allowPositionals: true
+				});
+			} catch (error) {
+				throw new UsageError(error instanceof Error ? error.message : String(error));
+			}
+			const { values, positionals } = parsed;
+			const shared = values;
+			if (shared.help) {
+				console.log(help);
+				return;
+			}
+			const [first, ...rest] = positionals;
+			if (first === void 0) throw new UsageError(`missing <${spec.argument.name}>.`);
+			if (rest.length > 0 && !spec.argument.variadic) throw new UsageError(`unexpected argument "${rest[0]}".`);
+			if (shared.snapshot === "") throw new UsageError("--snapshot needs a directory.");
+			if (shared.levels !== void 0 && !isLevelStyle(shared.levels)) throw new UsageError(`--levels must be ${LEVEL_STYLES.join(" or ")}, not "${shared.levels}".`);
+			const parsedValues = { ...values };
+			for (const [name, option] of Object.entries(spec.options)) {
+				const value = parsedValues[name];
+				if (!option.parse || typeof value !== "string") continue;
+				try {
+					parsedValues[name] = option.parse(value);
+				} catch (error) {
+					if (!(error instanceof UsageError)) throw error;
+					throw new UsageError(`--${name} ${error.message}`);
+				}
+			}
+			const catalog = await loadItemCatalog(resolve(process.env["INIT_CWD"] ?? process.cwd(), shared.snapshot ?? committedDataDirectory()), null, { levels: shared.levels ?? (await readSettings()).levels });
+			await spec.run({
+				values: parsedValues,
+				argument: positionals.join(" "),
+				catalog,
+				item: (id) => {
+					const item = catalog.summaryOf(id);
+					if (!item) throw new Error(`no item has the id "${id}".`);
+					return item;
+				}
+			});
+		}
+	};
+}
+// src/config.ts
+const STYLES = LEVEL_STYLES.join("|");
+/** `emerald config --help`, built here because no option or argument is shared with the rest. */
+const help = () => [
+	`Usage: emerald config levels [${STYLES}]`,
+	"",
+	"Show or save how runes, enchanted books and minions write their level. With a style,",
+	"saves it; without one, prints the current style.",
+	"",
+	`Settings file: ${settingsPath()}`,
+	"",
+	"Exit codes:",
+	...EXIT_CODES.map((line) => `  ${line}`)
+].join("\n");
+/**
+* `emerald config levels [roman|number]`: shows or saves the level style. It isn't declared
+* with `defineCommand`, because that loads the catalog, which a setting has no use for.
+*/
+const config = {
+	name: "config",
+	summary: "Show or save a setting.",
+	async run(args) {
+		let parsed;
+		try {
+			parsed = parseArgs({
+				args: [...args],
+				options: { help: {
+					type: "boolean",
+					short: "h"
+				} },
+				allowPositionals: true
+			});
+		} catch (error) {
+			throw new UsageError(error instanceof Error ? error.message : String(error));
+		}
+		if (parsed.values.help) {
+			console.log(help());
+			return;
+		}
+		const [setting, value, extra] = parsed.positionals;
+		if (setting === void 0) throw new UsageError("missing <setting>.");
+		if (setting !== "levels") throw new UsageError(`unknown setting "${setting}"; try levels.`);
+		if (extra !== void 0) throw new UsageError(`unexpected argument "${extra}".`);
+		if (value === void 0) {
+			console.log((await readSettings()).levels ?? "roman");
+			return;
+		}
+		if (!isLevelStyle(value)) throw new UsageError(`levels must be ${LEVEL_STYLES.join(" or ")}, not "${value}".`);
+		await saveSettings({
+			...await readSettings().catch(() => ({})),
+			levels: value
+		});
+		console.log(value);
+	}
+};
+// src/format-plan.ts
+/** Where a step's way comes from, such as `Kat`, `Trade` or `Buy from Oringo`. */
+function wayName(way) {
+	if (way.method !== "npcShopsAndTrades" || isListedWay(way)) return METHOD_NAMES[way.method];
+	return way.record.kind === "npc" ? `Buy from ${way.record.seller.displayName}` : "Trade";
+}
+/** What a step takes over all its runs, such as `128 × RAW_CHICKEN, 10,000 coins · 1d`. */
+function takesText({ inputs, currencies, coins, durationSeconds }) {
+	const costs = [...[...inputs, ...currencies].map(({ id, count }) => `${number(count)} × ${id}`), ...coins > 0 ? [`${number(coins)} coins`] : []].join(", ");
+	return [...costs ? [costs] : [], ...durationSeconds > 0 ? [durationText(durationSeconds)] : []].join(" · ");
+}
+/**
+* Prints an item's plan as text: numbered steps, inputs first, each with its way, runs and
+* tags, then what it takes and its unlock requirement; then the materials, each with its
+* ways as `emerald ways` lists them, and a gathered one with what buying it instead would
+* cost; then the totals that are not zero, labelled as base values. A section with
+* nothing in it is left out. Items are named by id, so one can be passed straight to
+* `emerald ways` or `emerald plan`.
+*
+* @param item - The item planned, for the title line.
+* @param count - How many of it the plan is for.
+* @param plan - Its plan, as the plan query answers it.
+*/
+function formatPlan(item, count, plan) {
+	const lines = [title(`${number(count)} × ${item.id}  ${item.displayName}`)];
+	const { steps, materials, totals } = plan;
+	if (steps.length > 0) lines.push("", heading("Steps"));
+	const width = String(steps.length).length;
+	steps.forEach((step, index) => {
+		const runs = `${number(step.runs)} run${step.runs === 1 ? "" : "s"}`;
+		const indent = " ".repeat(width + 4);
+		const takes = takesText(step);
+		lines.push(`  ${`${index + 1}.`.padStart(width + 1)} ${number(step.count)} × ${step.item} · ${wayName(step.way)}, ${runs}${tagsText(step.way)}`, ...takes ? [`${indent}${takes}`] : [], ...step.requirement ? [`${indent}${dim(step.requirement)}`] : []);
+	});
+	if (materials.length > 0) lines.push("", heading("Materials"));
+	for (const material of materials) {
+		const sections = waySections(material.ways);
+		const bought = material.purchase;
+		const buy = bought ? ` · ${dim(`or buy for ${number(bought.coins)} coins from ${bought.offer.seller.displayName}`)}` : "";
+		lines.push(`  ${number(material.count)} × ${material.item}${buy}`, ...sections.length === 0 ? [`    ${NO_WAY}`] : [], ...sections.flatMap(({ heading: heading$1, lines: ways }) => [`    ${heading(heading$1)}`, ...ways.map((line) => `      ${line}`)]));
+	}
+	const totalLines = [
+		...totals.coins > 0 ? [`  Coins: ${number(totals.coins)}`] : [],
+		...totals.currencies.map(({ id, count }) => `  ${id}: ${number(count)}`),
+		...totals.durationSeconds > 0 ? [`  Station time: ${durationText(totals.durationSeconds)}`] : []
+	];
+	if (totalLines.length > 0) lines.push("", heading("Totals, at base values"), ...totalLines);
+	return lines.join("\n");
+}
+// src/plan.ts
+/**
+* `emerald plan <item-id>`: prints the steps to get a count of an item, the materials they
+* stop at and the totals, as text or, with `--json`, exactly as the plan query answers.
+*/
+const plan = defineCommand({
+	name: "plan",
+	summary: "Plan every step to get an item.",
+	argument: { name: "item-id" },
+	options: {
+		json: {
+			type: "boolean",
+			description: "Print the plan query's answer as JSON."
+		},
+		count: {
+			type: "string",
+			value: "n",
+			default: "1",
+			parse: wholeNumber(1),
+			description: "How many of the item to plan for."
+		}
+	},
+	async run({ values, argument, catalog, item }) {
+		const found = item(argument);
+		const answer = itemPlan(catalog, found.id, values.count);
+		console.log(values.json ? JSON.stringify(answer, null, 2) : formatPlan(found, values.count, answer));
+	}
+});
+// src/format-search.ts
+/**
+* Prints a search page as text: an item row as its id, shown name and category on one
+* line; a family row as a heading with the family's name and category, then one indented
+* line per member with its id, shown name and rarity, the member the query named marked
+* with `>`. When more rows follow, a last line gives the `--offset` that shows them. Every
+* id printed can be passed straight to `emerald ways`.
+*
+* @param page - A page the core's search answered.
+*/
+function formatSearch({ rows, nextOffset }) {
+	const lines = rows.flatMap((row) => {
+		if (row.kind === "item") {
+			const { id, displayName, category } = row.item;
+			return [`${title(id)}  ${displayName}  ${dim(category)}`];
+		}
+		const [first] = row.members;
+		return [`${heading(first?.family.base ?? row.key)}  ${dim(`${first?.category ?? ""} family`)}`, ...row.members.map(({ id, displayName, rarity }) => `${id === row.target ? ">" : " "} ${title(id)}  ${displayName}  ${dim(rarity)}`)];
+	});
+	if (nextOffset !== null) lines.push(dim(`more: --offset ${nextOffset}`));
+	return lines.join("\n");
+}
+// src/search.ts
+/**
+* `emerald search <query>...`: finds items by name or id, ranked as the core's search ranks
+* them, so a person or an agent can find the id `emerald ways` takes.
+*/
+const search = defineCommand({
+	name: "search",
+	summary: "Find items by name or id.",
+	argument: {
+		name: "query",
+		variadic: true
+	},
+	options: {
+		json: {
+			type: "boolean",
+			description: "Print the search page as JSON."
+		},
+		limit: {
+			type: "string",
+			value: "n",
+			default: "25",
+			parse: wholeNumber(1),
+			description: "The most rows to print."
+		},
+		offset: {
+			type: "string",
+			value: "n",
+			default: "0",
+			parse: wholeNumber(0),
+			description: "How many of the best rows to skip, for the next page."
+		}
+	},
+	async run({ values, argument, catalog }) {
+		const page = catalog.search(argument, values.limit, values.offset);
+		if (values.json) console.log(JSON.stringify(page, null, 2));
+		else if (page.rows.length > 0) console.log(formatSearch(page));
+	}
+});
+// src/ways.ts
+/**
+* `emerald ways <item-id>`: prints every way to get the item, as text or, with `--json`,
+* exactly as the ways query answers it.
+*/
+const ways = defineCommand({
+	name: "ways",
+	summary: "Print every way to get an item.",
+	argument: { name: "item-id" },
+	options: { json: {
+		type: "boolean",
+		description: "Print the ways query's answer as JSON."
+	} },
+	async run({ values, argument, catalog, item }) {
+		const found = item(argument);
+		const answer = itemWays(catalog, found.id);
+		console.log(values.json ? JSON.stringify(answer, null, 2) : formatWays(found, answer));
+	}
+});
+// src/run.ts
+const COMMANDS = new Map([
+	search,
+	ways,
+	plan,
+	config
+].map((command) => [command.name, command]));
+const usage = [
+	"Usage: emerald <command> [arguments]",
+	"",
+	"Run emerald with no command in a terminal to browse items interactively.",
+	"",
+	"Commands:",
+	...[...COMMANDS.values()].map(({ name, summary }) => `  ${name.padEnd(8)}${summary}`),
+	"",
+	"Run 'emerald <command> --help' for a command's arguments and options.",
+	"",
+	"Exit codes:",
+	...EXIT_CODES.map((line) => `  ${line}`)
+].join("\n");
+/** Shows a failure as one line: a stack trace adds only noise for a user. */
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+/**
+* Runs `emerald` with the arguments after the program name, printing to the console.
+* `main.ts` calls it for the real command; tests call it in-process.
+*
+* @returns The exit code: 0 success, 1 an unanswerable request, 2 a usage error.
+*/
+async function run(argv) {
+	const [name, ...args] = argv;
+	const command = name === void 0 ? void 0 : COMMANDS.get(name);
+	if (name === void 0 && process.stdin.isTTY && process.stdout.isTTY) try {
+		const { levels } = await readSettings();
+		const catalog = await loadItemCatalog(committedDataDirectory(), null, { levels });
+		const { runInteractive } = await import("./terminal-CMDocsw8.mjs");
+		await runInteractive(catalog);
+		return 0;
+	} catch (error) {
+		console.error(`emerald: ${messageOf(error)}`);
+		return 1;
+	}
+	if (name === "--help" || name === "-h") {
+		console.log(usage);
+		return 0;
+	}
+	if (command) try {
+		await command.run(args);
+		return 0;
+	} catch (error) {
+		console.error(`emerald ${command.name}: ${messageOf(error)}`);
+		if (error instanceof UsageError) console.error(`Run 'emerald ${command.name} --help' for its usage.`);
+		return error instanceof UsageError ? 2 : 1;
+	}
+	if (name !== void 0) console.error(`emerald: unknown command "${name}".\n`);
+	console.error(usage);
+	return 2;
+}
+// src/main.ts
+process.exitCode = await run(process.argv.slice(2));
+export {};