@luna-park/plugin 1.8.0 → 2.0.0

package/dist/dist-CZjmIqBC.mjs

@@ -0,0 +1,894 @@
+// ../utils/dist/index.mjs
+function cloneDeep(object) {
+	if (typeof object !== "object") return object;
+	const strategies = [
+		() => JSON.parse(JSON.stringify(object)),
+		() => structuredClone(object),
+		() => safeClone(object)
+	];
+	let lastError;
+	for (const strategy of strategies) try {
+		return strategy();
+	} catch (error) {
+		lastError = error;
+		continue;
+	}
+	console.error("Failed to deep clone object:", object);
+	throw new Error(String(lastError));
+}
+function safeClone(object) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	return recursiveClone(object);
+	function recursiveClone(object) {
+		if (typeof object !== "object" || object === null) return object;
+		if (seen.has(object)) return { recursive: true };
+		seen.add(object);
+		if (Array.isArray(object)) return object.map((element) => recursiveClone(element));
+		const clone = {};
+		for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(object))) clone[key] = recursiveClone(descriptor.value);
+		return clone;
+	}
+}
+function cloneWithFunctions(object) {
+	if (Array.isArray(object)) return object.map(cloneWithFunctions);
+	if (typeof object !== "object" || object === null) return object;
+	const clone = {};
+	for (const [key, value] of Object.entries(object)) clone[key] = typeof value === "function" ? value : cloneWithFunctions(value);
+	return clone;
+}
+function assertType(_arg) {}
+function objectMap(source, func) {
+	if (!source) return {};
+	return Object.fromEntries(Object.entries(source).map(([key, value]) => [key, func({
+		key,
+		value
+	})]));
+}
+function objectFilter(source, func) {
+	if (!source) return {};
+	return Object.fromEntries(Object.entries(source).filter(([key, value]) => func({
+		key,
+		value
+	})));
+}
+function objectFullMap(source, func) {
+	if (!source) return {};
+	return Object.fromEntries(Object.entries(source).map(([key, value]) => {
+		const result = func({
+			key,
+			value
+		});
+		return [result.key, result.value];
+	}));
+}
+function cleanObject(target) {
+	const record = cloneDeep(target);
+	for (const key in record) cleanDeep(record, key);
+	function cleanDeep(value, key) {
+		const child = value[key];
+		if (child && typeof child === "object") {
+			for (const childKey in child) cleanDeep(child, childKey);
+			if (Object.keys(child).length === 0) delete value[key];
+		}
+	}
+	return record;
+}
+function isRawObject(target) {
+	if (target !== null && typeof target === "object") return Object.getPrototypeOf(target) === Object.prototype;
+	return false;
+}
+// ../logicnodes/dist/index.mjs
+const interfaceConfigs = {};
+function isInterfaceConstant(value) {
+	return isRawObject(value) && typeof value._interface === "string";
+}
+let EVarType = /* @__PURE__ */ function(EVarType) {
+	EVarType["exec"] = "exec";
+	EVarType["number"] = "number";
+	EVarType["string"] = "string";
+	EVarType["boolean"] = "boolean";
+	EVarType["object"] = "object";
+	EVarType["record"] = "record";
+	EVarType["array"] = "array";
+	EVarType["interface"] = "interface";
+	EVarType["type"] = "type";
+	EVarType["function"] = "function";
+	EVarType["union"] = "union";
+	EVarType["intersection"] = "intersection";
+	EVarType["unknown"] = "unknown";
+	EVarType["undefined"] = "undefined";
+	EVarType["void"] = "void";
+	return EVarType;
+}({});
+const LogicType = {
+	array: (items, args = {}) => {
+		return {
+			...args,
+			items,
+			type: "array"
+		};
+	},
+	boolean: (args = {}) => {
+		return {
+			...args,
+			type: "boolean"
+		};
+	},
+	exec: (args = {}) => {
+		return {
+			...args,
+			type: "exec"
+		};
+	},
+	function: createFunction,
+	interface: (interfaceClass, args = {}) => {
+		return {
+			...args,
+			className: typeof interfaceClass === "string" ? interfaceClass : interfaceClass.name,
+			type: "interface"
+		};
+	},
+	intersection: (elements, args = {}) => {
+		return {
+			...args,
+			elements,
+			type: "intersection"
+		};
+	},
+	number: (args = {}) => {
+		return {
+			...args,
+			type: "number"
+		};
+	},
+	object: (properties = {}, args = {}) => {
+		return {
+			...args,
+			properties,
+			type: "object"
+		};
+	},
+	record: (key, value, args = {}) => {
+		return {
+			...args,
+			key,
+			type: "record",
+			value
+		};
+	},
+	string: (args = {}) => {
+		return {
+			...args,
+			type: "string"
+		};
+	},
+	type: createType,
+	undefined: (args = {}) => {
+		return {
+			...args,
+			type: "undefined"
+		};
+	},
+	union: (elements, args = {}) => {
+		return {
+			...args,
+			elements,
+			type: "union"
+		};
+	},
+	unknown: (args = {}) => {
+		return {
+			...args,
+			type: "unknown"
+		};
+	},
+	void: (args = {}) => {
+		return {
+			...args,
+			type: "void"
+		};
+	}
+};
+function createFunction(inputs = [], output = LogicType.void(), args = {}) {
+	if (Array.isArray(inputs)) return createFunction(LogicType.object(Object.fromEntries(inputs)), output, args);
+	return {
+		...args,
+		inputs,
+		output,
+		type: "function"
+	};
+}
+function createType(target, args = {}) {
+	return {
+		...args,
+		target,
+		type: "type"
+	};
+}
+const LogicUtil = {
+	omit(target, keys) {
+		return {
+			...target,
+			properties: objectFilter(target.properties, ({ key }) => !keys.includes(key))
+		};
+	},
+	partial(target, force = false) {
+		return {
+			...target,
+			properties: objectMap(target.properties, ({ value }) => ({
+				...value,
+				optional: !force || !value.required
+			}))
+		};
+	},
+	pick(target, keys) {
+		return {
+			...target,
+			properties: objectFilter(target.properties, ({ key }) => keys.includes(key))
+		};
+	},
+	promise(target) {
+		return {
+			...target,
+			promise: true
+		};
+	},
+	required(target) {
+		return {
+			...target,
+			properties: objectMap(target.properties, ({ value }) => ({
+				...value,
+				optional: false
+			}))
+		};
+	}
+};
+function isSchemaCompatible(source, target) {
+	return !!getSchemaCompatibilityScore(source, target);
+}
+/**
+* Get the compatibility score between two schemas
+* @param source - The source schema (strict)
+* @param target - The target schema (loose)
+*/
+function getSchemaCompatibilityScore(source, target) {
+	if (!target || !source) return 1;
+	if (target.type === "unknown") return source.type !== "exec" ? 1 : 0;
+	if (source.type === "unknown" && source.customizable) return 1;
+	if (target.type === "type" && source.type === "type") return getTypeReferenceKey(target) === getTypeReferenceKey(source) ? 5 : 0;
+	if (target.type === "union") return Math.max(...target.elements.map((element) => getSchemaCompatibilityScore(source, element)));
+	if (target.type === "intersection") return Math.min(...target.elements.map((element) => getSchemaCompatibilityScore(source, element)));
+	if (source.type === "intersection") {
+		const merged = mergeIntersection(source);
+		if (merged.type === "object") return getSchemaCompatibilityScore(merged, target);
+		return Math.max(...source.elements.map((element) => getSchemaCompatibilityScore(element, target)));
+	}
+	if (target.type === "record" && source.type === "object") {
+		if (source.customizable) return 1;
+		const properties = Object.entries(source.properties ?? {});
+		if (properties.some(([key, property]) => !isRecordKeyCompatible(property.name || key, target.key))) return 0;
+		return Math.min(5, ...properties.map(([, property]) => getSchemaCompatibilityScore(property, target.value)));
+	}
+	if (target.type === "object" && source.type === "record") return Object.keys(target.properties ?? {}).length ? 0 : 2;
+	if (target.type !== source.type) return 0;
+	if (target.type === source.type) {
+		if (source.customizable && ![
+			"function",
+			"array",
+			"object",
+			"record"
+		].includes(source.type)) return 2;
+	}
+	if (source.type === "function" && target.type === "function") return Math.min(getSchemaCompatibilityScore({
+		...source.inputs,
+		customizable: source.customizable
+	}, target.inputs), getSchemaCompatibilityScore({
+		...source.output,
+		customizable: source.customizable
+	}, target.output)) + 1;
+	if (source.type === "array" && target.type === "array") {
+		if (source.customizable && (!source.items || source.items.type === "unknown")) return 1;
+		return getSchemaCompatibilityScore(source.items, target.items);
+	}
+	if (source.type === "record" && target.type === "record") {
+		if (source.customizable && (!source.value || source.value.type === "unknown")) return 1;
+		return Math.min(getSchemaCompatibilityScore(source.key, target.key), getSchemaCompatibilityScore(source.value, target.value));
+	}
+	if (source.type === "object" && target.type === "object") {
+		if (source === target) return 5;
+		if (!target.properties) target.properties = {};
+		if (!source.properties) source.properties = {};
+		if (source.customizable) return 5;
+		return Math.min(5, ...Object.keys(target.properties).filter((key) => !target.properties[key].optional).map((key) => {
+			const name = target.properties[key].name;
+			let toKey = key;
+			if (!source.properties[toKey] && name) toKey = name;
+			if (!source.properties[toKey]) {
+				const matchingKey = Object.keys(source.properties).find((sourceKey) => {
+					const sourceName = source.properties[sourceKey].name;
+					return sourceName === key || sourceName === name;
+				});
+				if (!matchingKey) return 0;
+				toKey = matchingKey;
+			}
+			return getSchemaCompatibilityScore(source.properties[toKey], target.properties[key]);
+		}));
+	}
+	if (source.type === "interface" && source.className) {
+		if (target.type !== "interface") return 0;
+		if (source.className === target.className) return 5;
+		if (getExtendedInterface(source.className).includes(target.className)) return 4;
+		return 0;
+	}
+	return 2;
+	function getExtendedInterface(interfaceName) {
+		const extendedInterface = interfaceConfigs[interfaceName]?.extends;
+		if (!extendedInterface) return [];
+		return extendedInterface.map((extend) => [extend, getExtendedInterface(extend)].flat()).flat();
+	}
+}
+function getTypeReferenceKey(schema) {
+	return [...schema.target, ...schema.path ?? []].join("/");
+}
+function getIndexedSchema(schema, key) {
+	if (key === "[]") return schema.type === "array" ? schema.items : void 0;
+	if (schema.type !== "object") return;
+	return schema.properties[key] ?? Object.values(schema.properties).find((property) => property.name === key);
+}
+/**
+* Merge the members of an intersection into a single object schema; a later member's property wins over an earlier one with the same name
+* @param schema - The intersection
+* @param resolve - Resolves type references to their target schema
+*/
+function mergeIntersection(schema, resolve = (schema) => schema) {
+	const properties = /* @__PURE__ */ new Map();
+	for (const element of schema.elements ?? []) {
+		const resolved = resolve(element);
+		const member = resolved.type === "intersection" ? mergeIntersection(resolved, resolve) : resolved;
+		if (member.type !== "object") return LogicType.unknown({
+			description: schema.description,
+			name: schema.name,
+			optional: schema.optional
+		});
+		for (const [key, property] of Object.entries(member.properties)) properties.set(property.name || key, [key, property]);
+	}
+	return LogicType.object(Object.fromEntries(properties.values()), {
+		description: schema.description,
+		name: schema.name,
+		optional: schema.optional
+	});
+}
+function isRecordKeyCompatible(key, schema) {
+	switch (schema?.type) {
+		case "number": return key.trim() !== "" && !Number.isNaN(Number(key));
+		default: return true;
+	}
+}
+function objectToSchema(object, args = {}) {
+	switch (typeof object) {
+		case "object":
+			if (Array.isArray(object)) {
+				if (object.length === 0) return LogicType.array(LogicType.unknown(), {
+					...args,
+					customizable: true
+				});
+				return LogicType.array(objectToSchema(object[0]), args);
+			}
+			if (object instanceof Date) return LogicType.interface("Date", args);
+			if (object === null) return LogicType.unknown(args);
+			if (isInterfaceConstant(object)) return LogicType.interface(object._interface, args);
+			if (object._dynamic) return LogicType.unknown(args);
+			return LogicType.object(objectMap(object, ({ key, value }) => objectToSchema(value, { name: key })), args);
+		case "boolean": return LogicType.boolean(args);
+		case "number": return LogicType.number(args);
+		case "string": return LogicType.string(args);
+		default: return LogicType.unknown(args);
+	}
+}
+function isValueSchemaCompatible(value, schema) {
+	return isSchemaCompatible(objectToSchema(value), schema);
+}
+let ELogicType = /* @__PURE__ */ function(ELogicType) {
+	ELogicType["function"] = "function";
+	ELogicType["macro"] = "macro";
+	ELogicType["operation"] = "operation";
+	return ELogicType;
+}({});
+let ELogicScope = /* @__PURE__ */ function(ELogicScope) {
+	ELogicScope["Frontend"] = "frontend";
+	ELogicScope["Backend"] = "backend";
+	ELogicScope["Desktop"] = "desktop";
+	ELogicScope["Shared"] = "shared";
+	return ELogicScope;
+}({});
+function makeLogicNode(node) {
+	return node;
+}
+const wrappers = [
+	["(", ")"],
+	["[", "]"],
+	["{", "}"],
+	["<", ">"],
+	["'", "'"],
+	["\"", "\""]
+];
+function lexer(scan) {
+	return cleanArray(splitUntil(scan, ";"));
+}
+function asLexerNode(element) {
+	return typeof element === "object" && !Array.isArray(element) ? element : void 0;
+}
+function getUntil(scan, until, depth = 1) {
+	const result = [];
+	const opening = wrappers.find((wrapper) => wrapper[1] === until)?.[0];
+	while (scan.length) {
+		if (scan[0] === opening) {}
+		if (scan[0] === until) {
+			depth--;
+			if (depth <= 0) break;
+		}
+		const element = getFirstElement(scan);
+		result.push(element);
+		const node = asLexerNode(element);
+		if (depth === 0 && node?.type === "wrap" && node.style?.endsWith(until)) break;
+	}
+	scan.shift();
+	return result;
+}
+function eraseUntil(scan, until) {
+	while (scan.length) {
+		if (scan[0] === until) {
+			scan.shift();
+			break;
+		}
+		scan.shift();
+	}
+}
+function splitUntil(scan, until) {
+	const result = [[]];
+	while (scan.length) {
+		if (scan[0] === until) {
+			result.push([]);
+			scan.shift();
+			continue;
+		}
+		result[result.length - 1].push(getFirstElement(scan));
+	}
+	return result.filter((chunk) => chunk.length);
+}
+function getFirstElement(scan) {
+	let element = scan.shift();
+	let exportFlag = false;
+	if (element === "export") {
+		exportFlag = true;
+		element = scan.shift();
+		if (element === "=") return {
+			content: scan.shift(),
+			type: "export"
+		};
+		if (element === "as") {
+			eraseUntil(scan, ";");
+			return getFirstElement(scan);
+		}
+	}
+	if (element === "declare") element = scan.shift();
+	if (element === "namespace") {
+		const name = scan.shift();
+		scan.shift();
+		const content = splitUntil(getUntil(scan, "}", 0), ";");
+		scan.unshift(";");
+		return {
+			content,
+			export: exportFlag,
+			name,
+			type: "namespace"
+		};
+	}
+	if (element === "function") {
+		const name = scan.shift();
+		const then = scan.shift();
+		const result = {
+			name,
+			type: "function"
+		};
+		if (then === "<") {
+			result.template = getUntil(scan, ">");
+			scan.shift();
+		}
+		const params = splitUntil(getUntil(scan, ")", 0), ",");
+		result.export = exportFlag;
+		result.params = params;
+		if (scan[0] === ":") {
+			scan.shift();
+			result.returns = getUntil(scan, ";");
+		}
+		scan.unshift(";");
+		return result;
+	}
+	if (element === "interface") {
+		const name = scan.shift();
+		scan.shift();
+		const content = splitUntil(getUntil(scan, "}", 0), ";");
+		scan.unshift(";");
+		return {
+			content,
+			name,
+			type: "interface"
+		};
+	}
+	if (element === "type" && /^[A-Za-z0-9]*$/.test(String(scan[0]))) {
+		const name = scan.shift();
+		const then = scan.shift();
+		const result = {
+			name,
+			type: "type"
+		};
+		if (then === "<") {
+			result.template = getUntil(scan, ">");
+			scan.shift();
+		}
+		result.content = getUntil(scan, ";");
+		scan.unshift(";");
+		return result;
+	}
+	if (element === "enum") {
+		const name = scan.shift();
+		scan.shift();
+		const content = getUntil(scan, "}");
+		scan.unshift(";");
+		return {
+			name,
+			options: Object.fromEntries(content.join("").split(",").filter((item) => item.trim()).map((item) => {
+				if (item.includes("=")) {
+					const [name, value] = item.split("=");
+					return [JSON.parse(value), name];
+				}
+				return [name, name];
+			})),
+			type: "enum"
+		};
+	}
+	if (typeof element === "string" && element.startsWith("/*")) return {
+		content: cleanComment(element),
+		type: "comment"
+	};
+	for (const wrapper of wrappers) if (element === wrapper[0]) return {
+		content: splitUntil(getUntil(scan, wrapper[1]), ";").map((item) => splitUntil(item, ",")).map((item) => splitUntil(item, "|")),
+		style: wrapper.join(""),
+		type: "wrap"
+	};
+	return element;
+}
+function cleanArray(input) {
+	if (Array.isArray(input)) {
+		if (input.length === 1) return cleanArray(input[0]);
+		return input.map((element) => cleanArray(element));
+	}
+	if (typeof input === "object" && input !== null) return objectMap(input, ({ value }) => cleanArray(value));
+	return input;
+}
+function cleanComment(comment) {
+	comment = comment.trim();
+	if (!(comment.startsWith("/**") && comment.endsWith("*/"))) return comment;
+	comment = comment.slice(3, -2).split("\n").map((line) => {
+		const trim = line.trim();
+		if (trim.startsWith("* ")) return trim.slice(2);
+		return trim;
+	}).join("\n").trim();
+	return comment.trim();
+}
+function cleanUnion(schema) {
+	if (schema.elements.find((element) => ["undefined", "void"].includes(element.type))) {
+		schema.optional = true;
+		schema.elements = schema.elements.filter((element) => !["undefined", "void"].includes(element.type));
+	}
+	const childUnions = schema.elements.filter((element) => element.type === "union");
+	if (childUnions.length > 0) {
+		schema.elements = schema.elements.filter((element) => element.type !== "union");
+		for (const childUnion of childUnions) schema.elements = [...schema.elements, ...childUnion.elements];
+	}
+	const stringElements = schema.elements.filter((element) => element.type === "string");
+	if (stringElements.length > 1) {
+		const enumValues = [];
+		let anyFlag = false;
+		for (const element of stringElements) if (element.enum) enumValues.push(...element.enum);
+		else anyFlag = true;
+		schema.elements = [...schema.elements.filter((element) => element.type !== "string"), anyFlag ? LogicType.string() : LogicType.string({ enum: enumValues })];
+	}
+	const numberElements = schema.elements.filter((element) => element.type === "number");
+	if (numberElements.length > 1) {
+		const enumValues = [];
+		let anyFlag = false;
+		for (const element of numberElements) if (element.enum) enumValues.push(...element.enum);
+		else anyFlag = true;
+		schema.elements = [...schema.elements.filter((element) => element.type !== "number"), anyFlag ? LogicType.number() : LogicType.number({ enum: enumValues })];
+	}
+	if (schema.elements.length === 1) {
+		const simpleSchema = schema.elements[0];
+		simpleSchema.optional = schema.optional;
+		return simpleSchema;
+	}
+	if (schema.elements.length === 0) return LogicType.void();
+	return schema;
+}
+function cleanInterface(schema) {
+	const template = schema.options?.template ?? [];
+	if (schema.className === "Array") return LogicType.array(template[0]);
+	if (schema.className === "Type" && template[0]?.enum?.length) {
+		const reference = template[0].enum[0];
+		const target = (Array.isArray(reference) ? reference.join("") : String(reference)).split("/");
+		return LogicType.type(target, schema.optional ? { optional: true } : {});
+	}
+	if (schema.className === "keyof") return LogicType.string();
+	if (schema.className === "Record") return LogicType.object({});
+	if (schema.className === "PropertyKey") return LogicType.union([LogicType.string(), LogicType.number()]);
+	if ([
+		"Promise",
+		"Partial",
+		"Required"
+	].includes(schema.className)) {
+		const transform = LogicUtil[schema.className.toLocaleLowerCase()];
+		return transform(template[0]);
+	}
+	if (["Omit", "Pick"].includes(schema.className)) {
+		const transform = LogicUtil[schema.className.toLocaleLowerCase()];
+		return transform(template[0], template[1]?.enum);
+	}
+	return schema;
+}
+function scanner(input) {
+	const elements = [];
+	input = input.replaceAll(/ +/g, " ");
+	input = input.replaceAll(/\s*\n\s*/g, "\n");
+	while (input.length) {
+		if ([" ", "\n"].includes(input[0])) {
+			input = input.slice(1);
+			continue;
+		}
+		if (input.startsWith("/*")) {
+			const commentEnd = input.indexOf("*/");
+			elements.push(input.slice(0, commentEnd + 2));
+			input = input.slice(commentEnd + 2);
+			continue;
+		}
+		if (["'", "\""].includes(input[0])) {
+			const quote = input[0];
+			const literal = input.match(quote === "'" ? /^'((?:[^'\\]|\\.)*)'/ : /^"((?:[^"\\]|\\.)*)"/);
+			if (literal) {
+				elements.push(quote, ...literal[1] ? [literal[1].replaceAll(/\\(.)/g, "$1")] : [], quote);
+				input = input.slice(literal[0].length);
+				continue;
+			}
+		}
+		const startingWord = input.match(/^([a-zA-Z_][a-zA-Z0-9_.]*)/)?.[0];
+		if (startingWord) {
+			input = input.slice(startingWord.length);
+			elements.push(startingWord);
+			continue;
+		}
+		const startingNumber = input.match(/^([0-9]+)/)?.[0];
+		if (startingNumber) {
+			input = input.slice(startingNumber.length);
+			elements.push(startingNumber);
+			continue;
+		}
+		if (input[0] === ">" && elements.at(-1) === "=") {
+			elements.pop();
+			elements.push("=>");
+			input = input.slice(1);
+			continue;
+		}
+		elements.push(input[0]);
+		input = input.slice(1);
+	}
+	return elements;
+}
+function parser(element, options = {}) {
+	if (typeof element === "string") {
+		if (element === "string") return LogicType.string(options);
+		if (element === "number") return LogicType.number(options);
+		if (element === "boolean") return LogicType.boolean(options);
+		if (element === "undefined") return LogicType.void(options);
+		if (["unknown", "any"].includes(element)) return LogicType.unknown(options);
+		if (["undefined", "null"].includes(element)) return LogicType.undefined(options);
+		return cleanInterface(LogicType.interface(element, options));
+	}
+	if (Array.isArray(element)) {
+		if (element[0] === "readonly") element.shift();
+		if (element.length === 1) return parser(element[0], options);
+		if (element.includes("|")) return cleanUnion(LogicType.union(separate(element, (element) => element === "|").map((element) => parser(element)), options));
+		if (element.includes("&")) {
+			const members = separate(element, (element) => element === "&").map((element) => parser(element));
+			if (members.every((member) => [
+				"object",
+				"type",
+				"intersection"
+			].includes(member.type))) return LogicType.intersection(members.flatMap((member) => member.type === "intersection" ? member.elements : [member]), options);
+			return cleanUnion(LogicType.union(members, options));
+		}
+		const last = asLexerNode(element.at(-1));
+		if (last?.type === "wrap" && last.style === "[]") {
+			const base = parser(element.slice(0, -1));
+			const key = getIndexKey(last.content);
+			if (key === void 0) return LogicType.array(base, options);
+			return withOptional(getIndexedType(base, key), options);
+		}
+		if (element[0] === "import" && element[2] === ".") return parser(element.slice(3), options);
+		if (element.length === 2) {
+			const generic = asLexerNode(element[1]);
+			if (generic?.type === "wrap" && generic.style === "<>") {
+				let template = Array.isArray(generic.content) ? generic.content : [generic.content];
+				if (!Array.isArray(template[0])) {
+					if (template.some((element) => isWrap(element, "[]")) || template.some((element) => isWrap(element, "<>")) || template.includes("&") || template.includes("|")) template = [template];
+					else template = template.map((element) => [element]);
+				}
+				return cleanInterface(LogicType.interface(element[0], {
+					...options,
+					options: { template: template.map((element) => parser(element)) }
+				}));
+			}
+		}
+		if (element.length === 3) {
+			if (element[1] === "=>") {
+				const content = asLexerNode(element[0])?.content ?? [];
+				const parameters = !content.length || Array.isArray(content[0]) ? content : [content];
+				return LogicType.function(LogicType.object(Object.fromEntries(parameters.map((parameter) => {
+					return [parameter[0], parser(parameter.slice(2))];
+				}))), parser(element[2]));
+			}
+		}
+		return parser(element[0], options);
+	}
+	if (element.type === "wrap") {
+		const style = element.style ?? "";
+		if (["''", "\"\""].includes(style)) return LogicType.string({
+			...options,
+			enum: [element.content]
+		});
+		if (style === "{}") {
+			const content = element.content;
+			const properties = !content.length || Array.isArray(content[0]) ? content : [content];
+			return LogicType.object(Object.fromEntries(properties.map((property) => [getPropertyKey(property[0]), property]).filter((entry) => entry[0] !== void 0).map(([key, property]) => [key, property[1] === "?" ? parser(property.slice(3), { optional: true }) : parser(property.slice(2))])), options);
+		}
+		if (style === "[]") {
+			const content = element.content;
+			if (content[1] === ":") return LogicType.array(parser(content.slice(2)), options);
+			return LogicType.array(parser(content), options);
+		}
+		if (style === "()") return parser(element.content, options);
+	}
+	console.log("Unknown element");
+	console.log(element);
+	return LogicType.unknown();
+}
+function getIndexKey(content) {
+	if (content === "number") return "[]";
+	return getQuotedString(content);
+}
+function getPropertyKey(element) {
+	return typeof element === "string" ? element : getQuotedString(element);
+}
+function getQuotedString(element) {
+	const node = asLexerNode(element);
+	if (node?.type === "wrap" && ["''", "\"\""].includes(node.style ?? "") && typeof node.content === "string") return node.content;
+}
+function getIndexedType(base, key) {
+	if (base.type === "type") return {
+		...base,
+		path: [...base.path ?? [], key]
+	};
+	return getIndexedSchema(base, key) ?? LogicType.unknown();
+}
+function withOptional(schema, options) {
+	return options.optional ? {
+		...schema,
+		optional: true
+	} : schema;
+}
+function isWrap(element, style) {
+	const node = asLexerNode(element);
+	return node?.type === "wrap" && node.style === style;
+}
+function separate(result, separator) {
+	const output = [[]];
+	for (const element of result) if (separator(element)) output.push([]);
+	else output[output.length - 1].push(element);
+	return output;
+}
+function typeToSchema(type) {
+	try {
+		if (/^[A-Za-z]+\??:/.test(type)) {
+			const [, name, optional, rest] = type.match(/([A-Za-z]+)(\??):(.*)/);
+			const schema = parser(lexer(scanner(rest)));
+			schema.name = name;
+			if (optional === "?") schema.optional = true;
+			return schema;
+		}
+		return parser(lexer(scanner(type)));
+	} catch (error) {
+		console.error("Failed to parse type", type);
+		console.error(error);
+		return LogicType.unknown();
+	}
+}
+function schemaLoop(schema, func, key) {
+	schema = func({
+		key,
+		schema
+	}) || schema;
+	if (schema.type === "object") for (const key in schema.properties) schema.properties[key] = schemaLoop(schema.properties[key], func, key);
+	if (schema.type === "array") schema.items = schemaLoop(schema.items, func);
+	if (schema.type === "record") schema.value = schemaLoop(schema.value, func);
+	if (schema.type === "function") {
+		schema.inputs = schemaLoop(schema.inputs, func);
+		schema.output = schemaLoop(schema.output, func);
+	}
+	if (["union", "intersection"].includes(schema.type)) for (const key in schema.elements) schema.elements[key] = schemaLoop(schema.elements[key], func);
+	return schema;
+}
+function getSubSchema(schema) {
+	while (schema?.sub) schema = schema.sub;
+	return schema;
+}
+function getSchemaDefault(schema) {
+	if (!schema.default) return getDefaultValue(schema);
+	return getValueDefault(schema.default, schema, "name");
+}
+function getValueDefault(value, schema, keyType = "id") {
+	if (schema.type === "object") return getObjectDefault(value || {}, schema);
+	if (schema.type === "array") return getArrayDefault(value ? cloneDeep(value) : [], schema);
+	if (schema.type === "record") return getRecordDefault(value || {}, schema);
+	if (schema.type === "interface" && !isInterfaceConstant(value) && window[schema.className]) return createInterfaceInstance(schema.className);
+	return value ?? getDefaultValue(schema);
+	function getObjectDefault(value, schema) {
+		return objectFullMap(schema.properties || {}, ({ key, value: schemaValue }) => ({
+			key: keyType === "id" ? key : schemaValue.name || key,
+			value: getValueDefault(value[key] ?? value[schemaValue.name], schemaValue, keyType)
+		}));
+	}
+	function getArrayDefault(value, schema) {
+		return value.map((item) => getValueDefault(item, schema.items, keyType));
+	}
+	function getRecordDefault(value, schema) {
+		return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, getValueDefault(item, schema.value, keyType)]));
+	}
+}
+function getDefaultValue(schema, keyType = "id") {
+	if (!schema) return;
+	if (schema.type === "unknown") schema = getSubSchema(schema);
+	if (schema.default !== void 0) {
+		if (isValueSchemaCompatible(schema.default, schema)) return cloneDeep(schema.default);
+	}
+	switch (schema.type) {
+		case "string":
+			if (schema.format === "color") return "#000000";
+			return "";
+		case "number": return 0;
+		case "boolean": return false;
+		case "object": {
+			const result = {};
+			for (const key in schema.properties) {
+				if (schema.properties[key].optional) continue;
+				if (keyType === "name") result[schema.properties[key].name || key] = getDefaultValue(schema.properties[key], keyType);
+				else result[key] = getDefaultValue(schema.properties[key], keyType);
+			}
+			return result;
+		}
+		case "array": return [];
+		case "record": return {};
+		case "interface": return createInterfaceInstance(schema.className);
+		case "union": return getDefaultValue(schema.elements[0], keyType);
+		case "intersection": return Object.assign({}, ...schema.elements.map((element) => getDefaultValue(element, keyType)));
+		default: return;
+	}
+}
+function createInterfaceInstance(className) {
+	const constructor = globalThis[className];
+	if (typeof constructor !== "function") return;
+	try {
+		return new constructor();
+	} catch {
+		return;
+	}
+}
+export { LogicUtil as a, mergeIntersection as c, assertType as d, cleanObject as f, LogicType as i, schemaLoop as l, objectMap as m, ELogicType as n, getSchemaDefault as o, cloneWithFunctions as p, EVarType as r, makeLogicNode as s, ELogicScope as t, typeToSchema as u };