@luna-park/plugin 1.2.0 → 1.2.1

package/dist/index.js

@@ -1,35 +1,2962 @@
-import { y as p } from "./index-Dv9uuje9.js";
-import { J as d, _ as y, i as L, u as P, x as S, T as h } from "./index-Dv9uuje9.js";
-var e = /* @__PURE__ */ ((o) => (o.ViteImport = "viteImport", o.VitePlugin = "vitePlugin", o.AppImport = "appImport", o.AppBody = "appBody", o.Style = "style", o.ServerImport = "serverImport", o.ServerBody = "serverBody", o))(e || {}), f = /* @__PURE__ */ ((o) => (o.Color = "color", o.FontSize = "font-size", o.FontWeight = "font-weight", o.FontFamily = "font-family", o.Length = "length", o.Time = "time", o))(f || {});
-function l(o) {
-  return o;
-}
-async function m(o, r) {
-  const t = p(o), n = r.app?.config?.plugins?.[o.id]?.config;
-  for (const i of ["build", "editor", "inject"])
-    if (t[i])
-      for (const a in t[i])
-        t[i][a] = await g(t[i][a], { ...r, config: n });
-  return t;
-}
-async function g(o, r) {
-  return typeof o == "function" ? o({
-    app: r.app,
-    config: r.config,
-    internal: r.internal,
-    mode: r.mode || "editor"
-  }) : o;
-}
-export {
-  e as EInjectionKey,
-  d as ELogicScope,
-  y as ELogicType,
-  f as ETokenType,
-  L as EVarType,
-  P as LogicType,
-  S as LogicUtil,
-  g as getPluginParam,
-  m as loadPlugin,
-  h as makeLogicNode,
-  l as makePlugin
+import { a as LogicUtil, i as LogicType, n as ELogicType, o as makeLogicNode, r as EVarType, t as ELogicScope, u as cloneWithFunctions } from "./dist-BUZt4gnZ.js";
+import { createElementBlock, openBlock, renderSlot } from "vue";
+var __defProp$1 = Object.defineProperty, __export$1 = (y, J) => {
+	let Y = {};
+	for (var X in y) __defProp$1(Y, X, {
+		get: y[X],
+		enumerable: !0
+	});
+	return J && __defProp$1(Y, Symbol.toStringTag, { value: "Module" }), Y;
+}, __plugin_vue_export_helper_default = (y, J) => {
+	let Y = y.__vccOpts || y;
+	for (let [y, X] of J) Y[y] = X;
+	return Y;
+}, _sfc_main = {}, _hoisted_1 = { class: "story-wrapper" };
+function _sfc_render(y, J) {
+	return openBlock(), createElementBlock("div", _hoisted_1, [renderSlot(y.$slots, "default", {}, void 0, !0)]);
+}
+var LSettingsStoryWrapper_default = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-8d6cff07"]]);
+let EInjectionKey = /* @__PURE__ */ function(y) {
+	return y.ViteImport = "viteImport", y.VitePlugin = "vitePlugin", y.AppImport = "appImport", y.AppBody = "appBody", y.AppSetup = "appSetup", y.Style = "style", y.ServerImport = "serverImport", y.ServerBody = "serverBody", y;
+}({}), ETokenType = /* @__PURE__ */ function(y) {
+	return y.Color = "color", y.FontSize = "font-size", y.FontWeight = "font-weight", y.FontFamily = "font-family", y.Length = "length", y.Time = "time", y;
+}({});
+function IsAsyncIterator(y) {
+	return IsObject$1(y) && !IsArray(y) && !IsUint8Array(y) && Symbol.asyncIterator in y;
+}
+function IsArray(y) {
+	return Array.isArray(y);
+}
+function IsBigInt(y) {
+	return typeof y == "bigint";
+}
+function IsBoolean$1(y) {
+	return typeof y == "boolean";
+}
+function IsDate(y) {
+	return y instanceof globalThis.Date;
+}
+function IsFunction(y) {
+	return typeof y == "function";
+}
+function IsIterator(y) {
+	return IsObject$1(y) && !IsArray(y) && !IsUint8Array(y) && Symbol.iterator in y;
+}
+function IsNull(y) {
+	return y === null;
+}
+function IsNumber$1(y) {
+	return typeof y == "number";
+}
+function IsObject$1(y) {
+	return typeof y == "object" && !!y;
+}
+function IsRegExp$2(y) {
+	return y instanceof globalThis.RegExp;
+}
+function IsString(y) {
+	return typeof y == "string";
+}
+function IsSymbol(y) {
+	return typeof y == "symbol";
+}
+function IsUint8Array(y) {
+	return y instanceof globalThis.Uint8Array;
+}
+function IsUndefined(y) {
+	return y === void 0;
+}
+function ArrayType(y) {
+	return y.map((y) => Visit$2(y));
+}
+function DateType(y) {
+	return new Date(y.getTime());
+}
+function Uint8ArrayType(y) {
+	return new Uint8Array(y);
+}
+function RegExpType(y) {
+	return new RegExp(y.source, y.flags);
+}
+function ObjectType(y) {
+	let J = {};
+	for (let Y of Object.getOwnPropertyNames(y)) J[Y] = Visit$2(y[Y]);
+	for (let Y of Object.getOwnPropertySymbols(y)) J[Y] = Visit$2(y[Y]);
+	return J;
+}
+function Visit$2(y) {
+	return IsArray(y) ? ArrayType(y) : IsDate(y) ? DateType(y) : IsUint8Array(y) ? Uint8ArrayType(y) : IsRegExp$2(y) ? RegExpType(y) : IsObject$1(y) ? ObjectType(y) : y;
+}
+function Clone(y) {
+	return Visit$2(y);
+}
+function CloneType(y, J) {
+	return Clone(J === void 0 ? y : {
+		...J,
+		...y
+	});
+}
+function IsObject$3(y) {
+	return typeof y == "object" && !!y;
+}
+function IsArray$3(y) {
+	return globalThis.Array.isArray(y) && !globalThis.ArrayBuffer.isView(y);
+}
+function IsUndefined$3(y) {
+	return y === void 0;
+}
+function IsNumber$3(y) {
+	return typeof y == "number";
+}
+var TypeSystemPolicy;
+(function(y) {
+	y.InstanceMode = "default", y.ExactOptionalPropertyTypes = !1, y.AllowArrayObject = !1, y.AllowNaN = !1, y.AllowNullVoid = !1;
+	function J(J, Y) {
+		return y.ExactOptionalPropertyTypes ? Y in J : J[Y] !== void 0;
+	}
+	y.IsExactOptionalProperty = J;
+	function Y(J) {
+		let Y = IsObject$3(J);
+		return y.AllowArrayObject ? Y : Y && !IsArray$3(J);
+	}
+	y.IsObjectLike = Y;
+	function X(y) {
+		return Y(y) && !(y instanceof Date) && !(y instanceof Uint8Array);
+	}
+	y.IsRecordLike = X;
+	function Z(J) {
+		return y.AllowNaN ? IsNumber$3(J) : Number.isFinite(J);
+	}
+	y.IsNumberLike = Z;
+	function Q(J) {
+		let Y = IsUndefined$3(J);
+		return y.AllowNullVoid ? Y || J === null : Y;
+	}
+	y.IsVoidLike = Q;
+})(TypeSystemPolicy ||= {});
+function ImmutableArray(y) {
+	return globalThis.Object.freeze(y).map((y) => Immutable(y));
+}
+function ImmutableDate(y) {
+	return y;
+}
+function ImmutableUint8Array(y) {
+	return y;
+}
+function ImmutableRegExp(y) {
+	return y;
+}
+function ImmutableObject(y) {
+	let J = {};
+	for (let Y of Object.getOwnPropertyNames(y)) J[Y] = Immutable(y[Y]);
+	for (let Y of Object.getOwnPropertySymbols(y)) J[Y] = Immutable(y[Y]);
+	return globalThis.Object.freeze(J);
+}
+function Immutable(y) {
+	return IsArray(y) ? ImmutableArray(y) : IsDate(y) ? ImmutableDate(y) : IsUint8Array(y) ? ImmutableUint8Array(y) : IsRegExp$2(y) ? ImmutableRegExp(y) : IsObject$1(y) ? ImmutableObject(y) : y;
+}
+function CreateType(y, J) {
+	let Y = J === void 0 ? y : {
+		...J,
+		...y
+	};
+	switch (TypeSystemPolicy.InstanceMode) {
+		case "freeze": return Immutable(Y);
+		case "clone": return Clone(Y);
+		default: return Y;
+	}
+}
+var TypeBoxError = class extends Error {
+	constructor(y) {
+		super(y);
+	}
+};
+const TransformKind = Symbol.for("TypeBox.Transform"), ReadonlyKind = Symbol.for("TypeBox.Readonly"), OptionalKind = Symbol.for("TypeBox.Optional"), Hint = Symbol.for("TypeBox.Hint"), Kind = Symbol.for("TypeBox.Kind");
+function IsReadonly(y) {
+	return IsObject$1(y) && y[ReadonlyKind] === "Readonly";
+}
+function IsOptional(y) {
+	return IsObject$1(y) && y[OptionalKind] === "Optional";
+}
+function IsAny(y) {
+	return IsKindOf$1(y, "Any");
+}
+function IsArgument$1(y) {
+	return IsKindOf$1(y, "Argument");
+}
+function IsArray$1(y) {
+	return IsKindOf$1(y, "Array");
+}
+function IsAsyncIterator$1(y) {
+	return IsKindOf$1(y, "AsyncIterator");
+}
+function IsBigInt$1(y) {
+	return IsKindOf$1(y, "BigInt");
+}
+function IsBoolean(y) {
+	return IsKindOf$1(y, "Boolean");
+}
+function IsComputed(y) {
+	return IsKindOf$1(y, "Computed");
+}
+function IsConstructor(y) {
+	return IsKindOf$1(y, "Constructor");
+}
+function IsDate$2(y) {
+	return IsKindOf$1(y, "Date");
+}
+function IsFunction$1(y) {
+	return IsKindOf$1(y, "Function");
+}
+function IsInteger(y) {
+	return IsKindOf$1(y, "Integer");
+}
+function IsIntersect(y) {
+	return IsKindOf$1(y, "Intersect");
+}
+function IsIterator$1(y) {
+	return IsKindOf$1(y, "Iterator");
+}
+function IsKindOf$1(y, J) {
+	return IsObject$1(y) && Kind in y && y[Kind] === J;
+}
+function IsLiteralValue(y) {
+	return IsBoolean$1(y) || IsNumber$1(y) || IsString(y);
+}
+function IsLiteral(y) {
+	return IsKindOf$1(y, "Literal");
+}
+function IsMappedKey(y) {
+	return IsKindOf$1(y, "MappedKey");
+}
+function IsMappedResult(y) {
+	return IsKindOf$1(y, "MappedResult");
+}
+function IsNever(y) {
+	return IsKindOf$1(y, "Never");
+}
+function IsNot$1(y) {
+	return IsKindOf$1(y, "Not");
+}
+function IsNull$2(y) {
+	return IsKindOf$1(y, "Null");
+}
+function IsNumber(y) {
+	return IsKindOf$1(y, "Number");
+}
+function IsObject(y) {
+	return IsKindOf$1(y, "Object");
+}
+function IsPromise(y) {
+	return IsKindOf$1(y, "Promise");
+}
+function IsRecord(y) {
+	return IsKindOf$1(y, "Record");
+}
+function IsRef(y) {
+	return IsKindOf$1(y, "Ref");
+}
+function IsRegExp(y) {
+	return IsKindOf$1(y, "RegExp");
+}
+function IsString$1(y) {
+	return IsKindOf$1(y, "String");
+}
+function IsSymbol$2(y) {
+	return IsKindOf$1(y, "Symbol");
+}
+function IsTemplateLiteral(y) {
+	return IsKindOf$1(y, "TemplateLiteral");
+}
+function IsThis$1(y) {
+	return IsKindOf$1(y, "This");
+}
+function IsTransform(y) {
+	return IsObject$1(y) && TransformKind in y;
+}
+function IsTuple(y) {
+	return IsKindOf$1(y, "Tuple");
+}
+function IsUndefined$2(y) {
+	return IsKindOf$1(y, "Undefined");
+}
+function IsUnion(y) {
+	return IsKindOf$1(y, "Union");
+}
+function IsUint8Array$2(y) {
+	return IsKindOf$1(y, "Uint8Array");
+}
+function IsUnknown$1(y) {
+	return IsKindOf$1(y, "Unknown");
+}
+function IsUnsafe$1(y) {
+	return IsKindOf$1(y, "Unsafe");
+}
+function IsVoid$1(y) {
+	return IsKindOf$1(y, "Void");
+}
+function IsKind$1(y) {
+	return IsObject$1(y) && Kind in y && IsString(y[Kind]);
+}
+function IsSchema(y) {
+	return IsAny(y) || IsArgument$1(y) || IsArray$1(y) || IsBoolean(y) || IsBigInt$1(y) || IsAsyncIterator$1(y) || IsComputed(y) || IsConstructor(y) || IsDate$2(y) || IsFunction$1(y) || IsInteger(y) || IsIntersect(y) || IsIterator$1(y) || IsLiteral(y) || IsMappedKey(y) || IsMappedResult(y) || IsNever(y) || IsNot$1(y) || IsNull$2(y) || IsNumber(y) || IsObject(y) || IsPromise(y) || IsRecord(y) || IsRef(y) || IsRegExp(y) || IsString$1(y) || IsSymbol$2(y) || IsTemplateLiteral(y) || IsThis$1(y) || IsTuple(y) || IsUndefined$2(y) || IsUnion(y) || IsUint8Array$2(y) || IsUnknown$1(y) || IsUnsafe$1(y) || IsVoid$1(y) || IsKind$1(y);
+}
+var KnownTypes = /* @__PURE__ */ "Argument.Any.Array.AsyncIterator.BigInt.Boolean.Computed.Constructor.Date.Enum.Function.Integer.Intersect.Iterator.Literal.MappedKey.MappedResult.Not.Null.Number.Object.Promise.Record.Ref.RegExp.String.Symbol.TemplateLiteral.This.Tuple.Undefined.Union.Uint8Array.Unknown.Void".split(".");
+function IsPattern(y) {
+	try {
+		return new RegExp(y), !0;
+	} catch {
+		return !1;
+	}
+}
+function IsControlCharacterFree(y) {
+	if (!IsString(y)) return !1;
+	for (let J = 0; J < y.length; J++) {
+		let Y = y.charCodeAt(J);
+		if (Y >= 7 && Y <= 13 || Y === 27 || Y === 127) return !1;
+	}
+	return !0;
+}
+function IsAdditionalProperties(y) {
+	return IsOptionalBoolean(y) || IsSchema$1(y);
+}
+function IsOptionalBigInt(y) {
+	return IsUndefined(y) || IsBigInt(y);
+}
+function IsOptionalNumber(y) {
+	return IsUndefined(y) || IsNumber$1(y);
+}
+function IsOptionalBoolean(y) {
+	return IsUndefined(y) || IsBoolean$1(y);
+}
+function IsOptionalString(y) {
+	return IsUndefined(y) || IsString(y);
+}
+function IsOptionalPattern(y) {
+	return IsUndefined(y) || IsString(y) && IsControlCharacterFree(y) && IsPattern(y);
+}
+function IsOptionalFormat(y) {
+	return IsUndefined(y) || IsString(y) && IsControlCharacterFree(y);
+}
+function IsOptionalSchema(y) {
+	return IsUndefined(y) || IsSchema$1(y);
+}
+function IsOptional$1(y) {
+	return IsObject$1(y) && y[OptionalKind] === "Optional";
+}
+function IsAny$1(y) {
+	return IsKindOf(y, "Any") && IsOptionalString(y.$id);
+}
+function IsArgument(y) {
+	return IsKindOf(y, "Argument") && IsNumber$1(y.index);
+}
+function IsArray$2(y) {
+	return IsKindOf(y, "Array") && y.type === "array" && IsOptionalString(y.$id) && IsSchema$1(y.items) && IsOptionalNumber(y.minItems) && IsOptionalNumber(y.maxItems) && IsOptionalBoolean(y.uniqueItems) && IsOptionalSchema(y.contains) && IsOptionalNumber(y.minContains) && IsOptionalNumber(y.maxContains);
+}
+function IsAsyncIterator$2(y) {
+	return IsKindOf(y, "AsyncIterator") && y.type === "AsyncIterator" && IsOptionalString(y.$id) && IsSchema$1(y.items);
+}
+function IsBigInt$2(y) {
+	return IsKindOf(y, "BigInt") && y.type === "bigint" && IsOptionalString(y.$id) && IsOptionalBigInt(y.exclusiveMaximum) && IsOptionalBigInt(y.exclusiveMinimum) && IsOptionalBigInt(y.maximum) && IsOptionalBigInt(y.minimum) && IsOptionalBigInt(y.multipleOf);
+}
+function IsBoolean$2(y) {
+	return IsKindOf(y, "Boolean") && y.type === "boolean" && IsOptionalString(y.$id);
+}
+function IsComputed$1(y) {
+	return IsKindOf(y, "Computed") && IsString(y.target) && IsArray(y.parameters) && y.parameters.every((y) => IsSchema$1(y));
+}
+function IsConstructor$1(y) {
+	return IsKindOf(y, "Constructor") && y.type === "Constructor" && IsOptionalString(y.$id) && IsArray(y.parameters) && y.parameters.every((y) => IsSchema$1(y)) && IsSchema$1(y.returns);
+}
+function IsDate$1(y) {
+	return IsKindOf(y, "Date") && y.type === "Date" && IsOptionalString(y.$id) && IsOptionalNumber(y.exclusiveMaximumTimestamp) && IsOptionalNumber(y.exclusiveMinimumTimestamp) && IsOptionalNumber(y.maximumTimestamp) && IsOptionalNumber(y.minimumTimestamp) && IsOptionalNumber(y.multipleOfTimestamp);
+}
+function IsFunction$2(y) {
+	return IsKindOf(y, "Function") && y.type === "Function" && IsOptionalString(y.$id) && IsArray(y.parameters) && y.parameters.every((y) => IsSchema$1(y)) && IsSchema$1(y.returns);
+}
+function IsInteger$1(y) {
+	return IsKindOf(y, "Integer") && y.type === "integer" && IsOptionalString(y.$id) && IsOptionalNumber(y.exclusiveMaximum) && IsOptionalNumber(y.exclusiveMinimum) && IsOptionalNumber(y.maximum) && IsOptionalNumber(y.minimum) && IsOptionalNumber(y.multipleOf);
+}
+function IsProperties(y) {
+	return IsObject$1(y) && Object.entries(y).every(([y, J]) => IsControlCharacterFree(y) && IsSchema$1(J));
+}
+function IsIntersect$1(y) {
+	return IsKindOf(y, "Intersect") && !(IsString(y.type) && y.type !== "object") && IsArray(y.allOf) && y.allOf.every((y) => IsSchema$1(y) && !IsTransform$1(y)) && IsOptionalString(y.type) && (IsOptionalBoolean(y.unevaluatedProperties) || IsOptionalSchema(y.unevaluatedProperties)) && IsOptionalString(y.$id);
+}
+function IsIterator$2(y) {
+	return IsKindOf(y, "Iterator") && y.type === "Iterator" && IsOptionalString(y.$id) && IsSchema$1(y.items);
+}
+function IsKindOf(y, J) {
+	return IsObject$1(y) && Kind in y && y[Kind] === J;
+}
+function IsLiteralString(y) {
+	return IsLiteral$1(y) && IsString(y.const);
+}
+function IsLiteralNumber(y) {
+	return IsLiteral$1(y) && IsNumber$1(y.const);
+}
+function IsLiteralBoolean(y) {
+	return IsLiteral$1(y) && IsBoolean$1(y.const);
+}
+function IsLiteral$1(y) {
+	return IsKindOf(y, "Literal") && IsOptionalString(y.$id) && IsLiteralValue$1(y.const);
+}
+function IsLiteralValue$1(y) {
+	return IsBoolean$1(y) || IsNumber$1(y) || IsString(y);
+}
+function IsMappedKey$1(y) {
+	return IsKindOf(y, "MappedKey") && IsArray(y.keys) && y.keys.every((y) => IsNumber$1(y) || IsString(y));
+}
+function IsMappedResult$1(y) {
+	return IsKindOf(y, "MappedResult") && IsProperties(y.properties);
+}
+function IsNever$1(y) {
+	return IsKindOf(y, "Never") && IsObject$1(y.not) && Object.getOwnPropertyNames(y.not).length === 0;
+}
+function IsNot(y) {
+	return IsKindOf(y, "Not") && IsSchema$1(y.not);
+}
+function IsNull$1(y) {
+	return IsKindOf(y, "Null") && y.type === "null" && IsOptionalString(y.$id);
+}
+function IsNumber$2(y) {
+	return IsKindOf(y, "Number") && y.type === "number" && IsOptionalString(y.$id) && IsOptionalNumber(y.exclusiveMaximum) && IsOptionalNumber(y.exclusiveMinimum) && IsOptionalNumber(y.maximum) && IsOptionalNumber(y.minimum) && IsOptionalNumber(y.multipleOf);
+}
+function IsObject$2(y) {
+	return IsKindOf(y, "Object") && y.type === "object" && IsOptionalString(y.$id) && IsProperties(y.properties) && IsAdditionalProperties(y.additionalProperties) && IsOptionalNumber(y.minProperties) && IsOptionalNumber(y.maxProperties);
+}
+function IsPromise$1(y) {
+	return IsKindOf(y, "Promise") && y.type === "Promise" && IsOptionalString(y.$id) && IsSchema$1(y.item);
+}
+function IsRecord$1(y) {
+	return IsKindOf(y, "Record") && y.type === "object" && IsOptionalString(y.$id) && IsAdditionalProperties(y.additionalProperties) && IsObject$1(y.patternProperties) && ((y) => {
+		let J = Object.getOwnPropertyNames(y.patternProperties);
+		return J.length === 1 && IsPattern(J[0]) && IsObject$1(y.patternProperties) && IsSchema$1(y.patternProperties[J[0]]);
+	})(y);
+}
+function IsRef$1(y) {
+	return IsKindOf(y, "Ref") && IsOptionalString(y.$id) && IsString(y.$ref);
+}
+function IsRegExp$1(y) {
+	return IsKindOf(y, "RegExp") && IsOptionalString(y.$id) && IsString(y.source) && IsString(y.flags) && IsOptionalNumber(y.maxLength) && IsOptionalNumber(y.minLength);
+}
+function IsString$2(y) {
+	return IsKindOf(y, "String") && y.type === "string" && IsOptionalString(y.$id) && IsOptionalNumber(y.minLength) && IsOptionalNumber(y.maxLength) && IsOptionalPattern(y.pattern) && IsOptionalFormat(y.format);
+}
+function IsSymbol$1(y) {
+	return IsKindOf(y, "Symbol") && y.type === "symbol" && IsOptionalString(y.$id);
+}
+function IsTemplateLiteral$1(y) {
+	return IsKindOf(y, "TemplateLiteral") && y.type === "string" && IsString(y.pattern) && y.pattern[0] === "^" && y.pattern[y.pattern.length - 1] === "$";
+}
+function IsThis(y) {
+	return IsKindOf(y, "This") && IsOptionalString(y.$id) && IsString(y.$ref);
+}
+function IsTransform$1(y) {
+	return IsObject$1(y) && TransformKind in y;
+}
+function IsTuple$1(y) {
+	return IsKindOf(y, "Tuple") && y.type === "array" && IsOptionalString(y.$id) && IsNumber$1(y.minItems) && IsNumber$1(y.maxItems) && y.minItems === y.maxItems && (IsUndefined(y.items) && IsUndefined(y.additionalItems) && y.minItems === 0 || IsArray(y.items) && y.items.every((y) => IsSchema$1(y)));
+}
+function IsUndefined$1(y) {
+	return IsKindOf(y, "Undefined") && y.type === "undefined" && IsOptionalString(y.$id);
+}
+function IsUnion$1(y) {
+	return IsKindOf(y, "Union") && IsOptionalString(y.$id) && IsObject$1(y) && IsArray(y.anyOf) && y.anyOf.every((y) => IsSchema$1(y));
+}
+function IsUint8Array$1(y) {
+	return IsKindOf(y, "Uint8Array") && y.type === "Uint8Array" && IsOptionalString(y.$id) && IsOptionalNumber(y.minByteLength) && IsOptionalNumber(y.maxByteLength);
+}
+function IsUnknown(y) {
+	return IsKindOf(y, "Unknown") && IsOptionalString(y.$id);
+}
+function IsUnsafe(y) {
+	return IsKindOf(y, "Unsafe");
+}
+function IsVoid(y) {
+	return IsKindOf(y, "Void") && y.type === "void" && IsOptionalString(y.$id);
+}
+function IsKind(y) {
+	return IsObject$1(y) && Kind in y && IsString(y[Kind]) && !KnownTypes.includes(y[Kind]);
+}
+function IsSchema$1(y) {
+	return IsObject$1(y) && (IsAny$1(y) || IsArgument(y) || IsArray$2(y) || IsBoolean$2(y) || IsBigInt$2(y) || IsAsyncIterator$2(y) || IsComputed$1(y) || IsConstructor$1(y) || IsDate$1(y) || IsFunction$2(y) || IsInteger$1(y) || IsIntersect$1(y) || IsIterator$2(y) || IsLiteral$1(y) || IsMappedKey$1(y) || IsMappedResult$1(y) || IsNever$1(y) || IsNot(y) || IsNull$1(y) || IsNumber$2(y) || IsObject$2(y) || IsPromise$1(y) || IsRecord$1(y) || IsRef$1(y) || IsRegExp$1(y) || IsString$2(y) || IsSymbol$1(y) || IsTemplateLiteral$1(y) || IsThis(y) || IsTuple$1(y) || IsUndefined$1(y) || IsUnion$1(y) || IsUint8Array$1(y) || IsUnknown(y) || IsUnsafe(y) || IsVoid(y) || IsKind(y));
+}
+const PatternBoolean = "(true|false)", PatternNumber = "(0|[1-9][0-9]*)", PatternString = "(.*)";
+`${PatternBoolean}`;
+const PatternNumberExact = `^${PatternNumber}$`, PatternStringExact = `^${PatternString}$`;
+function SetIncludes(y, J) {
+	return y.includes(J);
+}
+function SetDistinct(y) {
+	return [...new Set(y)];
+}
+function SetIntersect(y, J) {
+	return y.filter((y) => J.includes(y));
+}
+function SetIntersectManyResolve(y, J) {
+	return y.reduce((y, J) => SetIntersect(y, J), J);
+}
+function SetIntersectMany(y) {
+	return y.length === 1 ? y[0] : y.length > 1 ? SetIntersectManyResolve(y.slice(1), y[0]) : [];
+}
+function SetUnionMany(y) {
+	let J = [];
+	for (let Y of y) J.push(...Y);
+	return J;
+}
+function Any(y) {
+	return CreateType({ [Kind]: "Any" }, y);
+}
+function Array$1(y, J) {
+	return CreateType({
+		[Kind]: "Array",
+		type: "array",
+		items: y
+	}, J);
+}
+function Argument(y) {
+	return CreateType({
+		[Kind]: "Argument",
+		index: y
+	});
+}
+function AsyncIterator(y, J) {
+	return CreateType({
+		[Kind]: "AsyncIterator",
+		type: "AsyncIterator",
+		items: y
+	}, J);
+}
+function Computed(y, J, Y) {
+	return CreateType({
+		[Kind]: "Computed",
+		target: y,
+		parameters: J
+	}, Y);
+}
+function DiscardKey(y, J) {
+	let { [J]: Y, ...X } = y;
+	return X;
+}
+function Discard(y, J) {
+	return J.reduce((y, J) => DiscardKey(y, J), y);
+}
+function Never(y) {
+	return CreateType({
+		[Kind]: "Never",
+		not: {}
+	}, y);
+}
+function MappedResult(y) {
+	return CreateType({
+		[Kind]: "MappedResult",
+		properties: y
+	});
+}
+function Constructor(y, J, Y) {
+	return CreateType({
+		[Kind]: "Constructor",
+		type: "Constructor",
+		parameters: y,
+		returns: J
+	}, Y);
+}
+function Function(y, J, Y) {
+	return CreateType({
+		[Kind]: "Function",
+		type: "Function",
+		parameters: y,
+		returns: J
+	}, Y);
+}
+function UnionCreate(y, J) {
+	return CreateType({
+		[Kind]: "Union",
+		anyOf: y
+	}, J);
+}
+function IsUnionOptional(y) {
+	return y.some((y) => IsOptional(y));
+}
+function RemoveOptionalFromRest$1(y) {
+	return y.map((y) => IsOptional(y) ? RemoveOptionalFromType$1(y) : y);
+}
+function RemoveOptionalFromType$1(y) {
+	return Discard(y, [OptionalKind]);
+}
+function ResolveUnion(y, J) {
+	return IsUnionOptional(y) ? Optional(UnionCreate(RemoveOptionalFromRest$1(y), J)) : UnionCreate(RemoveOptionalFromRest$1(y), J);
+}
+function UnionEvaluated(y, J) {
+	return y.length === 1 ? CreateType(y[0], J) : y.length === 0 ? Never(J) : ResolveUnion(y, J);
+}
+function Union(y, J) {
+	return y.length === 0 ? Never(J) : y.length === 1 ? CreateType(y[0], J) : UnionCreate(y, J);
+}
+var TemplateLiteralParserError = class extends TypeBoxError {};
+function Unescape(y) {
+	return y.replace(/\\\$/g, "$").replace(/\\\*/g, "*").replace(/\\\^/g, "^").replace(/\\\|/g, "|").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
+}
+function IsNonEscaped(y, J, Y) {
+	return y[J] === Y && y.charCodeAt(J - 1) !== 92;
+}
+function IsOpenParen(y, J) {
+	return IsNonEscaped(y, J, "(");
+}
+function IsCloseParen(y, J) {
+	return IsNonEscaped(y, J, ")");
+}
+function IsSeparator(y, J) {
+	return IsNonEscaped(y, J, "|");
+}
+function IsGroup(y) {
+	if (!(IsOpenParen(y, 0) && IsCloseParen(y, y.length - 1))) return !1;
+	let J = 0;
+	for (let Y = 0; Y < y.length; Y++) if (IsOpenParen(y, Y) && (J += 1), IsCloseParen(y, Y) && --J, J === 0 && Y !== y.length - 1) return !1;
+	return !0;
+}
+function InGroup(y) {
+	return y.slice(1, y.length - 1);
+}
+function IsPrecedenceOr(y) {
+	let J = 0;
+	for (let Y = 0; Y < y.length; Y++) if (IsOpenParen(y, Y) && (J += 1), IsCloseParen(y, Y) && --J, IsSeparator(y, Y) && J === 0) return !0;
+	return !1;
+}
+function IsPrecedenceAnd(y) {
+	for (let J = 0; J < y.length; J++) if (IsOpenParen(y, J)) return !0;
+	return !1;
+}
+function Or(y) {
+	let [J, Y] = [0, 0], X = [];
+	for (let Z = 0; Z < y.length; Z++) if (IsOpenParen(y, Z) && (J += 1), IsCloseParen(y, Z) && --J, IsSeparator(y, Z) && J === 0) {
+		let J = y.slice(Y, Z);
+		J.length > 0 && X.push(TemplateLiteralParse(J)), Y = Z + 1;
+	}
+	let Z = y.slice(Y);
+	return Z.length > 0 && X.push(TemplateLiteralParse(Z)), X.length === 0 ? {
+		type: "const",
+		const: ""
+	} : X.length === 1 ? X[0] : {
+		type: "or",
+		expr: X
+	};
+}
+function And(y) {
+	function J(y, J) {
+		if (!IsOpenParen(y, J)) throw new TemplateLiteralParserError("TemplateLiteralParser: Index must point to open parens");
+		let Y = 0;
+		for (let X = J; X < y.length; X++) if (IsOpenParen(y, X) && (Y += 1), IsCloseParen(y, X) && --Y, Y === 0) return [J, X];
+		throw new TemplateLiteralParserError("TemplateLiteralParser: Unclosed group parens in expression");
+	}
+	function Y(y, J) {
+		for (let Y = J; Y < y.length; Y++) if (IsOpenParen(y, Y)) return [J, Y];
+		return [J, y.length];
+	}
+	let X = [];
+	for (let Z = 0; Z < y.length; Z++) if (IsOpenParen(y, Z)) {
+		let [Y, Q] = J(y, Z), $ = y.slice(Y, Q + 1);
+		X.push(TemplateLiteralParse($)), Z = Q;
+	} else {
+		let [J, Q] = Y(y, Z), $ = y.slice(J, Q);
+		$.length > 0 && X.push(TemplateLiteralParse($)), Z = Q - 1;
+	}
+	return X.length === 0 ? {
+		type: "const",
+		const: ""
+	} : X.length === 1 ? X[0] : {
+		type: "and",
+		expr: X
+	};
+}
+function TemplateLiteralParse(y) {
+	return IsGroup(y) ? TemplateLiteralParse(InGroup(y)) : IsPrecedenceOr(y) ? Or(y) : IsPrecedenceAnd(y) ? And(y) : {
+		type: "const",
+		const: Unescape(y)
+	};
+}
+function TemplateLiteralParseExact(y) {
+	return TemplateLiteralParse(y.slice(1, y.length - 1));
+}
+var TemplateLiteralFiniteError = class extends TypeBoxError {};
+function IsNumberExpression(y) {
+	return y.type === "or" && y.expr.length === 2 && y.expr[0].type === "const" && y.expr[0].const === "0" && y.expr[1].type === "const" && y.expr[1].const === "[1-9][0-9]*";
+}
+function IsBooleanExpression(y) {
+	return y.type === "or" && y.expr.length === 2 && y.expr[0].type === "const" && y.expr[0].const === "true" && y.expr[1].type === "const" && y.expr[1].const === "false";
+}
+function IsStringExpression(y) {
+	return y.type === "const" && y.const === ".*";
+}
+function IsTemplateLiteralExpressionFinite(y) {
+	return IsNumberExpression(y) || IsStringExpression(y) ? !1 : IsBooleanExpression(y) ? !0 : y.type === "and" || y.type === "or" ? y.expr.every((y) => IsTemplateLiteralExpressionFinite(y)) : y.type === "const" ? !0 : (() => {
+		throw new TemplateLiteralFiniteError("Unknown expression type");
+	})();
+}
+function IsTemplateLiteralFinite(y) {
+	return IsTemplateLiteralExpressionFinite(TemplateLiteralParseExact(y.pattern));
+}
+var TemplateLiteralGenerateError = class extends TypeBoxError {};
+function* GenerateReduce(y) {
+	if (y.length === 1) return yield* y[0];
+	for (let J of y[0]) for (let Y of GenerateReduce(y.slice(1))) yield `${J}${Y}`;
+}
+function* GenerateAnd(y) {
+	return yield* GenerateReduce(y.expr.map((y) => [...TemplateLiteralExpressionGenerate(y)]));
+}
+function* GenerateOr(y) {
+	for (let J of y.expr) yield* TemplateLiteralExpressionGenerate(J);
+}
+function* GenerateConst(y) {
+	return yield y.const;
+}
+function* TemplateLiteralExpressionGenerate(y) {
+	return y.type === "and" ? yield* GenerateAnd(y) : y.type === "or" ? yield* GenerateOr(y) : y.type === "const" ? yield* GenerateConst(y) : (() => {
+		throw new TemplateLiteralGenerateError("Unknown expression");
+	})();
+}
+function TemplateLiteralGenerate(y) {
+	let J = TemplateLiteralParseExact(y.pattern);
+	return IsTemplateLiteralExpressionFinite(J) ? [...TemplateLiteralExpressionGenerate(J)] : [];
+}
+function Literal(y, J) {
+	return CreateType({
+		[Kind]: "Literal",
+		const: y,
+		type: typeof y
+	}, J);
+}
+function Boolean(y) {
+	return CreateType({
+		[Kind]: "Boolean",
+		type: "boolean"
+	}, y);
+}
+function BigInt(y) {
+	return CreateType({
+		[Kind]: "BigInt",
+		type: "bigint"
+	}, y);
+}
+function Number$1(y) {
+	return CreateType({
+		[Kind]: "Number",
+		type: "number"
+	}, y);
+}
+function String(y) {
+	return CreateType({
+		[Kind]: "String",
+		type: "string"
+	}, y);
+}
+function* FromUnion$9(y) {
+	let J = y.trim().replace(/"|'/g, "");
+	return J === "boolean" ? yield Boolean() : J === "number" ? yield Number$1() : J === "bigint" ? yield BigInt() : J === "string" ? yield String() : yield (() => {
+		let y = J.split("|").map((y) => Literal(y.trim()));
+		return y.length === 0 ? Never() : y.length === 1 ? y[0] : UnionEvaluated(y);
+	})();
+}
+function* FromTerminal(y) {
+	if (y[1] !== "{") return yield* [Literal("$"), ...FromSyntax(y.slice(1))];
+	for (let J = 2; J < y.length; J++) if (y[J] === "}") {
+		let Y = FromUnion$9(y.slice(2, J)), X = FromSyntax(y.slice(J + 1));
+		return yield* [...Y, ...X];
+	}
+	yield Literal(y);
+}
+function* FromSyntax(y) {
+	for (let J = 0; J < y.length; J++) if (y[J] === "$") return yield* [Literal(y.slice(0, J)), ...FromTerminal(y.slice(J))];
+	yield Literal(y);
+}
+function TemplateLiteralSyntax(y) {
+	return [...FromSyntax(y)];
+}
+var TemplateLiteralPatternError = class extends TypeBoxError {};
+function Escape(y) {
+	return y.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function Visit$1(y, J) {
+	return IsTemplateLiteral(y) ? y.pattern.slice(1, y.pattern.length - 1) : IsUnion(y) ? `(${y.anyOf.map((y) => Visit$1(y, J)).join("|")})` : IsNumber(y) || IsInteger(y) || IsBigInt$1(y) ? `${J}${PatternNumber}` : IsString$1(y) ? `${J}${PatternString}` : IsLiteral(y) ? `${J}${Escape(y.const.toString())}` : IsBoolean(y) ? `${J}${PatternBoolean}` : (() => {
+		throw new TemplateLiteralPatternError(`Unexpected Kind '${y[Kind]}'`);
+	})();
+}
+function TemplateLiteralPattern(y) {
+	return `^${y.map((y) => Visit$1(y, "")).join("")}\$`;
+}
+function TemplateLiteralToUnion(y) {
+	return UnionEvaluated(TemplateLiteralGenerate(y).map((y) => Literal(y)));
+}
+function TemplateLiteral(y, J) {
+	let Y = IsString(y) ? TemplateLiteralPattern(TemplateLiteralSyntax(y)) : TemplateLiteralPattern(y);
+	return CreateType({
+		[Kind]: "TemplateLiteral",
+		type: "string",
+		pattern: Y
+	}, J);
+}
+function FromTemplateLiteral$2(y) {
+	return TemplateLiteralGenerate(y).map((y) => y.toString());
+}
+function FromUnion$8(y) {
+	let J = [];
+	for (let Y of y) J.push(...IndexPropertyKeys(Y));
+	return J;
+}
+function FromLiteral$1(y) {
+	return [y.toString()];
+}
+function IndexPropertyKeys(y) {
+	return [...new Set(IsTemplateLiteral(y) ? FromTemplateLiteral$2(y) : IsUnion(y) ? FromUnion$8(y.anyOf) : IsLiteral(y) ? FromLiteral$1(y.const) : IsNumber(y) || IsInteger(y) ? ["[number]"] : [])];
+}
+function FromProperties$18(y, J, Y) {
+	let X = {};
+	for (let Z of Object.getOwnPropertyNames(J)) X[Z] = Index(y, IndexPropertyKeys(J[Z]), Y);
+	return X;
+}
+function FromMappedResult$11(y, J, Y) {
+	return FromProperties$18(y, J.properties, Y);
+}
+function IndexFromMappedResult(y, J, Y) {
+	return MappedResult(FromMappedResult$11(y, J, Y));
+}
+function FromRest$6(y, J) {
+	return y.map((y) => IndexFromPropertyKey(y, J));
+}
+function FromIntersectRest(y) {
+	return y.filter((y) => !IsNever(y));
+}
+function FromIntersect$7(y, J) {
+	return IntersectEvaluated(FromIntersectRest(FromRest$6(y, J)));
+}
+function FromUnionRest(y) {
+	return y.some((y) => IsNever(y)) ? [] : y;
+}
+function FromUnion$7(y, J) {
+	return UnionEvaluated(FromUnionRest(FromRest$6(y, J)));
+}
+function FromTuple$4(y, J) {
+	return J in y ? y[J] : J === "[number]" ? UnionEvaluated(y) : Never();
+}
+function FromArray$5(y, J) {
+	return J === "[number]" ? y : Never();
+}
+function FromProperty$2(y, J) {
+	return J in y ? y[J] : Never();
+}
+function IndexFromPropertyKey(y, J) {
+	return IsIntersect(y) ? FromIntersect$7(y.allOf, J) : IsUnion(y) ? FromUnion$7(y.anyOf, J) : IsTuple(y) ? FromTuple$4(y.items ?? [], J) : IsArray$1(y) ? FromArray$5(y.items, J) : IsObject(y) ? FromProperty$2(y.properties, J) : Never();
+}
+function IndexFromPropertyKeys(y, J) {
+	return J.map((J) => IndexFromPropertyKey(y, J));
+}
+function FromSchema(y, J) {
+	return UnionEvaluated(IndexFromPropertyKeys(y, J));
+}
+function Index(y, J, Y) {
+	if (IsRef(y) || IsRef(J)) {
+		if (!IsSchema(y) || !IsSchema(J)) throw new TypeBoxError("Index types using Ref parameters require both Type and Key to be of TSchema");
+		return Computed("Index", [y, J]);
+	}
+	return IsMappedResult(J) ? IndexFromMappedResult(y, J, Y) : IsMappedKey(J) ? IndexFromMappedKey(y, J, Y) : CreateType(IsSchema(J) ? FromSchema(y, IndexPropertyKeys(J)) : FromSchema(y, J), Y);
+}
+function MappedIndexPropertyKey(y, J, Y) {
+	return { [J]: Index(y, [J], Clone(Y)) };
+}
+function MappedIndexPropertyKeys(y, J, Y) {
+	return J.reduce((J, X) => ({
+		...J,
+		...MappedIndexPropertyKey(y, X, Y)
+	}), {});
+}
+function MappedIndexProperties(y, J, Y) {
+	return MappedIndexPropertyKeys(y, J.keys, Y);
+}
+function IndexFromMappedKey(y, J, Y) {
+	return MappedResult(MappedIndexProperties(y, J, Y));
+}
+function Iterator(y, J) {
+	return CreateType({
+		[Kind]: "Iterator",
+		type: "Iterator",
+		items: y
+	}, J);
+}
+function RequiredArray(y) {
+	return globalThis.Object.keys(y).filter((J) => !IsOptional(y[J]));
+}
+function _Object(y, J) {
+	let Y = RequiredArray(y);
+	return CreateType(Y.length > 0 ? {
+		[Kind]: "Object",
+		type: "object",
+		required: Y,
+		properties: y
+	} : {
+		[Kind]: "Object",
+		type: "object",
+		properties: y
+	}, J);
+}
+var Object$1 = _Object;
+function Promise$1(y, J) {
+	return CreateType({
+		[Kind]: "Promise",
+		type: "Promise",
+		item: y
+	}, J);
+}
+function RemoveReadonly(y) {
+	return CreateType(Discard(y, [ReadonlyKind]));
+}
+function AddReadonly(y) {
+	return CreateType({
+		...y,
+		[ReadonlyKind]: "Readonly"
+	});
+}
+function ReadonlyWithFlag(y, J) {
+	return J === !1 ? RemoveReadonly(y) : AddReadonly(y);
+}
+function Readonly(y, J) {
+	let Y = J ?? !0;
+	return IsMappedResult(y) ? ReadonlyFromMappedResult(y, Y) : ReadonlyWithFlag(y, Y);
+}
+function FromProperties$17(y, J) {
+	let Y = {};
+	for (let X of globalThis.Object.getOwnPropertyNames(y)) Y[X] = Readonly(y[X], J);
+	return Y;
+}
+function FromMappedResult$10(y, J) {
+	return FromProperties$17(y.properties, J);
+}
+function ReadonlyFromMappedResult(y, J) {
+	return MappedResult(FromMappedResult$10(y, J));
+}
+function Tuple(y, J) {
+	return CreateType(y.length > 0 ? {
+		[Kind]: "Tuple",
+		type: "array",
+		items: y,
+		additionalItems: !1,
+		minItems: y.length,
+		maxItems: y.length
+	} : {
+		[Kind]: "Tuple",
+		type: "array",
+		minItems: y.length,
+		maxItems: y.length
+	}, J);
+}
+function FromMappedResult$9(y, J) {
+	return y in J ? FromSchemaType(y, J[y]) : MappedResult(J);
+}
+function MappedKeyToKnownMappedResultProperties(y) {
+	return { [y]: Literal(y) };
+}
+function MappedKeyToUnknownMappedResultProperties(y) {
+	let J = {};
+	for (let Y of y) J[Y] = Literal(Y);
+	return J;
+}
+function MappedKeyToMappedResultProperties(y, J) {
+	return SetIncludes(J, y) ? MappedKeyToKnownMappedResultProperties(y) : MappedKeyToUnknownMappedResultProperties(J);
+}
+function FromMappedKey$3(y, J) {
+	return FromMappedResult$9(y, MappedKeyToMappedResultProperties(y, J));
+}
+function FromRest$5(y, J) {
+	return J.map((J) => FromSchemaType(y, J));
+}
+function FromProperties$16(y, J) {
+	let Y = {};
+	for (let X of globalThis.Object.getOwnPropertyNames(J)) Y[X] = FromSchemaType(y, J[X]);
+	return Y;
+}
+function FromSchemaType(y, J) {
+	let Y = { ...J };
+	return IsOptional(J) ? Optional(FromSchemaType(y, Discard(J, [OptionalKind]))) : IsReadonly(J) ? Readonly(FromSchemaType(y, Discard(J, [ReadonlyKind]))) : IsMappedResult(J) ? FromMappedResult$9(y, J.properties) : IsMappedKey(J) ? FromMappedKey$3(y, J.keys) : IsConstructor(J) ? Constructor(FromRest$5(y, J.parameters), FromSchemaType(y, J.returns), Y) : IsFunction$1(J) ? Function(FromRest$5(y, J.parameters), FromSchemaType(y, J.returns), Y) : IsAsyncIterator$1(J) ? AsyncIterator(FromSchemaType(y, J.items), Y) : IsIterator$1(J) ? Iterator(FromSchemaType(y, J.items), Y) : IsIntersect(J) ? Intersect(FromRest$5(y, J.allOf), Y) : IsUnion(J) ? Union(FromRest$5(y, J.anyOf), Y) : IsTuple(J) ? Tuple(FromRest$5(y, J.items ?? []), Y) : IsObject(J) ? Object$1(FromProperties$16(y, J.properties), Y) : IsArray$1(J) ? Array$1(FromSchemaType(y, J.items), Y) : IsPromise(J) ? Promise$1(FromSchemaType(y, J.item), Y) : J;
+}
+function MappedFunctionReturnType(y, J) {
+	let Y = {};
+	for (let X of y) Y[X] = FromSchemaType(X, J);
+	return Y;
+}
+function Mapped(y, J, Y) {
+	let X = IsSchema(y) ? IndexPropertyKeys(y) : y;
+	return Object$1(MappedFunctionReturnType(X, J({
+		[Kind]: "MappedKey",
+		keys: X
+	})), Y);
+}
+function RemoveOptional(y) {
+	return CreateType(Discard(y, [OptionalKind]));
+}
+function AddOptional(y) {
+	return CreateType({
+		...y,
+		[OptionalKind]: "Optional"
+	});
+}
+function OptionalWithFlag(y, J) {
+	return J === !1 ? RemoveOptional(y) : AddOptional(y);
+}
+function Optional(y, J) {
+	let Y = J ?? !0;
+	return IsMappedResult(y) ? OptionalFromMappedResult(y, Y) : OptionalWithFlag(y, Y);
+}
+function FromProperties$15(y, J) {
+	let Y = {};
+	for (let X of globalThis.Object.getOwnPropertyNames(y)) Y[X] = Optional(y[X], J);
+	return Y;
+}
+function FromMappedResult$8(y, J) {
+	return FromProperties$15(y.properties, J);
+}
+function OptionalFromMappedResult(y, J) {
+	return MappedResult(FromMappedResult$8(y, J));
+}
+function IntersectCreate(y, J = {}) {
+	let Y = y.every((y) => IsObject(y)), X = IsSchema(J.unevaluatedProperties) ? { unevaluatedProperties: J.unevaluatedProperties } : {};
+	return CreateType(J.unevaluatedProperties === !1 || IsSchema(J.unevaluatedProperties) || Y ? {
+		...X,
+		[Kind]: "Intersect",
+		type: "object",
+		allOf: y
+	} : {
+		...X,
+		[Kind]: "Intersect",
+		allOf: y
+	}, J);
+}
+function IsIntersectOptional(y) {
+	return y.every((y) => IsOptional(y));
+}
+function RemoveOptionalFromType(y) {
+	return Discard(y, [OptionalKind]);
+}
+function RemoveOptionalFromRest(y) {
+	return y.map((y) => IsOptional(y) ? RemoveOptionalFromType(y) : y);
+}
+function ResolveIntersect(y, J) {
+	return IsIntersectOptional(y) ? Optional(IntersectCreate(RemoveOptionalFromRest(y), J)) : IntersectCreate(RemoveOptionalFromRest(y), J);
+}
+function IntersectEvaluated(y, J = {}) {
+	if (y.length === 1) return CreateType(y[0], J);
+	if (y.length === 0) return Never(J);
+	if (y.some((y) => IsTransform(y))) throw Error("Cannot intersect transform types");
+	return ResolveIntersect(y, J);
+}
+function Intersect(y, J) {
+	if (y.length === 1) return CreateType(y[0], J);
+	if (y.length === 0) return Never(J);
+	if (y.some((y) => IsTransform(y))) throw Error("Cannot intersect transform types");
+	return IntersectCreate(y, J);
+}
+function Ref(...y) {
+	let [J, Y] = typeof y[0] == "string" ? [y[0], y[1]] : [y[0].$id, y[1]];
+	if (typeof J != "string") throw new TypeBoxError("Ref: $ref must be a string");
+	return CreateType({
+		[Kind]: "Ref",
+		$ref: J
+	}, Y);
+}
+function FromComputed$4(y, J) {
+	return Computed("Awaited", [Computed(y, J)]);
+}
+function FromRef$3(y) {
+	return Computed("Awaited", [Ref(y)]);
+}
+function FromIntersect$6(y) {
+	return Intersect(FromRest$4(y));
+}
+function FromUnion$6(y) {
+	return Union(FromRest$4(y));
+}
+function FromPromise$2(y) {
+	return Awaited(y);
+}
+function FromRest$4(y) {
+	return y.map((y) => Awaited(y));
+}
+function Awaited(y, J) {
+	return CreateType(IsComputed(y) ? FromComputed$4(y.target, y.parameters) : IsIntersect(y) ? FromIntersect$6(y.allOf) : IsUnion(y) ? FromUnion$6(y.anyOf) : IsPromise(y) ? FromPromise$2(y.item) : IsRef(y) ? FromRef$3(y.$ref) : y, J);
+}
+function FromRest$3(y) {
+	let J = [];
+	for (let Y of y) J.push(KeyOfPropertyKeys(Y));
+	return J;
+}
+function FromIntersect$5(y) {
+	return SetUnionMany(FromRest$3(y));
+}
+function FromUnion$5(y) {
+	return SetIntersectMany(FromRest$3(y));
+}
+function FromTuple$3(y) {
+	return y.map((y, J) => J.toString());
+}
+function FromArray$4(y) {
+	return ["[number]"];
+}
+function FromProperties$14(y) {
+	return globalThis.Object.getOwnPropertyNames(y);
+}
+function FromPatternProperties(y) {
+	return includePatternProperties ? globalThis.Object.getOwnPropertyNames(y).map((y) => y[0] === "^" && y[y.length - 1] === "$" ? y.slice(1, y.length - 1) : y) : [];
+}
+function KeyOfPropertyKeys(y) {
+	return IsIntersect(y) ? FromIntersect$5(y.allOf) : IsUnion(y) ? FromUnion$5(y.anyOf) : IsTuple(y) ? FromTuple$3(y.items ?? []) : IsArray$1(y) ? FromArray$4(y.items) : IsObject(y) ? FromProperties$14(y.properties) : IsRecord(y) ? FromPatternProperties(y.patternProperties) : [];
+}
+var includePatternProperties = !1;
+function FromComputed$3(y, J) {
+	return Computed("KeyOf", [Computed(y, J)]);
+}
+function FromRef$2(y) {
+	return Computed("KeyOf", [Ref(y)]);
+}
+function KeyOfFromType(y, J) {
+	return CreateType(UnionEvaluated(KeyOfPropertyKeysToRest(KeyOfPropertyKeys(y))), J);
+}
+function KeyOfPropertyKeysToRest(y) {
+	return y.map((y) => y === "[number]" ? Number$1() : Literal(y));
+}
+function KeyOf(y, J) {
+	return IsComputed(y) ? FromComputed$3(y.target, y.parameters) : IsRef(y) ? FromRef$2(y.$ref) : IsMappedResult(y) ? KeyOfFromMappedResult(y, J) : KeyOfFromType(y, J);
+}
+function FromProperties$13(y, J) {
+	let Y = {};
+	for (let X of globalThis.Object.getOwnPropertyNames(y)) Y[X] = KeyOf(y[X], Clone(J));
+	return Y;
+}
+function FromMappedResult$7(y, J) {
+	return FromProperties$13(y.properties, J);
+}
+function KeyOfFromMappedResult(y, J) {
+	return MappedResult(FromMappedResult$7(y, J));
+}
+function CompositeKeys(y) {
+	let J = [];
+	for (let Y of y) J.push(...KeyOfPropertyKeys(Y));
+	return SetDistinct(J);
+}
+function FilterNever(y) {
+	return y.filter((y) => !IsNever(y));
+}
+function CompositeProperty(y, J) {
+	let Y = [];
+	for (let X of y) Y.push(...IndexFromPropertyKeys(X, [J]));
+	return FilterNever(Y);
+}
+function CompositeProperties(y, J) {
+	let Y = {};
+	for (let X of J) Y[X] = IntersectEvaluated(CompositeProperty(y, X));
+	return Y;
+}
+function Composite(y, J) {
+	return Object$1(CompositeProperties(y, CompositeKeys(y)), J);
+}
+function Date$1(y) {
+	return CreateType({
+		[Kind]: "Date",
+		type: "Date"
+	}, y);
+}
+function Null(y) {
+	return CreateType({
+		[Kind]: "Null",
+		type: "null"
+	}, y);
+}
+function Symbol$1(y) {
+	return CreateType({
+		[Kind]: "Symbol",
+		type: "symbol"
+	}, y);
+}
+function Undefined(y) {
+	return CreateType({
+		[Kind]: "Undefined",
+		type: "undefined"
+	}, y);
+}
+function Uint8Array$1(y) {
+	return CreateType({
+		[Kind]: "Uint8Array",
+		type: "Uint8Array"
+	}, y);
+}
+function Unknown(y) {
+	return CreateType({ [Kind]: "Unknown" }, y);
+}
+function FromArray$3(y) {
+	return y.map((y) => FromValue(y, !1));
+}
+function FromProperties$12(y) {
+	let J = {};
+	for (let Y of globalThis.Object.getOwnPropertyNames(y)) J[Y] = Readonly(FromValue(y[Y], !1));
+	return J;
+}
+function ConditionalReadonly(y, J) {
+	return J === !0 ? y : Readonly(y);
+}
+function FromValue(y, J) {
+	return IsAsyncIterator(y) || IsIterator(y) ? ConditionalReadonly(Any(), J) : IsArray(y) ? Readonly(Tuple(FromArray$3(y))) : IsUint8Array(y) ? Uint8Array$1() : IsDate(y) ? Date$1() : IsObject$1(y) ? ConditionalReadonly(Object$1(FromProperties$12(y)), J) : IsFunction(y) ? ConditionalReadonly(Function([], Unknown()), J) : IsUndefined(y) ? Undefined() : IsNull(y) ? Null() : IsSymbol(y) ? Symbol$1() : IsBigInt(y) ? BigInt() : IsNumber$1(y) || IsBoolean$1(y) || IsString(y) ? Literal(y) : Object$1({});
+}
+function Const(y, J) {
+	return CreateType(FromValue(y, !0), J);
+}
+function ConstructorParameters(y, J) {
+	return IsConstructor(y) ? Tuple(y.parameters, J) : Never(J);
+}
+function Enum(y, J) {
+	if (IsUndefined(y)) throw Error("Enum undefined or empty");
+	let Y = globalThis.Object.getOwnPropertyNames(y).filter((y) => isNaN(y)).map((J) => y[J]);
+	return Union([...new Set(Y)].map((y) => Literal(y)), {
+		...J,
+		[Hint]: "Enum"
+	});
+}
+var ExtendsResolverError = class extends TypeBoxError {}, ExtendsResult;
+(function(y) {
+	y[y.Union = 0] = "Union", y[y.True = 1] = "True", y[y.False = 2] = "False";
+})(ExtendsResult ||= {});
+function IntoBooleanResult(y) {
+	return y === ExtendsResult.False ? y : ExtendsResult.True;
+}
+function Throw(y) {
+	throw new ExtendsResolverError(y);
+}
+function IsStructuralRight(y) {
+	return IsNever$1(y) || IsIntersect$1(y) || IsUnion$1(y) || IsUnknown(y) || IsAny$1(y);
+}
+function StructuralRight(y, J) {
+	return IsNever$1(J) ? FromNeverRight(y, J) : IsIntersect$1(J) ? FromIntersectRight(y, J) : IsUnion$1(J) ? FromUnionRight(y, J) : IsUnknown(J) ? FromUnknownRight(y, J) : IsAny$1(J) ? FromAnyRight(y, J) : Throw("StructuralRight");
+}
+function FromAnyRight(y, J) {
+	return ExtendsResult.True;
+}
+function FromAny(y, J) {
+	return IsIntersect$1(J) ? FromIntersectRight(y, J) : IsUnion$1(J) && J.anyOf.some((y) => IsAny$1(y) || IsUnknown(y)) ? ExtendsResult.True : IsUnion$1(J) ? ExtendsResult.Union : IsUnknown(J) || IsAny$1(J) ? ExtendsResult.True : ExtendsResult.Union;
+}
+function FromArrayRight(y, J) {
+	return IsUnknown(y) ? ExtendsResult.False : IsAny$1(y) ? ExtendsResult.Union : IsNever$1(y) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromArray$2(y, J) {
+	return IsObject$2(J) && IsObjectArrayLike(J) ? ExtendsResult.True : IsStructuralRight(J) ? StructuralRight(y, J) : IsArray$2(J) ? IntoBooleanResult(Visit(y.items, J.items)) : ExtendsResult.False;
+}
+function FromAsyncIterator$2(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsAsyncIterator$2(J) ? IntoBooleanResult(Visit(y.items, J.items)) : ExtendsResult.False;
+}
+function FromBigInt(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : IsBigInt$2(J) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromBooleanRight(y, J) {
+	return IsLiteralBoolean(y) || IsBoolean$2(y) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromBoolean(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : IsBoolean$2(J) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromConstructor$2(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsConstructor$1(J) ? y.parameters.length > J.parameters.length ? ExtendsResult.False : y.parameters.every((y, Y) => IntoBooleanResult(Visit(J.parameters[Y], y)) === ExtendsResult.True) ? IntoBooleanResult(Visit(y.returns, J.returns)) : ExtendsResult.False : ExtendsResult.False;
+}
+function FromDate(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : IsDate$1(J) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromFunction$2(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsFunction$2(J) ? y.parameters.length > J.parameters.length ? ExtendsResult.False : y.parameters.every((y, Y) => IntoBooleanResult(Visit(J.parameters[Y], y)) === ExtendsResult.True) ? IntoBooleanResult(Visit(y.returns, J.returns)) : ExtendsResult.False : ExtendsResult.False;
+}
+function FromIntegerRight(y, J) {
+	return IsLiteral$1(y) && IsNumber$1(y.const) || IsNumber$2(y) || IsInteger$1(y) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromInteger(y, J) {
+	return IsInteger$1(J) || IsNumber$2(J) ? ExtendsResult.True : IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : ExtendsResult.False;
+}
+function FromIntersectRight(y, J) {
+	return J.allOf.every((J) => Visit(y, J) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromIntersect$4(y, J) {
+	return y.allOf.some((y) => Visit(y, J) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromIterator$2(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsIterator$2(J) ? IntoBooleanResult(Visit(y.items, J.items)) : ExtendsResult.False;
+}
+function FromLiteral(y, J) {
+	return IsLiteral$1(J) && J.const === y.const ? ExtendsResult.True : IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : IsString$2(J) ? FromStringRight(y, J) : IsNumber$2(J) ? FromNumberRight(y, J) : IsInteger$1(J) ? FromIntegerRight(y, J) : IsBoolean$2(J) ? FromBooleanRight(y, J) : ExtendsResult.False;
+}
+function FromNeverRight(y, J) {
+	return ExtendsResult.False;
+}
+function FromNever(y, J) {
+	return ExtendsResult.True;
+}
+function UnwrapTNot(y) {
+	let [J, Y] = [y, 0];
+	for (; IsNot(J);) J = J.not, Y += 1;
+	return Y % 2 == 0 ? J : Unknown();
+}
+function FromNot(y, J) {
+	return IsNot(y) ? Visit(UnwrapTNot(y), J) : IsNot(J) ? Visit(y, UnwrapTNot(J)) : Throw("Invalid fallthrough for Not");
+}
+function FromNull(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : IsNull$1(J) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumberRight(y, J) {
+	return IsLiteralNumber(y) || IsNumber$2(y) || IsInteger$1(y) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumber(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : IsInteger$1(J) || IsNumber$2(J) ? ExtendsResult.True : ExtendsResult.False;
+}
+function IsObjectPropertyCount(y, J) {
+	return Object.getOwnPropertyNames(y.properties).length === J;
+}
+function IsObjectStringLike(y) {
+	return IsObjectArrayLike(y);
+}
+function IsObjectSymbolLike(y) {
+	return IsObjectPropertyCount(y, 0) || IsObjectPropertyCount(y, 1) && "description" in y.properties && IsUnion$1(y.properties.description) && y.properties.description.anyOf.length === 2 && (IsString$2(y.properties.description.anyOf[0]) && IsUndefined$1(y.properties.description.anyOf[1]) || IsString$2(y.properties.description.anyOf[1]) && IsUndefined$1(y.properties.description.anyOf[0]));
+}
+function IsObjectNumberLike(y) {
+	return IsObjectPropertyCount(y, 0);
+}
+function IsObjectBooleanLike(y) {
+	return IsObjectPropertyCount(y, 0);
+}
+function IsObjectBigIntLike(y) {
+	return IsObjectPropertyCount(y, 0);
+}
+function IsObjectDateLike(y) {
+	return IsObjectPropertyCount(y, 0);
+}
+function IsObjectUint8ArrayLike(y) {
+	return IsObjectArrayLike(y);
+}
+function IsObjectFunctionLike(y) {
+	let J = Number$1();
+	return IsObjectPropertyCount(y, 0) || IsObjectPropertyCount(y, 1) && "length" in y.properties && IntoBooleanResult(Visit(y.properties.length, J)) === ExtendsResult.True;
+}
+function IsObjectConstructorLike(y) {
+	return IsObjectPropertyCount(y, 0);
+}
+function IsObjectArrayLike(y) {
+	let J = Number$1();
+	return IsObjectPropertyCount(y, 0) || IsObjectPropertyCount(y, 1) && "length" in y.properties && IntoBooleanResult(Visit(y.properties.length, J)) === ExtendsResult.True;
+}
+function IsObjectPromiseLike(y) {
+	let J = Function([Any()], Any());
+	return IsObjectPropertyCount(y, 0) || IsObjectPropertyCount(y, 1) && "then" in y.properties && IntoBooleanResult(Visit(y.properties.then, J)) === ExtendsResult.True;
+}
+function Property(y, J) {
+	return Visit(y, J) === ExtendsResult.False || IsOptional$1(y) && !IsOptional$1(J) ? ExtendsResult.False : ExtendsResult.True;
+}
+function FromObjectRight(y, J) {
+	return IsUnknown(y) ? ExtendsResult.False : IsAny$1(y) ? ExtendsResult.Union : IsNever$1(y) || IsLiteralString(y) && IsObjectStringLike(J) || IsLiteralNumber(y) && IsObjectNumberLike(J) || IsLiteralBoolean(y) && IsObjectBooleanLike(J) || IsSymbol$1(y) && IsObjectSymbolLike(J) || IsBigInt$2(y) && IsObjectBigIntLike(J) || IsString$2(y) && IsObjectStringLike(J) || IsSymbol$1(y) && IsObjectSymbolLike(J) || IsNumber$2(y) && IsObjectNumberLike(J) || IsInteger$1(y) && IsObjectNumberLike(J) || IsBoolean$2(y) && IsObjectBooleanLike(J) || IsUint8Array$1(y) && IsObjectUint8ArrayLike(J) || IsDate$1(y) && IsObjectDateLike(J) || IsConstructor$1(y) && IsObjectConstructorLike(J) || IsFunction$2(y) && IsObjectFunctionLike(J) ? ExtendsResult.True : IsRecord$1(y) && IsString$2(RecordKey$1(y)) ? (() => J[Hint] === "Record" ? ExtendsResult.True : ExtendsResult.False)() : IsRecord$1(y) && IsNumber$2(RecordKey$1(y)) ? (() => IsObjectPropertyCount(J, 0) ? ExtendsResult.True : ExtendsResult.False)() : ExtendsResult.False;
+}
+function FromObject$6(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : IsObject$2(J) ? (() => {
+		for (let Y of Object.getOwnPropertyNames(J.properties)) {
+			if (!(Y in y.properties) && !IsOptional$1(J.properties[Y])) return ExtendsResult.False;
+			if (IsOptional$1(J.properties[Y])) return ExtendsResult.True;
+			if (Property(y.properties[Y], J.properties[Y]) === ExtendsResult.False) return ExtendsResult.False;
+		}
+		return ExtendsResult.True;
+	})() : ExtendsResult.False;
+}
+function FromPromise$1(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) && IsObjectPromiseLike(J) ? ExtendsResult.True : IsPromise$1(J) ? IntoBooleanResult(Visit(y.item, J.item)) : ExtendsResult.False;
+}
+function RecordKey$1(y) {
+	return PatternNumberExact in y.patternProperties ? Number$1() : PatternStringExact in y.patternProperties ? String() : Throw("Unknown record key pattern");
+}
+function RecordValue$1(y) {
+	return PatternNumberExact in y.patternProperties ? y.patternProperties[PatternNumberExact] : PatternStringExact in y.patternProperties ? y.patternProperties[PatternStringExact] : Throw("Unable to get record value schema");
+}
+function FromRecordRight(y, J) {
+	let [Y, X] = [RecordKey$1(J), RecordValue$1(J)];
+	return IsLiteralString(y) && IsNumber$2(Y) && IntoBooleanResult(Visit(y, X)) === ExtendsResult.True ? ExtendsResult.True : IsUint8Array$1(y) && IsNumber$2(Y) || IsString$2(y) && IsNumber$2(Y) || IsArray$2(y) && IsNumber$2(Y) ? Visit(y, X) : IsObject$2(y) ? (() => {
+		for (let J of Object.getOwnPropertyNames(y.properties)) if (Property(X, y.properties[J]) === ExtendsResult.False) return ExtendsResult.False;
+		return ExtendsResult.True;
+	})() : ExtendsResult.False;
+}
+function FromRecord$2(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? Visit(RecordValue$1(y), RecordValue$1(J)) : ExtendsResult.False;
+}
+function FromRegExp(y, J) {
+	return Visit(IsRegExp$1(y) ? String() : y, IsRegExp$1(J) ? String() : J);
+}
+function FromStringRight(y, J) {
+	return IsLiteral$1(y) && IsString(y.const) || IsString$2(y) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromString(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : IsString$2(J) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromSymbol(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : IsSymbol$1(J) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromTemplateLiteral$1(y, J) {
+	return IsTemplateLiteral$1(y) ? Visit(TemplateLiteralToUnion(y), J) : IsTemplateLiteral$1(J) ? Visit(y, TemplateLiteralToUnion(J)) : Throw("Invalid fallthrough for TemplateLiteral");
+}
+function IsArrayOfTuple(y, J) {
+	return IsArray$2(J) && y.items !== void 0 && y.items.every((y) => Visit(y, J.items) === ExtendsResult.True);
+}
+function FromTupleRight(y, J) {
+	return IsNever$1(y) ? ExtendsResult.True : IsUnknown(y) ? ExtendsResult.False : IsAny$1(y) ? ExtendsResult.Union : ExtendsResult.False;
+}
+function FromTuple$2(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) && IsObjectArrayLike(J) || IsArray$2(J) && IsArrayOfTuple(y, J) ? ExtendsResult.True : IsTuple$1(J) ? IsUndefined(y.items) && !IsUndefined(J.items) || !IsUndefined(y.items) && IsUndefined(J.items) ? ExtendsResult.False : IsUndefined(y.items) && !IsUndefined(J.items) || y.items.every((y, Y) => Visit(y, J.items[Y]) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False : ExtendsResult.False;
+}
+function FromUint8Array(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : IsUint8Array$1(J) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUndefined(y, J) {
+	return IsStructuralRight(J) ? StructuralRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsRecord$1(J) ? FromRecordRight(y, J) : IsVoid(J) ? FromVoidRight(y, J) : IsUndefined$1(J) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnionRight(y, J) {
+	return J.anyOf.some((J) => Visit(y, J) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnion$4(y, J) {
+	return y.anyOf.every((y) => Visit(y, J) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnknownRight(y, J) {
+	return ExtendsResult.True;
+}
+function FromUnknown(y, J) {
+	return IsNever$1(J) ? FromNeverRight(y, J) : IsIntersect$1(J) ? FromIntersectRight(y, J) : IsUnion$1(J) ? FromUnionRight(y, J) : IsAny$1(J) ? FromAnyRight(y, J) : IsString$2(J) ? FromStringRight(y, J) : IsNumber$2(J) ? FromNumberRight(y, J) : IsInteger$1(J) ? FromIntegerRight(y, J) : IsBoolean$2(J) ? FromBooleanRight(y, J) : IsArray$2(J) ? FromArrayRight(y, J) : IsTuple$1(J) ? FromTupleRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsUnknown(J) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoidRight(y, J) {
+	return IsUndefined$1(y) || IsUndefined$1(y) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoid(y, J) {
+	return IsIntersect$1(J) ? FromIntersectRight(y, J) : IsUnion$1(J) ? FromUnionRight(y, J) : IsUnknown(J) ? FromUnknownRight(y, J) : IsAny$1(J) ? FromAnyRight(y, J) : IsObject$2(J) ? FromObjectRight(y, J) : IsVoid(J) ? ExtendsResult.True : ExtendsResult.False;
+}
+function Visit(y, J) {
+	return IsTemplateLiteral$1(y) || IsTemplateLiteral$1(J) ? FromTemplateLiteral$1(y, J) : IsRegExp$1(y) || IsRegExp$1(J) ? FromRegExp(y, J) : IsNot(y) || IsNot(J) ? FromNot(y, J) : IsAny$1(y) ? FromAny(y, J) : IsArray$2(y) ? FromArray$2(y, J) : IsBigInt$2(y) ? FromBigInt(y, J) : IsBoolean$2(y) ? FromBoolean(y, J) : IsAsyncIterator$2(y) ? FromAsyncIterator$2(y, J) : IsConstructor$1(y) ? FromConstructor$2(y, J) : IsDate$1(y) ? FromDate(y, J) : IsFunction$2(y) ? FromFunction$2(y, J) : IsInteger$1(y) ? FromInteger(y, J) : IsIntersect$1(y) ? FromIntersect$4(y, J) : IsIterator$2(y) ? FromIterator$2(y, J) : IsLiteral$1(y) ? FromLiteral(y, J) : IsNever$1(y) ? FromNever(y, J) : IsNull$1(y) ? FromNull(y, J) : IsNumber$2(y) ? FromNumber(y, J) : IsObject$2(y) ? FromObject$6(y, J) : IsRecord$1(y) ? FromRecord$2(y, J) : IsString$2(y) ? FromString(y, J) : IsSymbol$1(y) ? FromSymbol(y, J) : IsTuple$1(y) ? FromTuple$2(y, J) : IsPromise$1(y) ? FromPromise$1(y, J) : IsUint8Array$1(y) ? FromUint8Array(y, J) : IsUndefined$1(y) ? FromUndefined(y, J) : IsUnion$1(y) ? FromUnion$4(y, J) : IsUnknown(y) ? FromUnknown(y, J) : IsVoid(y) ? FromVoid(y, J) : Throw(`Unknown left type operand '${y[Kind]}'`);
+}
+function ExtendsCheck(y, J) {
+	return Visit(y, J);
+}
+function FromProperties$11(y, J, Y, X, Z) {
+	let Q = {};
+	for (let $ of globalThis.Object.getOwnPropertyNames(y)) Q[$] = Extends(y[$], J, Y, X, Clone(Z));
+	return Q;
+}
+function FromMappedResult$6(y, J, Y, X, Z) {
+	return FromProperties$11(y.properties, J, Y, X, Z);
+}
+function ExtendsFromMappedResult(y, J, Y, X, Z) {
+	return MappedResult(FromMappedResult$6(y, J, Y, X, Z));
+}
+function ExtendsResolve(y, J, Y, X) {
+	let Z = ExtendsCheck(y, J);
+	return Z === ExtendsResult.Union ? Union([Y, X]) : Z === ExtendsResult.True ? Y : X;
+}
+function Extends(y, J, Y, X, Z) {
+	return IsMappedResult(y) ? ExtendsFromMappedResult(y, J, Y, X, Z) : IsMappedKey(y) ? CreateType(ExtendsFromMappedKey(y, J, Y, X, Z)) : CreateType(ExtendsResolve(y, J, Y, X), Z);
+}
+function FromPropertyKey$2(y, J, Y, X, Z) {
+	return { [y]: Extends(Literal(y), J, Y, X, Clone(Z)) };
+}
+function FromPropertyKeys$2(y, J, Y, X, Z) {
+	return y.reduce((y, Q) => ({
+		...y,
+		...FromPropertyKey$2(Q, J, Y, X, Z)
+	}), {});
+}
+function FromMappedKey$2(y, J, Y, X, Z) {
+	return FromPropertyKeys$2(y.keys, J, Y, X, Z);
+}
+function ExtendsFromMappedKey(y, J, Y, X, Z) {
+	return MappedResult(FromMappedKey$2(y, J, Y, X, Z));
+}
+function ExcludeFromTemplateLiteral(y, J) {
+	return Exclude(TemplateLiteralToUnion(y), J);
+}
+function ExcludeRest(y, J) {
+	let Y = y.filter((y) => ExtendsCheck(y, J) === ExtendsResult.False);
+	return Y.length === 1 ? Y[0] : Union(Y);
+}
+function Exclude(y, J, Y = {}) {
+	return IsTemplateLiteral(y) ? CreateType(ExcludeFromTemplateLiteral(y, J), Y) : IsMappedResult(y) ? CreateType(ExcludeFromMappedResult(y, J), Y) : CreateType(IsUnion(y) ? ExcludeRest(y.anyOf, J) : ExtendsCheck(y, J) === ExtendsResult.False ? y : Never(), Y);
+}
+function FromProperties$10(y, J) {
+	let Y = {};
+	for (let X of globalThis.Object.getOwnPropertyNames(y)) Y[X] = Exclude(y[X], J);
+	return Y;
+}
+function FromMappedResult$5(y, J) {
+	return FromProperties$10(y.properties, J);
+}
+function ExcludeFromMappedResult(y, J) {
+	return MappedResult(FromMappedResult$5(y, J));
+}
+function ExtractFromTemplateLiteral(y, J) {
+	return Extract(TemplateLiteralToUnion(y), J);
+}
+function ExtractRest(y, J) {
+	let Y = y.filter((y) => ExtendsCheck(y, J) !== ExtendsResult.False);
+	return Y.length === 1 ? Y[0] : Union(Y);
+}
+function Extract(y, J, Y) {
+	return IsTemplateLiteral(y) ? CreateType(ExtractFromTemplateLiteral(y, J), Y) : IsMappedResult(y) ? CreateType(ExtractFromMappedResult(y, J), Y) : CreateType(IsUnion(y) ? ExtractRest(y.anyOf, J) : ExtendsCheck(y, J) === ExtendsResult.False ? Never() : y, Y);
+}
+function FromProperties$9(y, J) {
+	let Y = {};
+	for (let X of globalThis.Object.getOwnPropertyNames(y)) Y[X] = Extract(y[X], J);
+	return Y;
+}
+function FromMappedResult$4(y, J) {
+	return FromProperties$9(y.properties, J);
+}
+function ExtractFromMappedResult(y, J) {
+	return MappedResult(FromMappedResult$4(y, J));
+}
+function InstanceType(y, J) {
+	return IsConstructor(y) ? CreateType(y.returns, J) : Never(J);
+}
+function ReadonlyOptional(y) {
+	return Readonly(Optional(y));
+}
+function RecordCreateFromPattern(y, J, Y) {
+	return CreateType({
+		[Kind]: "Record",
+		type: "object",
+		patternProperties: { [y]: J }
+	}, Y);
+}
+function RecordCreateFromKeys(y, J, Y) {
+	let X = {};
+	for (let Y of y) X[Y] = J;
+	return Object$1(X, {
+		...Y,
+		[Hint]: "Record"
+	});
+}
+function FromTemplateLiteralKey(y, J, Y) {
+	return IsTemplateLiteralFinite(y) ? RecordCreateFromKeys(IndexPropertyKeys(y), J, Y) : RecordCreateFromPattern(y.pattern, J, Y);
+}
+function FromUnionKey(y, J, Y) {
+	return RecordCreateFromKeys(IndexPropertyKeys(Union(y)), J, Y);
+}
+function FromLiteralKey(y, J, Y) {
+	return RecordCreateFromKeys([y.toString()], J, Y);
+}
+function FromRegExpKey(y, J, Y) {
+	return RecordCreateFromPattern(y.source, J, Y);
+}
+function FromStringKey(y, J, Y) {
+	return RecordCreateFromPattern(IsUndefined(y.pattern) ? PatternStringExact : y.pattern, J, Y);
+}
+function FromAnyKey(y, J, Y) {
+	return RecordCreateFromPattern(PatternStringExact, J, Y);
+}
+function FromNeverKey(y, J, Y) {
+	return RecordCreateFromPattern("^(?!.*)$", J, Y);
+}
+function FromBooleanKey(y, J, Y) {
+	return Object$1({
+		true: J,
+		false: J
+	}, Y);
+}
+function FromIntegerKey(y, J, Y) {
+	return RecordCreateFromPattern(PatternNumberExact, J, Y);
+}
+function FromNumberKey(y, J, Y) {
+	return RecordCreateFromPattern(PatternNumberExact, J, Y);
+}
+function Record(y, J, Y = {}) {
+	return IsUnion(y) ? FromUnionKey(y.anyOf, J, Y) : IsTemplateLiteral(y) ? FromTemplateLiteralKey(y, J, Y) : IsLiteral(y) ? FromLiteralKey(y.const, J, Y) : IsBoolean(y) ? FromBooleanKey(y, J, Y) : IsInteger(y) ? FromIntegerKey(y, J, Y) : IsNumber(y) ? FromNumberKey(y, J, Y) : IsRegExp(y) ? FromRegExpKey(y, J, Y) : IsString$1(y) ? FromStringKey(y, J, Y) : IsAny(y) ? FromAnyKey(y, J, Y) : IsNever(y) ? FromNeverKey(y, J, Y) : Never(Y);
+}
+function RecordPattern(y) {
+	return globalThis.Object.getOwnPropertyNames(y.patternProperties)[0];
+}
+function RecordKey(y) {
+	let J = RecordPattern(y);
+	return J === PatternStringExact ? String() : J === PatternNumberExact ? Number$1() : String({ pattern: J });
+}
+function RecordValue(y) {
+	return y.patternProperties[RecordPattern(y)];
+}
+function FromConstructor$1(y, J) {
+	return J.parameters = FromTypes$1(y, J.parameters), J.returns = FromType$1(y, J.returns), J;
+}
+function FromFunction$1(y, J) {
+	return J.parameters = FromTypes$1(y, J.parameters), J.returns = FromType$1(y, J.returns), J;
+}
+function FromIntersect$3(y, J) {
+	return J.allOf = FromTypes$1(y, J.allOf), J;
+}
+function FromUnion$3(y, J) {
+	return J.anyOf = FromTypes$1(y, J.anyOf), J;
+}
+function FromTuple$1(y, J) {
+	return IsUndefined(J.items) || (J.items = FromTypes$1(y, J.items)), J;
+}
+function FromArray$1(y, J) {
+	return J.items = FromType$1(y, J.items), J;
+}
+function FromAsyncIterator$1(y, J) {
+	return J.items = FromType$1(y, J.items), J;
+}
+function FromIterator$1(y, J) {
+	return J.items = FromType$1(y, J.items), J;
+}
+function FromPromise(y, J) {
+	return J.item = FromType$1(y, J.item), J;
+}
+function FromObject$5(y, J) {
+	let Y = FromProperties$8(y, J.properties);
+	return {
+		...J,
+		...Object$1(Y)
+	};
+}
+function FromRecord$1(y, J) {
+	let Y = Record(FromType$1(y, RecordKey(J)), FromType$1(y, RecordValue(J)));
+	return {
+		...J,
+		...Y
+	};
+}
+function FromArgument(y, J) {
+	return J.index in y ? y[J.index] : Unknown();
+}
+function FromProperty$1(y, J) {
+	let Y = IsReadonly(J), X = IsOptional(J), Z = FromType$1(y, J);
+	return Y && X ? ReadonlyOptional(Z) : Y && !X ? Readonly(Z) : !Y && X ? Optional(Z) : Z;
+}
+function FromProperties$8(y, J) {
+	return globalThis.Object.getOwnPropertyNames(J).reduce((Y, X) => ({
+		...Y,
+		[X]: FromProperty$1(y, J[X])
+	}), {});
+}
+function FromTypes$1(y, J) {
+	return J.map((J) => FromType$1(y, J));
+}
+function FromType$1(y, J) {
+	return IsConstructor(J) ? FromConstructor$1(y, J) : IsFunction$1(J) ? FromFunction$1(y, J) : IsIntersect(J) ? FromIntersect$3(y, J) : IsUnion(J) ? FromUnion$3(y, J) : IsTuple(J) ? FromTuple$1(y, J) : IsArray$1(J) ? FromArray$1(y, J) : IsAsyncIterator$1(J) ? FromAsyncIterator$1(y, J) : IsIterator$1(J) ? FromIterator$1(y, J) : IsPromise(J) ? FromPromise(y, J) : IsObject(J) ? FromObject$5(y, J) : IsRecord(J) ? FromRecord$1(y, J) : IsArgument$1(J) ? FromArgument(y, J) : J;
+}
+function Instantiate(y, J) {
+	return FromType$1(J, CloneType(y));
+}
+function Integer(y) {
+	return CreateType({
+		[Kind]: "Integer",
+		type: "integer"
+	}, y);
+}
+function MappedIntrinsicPropertyKey(y, J, Y) {
+	return { [y]: Intrinsic(Literal(y), J, Clone(Y)) };
+}
+function MappedIntrinsicPropertyKeys(y, J, Y) {
+	return y.reduce((y, X) => ({
+		...y,
+		...MappedIntrinsicPropertyKey(X, J, Y)
+	}), {});
+}
+function MappedIntrinsicProperties(y, J, Y) {
+	return MappedIntrinsicPropertyKeys(y.keys, J, Y);
+}
+function IntrinsicFromMappedKey(y, J, Y) {
+	return MappedResult(MappedIntrinsicProperties(y, J, Y));
+}
+function ApplyUncapitalize(y) {
+	let [J, Y] = [y.slice(0, 1), y.slice(1)];
+	return [J.toLowerCase(), Y].join("");
+}
+function ApplyCapitalize(y) {
+	let [J, Y] = [y.slice(0, 1), y.slice(1)];
+	return [J.toUpperCase(), Y].join("");
+}
+function ApplyUppercase(y) {
+	return y.toUpperCase();
+}
+function ApplyLowercase(y) {
+	return y.toLowerCase();
+}
+function FromTemplateLiteral(y, J, Y) {
+	let X = TemplateLiteralParseExact(y.pattern);
+	return IsTemplateLiteralExpressionFinite(X) ? TemplateLiteral([Union(FromRest$2([...TemplateLiteralExpressionGenerate(X)].map((y) => Literal(y)), J))], Y) : {
+		...y,
+		pattern: FromLiteralValue(y.pattern, J)
+	};
+}
+function FromLiteralValue(y, J) {
+	return typeof y == "string" ? J === "Uncapitalize" ? ApplyUncapitalize(y) : J === "Capitalize" ? ApplyCapitalize(y) : J === "Uppercase" ? ApplyUppercase(y) : J === "Lowercase" ? ApplyLowercase(y) : y : y.toString();
+}
+function FromRest$2(y, J) {
+	return y.map((y) => Intrinsic(y, J));
+}
+function Intrinsic(y, J, Y = {}) {
+	return IsMappedKey(y) ? IntrinsicFromMappedKey(y, J, Y) : IsTemplateLiteral(y) ? FromTemplateLiteral(y, J, Y) : IsUnion(y) ? Union(FromRest$2(y.anyOf, J), Y) : IsLiteral(y) ? Literal(FromLiteralValue(y.const, J), Y) : CreateType(y, Y);
+}
+function Capitalize(y, J = {}) {
+	return Intrinsic(y, "Capitalize", J);
+}
+function Lowercase(y, J = {}) {
+	return Intrinsic(y, "Lowercase", J);
+}
+function Uncapitalize(y, J = {}) {
+	return Intrinsic(y, "Uncapitalize", J);
+}
+function Uppercase(y, J = {}) {
+	return Intrinsic(y, "Uppercase", J);
+}
+function FromProperties$7(y, J, Y) {
+	let X = {};
+	for (let Z of globalThis.Object.getOwnPropertyNames(y)) X[Z] = Omit(y[Z], J, Clone(Y));
+	return X;
+}
+function FromMappedResult$3(y, J, Y) {
+	return FromProperties$7(y.properties, J, Y);
+}
+function OmitFromMappedResult(y, J, Y) {
+	return MappedResult(FromMappedResult$3(y, J, Y));
+}
+function FromIntersect$2(y, J) {
+	return y.map((y) => OmitResolve(y, J));
+}
+function FromUnion$2(y, J) {
+	return y.map((y) => OmitResolve(y, J));
+}
+function FromProperty(y, J) {
+	let { [J]: Y, ...X } = y;
+	return X;
+}
+function FromProperties$6(y, J) {
+	return J.reduce((y, J) => FromProperty(y, J), y);
+}
+function FromObject$4(y, J, Y) {
+	let X = Discard(y, [
+		TransformKind,
+		"$id",
+		"required",
+		"properties"
+	]);
+	return Object$1(FromProperties$6(Y, J), X);
+}
+function UnionFromPropertyKeys$1(y) {
+	return Union(y.reduce((y, J) => IsLiteralValue(J) ? [...y, Literal(J)] : y, []));
+}
+function OmitResolve(y, J) {
+	return IsIntersect(y) ? Intersect(FromIntersect$2(y.allOf, J)) : IsUnion(y) ? Union(FromUnion$2(y.anyOf, J)) : IsObject(y) ? FromObject$4(y, J, y.properties) : Object$1({});
+}
+function Omit(y, J, Y) {
+	let X = IsArray(J) ? UnionFromPropertyKeys$1(J) : J, Z = IsSchema(J) ? IndexPropertyKeys(J) : J, Q = IsRef(y), $ = IsRef(J);
+	return IsMappedResult(y) ? OmitFromMappedResult(y, Z, Y) : IsMappedKey(J) ? OmitFromMappedKey(y, J, Y) : Q && $ || !Q && $ || Q && !$ ? Computed("Omit", [y, X], Y) : CreateType({
+		...OmitResolve(y, Z),
+		...Y
+	});
+}
+function FromPropertyKey$1(y, J, Y) {
+	return { [J]: Omit(y, [J], Clone(Y)) };
+}
+function FromPropertyKeys$1(y, J, Y) {
+	return J.reduce((J, X) => ({
+		...J,
+		...FromPropertyKey$1(y, X, Y)
+	}), {});
+}
+function FromMappedKey$1(y, J, Y) {
+	return FromPropertyKeys$1(y, J.keys, Y);
+}
+function OmitFromMappedKey(y, J, Y) {
+	return MappedResult(FromMappedKey$1(y, J, Y));
+}
+function FromProperties$5(y, J, Y) {
+	let X = {};
+	for (let Z of globalThis.Object.getOwnPropertyNames(y)) X[Z] = Pick(y[Z], J, Clone(Y));
+	return X;
+}
+function FromMappedResult$2(y, J, Y) {
+	return FromProperties$5(y.properties, J, Y);
+}
+function PickFromMappedResult(y, J, Y) {
+	return MappedResult(FromMappedResult$2(y, J, Y));
+}
+function FromIntersect$1(y, J) {
+	return y.map((y) => PickResolve(y, J));
+}
+function FromUnion$1(y, J) {
+	return y.map((y) => PickResolve(y, J));
+}
+function FromProperties$4(y, J) {
+	let Y = {};
+	for (let X of J) X in y && (Y[X] = y[X]);
+	return Y;
+}
+function FromObject$3(y, J, Y) {
+	let X = Discard(y, [
+		TransformKind,
+		"$id",
+		"required",
+		"properties"
+	]);
+	return Object$1(FromProperties$4(Y, J), X);
+}
+function UnionFromPropertyKeys(y) {
+	return Union(y.reduce((y, J) => IsLiteralValue(J) ? [...y, Literal(J)] : y, []));
+}
+function PickResolve(y, J) {
+	return IsIntersect(y) ? Intersect(FromIntersect$1(y.allOf, J)) : IsUnion(y) ? Union(FromUnion$1(y.anyOf, J)) : IsObject(y) ? FromObject$3(y, J, y.properties) : Object$1({});
+}
+function Pick(y, J, Y) {
+	let X = IsArray(J) ? UnionFromPropertyKeys(J) : J, Z = IsSchema(J) ? IndexPropertyKeys(J) : J, Q = IsRef(y), $ = IsRef(J);
+	return IsMappedResult(y) ? PickFromMappedResult(y, Z, Y) : IsMappedKey(J) ? PickFromMappedKey(y, J, Y) : Q && $ || !Q && $ || Q && !$ ? Computed("Pick", [y, X], Y) : CreateType({
+		...PickResolve(y, Z),
+		...Y
+	});
+}
+function FromPropertyKey(y, J, Y) {
+	return { [J]: Pick(y, [J], Clone(Y)) };
+}
+function FromPropertyKeys(y, J, Y) {
+	return J.reduce((J, X) => ({
+		...J,
+		...FromPropertyKey(y, X, Y)
+	}), {});
+}
+function FromMappedKey(y, J, Y) {
+	return FromPropertyKeys(y, J.keys, Y);
+}
+function PickFromMappedKey(y, J, Y) {
+	return MappedResult(FromMappedKey(y, J, Y));
+}
+function FromComputed$2(y, J) {
+	return Computed("Partial", [Computed(y, J)]);
+}
+function FromRef$1(y) {
+	return Computed("Partial", [Ref(y)]);
+}
+function FromProperties$3(y) {
+	let J = {};
+	for (let Y of globalThis.Object.getOwnPropertyNames(y)) J[Y] = Optional(y[Y]);
+	return J;
+}
+function FromObject$2(y, J) {
+	let Y = Discard(y, [
+		TransformKind,
+		"$id",
+		"required",
+		"properties"
+	]);
+	return Object$1(FromProperties$3(J), Y);
+}
+function FromRest$1(y) {
+	return y.map((y) => PartialResolve(y));
+}
+function PartialResolve(y) {
+	return IsComputed(y) ? FromComputed$2(y.target, y.parameters) : IsRef(y) ? FromRef$1(y.$ref) : IsIntersect(y) ? Intersect(FromRest$1(y.allOf)) : IsUnion(y) ? Union(FromRest$1(y.anyOf)) : IsObject(y) ? FromObject$2(y, y.properties) : IsBigInt$1(y) || IsBoolean(y) || IsInteger(y) || IsLiteral(y) || IsNull$2(y) || IsNumber(y) || IsString$1(y) || IsSymbol$2(y) || IsUndefined$2(y) ? y : Object$1({});
+}
+function Partial(y, J) {
+	return IsMappedResult(y) ? PartialFromMappedResult(y, J) : CreateType({
+		...PartialResolve(y),
+		...J
+	});
+}
+function FromProperties$2(y, J) {
+	let Y = {};
+	for (let X of globalThis.Object.getOwnPropertyNames(y)) Y[X] = Partial(y[X], Clone(J));
+	return Y;
+}
+function FromMappedResult$1(y, J) {
+	return FromProperties$2(y.properties, J);
+}
+function PartialFromMappedResult(y, J) {
+	return MappedResult(FromMappedResult$1(y, J));
+}
+function FromComputed$1(y, J) {
+	return Computed("Required", [Computed(y, J)]);
+}
+function FromRef(y) {
+	return Computed("Required", [Ref(y)]);
+}
+function FromProperties$1(y) {
+	let J = {};
+	for (let Y of globalThis.Object.getOwnPropertyNames(y)) J[Y] = Discard(y[Y], [OptionalKind]);
+	return J;
+}
+function FromObject$1(y, J) {
+	let Y = Discard(y, [
+		TransformKind,
+		"$id",
+		"required",
+		"properties"
+	]);
+	return Object$1(FromProperties$1(J), Y);
+}
+function FromRest(y) {
+	return y.map((y) => RequiredResolve(y));
+}
+function RequiredResolve(y) {
+	return IsComputed(y) ? FromComputed$1(y.target, y.parameters) : IsRef(y) ? FromRef(y.$ref) : IsIntersect(y) ? Intersect(FromRest(y.allOf)) : IsUnion(y) ? Union(FromRest(y.anyOf)) : IsObject(y) ? FromObject$1(y, y.properties) : IsBigInt$1(y) || IsBoolean(y) || IsInteger(y) || IsLiteral(y) || IsNull$2(y) || IsNumber(y) || IsString$1(y) || IsSymbol$2(y) || IsUndefined$2(y) ? y : Object$1({});
+}
+function Required(y, J) {
+	return IsMappedResult(y) ? RequiredFromMappedResult(y, J) : CreateType({
+		...RequiredResolve(y),
+		...J
+	});
+}
+function FromProperties(y, J) {
+	let Y = {};
+	for (let X of globalThis.Object.getOwnPropertyNames(y)) Y[X] = Required(y[X], J);
+	return Y;
+}
+function FromMappedResult(y, J) {
+	return FromProperties(y.properties, J);
+}
+function RequiredFromMappedResult(y, J) {
+	return MappedResult(FromMappedResult(y, J));
+}
+function DereferenceParameters(y, J) {
+	return J.map((J) => IsRef(J) ? Dereference(y, J.$ref) : FromType(y, J));
+}
+function Dereference(y, J) {
+	return J in y ? IsRef(y[J]) ? Dereference(y, y[J].$ref) : FromType(y, y[J]) : Never();
+}
+function FromAwaited(y) {
+	return Awaited(y[0]);
+}
+function FromIndex(y) {
+	return Index(y[0], y[1]);
+}
+function FromKeyOf(y) {
+	return KeyOf(y[0]);
+}
+function FromPartial(y) {
+	return Partial(y[0]);
+}
+function FromOmit(y) {
+	return Omit(y[0], y[1]);
+}
+function FromPick(y) {
+	return Pick(y[0], y[1]);
+}
+function FromRequired(y) {
+	return Required(y[0]);
+}
+function FromComputed(y, J, Y) {
+	let X = DereferenceParameters(y, Y);
+	return J === "Awaited" ? FromAwaited(X) : J === "Index" ? FromIndex(X) : J === "KeyOf" ? FromKeyOf(X) : J === "Partial" ? FromPartial(X) : J === "Omit" ? FromOmit(X) : J === "Pick" ? FromPick(X) : J === "Required" ? FromRequired(X) : Never();
+}
+function FromArray(y, J) {
+	return Array$1(FromType(y, J));
+}
+function FromAsyncIterator(y, J) {
+	return AsyncIterator(FromType(y, J));
+}
+function FromConstructor(y, J, Y) {
+	return Constructor(FromTypes(y, J), FromType(y, Y));
+}
+function FromFunction(y, J, Y) {
+	return Function(FromTypes(y, J), FromType(y, Y));
+}
+function FromIntersect(y, J) {
+	return Intersect(FromTypes(y, J));
+}
+function FromIterator(y, J) {
+	return Iterator(FromType(y, J));
+}
+function FromObject(y, J) {
+	return Object$1(globalThis.Object.keys(J).reduce((Y, X) => ({
+		...Y,
+		[X]: FromType(y, J[X])
+	}), {}));
+}
+function FromRecord(y, J) {
+	let [Y, X] = [FromType(y, RecordValue(J)), RecordPattern(J)], Z = CloneType(J);
+	return Z.patternProperties[X] = Y, Z;
+}
+function FromTransform(y, J) {
+	return IsRef(J) ? {
+		...Dereference(y, J.$ref),
+		[TransformKind]: J[TransformKind]
+	} : J;
+}
+function FromTuple(y, J) {
+	return Tuple(FromTypes(y, J));
+}
+function FromUnion(y, J) {
+	return Union(FromTypes(y, J));
+}
+function FromTypes(y, J) {
+	return J.map((J) => FromType(y, J));
+}
+function FromType(y, J) {
+	return IsOptional(J) ? CreateType(FromType(y, Discard(J, [OptionalKind])), J) : IsReadonly(J) ? CreateType(FromType(y, Discard(J, [ReadonlyKind])), J) : IsTransform(J) ? CreateType(FromTransform(y, J), J) : IsArray$1(J) ? CreateType(FromArray(y, J.items), J) : IsAsyncIterator$1(J) ? CreateType(FromAsyncIterator(y, J.items), J) : IsComputed(J) ? CreateType(FromComputed(y, J.target, J.parameters)) : IsConstructor(J) ? CreateType(FromConstructor(y, J.parameters, J.returns), J) : IsFunction$1(J) ? CreateType(FromFunction(y, J.parameters, J.returns), J) : IsIntersect(J) ? CreateType(FromIntersect(y, J.allOf), J) : IsIterator$1(J) ? CreateType(FromIterator(y, J.items), J) : IsObject(J) ? CreateType(FromObject(y, J.properties), J) : IsRecord(J) ? CreateType(FromRecord(y, J)) : IsTuple(J) ? CreateType(FromTuple(y, J.items || []), J) : IsUnion(J) ? CreateType(FromUnion(y, J.anyOf), J) : J;
+}
+function ComputeType(y, J) {
+	return J in y ? FromType(y, y[J]) : Never();
+}
+function ComputeModuleProperties(y) {
+	return globalThis.Object.getOwnPropertyNames(y).reduce((J, Y) => ({
+		...J,
+		[Y]: ComputeType(y, Y)
+	}), {});
+}
+var TModule = class {
+	constructor(y) {
+		let J = ComputeModuleProperties(y);
+		this.$defs = this.WithIdentifiers(J);
+	}
+	Import(y, J) {
+		let Y = {
+			...this.$defs,
+			[y]: CreateType(this.$defs[y], J)
+		};
+		return CreateType({
+			[Kind]: "Import",
+			$defs: Y,
+			$ref: y
+		});
+	}
+	WithIdentifiers(y) {
+		return globalThis.Object.getOwnPropertyNames(y).reduce((J, Y) => ({
+			...J,
+			[Y]: {
+				...y[Y],
+				$id: Y
+			}
+		}), {});
+	}
+};
+function Module(y) {
+	return new TModule(y);
+}
+function Not(y, J) {
+	return CreateType({
+		[Kind]: "Not",
+		not: y
+	}, J);
+}
+function Parameters(y, J) {
+	return IsFunction$1(y) ? Tuple(y.parameters, J) : Never();
+}
+var Ordinal = 0;
+function Recursive(y, J = {}) {
+	IsUndefined(J.$id) && (J.$id = `T${Ordinal++}`);
+	let Y = CloneType(y({
+		[Kind]: "This",
+		$ref: `${J.$id}`
+	}));
+	return Y.$id = J.$id, CreateType({
+		[Hint]: "Recursive",
+		...Y
+	}, J);
+}
+function RegExp$1(y, J) {
+	let Y = IsString(y) ? new globalThis.RegExp(y) : y;
+	return CreateType({
+		[Kind]: "RegExp",
+		type: "RegExp",
+		source: Y.source,
+		flags: Y.flags
+	}, J);
+}
+function RestResolve(y) {
+	return IsIntersect(y) ? y.allOf : IsUnion(y) ? y.anyOf : IsTuple(y) ? y.items ?? [] : [];
+}
+function Rest(y) {
+	return RestResolve(y);
+}
+function ReturnType(y, J) {
+	return IsFunction$1(y) ? CreateType(y.returns, J) : Never(J);
+}
+var TransformDecodeBuilder = class {
+	constructor(y) {
+		this.schema = y;
+	}
+	Decode(y) {
+		return new TransformEncodeBuilder(this.schema, y);
+	}
+}, TransformEncodeBuilder = class {
+	constructor(y, J) {
+		this.schema = y, this.decode = J;
+	}
+	EncodeTransform(y, J) {
+		let Y = {
+			Encode: (Y) => J[TransformKind].Encode(y(Y)),
+			Decode: (y) => this.decode(J[TransformKind].Decode(y))
+		};
+		return {
+			...J,
+			[TransformKind]: Y
+		};
+	}
+	EncodeSchema(y, J) {
+		let Y = {
+			Decode: this.decode,
+			Encode: y
+		};
+		return {
+			...J,
+			[TransformKind]: Y
+		};
+	}
+	Encode(y) {
+		return IsTransform(this.schema) ? this.EncodeTransform(y, this.schema) : this.EncodeSchema(y, this.schema);
+	}
+};
+function Transform(y) {
+	return new TransformDecodeBuilder(y);
+}
+function Unsafe(y = {}) {
+	return CreateType({ [Kind]: y[Kind] ?? "Unsafe" }, y);
+}
+function Void(y) {
+	return CreateType({
+		[Kind]: "Void",
+		type: "void"
+	}, y);
+}
+var Type = /* @__PURE__ */ __export$1({
+	Any: () => Any,
+	Argument: () => Argument,
+	Array: () => Array$1,
+	AsyncIterator: () => AsyncIterator,
+	Awaited: () => Awaited,
+	BigInt: () => BigInt,
+	Boolean: () => Boolean,
+	Capitalize: () => Capitalize,
+	Composite: () => Composite,
+	Const: () => Const,
+	Constructor: () => Constructor,
+	ConstructorParameters: () => ConstructorParameters,
+	Date: () => Date$1,
+	Enum: () => Enum,
+	Exclude: () => Exclude,
+	Extends: () => Extends,
+	Extract: () => Extract,
+	Function: () => Function,
+	Index: () => Index,
+	InstanceType: () => InstanceType,
+	Instantiate: () => Instantiate,
+	Integer: () => Integer,
+	Intersect: () => Intersect,
+	Iterator: () => Iterator,
+	KeyOf: () => KeyOf,
+	Literal: () => Literal,
+	Lowercase: () => Lowercase,
+	Mapped: () => Mapped,
+	Module: () => Module,
+	Never: () => Never,
+	Not: () => Not,
+	Null: () => Null,
+	Number: () => Number$1,
+	Object: () => Object$1,
+	Omit: () => Omit,
+	Optional: () => Optional,
+	Parameters: () => Parameters,
+	Partial: () => Partial,
+	Pick: () => Pick,
+	Promise: () => Promise$1,
+	Readonly: () => Readonly,
+	ReadonlyOptional: () => ReadonlyOptional,
+	Record: () => Record,
+	Recursive: () => Recursive,
+	Ref: () => Ref,
+	RegExp: () => RegExp$1,
+	Required: () => Required,
+	Rest: () => Rest,
+	ReturnType: () => ReturnType,
+	String: () => String,
+	Symbol: () => Symbol$1,
+	TemplateLiteral: () => TemplateLiteral,
+	Transform: () => Transform,
+	Tuple: () => Tuple,
+	Uint8Array: () => Uint8Array$1,
+	Uncapitalize: () => Uncapitalize,
+	Undefined: () => Undefined,
+	Union: () => Union,
+	Unknown: () => Unknown,
+	Unsafe: () => Unsafe,
+	Uppercase: () => Uppercase,
+	Void: () => Void
+}, 1), __defProp = Object.defineProperty, __export = (y, J) => {
+	let Y = {};
+	for (var X in y) __defProp(Y, X, {
+		get: y[X],
+		enumerable: !0
+	});
+	return J && __defProp(Y, Symbol.toStringTag, { value: "Module" }), Y;
+}, config = {
+	backendUrl: "https://luna-park.app",
+	hostUrl: "https://host.luna-park.app"
+}, baseConfig = {
+	credentials: "include",
+	headers: {
+		Accept: "application/json, text/plain",
+		"Content-Type": "application/json"
+	},
+	mode: "cors"
+}, baseMultiConfig = {
+	credentials: "include",
+	headers: { Accept: "application/json, text/plain" },
+	mode: "cors"
+}, api_default$1 = {
+	async delete(y, J) {
+		let Y = {
+			...baseConfig,
+			method: "DELETE",
+			...J
+		};
+		return Y.body || (Y.headers = { ...Y.headers }, delete Y.headers?.["Content-Type"]), fetch(y, Y);
+	},
+	async get(y, J) {
+		return await fetch(y, {
+			...baseConfig,
+			method: "GET",
+			...J
+		});
+	},
+	getBaseUrl({ dev: y } = { dev: !1 }) {
+		return `${config.backendUrl}/${y ? "dev" : "api"}`;
+	},
+	async multipart(y, J, Y) {
+		return await fetch(y, {
+			...baseMultiConfig,
+			body: J,
+			method: "POST",
+			...Y
+		});
+	},
+	async post(y, J, Y) {
+		return await fetch(y, {
+			...baseConfig,
+			body: JSON.stringify(J) || "{}",
+			method: "POST",
+			...Y
+		});
+	},
+	async put(y, J, Y) {
+		return await fetch(y, {
+			...baseConfig,
+			body: JSON.stringify(J) || "{}",
+			method: "PUT",
+			...Y
+		});
+	}
+}, ERouteType = /* @__PURE__ */ function(y) {
+	return y.Get = "get", y.Post = "post", y.Delete = "delete", y.Put = "put", y;
+}({}), TypeDate = Type.String({ format: "date-time" }), ai_exports = /* @__PURE__ */ __export({
+	component: () => component,
+	logic: () => logic
+}, 1), component = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		instruction: Type.String(),
+		layout: Type.Optional(Type.Unknown())
+	}),
+	response: { 200: Type.Object({ layout: Type.Unknown() }) },
+	url: "/ai/component"
+}, logic = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		instruction: Type.String(),
+		prototype: Type.Optional(Type.String())
+	}),
+	response: { 200: Type.Object({
+		code: Type.String(),
+		prototype: Type.Optional(Type.String())
+	}) },
+	url: "/ai/logic"
+}, app_exports$1 = /* @__PURE__ */ __export({
+	app: () => app,
+	appEdits: () => appEdits
+}, 1), app = Type.Object({
+	name: Type.String(),
+	config: Type.Record(Type.String(), Type.Unknown()),
+	tree: Type.Unknown(),
+	version: Type.Optional(Type.Number())
+}), appEdits = Type.Array(Type.Object({
+	file: Type.Unknown(),
+	path: Type.String()
+})), keyConfig = Type.Object({
+	id: Type.Optional(Type.String()),
+	domain: Type.String(),
+	owner: Type.String(),
+	private: Type.String(),
+	public: Type.String()
+}), project = Type.Object({
+	id: Type.String(),
+	app: Type.Object({
+		name: Type.String(),
+		config: Type.Unknown()
+	}),
+	createdAt: TypeDate,
+	icon: Type.String(),
+	owner: Type.Unknown(),
+	updatedAt: TypeDate,
+	visibility: Type.Object({
+		liked: Type.Boolean(),
+		public: Type.Boolean(),
+		shareKey: Type.Optional(Type.String()),
+		starsCount: Type.Number()
+	})
+}), publicProject = Type.Object({ ...project.properties }), privateProject = Type.Object({
+	...project.properties,
+	app: Type.Unknown()
+}), EPlanKey = /* @__PURE__ */ function(y) {
+	return y.Free = "free", y.Edu = "edu", y.Pro = "pro", y.Org = "org", y;
+}({}), flags = {
+	free: {
+		compilation: {
+			desktop: !1,
+			export: !0,
+			mobile: !1,
+			source: !1,
+			web: !0
+		},
+		editor: {
+			desktop: !1,
+			web: !0
+		},
+		watermark: !0
+	},
+	pro: {
+		compilation: {
+			desktop: !0,
+			export: !0,
+			mobile: !0,
+			source: !0,
+			web: !0
+		},
+		editor: {
+			desktop: !0,
+			web: !0
+		},
+		watermark: !1
+	}
 };
+EPlanKey.Org, flags.pro, {
+	BASE_URL: "/",
+	DEV: !1,
+	MODE: "production",
+	PROD: !0,
+	SSR: !1,
+	"VITE_STRIPE.LP_PRO.PRICE_ID": "price_1OqeY1JFBGA2uuxte3UGjLCv",
+	"VITE_STRIPE.LP_PRO.PRODUCT_ID": "prod_Pg0Z4ompDLdXVM",
+	"VITE_STRIPE.LP_TEAM.PRICE_ID": "price_1OqeYcJFBGA2uuxtzaNN5WKS",
+	"VITE_STRIPE.LP_TEAM.PRODUCT_ID": "prod_Pg0ZH8QzIjUoVj"
+}["VITE_STRIPE.LP_TEAM.PRICE_ID"], {
+	BASE_URL: "/",
+	DEV: !1,
+	MODE: "production",
+	PROD: !0,
+	SSR: !1,
+	"VITE_STRIPE.LP_PRO.PRICE_ID": "price_1OqeY1JFBGA2uuxte3UGjLCv",
+	"VITE_STRIPE.LP_PRO.PRODUCT_ID": "prod_Pg0Z4ompDLdXVM",
+	"VITE_STRIPE.LP_TEAM.PRICE_ID": "price_1OqeYcJFBGA2uuxtzaNN5WKS",
+	"VITE_STRIPE.LP_TEAM.PRODUCT_ID": "prod_Pg0ZH8QzIjUoVj"
+}["VITE_STRIPE.LP_TEAM.PRODUCT_ID"], EPlanKey.Pro, flags.pro, {
+	BASE_URL: "/",
+	DEV: !1,
+	MODE: "production",
+	PROD: !0,
+	SSR: !1,
+	"VITE_STRIPE.LP_PRO.PRICE_ID": "price_1OqeY1JFBGA2uuxte3UGjLCv",
+	"VITE_STRIPE.LP_PRO.PRODUCT_ID": "prod_Pg0Z4ompDLdXVM",
+	"VITE_STRIPE.LP_TEAM.PRICE_ID": "price_1OqeYcJFBGA2uuxtzaNN5WKS",
+	"VITE_STRIPE.LP_TEAM.PRODUCT_ID": "prod_Pg0ZH8QzIjUoVj"
+}["VITE_STRIPE.LP_PRO.PRICE_ID"], {
+	BASE_URL: "/",
+	DEV: !1,
+	MODE: "production",
+	PROD: !0,
+	SSR: !1,
+	"VITE_STRIPE.LP_PRO.PRICE_ID": "price_1OqeY1JFBGA2uuxte3UGjLCv",
+	"VITE_STRIPE.LP_PRO.PRODUCT_ID": "prod_Pg0Z4ompDLdXVM",
+	"VITE_STRIPE.LP_TEAM.PRICE_ID": "price_1OqeYcJFBGA2uuxtzaNN5WKS",
+	"VITE_STRIPE.LP_TEAM.PRODUCT_ID": "prod_Pg0ZH8QzIjUoVj"
+}["VITE_STRIPE.LP_PRO.PRODUCT_ID"], EPlanKey.Edu, flags.pro, EPlanKey.Free, flags.free;
+var user = Type.Object({
+	id: Type.Optional(Type.String()),
+	auth: Type.Optional(Type.Object({})),
+	mail: Type.String(),
+	plan: Type.Object({ name: Type.String({ enum: Object.values(EPlanKey) }) }),
+	profile: Type.Object({
+		other: Type.Object({
+			avatar: Type.String(),
+			bio: Type.String(),
+			referral: Type.String()
+		}),
+		public: Type.Object({
+			company: Type.String(),
+			location: Type.String(),
+			url: Type.String(),
+			username: Type.String()
+		}),
+		social: Type.Object({
+			discord: Type.String(),
+			github: Type.String(),
+			linkedin: Type.String(),
+			twitter: Type.String()
+		})
+	}),
+	settings: Type.Object({ newsletter: Type.Boolean() })
+}), EElementType = /* @__PURE__ */ function(y) {
+	return y.Script = "script", y.Standalone = "standalone", y.Folder = "folder", y.MainLogic = "main", y.Logic = "logic", y.Config = "config", y.Text = "text", y.Store = "store", y.Database = "database", y.Component = "component", y.Route = "route", y.Type = "type", y.Cron = "cron", y.Media = "media", y;
+}({}), types = {
+	...app_exports$1,
+	keyConfig,
+	privateProject,
+	project,
+	publicProject,
+	user
+}, app_exports = /* @__PURE__ */ __export({
+	edit: () => edit$1,
+	get: () => get$2
+}, 1), get$2 = {
+	type: ERouteType.Get,
+	params: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({
+		app: types.app,
+		readOnly: Type.Boolean()
+	}) },
+	url: "/app/:id"
+}, edit$1 = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		app: Type.Optional(types.app),
+		deletes: Type.Optional(Type.Array(Type.String())),
+		edits: Type.Optional(types.appEdits)
+	}),
+	params: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/app/:id"
+}, auth_exports = /* @__PURE__ */ __export({
+	authorize: () => authorize,
+	client: () => client,
+	me: () => me,
+	token: () => token
+}, 1), authorize = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		client_id: Type.String(),
+		redirect_uri: Type.String(),
+		response_type: Type.Literal("code"),
+		scope: Type.Optional(Type.String())
+	}),
+	response: { 200: Type.Object({ authorization_code: Type.String() }) },
+	url: "/auth/authorize"
+}, token = {
+	type: ERouteType.Post,
+	body: Type.Union([Type.Object({
+		client_id: Type.String(),
+		client_secret: Type.String(),
+		code: Type.String(),
+		grant_type: Type.Literal("authorization_code"),
+		redirect_uri: Type.String()
+	}), Type.Object({
+		client_id: Type.String(),
+		client_secret: Type.String(),
+		grant_type: Type.Literal("refresh_token"),
+		refresh_token: Type.String()
+	})]),
+	response: { 200: Type.Object({
+		access_token: Type.String(),
+		expires_in: Type.Number(),
+		refresh_token: Type.String(),
+		token_type: Type.Literal("Bearer")
+	}) },
+	url: "/auth/token"
+}, me = {
+	type: ERouteType.Get,
+	headers: Type.Object({ authorization: Type.String() }),
+	response: { 200: Type.Object({
+		id: Type.String(),
+		mail: Type.String()
+	}) },
+	url: "/auth/me"
+}, client = {
+	type: ERouteType.Get,
+	querystring: Type.Object({
+		client_id: Type.String(),
+		redirect_uri: Type.String()
+	}),
+	response: { 200: Type.Object({ client_name: Type.String() }) },
+	url: "/auth/client"
+}, integrations_exports = /* @__PURE__ */ __export({ googleAuth: () => googleAuth }, 1), googleAuth = {
+	type: ERouteType.Get,
+	querystring: Type.Object({
+		code: Type.Optional(Type.String()),
+		scope: Type.Optional(Type.String()),
+		state: Type.Optional(Type.String())
+	}),
+	response: { 200: Type.Object({ token: Type.Optional(Type.String()) }) },
+	url: "/integrations/google/auth"
+}, compiler_exports = /* @__PURE__ */ __export({
+	build: () => build,
+	compile: () => compile$1,
+	download: () => download
+}, 1), build = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		entry: Type.Optional(Type.String()),
+		key: Type.String(),
+		script: Type.Unknown()
+	}),
+	params: Type.Object({ type: Type.Union([Type.Literal("main"), Type.Literal("logic")]) }),
+	response: { 200: Type.Object({
+		code: Type.String(),
+		message: Type.String()
+	}) },
+	url: "/compiler/build/:type"
+}, compile$1 = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		platform: Type.Optional(Type.Union([
+			Type.Literal("win32"),
+			Type.Literal("darwin"),
+			Type.Literal("linux")
+		])),
+		target: Type.Union([
+			Type.Literal("source"),
+			Type.Literal("export"),
+			Type.Literal("web"),
+			Type.Literal("desktop")
+		])
+	}),
+	params: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({
+		message: Type.String(),
+		target: Type.String()
+	}) },
+	url: "/compiler/compile/:id"
+}, download = {
+	type: ERouteType.Get,
+	params: Type.Object({
+		id: Type.String(),
+		platform: Type.Optional(Type.Union([
+			Type.Literal("win32-installer"),
+			Type.Literal("darwin-installer"),
+			Type.Literal("linux-installer"),
+			Type.Literal("win32-portable"),
+			Type.Literal("darwin-portable"),
+			Type.Literal("linux-portable")
+		])),
+		target: Type.Union([
+			Type.Literal("source"),
+			Type.Literal("export"),
+			Type.Literal("desktop")
+		])
+	}),
+	response: { 200: Type.Unknown() },
+	url: "/compiler/download/:id/:target/:platform?"
+}, desktop_exports = /* @__PURE__ */ __export({ latest: () => latest }, 1), latest = {
+	type: ERouteType.Get,
+	dev: !0,
+	querystring: Type.Object({
+		arch: Type.Union([
+			Type.Literal("x86_64"),
+			Type.Literal("i686"),
+			Type.Literal("aarch64"),
+			Type.Literal("armv7")
+		]),
+		target: Type.Union([
+			Type.Literal("windows"),
+			Type.Literal("linux"),
+			Type.Literal("darwin")
+		]),
+		version: Type.Optional(Type.String())
+	}),
+	response: { 200: Type.Object({
+		notes: Type.String(),
+		pub_date: Type.String(),
+		signature: Type.String(),
+		url: Type.String(),
+		version: Type.String()
+	}) },
+	url: "/desktop/release/latest"
+}, keyConfig_exports = /* @__PURE__ */ __export({
+	check: () => check$1,
+	create: () => create$2,
+	list: () => list$3,
+	remove: () => remove$2
+}, 1), create$2 = {
+	type: ERouteType.Post,
+	body: Type.Object({ domain: Type.String() }),
+	response: { 200: Type.Object({
+		key: types.keyConfig,
+		message: Type.String()
+	}) },
+	url: "/key-config"
+}, list$3 = {
+	type: ERouteType.Get,
+	response: { 200: Type.Array(types.keyConfig) },
+	url: "/key-config"
+}, remove$2 = {
+	type: ERouteType.Delete,
+	params: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/key-config/:id"
+}, check$1 = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		domain: Type.String(),
+		key: Type.String()
+	}),
+	dev: !0,
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/key-config/check"
+}, license_exports = /* @__PURE__ */ __export({
+	check: () => check,
+	link: () => link,
+	list: () => list$2,
+	reset: () => reset
+}, 1), reset = {
+	type: ERouteType.Post,
+	body: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/license/reset"
+}, link = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		name: Type.String(),
+		fingerprint: Type.String(),
+		key: Type.String()
+	}),
+	dev: !0,
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/license/link"
+}, check = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		fingerprint: Type.String(),
+		key: Type.String()
+	}),
+	dev: !0,
+	response: { 200: Type.Object({
+		mail: Type.Optional(Type.String()),
+		valid: Type.Boolean(),
+		version: Type.Optional(Type.String())
+	}) },
+	url: "/license/check"
+}, list$2 = {
+	type: ERouteType.Get,
+	response: { 200: Type.Array(Type.Object({
+		id: Type.String(),
+		name: Type.String(),
+		expirationDate: TypeDate,
+		key: Type.String(),
+		lastUsed: TypeDate,
+		version: Type.String()
+	})) },
+	url: "/license/list"
+}, magiclink_exports = /* @__PURE__ */ __export({
+	activate: () => activate,
+	create: () => create$1,
+	signup: () => signup
+}, 1), activate = {
+	type: ERouteType.Get,
+	params: Type.Object({
+		id: Type.String(),
+		token: Type.String()
+	}),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/magiclink/activate/:id/:token"
+}, create$1 = {
+	type: ERouteType.Post,
+	body: Type.Object({ mail: Type.String({ format: "email" }) }),
+	response: { 200: Type.Object({
+		expirationDate: Type.String(),
+		message: Type.String()
+	}) },
+	url: "/magiclink/create"
+}, signup = {
+	type: ERouteType.Post,
+	body: Type.Object({ mail: Type.String({ format: "email" }) }),
+	response: { 200: Type.Object({
+		expirationDate: Type.String(),
+		message: Type.String()
+	}) },
+	url: "/magiclink/signup"
+}, payment_exports = /* @__PURE__ */ __export({
+	checkout: () => checkout,
+	portal: () => portal
+}, 1), checkout = {
+	type: ERouteType.Post,
+	body: Type.Object({ plan: Type.Union([Type.Literal(EPlanKey.Pro), Type.Literal(EPlanKey.Org)]) }),
+	response: { 200: Type.Object({
+		message: Type.String(),
+		redirection: Type.String()
+	}) },
+	url: "/payment/checkout"
+}, portal = {
+	type: ERouteType.Post,
+	response: { 200: Type.Object({
+		message: Type.String(),
+		redirection: Type.String()
+	}) },
+	url: "/payment/portal"
+}, project_exports = /* @__PURE__ */ __export({
+	create: () => create,
+	edit: () => edit,
+	list: () => list$1,
+	proxy: () => proxy,
+	remove: () => remove$1,
+	star: () => star
+}, 1), create = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		title: Type.String(),
+		icon: Type.String(),
+		template: Type.Union([
+			Type.Literal("default"),
+			Type.Literal("empty"),
+			Type.Literal("frontend"),
+			Type.Literal("backend"),
+			Type.Literal("database"),
+			Type.Literal("testing")
+		])
+	}),
+	response: { 200: Type.Object({
+		message: Type.String(),
+		project: types.publicProject
+	}) },
+	url: "/project/create"
+}, list$1 = {
+	type: ERouteType.Get,
+	params: Type.Object({ type: Type.Union([
+		Type.Literal("mine"),
+		Type.Literal("popular"),
+		Type.Literal("newest"),
+		Type.Literal("random"),
+		Type.Literal("search")
+	]) }),
+	querystring: Type.Object({
+		limit: Type.Optional(Type.Number()),
+		search: Type.Optional(Type.String()),
+		skip: Type.Optional(Type.Number())
+	}),
+	response: { 200: Type.Object({ projects: Type.Array(types.publicProject) }) },
+	url: "/project/list/:type"
+}, remove$1 = {
+	type: ERouteType.Delete,
+	params: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/project/remove/:id"
+}, edit = {
+	type: ERouteType.Post,
+	body: types.privateProject,
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/project/edit"
+}, star = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		id: Type.String(),
+		like: Type.Boolean()
+	}),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/project/star"
+}, proxy = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		body: Type.Optional(Type.Unknown()),
+		headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+		method: Type.Optional(Type.Union([
+			Type.Literal("GET"),
+			Type.Literal("POST"),
+			Type.Literal("PUT"),
+			Type.Literal("DELETE")
+		])),
+		url: Type.String({ format: "uri" })
+	}),
+	response: { 200: Type.Unknown() },
+	url: "/project/proxy"
+}, script_exports = /* @__PURE__ */ __export({
+	compile: () => compile,
+	get: () => get$1,
+	update: () => update$1
+}, 1), get$1 = {
+	type: ERouteType.Get,
+	params: Type.Object({
+		id: Type.String(),
+		script: Type.String()
+	}),
+	response: { 200: Type.String() },
+	url: "/script/:id/:script"
+}, compile = {
+	type: ERouteType.Post,
+	params: Type.Object({
+		id: Type.String(),
+		script: Type.String()
+	}),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/script/:id/:script/compile"
+}, update$1 = {
+	type: ERouteType.Post,
+	body: Type.Object({ autoReload: Type.Optional(Type.Boolean()) }),
+	params: Type.Object({
+		id: Type.String(),
+		script: Type.String()
+	}),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/script/:id/:script/update"
+}, file_exports = /* @__PURE__ */ __export({
+	list: () => list,
+	remove: () => remove,
+	status: () => status,
+	upload: () => upload
+}, 1), upload = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		file: Type.Object({
+			filename: Type.String(),
+			mimetype: Type.String()
+		}),
+		project: Type.Object({ value: Type.String() })
+	}),
+	multipart: !0,
+	response: { 200: Type.Object({
+		name: Type.String(),
+		mimeType: Type.String(),
+		target: Type.String()
+	}) },
+	url: "/file/upload"
+}, remove = {
+	type: ERouteType.Post,
+	body: Type.Object({ target: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/file/remove"
+}, list = {
+	type: ERouteType.Get,
+	querystring: Type.Object({
+		limit: Type.Optional(Type.String()),
+		search: Type.Optional(Type.String()),
+		skip: Type.Optional(Type.String())
+	}),
+	response: { 200: Type.Object({
+		result: Type.Array(Type.Object({
+			id: Type.String(),
+			name: Type.String(),
+			mimeType: Type.String(),
+			project: Type.Object({
+				id: Type.String(),
+				name: Type.String(),
+				icon: Type.String()
+			}),
+			size: Type.Number(),
+			target: Type.String()
+		})),
+		total: Type.Number()
+	}) },
+	url: "/file/list"
+}, status = {
+	type: ERouteType.Get,
+	response: { 200: Type.Object({
+		limit: Type.Number(),
+		total: Type.Number()
+	}) },
+	url: "/file/status"
+}, turnstile_exports = /* @__PURE__ */ __export({ tick: () => tick }, 1), tick = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		data: Type.Optional(Type.Unknown()),
+		scope: Type.String()
+	}),
+	response: { 200: Type.Object({}) },
+	url: "/turnstile/tick"
+}, user_exports = /* @__PURE__ */ __export({
+	disconnect: () => disconnect,
+	get: () => get,
+	ping: () => ping,
+	unsubscribe: () => unsubscribe,
+	update: () => update,
+	waitlist: () => waitlist
+}, 1), ping = {
+	type: ERouteType.Get,
+	response: { 200: Type.Object({
+		message: Type.String(),
+		user: Type.Optional(types.user)
+	}) },
+	url: "/user/ping"
+}, get = {
+	type: ERouteType.Get,
+	response: { 200: types.user },
+	url: "/user"
+}, update = {
+	type: ERouteType.Post,
+	body: Type.Partial(types.user),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/user"
+}, disconnect = {
+	type: ERouteType.Get,
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/user/disconnect"
+}, waitlist = {
+	type: ERouteType.Post,
+	body: Type.Object({ mail: Type.String({ format: "email" }) }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/user/waitlist"
+}, unsubscribe = {
+	type: ERouteType.Post,
+	body: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/user/unsubscribe"
+}, routes = {
+	ai: ai_exports,
+	app: app_exports,
+	auth: auth_exports,
+	compiler: compiler_exports,
+	desktop: desktop_exports,
+	file: file_exports,
+	integrations: integrations_exports,
+	keyConfig: keyConfig_exports,
+	license: license_exports,
+	magiclink: magiclink_exports,
+	payment: payment_exports,
+	project: project_exports,
+	script: script_exports,
+	turnstile: turnstile_exports,
+	user: user_exports
+}, api = {};
+for (let y of Object.keys(routes)) {
+	api[y] = {};
+	for (let J of Object.keys(routes[y])) {
+		let Y = routes[y][J];
+		api[y][J] = async (y = {}) => {
+			let J = new URL(api_default$1.getBaseUrl({ dev: Y.dev }) + Y.url);
+			if (Y.params && y.params) for (let X of Object.keys(Y.params.properties)) J.href = J.href.replace(`:${X}`, y.params[X]);
+			if (y.querystring) for (let Y of Object.keys(y.querystring)) y.querystring[Y] && J.searchParams.append(Y, y.querystring[Y].toString());
+			let X = api_default$1[Y.type];
+			Y.multipart && (X = api_default$1.multipart);
+			let Z = await X(J.href, y.body), Q = await getContent(Z);
+			if (Z.status >= 400) throw Error(`Error ${Z.status} (${Z.statusText}): ${Q.message || Q}`);
+			return Q;
+		};
+	}
+}
+function getContent(y) {
+	return y.headers.get("Content-Type")?.startsWith("application/json") ? y.json() : y.text();
+}
+function makePlugin(y) {
+	return y;
+}
+function makeComponent(y) {
+	return y;
+}
+async function loadPlugin(y, J) {
+	let Y = cloneWithFunctions(y), X = J.app?.config?.plugins?.[y.id]?.config;
+	for (let y of [
+		"build",
+		"editor",
+		"inject"
+	]) if (Y[y]) for (let Z in Y[y]) Y[y][Z] = await getPluginParam(Y[y][Z], {
+		...J,
+		config: X
+	});
+	return Y;
+}
+async function getPluginParam(y, J) {
+	return typeof y == "function" ? y({
+		addFile: J.addFile,
+		app: J.app,
+		config: J.config,
+		internals: J.internals,
+		mode: J.mode || "editor"
+	}) : y;
+}
+export { EElementType, EInjectionKey, ELogicScope, ELogicType, ETokenType, EVarType, LSettingsStoryWrapper_default as LSettingsStoryWrapper, LogicType, LogicUtil, getPluginParam, loadPlugin, makeComponent, makeLogicNode, makePlugin };