@luna-park/plugin 1.3.1 → 1.4.1

package/dist/index.mjs

@@ -0,0 +1,887 @@
+import { a as LogicUtil, i as LogicType, n as ELogicType, o as makeLogicNode, r as EVarType, t as ELogicScope, u as cloneWithFunctions } from "./dist-hc-SHkAg.mjs";
+import { createElementBlock, openBlock, renderSlot } from "vue";
+import { Type } from "@sinclair/typebox";
+//#region \0/plugin-vue/export-helper
+var export_helper_default = (sfc, props) => {
+	const target = sfc.__vccOpts || sfc;
+	for (const [key, val] of props) target[key] = val;
+	return target;
+};
+//#endregion
+//#region src/components/LSettingsStoryWrapper.vue
+const _sfc_main = {};
+const _hoisted_1 = { class: "story-wrapper" };
+function _sfc_render(_ctx, _cache) {
+	return openBlock(), createElementBlock("div", _hoisted_1, [renderSlot(_ctx.$slots, "default", {}, void 0, true)]);
+}
+var LSettingsStoryWrapper_default = /* @__PURE__ */ export_helper_default(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-8d6cff07"]]);
+//#endregion
+//#region src/types/hooks.ts
+let EPluginHooks = /* @__PURE__ */ function(EPluginHooks) {
+	EPluginHooks["BackendMiddleware"] = "backend/middleware";
+	EPluginHooks["BackendInputNode"] = "backend/input-node";
+	return EPluginHooks;
+}({});
+//#endregion
+//#region src/types/plugin.ts
+let EInjectionKey = /* @__PURE__ */ function(EInjectionKey) {
+	EInjectionKey["ViteImport"] = "viteImport";
+	EInjectionKey["VitePlugin"] = "vitePlugin";
+	EInjectionKey["AppImport"] = "appImport";
+	EInjectionKey["AppBody"] = "appBody";
+	EInjectionKey["AppSetup"] = "appSetup";
+	EInjectionKey["Style"] = "style";
+	EInjectionKey["ServerImport"] = "serverImport";
+	EInjectionKey["ServerBody"] = "serverBody";
+	return EInjectionKey;
+}({});
+//#endregion
+//#region src/types/token.ts
+let ETokenType = /* @__PURE__ */ function(ETokenType) {
+	ETokenType["Color"] = "color";
+	ETokenType["FontSize"] = "font-size";
+	ETokenType["FontWeight"] = "font-weight";
+	ETokenType["FontFamily"] = "font-family";
+	ETokenType["Length"] = "length";
+	ETokenType["Time"] = "time";
+	return ETokenType;
+}({});
+//#endregion
+//#region ../shared/dist/chunk-CfYAbeIz.mjs
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region ../shared/dist/index.mjs
+const config = {
+	backendUrl: "https://luna-park.app",
+	hostUrl: "https://host.luna-park.app",
+	webSocketUrl: "wss://luna-park.app"
+};
+const baseConfig = {
+	credentials: "include",
+	headers: {
+		"Accept": "application/json, text/plain",
+		"Content-Type": "application/json"
+	},
+	mode: "cors"
+};
+const baseMultiConfig = {
+	credentials: "include",
+	headers: { Accept: "application/json, text/plain" },
+	mode: "cors"
+};
+var api_default = {
+	async delete(url, config) {
+		const init = {
+			...baseConfig,
+			method: "DELETE",
+			...config
+		};
+		if (!init.body) {
+			init.headers = { ...init.headers };
+			delete init.headers?.["Content-Type"];
+		}
+		return fetch(url, init);
+	},
+	async get(url, config) {
+		return await fetch(url, {
+			...baseConfig,
+			method: "GET",
+			...config
+		});
+	},
+	getBaseUrl({ dev } = { dev: false }) {
+		return `${config.backendUrl}/${dev ? "dev" : "api"}`;
+	},
+	async multipart(url, data, config) {
+		return await fetch(url, {
+			...baseMultiConfig,
+			body: data,
+			method: "POST",
+			...config
+		});
+	},
+	async post(url, data, config) {
+		return await fetch(url, {
+			...baseConfig,
+			body: JSON.stringify(data) || "{}",
+			method: "POST",
+			...config
+		});
+	},
+	async put(url, data, config) {
+		return await fetch(url, {
+			...baseConfig,
+			body: JSON.stringify(data) || "{}",
+			method: "PUT",
+			...config
+		});
+	}
+};
+let ERouteType = /* @__PURE__ */ function(ERouteType) {
+	ERouteType["Get"] = "get";
+	ERouteType["Post"] = "post";
+	ERouteType["Delete"] = "delete";
+	ERouteType["Put"] = "put";
+	return ERouteType;
+}({});
+const TypeDate = Type.String({ format: "date-time" });
+var app_exports$1 = /* @__PURE__ */ __exportAll({
+	app: () => app,
+	appEdits: () => appEdits
+});
+const app = Type.Object({
+	name: Type.String(),
+	config: Type.Record(Type.String(), Type.Unknown()),
+	tree: Type.Unknown(),
+	version: Type.Optional(Type.Number())
+});
+const appEdits = Type.Array(Type.Object({
+	file: Type.Unknown(),
+	path: Type.String()
+}));
+const keyConfig = Type.Object({
+	id: Type.Optional(Type.String()),
+	domain: Type.String(),
+	owner: Type.String(),
+	private: Type.String(),
+	public: Type.String()
+});
+const 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()
+	})
+});
+const publicProject = Type.Object({ ...project.properties });
+const privateProject = Type.Object({
+	...project.properties,
+	app: Type.Unknown()
+});
+let EPlanKey = /* @__PURE__ */ function(EPlanKey) {
+	EPlanKey["Free"] = "free";
+	EPlanKey["Edu"] = "edu";
+	EPlanKey["Pro"] = "pro";
+	EPlanKey["Org"] = "org";
+	return EPlanKey;
+}({});
+const flags = {
+	free: {
+		compilation: {
+			desktop: false,
+			export: true,
+			mobile: false,
+			source: false,
+			web: true
+		},
+		editor: {
+			desktop: false,
+			web: true
+		},
+		watermark: true
+	},
+	pro: {
+		compilation: {
+			desktop: true,
+			export: true,
+			mobile: true,
+			source: true,
+			web: true
+		},
+		editor: {
+			desktop: true,
+			web: true
+		},
+		watermark: false
+	}
+};
+EPlanKey.Org, flags.pro, EPlanKey.Pro, flags.pro, EPlanKey.Edu, flags.pro, EPlanKey.Free, flags.free;
+const 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() })
+});
+let EElementType = /* @__PURE__ */ function(EElementType) {
+	EElementType["Script"] = "script";
+	EElementType["Standalone"] = "standalone";
+	EElementType["Folder"] = "folder";
+	EElementType["MainLogic"] = "main";
+	EElementType["Logic"] = "logic";
+	EElementType["Config"] = "config";
+	EElementType["Text"] = "text";
+	EElementType["Store"] = "store";
+	EElementType["Database"] = "database";
+	EElementType["Component"] = "component";
+	EElementType["Route"] = "route";
+	EElementType["Type"] = "type";
+	EElementType["Cron"] = "cron";
+	EElementType["Media"] = "media";
+	return EElementType;
+}({});
+const types = {
+	...app_exports$1,
+	keyConfig,
+	privateProject,
+	project,
+	publicProject,
+	user
+};
+var app_exports = /* @__PURE__ */ __exportAll({
+	edit: () => edit$1,
+	get: () => get$2
+});
+const get$2 = {
+	type: ERouteType.Get,
+	params: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({
+		app: types.app,
+		readOnly: Type.Boolean()
+	}) },
+	url: "/app/:id"
+};
+const 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"
+};
+var auth_exports = /* @__PURE__ */ __exportAll({
+	authorize: () => authorize,
+	client: () => client,
+	me: () => me,
+	token: () => token
+});
+const 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"
+};
+const 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"
+};
+const me = {
+	type: ERouteType.Get,
+	headers: Type.Object({ authorization: Type.String() }),
+	response: { 200: Type.Object({
+		id: Type.String(),
+		mail: Type.String()
+	}) },
+	url: "/auth/me"
+};
+const 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"
+};
+var compiler_exports = /* @__PURE__ */ __exportAll({
+	build: () => build,
+	compile: () => compile$1,
+	download: () => download
+});
+const 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"
+};
+const 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"
+};
+const 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?"
+};
+var desktop_exports = /* @__PURE__ */ __exportAll({ latest: () => latest });
+const latest = {
+	type: ERouteType.Get,
+	dev: true,
+	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"
+};
+var file_exports = /* @__PURE__ */ __exportAll({
+	list: () => list$3,
+	remove: () => remove$2,
+	status: () => status,
+	upload: () => upload
+});
+const upload = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		file: Type.Object({
+			filename: Type.String(),
+			mimetype: Type.String()
+		}),
+		project: Type.Object({ value: Type.String() })
+	}),
+	multipart: true,
+	response: { 200: Type.Object({
+		name: Type.String(),
+		mimeType: Type.String(),
+		target: Type.String()
+	}) },
+	url: "/file/upload"
+};
+const remove$2 = {
+	type: ERouteType.Post,
+	body: Type.Object({ target: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/file/remove"
+};
+const list$3 = {
+	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"
+};
+const status = {
+	type: ERouteType.Get,
+	response: { 200: Type.Object({
+		limit: Type.Number(),
+		total: Type.Number()
+	}) },
+	url: "/file/status"
+};
+var integrations_exports = /* @__PURE__ */ __exportAll({ googleAuth: () => googleAuth });
+const 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"
+};
+var keyConfig_exports = /* @__PURE__ */ __exportAll({
+	check: () => check$1,
+	create: () => create$2,
+	list: () => list$2,
+	remove: () => remove$1
+});
+const create$2 = {
+	type: ERouteType.Post,
+	body: Type.Object({ domain: Type.String() }),
+	response: { 200: Type.Object({
+		key: types.keyConfig,
+		message: Type.String()
+	}) },
+	url: "/key-config"
+};
+const list$2 = {
+	type: ERouteType.Get,
+	response: { 200: Type.Array(types.keyConfig) },
+	url: "/key-config"
+};
+const remove$1 = {
+	type: ERouteType.Delete,
+	params: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/key-config/:id"
+};
+const check$1 = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		domain: Type.String(),
+		key: Type.String()
+	}),
+	dev: true,
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/key-config/check"
+};
+var license_exports = /* @__PURE__ */ __exportAll({
+	check: () => check,
+	link: () => link,
+	list: () => list$1,
+	reset: () => reset
+});
+const reset = {
+	type: ERouteType.Post,
+	body: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/license/reset"
+};
+const link = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		name: Type.String(),
+		fingerprint: Type.String(),
+		key: Type.String()
+	}),
+	dev: true,
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/license/link"
+};
+const check = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		fingerprint: Type.String(),
+		key: Type.String()
+	}),
+	dev: true,
+	response: { 200: Type.Object({
+		mail: Type.Optional(Type.String()),
+		valid: Type.Boolean(),
+		version: Type.Optional(Type.String())
+	}) },
+	url: "/license/check"
+};
+const list$1 = {
+	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"
+};
+var magiclink_exports = /* @__PURE__ */ __exportAll({
+	activate: () => activate,
+	create: () => create$1,
+	signup: () => signup
+});
+const 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"
+};
+const 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"
+};
+const 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"
+};
+var payment_exports = /* @__PURE__ */ __exportAll({
+	checkout: () => checkout,
+	portal: () => portal
+});
+const 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"
+};
+const portal = {
+	type: ERouteType.Post,
+	response: { 200: Type.Object({
+		message: Type.String(),
+		redirection: Type.String()
+	}) },
+	url: "/payment/portal"
+};
+var project_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	edit: () => edit,
+	list: () => list,
+	proxy: () => proxy,
+	remove: () => remove,
+	star: () => star
+});
+const create = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		icon: Type.String(),
+		template: Type.Union([
+			Type.Literal("default"),
+			Type.Literal("empty"),
+			Type.Literal("frontend"),
+			Type.Literal("backend"),
+			Type.Literal("database"),
+			Type.Literal("testing")
+		]),
+		title: Type.String()
+	}),
+	response: { 200: Type.Object({
+		message: Type.String(),
+		project: types.publicProject
+	}) },
+	url: "/project/create"
+};
+const list = {
+	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"
+};
+const remove = {
+	type: ERouteType.Delete,
+	params: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/project/remove/:id"
+};
+const edit = {
+	type: ERouteType.Post,
+	body: types.privateProject,
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/project/edit"
+};
+const star = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		id: Type.String(),
+		like: Type.Boolean()
+	}),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/project/star"
+};
+const 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"
+};
+var script_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile,
+	get: () => get$1,
+	update: () => update$1
+});
+const get$1 = {
+	type: ERouteType.Get,
+	params: Type.Object({
+		id: Type.String(),
+		script: Type.String()
+	}),
+	response: { 200: Type.String() },
+	url: "/script/:id/:script"
+};
+const 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"
+};
+const 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"
+};
+var turnstile_exports = /* @__PURE__ */ __exportAll({ tick: () => tick });
+const tick = {
+	type: ERouteType.Post,
+	body: Type.Object({
+		data: Type.Optional(Type.Unknown()),
+		scope: Type.String()
+	}),
+	response: { 200: Type.Object({}) },
+	url: "/turnstile/tick"
+};
+var user_exports = /* @__PURE__ */ __exportAll({
+	disconnect: () => disconnect,
+	get: () => get,
+	ping: () => ping,
+	unsubscribe: () => unsubscribe,
+	update: () => update,
+	waitlist: () => waitlist
+});
+const ping = {
+	type: ERouteType.Get,
+	response: { 200: Type.Object({
+		message: Type.String(),
+		user: Type.Optional(types.user)
+	}) },
+	url: "/user/ping"
+};
+const get = {
+	type: ERouteType.Get,
+	response: { 200: types.user },
+	url: "/user"
+};
+const update = {
+	type: ERouteType.Post,
+	body: Type.Partial(types.user),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/user"
+};
+const disconnect = {
+	type: ERouteType.Get,
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/user/disconnect"
+};
+const waitlist = {
+	type: ERouteType.Post,
+	body: Type.Object({ mail: Type.String({ format: "email" }) }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/user/waitlist"
+};
+const unsubscribe = {
+	type: ERouteType.Post,
+	body: Type.Object({ id: Type.String() }),
+	response: { 200: Type.Object({ message: Type.String() }) },
+	url: "/user/unsubscribe"
+};
+const routes = {
+	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
+};
+const api = {};
+for (const serviceName of Object.keys(routes)) {
+	api[serviceName] = {};
+	for (const routeName of Object.keys(routes[serviceName])) {
+		const route = routes[serviceName][routeName];
+		api[serviceName][routeName] = async (args = {}) => {
+			const url = new URL(api_default.getBaseUrl({ dev: route.dev }) + route.url);
+			if (route.params && args.params) for (const key of Object.keys(route.params.properties)) url.href = url.href.replace(`:${key}`, args.params[key]);
+			if (args.querystring) {
+				for (const key of Object.keys(args.querystring)) if (args.querystring[key]) url.searchParams.append(key, args.querystring[key].toString());
+			}
+			let service = api_default[route.type];
+			if (route.multipart) service = api_default.multipart;
+			const result = await service(url.href, args.body);
+			const content = await getContent(result);
+			if (result.status >= 400) throw new Error(`Error ${result.status} (${result.statusText}): ${content.message || content}`);
+			return content;
+		};
+	}
+}
+function getContent(response) {
+	if (response.headers.get("Content-Type")?.startsWith("application/json")) return response.json();
+	return response.text();
+}
+//#endregion
+//#region src/index.ts
+function makePlugin(plugin) {
+	return plugin;
+}
+function makeComponent(component) {
+	return component;
+}
+async function loadPlugin(plugin, env) {
+	const result = cloneWithFunctions(plugin);
+	const config = env.app?.config?.plugins?.[plugin.id]?.config;
+	for (const category of [
+		"build",
+		"editor",
+		"inject"
+	]) if (result[category]) for (const key in result[category]) result[category][key] = await getPluginParam(result[category][key], {
+		...env,
+		config
+	});
+	return result;
+}
+async function getPluginParam(target, env) {
+	if (typeof target === "function") return target({
+		mode: "editor",
+		...env
+	});
+	return target;
+}
+//#endregion
+export { EElementType, EInjectionKey, ELogicScope, ELogicType, EPluginHooks, ETokenType, EVarType, LSettingsStoryWrapper_default as LSettingsStoryWrapper, LogicType, LogicUtil, getPluginParam, loadPlugin, makeComponent, makeLogicNode, makePlugin };