@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/grid/dist/scene/state.js

@@ -0,0 +1,269 @@
+import { observable } from "../../../r-html/dist/observable/index.js";
+import { lightTheme } from "../theme.js";
+import { DEFAULT_FONT, fontLoaded, measureFont } from "../font.js";
+import { selectCell, selectedColumns, selectedRows } from "../model/selection.js";
+import { columnOffsets } from "../model/columns.js";
+import { DEFAULT_OVERSCAN, visibleRange } from "../model/viewport.js";
+import { createTextFitter, emptyPretextCaches } from "../model/text.js";
+import { markDirty, requestFlush } from "../../../r-html-konva/dist/batchDraw.js";
+import { computeLayout } from "./layout.js";
+//#region ../grid/dist/scene/state.js
+var NO_HEADERS = Object.freeze({
+	intersected: [],
+	covered: []
+});
+var digitWidths = /* @__PURE__ */ new Map();
+function measureDigitWidth(font) {
+	const held = digitWidths.get(font);
+	if (held !== void 0) return held;
+	const context = typeof document === "undefined" ? null : document.createElement("canvas").getContext("2d");
+	if (!context) return 0;
+	context.font = font;
+	let width = 0;
+	for (const digit of "0123456789") width = Math.max(width, context.measureText(digit).width);
+	if (fontLoaded(font)) digitWidths.set(font, width);
+	return width;
+}
+var trackable = (value) => Object.isFrozen(value) ? { ...value } : value;
+var wholeCount = (value) => Math.max(0, Math.floor(value) || 0);
+var wholePixels = (value) => Math.max(0, Math.round(value) || 0);
+var clamp = (value, max) => Math.min(max, Math.max(0, Number.isFinite(value) ? Math.round(value) : 0));
+function drawnOffsets(columns, resize) {
+	if (!resize || !columns[resize.col]) return columnOffsets(columns);
+	return columnOffsets(columns.map((column, index) => index === resize.col ? {
+		...column,
+		width: resize.width
+	} : column));
+}
+function sameResize(a, b) {
+	if (a === b) return true;
+	return a !== null && b !== null && a.col === b.col && a.width === b.width;
+}
+function createSceneState(init) {
+	const font = init.font ?? DEFAULT_FONT;
+	const theme = init.theme ?? lightTheme;
+	const selection = init.selection ?? selectCell({
+		row: 0,
+		col: 0
+	});
+	const columns = init.columns;
+	const offsets = columnOffsets(columns);
+	const rowCount = wholeCount(init.rowCount);
+	const rowHeight = init.rowHeight !== void 0 && init.rowHeight > 0 ? init.rowHeight : 28;
+	const width = wholePixels(init.width ?? 0);
+	const height = wholePixels(init.height ?? 0);
+	const frozenColumns = init.frozenColumns ?? 0;
+	const digitWidth = measureDigitWidth(font);
+	const state = {
+		width,
+		height,
+		scrollTop: 0,
+		scrollLeft: 0,
+		rowCount,
+		columns,
+		offsets,
+		frozenColumns,
+		rowHeight,
+		theme: trackable(theme),
+		font,
+		metrics: measureFont(font),
+		digitWidth,
+		version: init.version ?? 0,
+		getCell: init.getCell,
+		getCellStyle: init.getCellStyle,
+		selection: trackable(selection),
+		resize: null,
+		layout: computeLayout({
+			width,
+			height,
+			rowCount,
+			rowHeight,
+			offsets,
+			frozenColumns,
+			digitWidth
+		})
+	};
+	const observed = observable(state, { shallow: true });
+	const fitter = createTextFitter();
+	const layers = {
+		body: null,
+		overlay: null
+	};
+	const frame = {
+		range: {
+			rowStart: 0,
+			rowEnd: -1,
+			colStart: 0,
+			colEnd: -1,
+			frozenEnd: -1
+		},
+		rows: NO_HEADERS,
+		columns: NO_HEADERS
+	};
+	let pendingSize = null;
+	let provisional = !fontLoaded(font);
+	let themeSource = theme;
+	let selectionSource = selection;
+	const mark = (body, overlay) => {
+		if (body && layers.body) markDirty(layers.body);
+		if (overlay && layers.overlay) markDirty(layers.overlay);
+	};
+	const relayout = () => {
+		const layout = computeLayout(state);
+		observed.layout = layout;
+		if (state.scrollTop > layout.maxScrollTop) observed.scrollTop = layout.maxScrollTop;
+		if (state.scrollLeft > layout.maxScrollLeft) observed.scrollLeft = layout.maxScrollLeft;
+	};
+	const remeasure = () => {
+		observed.metrics = measureFont(state.font);
+		observed.digitWidth = measureDigitWidth(state.font);
+		relayout();
+		mark(true, true);
+	};
+	const range = (overscan = DEFAULT_OVERSCAN) => visibleRange(state.scrollTop, state.scrollLeft, {
+		width: state.layout.cellWidth,
+		height: state.layout.cellHeight,
+		rowCount: state.rowCount,
+		frozenColumns: state.frozenColumns
+	}, state.rowHeight, state.offsets, overscan);
+	const beginFrame = (headers) => {
+		const next = range();
+		const rows = next.rowEnd - next.rowStart + 1;
+		const cols = next.frozenEnd + 1 + next.colEnd - next.colStart + 1;
+		frame.range = next;
+		if (headers) {
+			const bounds = {
+				rowCount: state.rowCount,
+				colCount: state.columns.length
+			};
+			frame.rows = selectedRows(state.selection, bounds);
+			frame.columns = selectedColumns(state.selection, bounds);
+		}
+		fitter.beginFrame(state.font, state.metrics.maxAdvance);
+		fitter.reserve(rows * cols + cols);
+	};
+	const bindFrame = (layer, headers) => {
+		layer.on("beforeDraw.grid", () => beginFrame(headers));
+		layer.on("draw.grid", () => {
+			if (fitter.hasDeferred()) markDirty(layer);
+		});
+	};
+	return {
+		state,
+		observed,
+		frame,
+		fitter,
+		layers,
+		visibleRange: range,
+		setScroll(top, left) {
+			const nextTop = clamp(top, state.layout.maxScrollTop);
+			const nextLeft = clamp(left, state.layout.maxScrollLeft);
+			if (nextTop === state.scrollTop && nextLeft === state.scrollLeft) return;
+			observed.scrollTop = nextTop;
+			observed.scrollLeft = nextLeft;
+			mark(true, false);
+		},
+		setSize(sizeWidth, sizeHeight) {
+			const nextWidth = wholePixels(sizeWidth);
+			const nextHeight = wholePixels(sizeHeight);
+			if (nextWidth === state.width && nextHeight === state.height) return;
+			observed.width = nextWidth;
+			observed.height = nextHeight;
+			relayout();
+			pendingSize = {
+				width: nextWidth,
+				height: nextHeight
+			};
+			requestFlush();
+		},
+		setSelection(selection) {
+			if (selection !== selectionSource) {
+				selectionSource = selection;
+				observed.selection = trackable(selection);
+			}
+			mark(false, true);
+		},
+		setTheme(theme) {
+			if (theme === themeSource) return;
+			themeSource = theme;
+			observed.theme = trackable(theme);
+			mark(true, true);
+		},
+		setFont(nextFont) {
+			if (nextFont === state.font) return;
+			observed.font = nextFont;
+			remeasure();
+			provisional = !fontLoaded(nextFont);
+		},
+		refreshFont() {
+			if (!provisional || !fontLoaded(state.font)) return;
+			provisional = false;
+			emptyPretextCaches();
+			fitter.reset();
+			remeasure();
+		},
+		setVersion(version) {
+			if (version === state.version) return;
+			observed.version = version;
+			mark(true, true);
+		},
+		setColumns(nextColumns) {
+			if (nextColumns === state.columns) return;
+			observed.columns = nextColumns;
+			observed.offsets = drawnOffsets(nextColumns, state.resize);
+			relayout();
+			mark(true, true);
+		},
+		setRowCount(nextRowCount) {
+			const count = wholeCount(nextRowCount);
+			if (count === state.rowCount) return;
+			observed.rowCount = count;
+			relayout();
+			mark(true, true);
+		},
+		setFrozenColumns(nextFrozen) {
+			if (nextFrozen === state.frozenColumns) return;
+			observed.frozenColumns = nextFrozen;
+			relayout();
+			mark(true, true);
+		},
+		setRowHeight(nextRowHeight) {
+			if (!(nextRowHeight > 0) || nextRowHeight === state.rowHeight) return;
+			observed.rowHeight = nextRowHeight;
+			relayout();
+			mark(true, true);
+		},
+		setGetters(getCell, getCellStyle) {
+			if (getCell === state.getCell && getCellStyle === state.getCellStyle) return;
+			observed.getCell = getCell;
+			observed.getCellStyle = getCellStyle;
+			mark(true, false);
+		},
+		setResize(resize) {
+			if (sameResize(resize, state.resize)) return;
+			observed.resize = resize;
+			observed.offsets = drawnOffsets(state.columns, resize);
+			relayout();
+			mark(true, true);
+		},
+		bindLayers(body, overlay) {
+			layers.body = body;
+			layers.overlay = overlay;
+			bindFrame(body, false);
+			bindFrame(overlay, true);
+			return () => {
+				body.off("beforeDraw.grid draw.grid");
+				overlay.off("beforeDraw.grid draw.grid");
+				if (layers.body === body) layers.body = null;
+				if (layers.overlay === overlay) layers.overlay = null;
+			};
+		},
+		takePendingSize() {
+			const size = pendingSize;
+			pendingSize = null;
+			return size;
+		}
+	};
+}
+//#endregion
+export { createSceneState };

package/dist/grid/dist/theme.js

@@ -0,0 +1,37 @@
+//#region ../grid/dist/theme.js
+var lightTheme = Object.freeze({
+	background: "#ffffff",
+	headerBackground: "#f8f9fa",
+	headerText: "#444746",
+	text: "#1f1f1f",
+	gridLine: "#e1e3e1",
+	frozenBorder: "#c4c7c5",
+	selectionFill: "#1a73e81a",
+	selectionBorder: "#1a73e8",
+	activeCellBorder: "#1a73e8",
+	selectedHeaderBackground: "#d6eedb",
+	selectedHeaderText: "#ffffff",
+	fullSelectionBackground: "#137333",
+	readonlyBackground: "#f1f3f4",
+	scrollbarThumb: "#bdc1c6",
+	scrollbarTrack: "#f8f9fa"
+});
+Object.freeze({
+	background: "#1f1f1f",
+	headerBackground: "#282a2c",
+	headerText: "#c4c7c5",
+	text: "#e3e3e3",
+	gridLine: "#3c4043",
+	frozenBorder: "#5f6368",
+	selectionFill: "#8ab4f829",
+	selectionBorder: "#8ab4f8",
+	activeCellBorder: "#8ab4f8",
+	selectedHeaderBackground: "#24392b",
+	selectedHeaderText: "#ffffff",
+	fullSelectionBackground: "#198639",
+	readonlyBackground: "#2a2b2e",
+	scrollbarThumb: "#5f6368",
+	scrollbarTrack: "#242526"
+});
+//#endregion
+export { lightTheme };

package/dist/hooks/useDarkMode.d.ts

@@ -2,5 +2,7 @@ export declare function useDarkMode(): {
     state: {
         isDark: boolean;
     };
+    /** Lets the OS color scheme go now and on every later mount, for an element destroyed while still in a page. */
+    stop: () => void;
 };
 //# sourceMappingURL=useDarkMode.d.ts.map

package/dist/hooks/useDarkMode.js

@@ -0,0 +1,35 @@
+import { onMounted } from "../r-html/dist/render/part/node/component/hooks.js";
+import { observable } from "../r-html/dist/observable/index.js";
+import { useUnmounted } from "./useUnmounted.js";
+//#region src/hooks/useDarkMode.ts
+function useDarkMode() {
+	const mediaQuery = globalThis.matchMedia("(prefers-color-scheme: dark)");
+	const state = observable({ isDark: mediaQuery.matches }, { shallow: true });
+	const { addUnsubscribe } = useUnmounted();
+	let listening = false;
+	let stopped = false;
+	const handleChange = (event) => {
+		state.isDark = event.matches;
+	};
+	const unlisten = () => {
+		if (!listening) return;
+		listening = false;
+		mediaQuery.removeEventListener("change", handleChange);
+	};
+	onMounted(() => {
+		if (stopped) return;
+		state.isDark = mediaQuery.matches;
+		mediaQuery.addEventListener("change", handleChange);
+		listening = true;
+		addUnsubscribe(unlisten);
+	});
+	return {
+		state,
+		stop: () => {
+			stopped = true;
+			unlisten();
+		}
+	};
+}
+//#endregion
+export { useDarkMode };

package/dist/hooks/useFlipAnimation.js

@@ -0,0 +1,10 @@
+import { onBeforeUpdate, onUpdated } from "../r-html/dist/render/part/node/component/hooks.js";
+import { FlipAnimation } from "../utils/flipAnimation.js";
+//#region src/hooks/useFlipAnimation.ts
+function useFlipAnimation(root, selector, animationName) {
+	const flipAnimation = new FlipAnimation(root, selector, animationName);
+	onBeforeUpdate(() => flipAnimation.snapshot());
+	onUpdated(() => flipAnimation.play());
+}
+//#endregion
+export { useFlipAnimation };

package/dist/hooks/useKeyBindingMap.js

@@ -0,0 +1,55 @@
+import { bindKeys } from "../utils/keyboard-shortcut/bindKeys.js";
+import { KeyBindingName, isComposing } from "../utils/keyboard-shortcut/index.js";
+import { isEditableTarget } from "../utils/validation.js";
+import { onMounted } from "../r-html/dist/render/part/node/component/hooks.js";
+import { watch } from "../r-html/dist/observable/index.js";
+import { useAppContext } from "../components/appContext.js";
+import { useUnmounted } from "./useUnmounted.js";
+import { isTakenOver } from "../utils/takeover.js";
+//#region src/hooks/useKeyBindingMap.ts
+var YIELDS_TO_A_CARET = /* @__PURE__ */ new Set([
+	KeyBindingName.selectAllTable,
+	KeyBindingName.handTool,
+	KeyBindingName.removeSelection,
+	KeyBindingName.groupSelectedTables
+]);
+var YIELDS_TO_A_TAKEOVER = /* @__PURE__ */ new Set([KeyBindingName.findReplace]);
+function useKeyBindingMap(ctx, root) {
+	const app = useAppContext(ctx);
+	const { addUnsubscribe } = useUnmounted();
+	const yields = (type, event) => {
+		const { state } = app.value.store;
+		return YIELDS_TO_A_CARET.has(type) && isEditableTarget(event.target) || YIELDS_TO_A_TAKEOVER.has(type) && isTakenOver(state);
+	};
+	let unbinding = () => {};
+	const keyBinding = () => {
+		const { keyBindingMap, shortcut$ } = app.value;
+		const $root = root.value;
+		unbinding();
+		unbinding = bindKeys($root, Object.keys(keyBindingMap).reduce((acc, key) => {
+			const type = key;
+			keyBindingMap[type].forEach((option) => {
+				acc[option.shortcut] = (event) => {
+					if (isComposing(event)) return;
+					if (yields(type, event)) return;
+					if (option.preventDefault) event.preventDefault();
+					if (option.stopPropagation) event.stopPropagation();
+					shortcut$.next({
+						type,
+						event
+					});
+				};
+			});
+			return acc;
+		}, {}));
+	};
+	onMounted(() => {
+		const { keyBindingMap } = app.value;
+		keyBinding();
+		addUnsubscribe(watch(keyBindingMap).subscribe(keyBinding), () => {
+			unbinding();
+		});
+	});
+}
+//#endregion
+export { useKeyBindingMap };

package/dist/hooks/useNavigatorLanguages.js

@@ -0,0 +1,22 @@
+import { onMounted } from "../r-html/dist/render/part/node/component/hooks.js";
+import { observable } from "../r-html/dist/observable/index.js";
+import { useUnmounted } from "./useUnmounted.js";
+//#region src/hooks/useNavigatorLanguages.ts
+var readLanguages = () => [...window.navigator.languages];
+function useNavigatorLanguages() {
+	const state = observable({ languages: readLanguages() }, { shallow: true });
+	const { addUnsubscribe } = useUnmounted();
+	const handleChange = () => {
+		state.languages = readLanguages();
+	};
+	onMounted(() => {
+		state.languages = readLanguages();
+		window.addEventListener("languagechange", handleChange);
+		addUnsubscribe(() => {
+			window.removeEventListener("languagechange", handleChange);
+		});
+	});
+	return { state };
+}
+//#endregion
+export { useNavigatorLanguages };

package/dist/hooks/usePinchZoom.d.ts

@@ -10,6 +10,11 @@ export type PinchZoomOptions = {
     source?: GeometrySource;
     /** Whether the scene zooms by a pinch now; an overlay over it does not. */
     enabled?: () => boolean;
+    /**
+     * Whether the scene takes a wheel, a pinch or a touch at all. While it does
+     * not, none is held off the page or spent here.
+     */
+    interactive?: () => boolean;
 };
 /**
  * The pinches a store scene zooms by: a trackpad's about the pointer, and two
@@ -20,7 +25,7 @@ export type PinchZoomOptions = {
  * const pinch = usePinchZoom({ app: () => app.value, root });
  * if (pinch.handleWheel(event)) return;
  */
-export declare function usePinchZoom({ app, root, source, enabled, }: PinchZoomOptions): {
+export declare function usePinchZoom({ app, root, source, enabled, interactive, }: PinchZoomOptions): {
     handleWheel: (event: WheelEvent) => boolean;
     handleTouchstart: (event: MouseEvent | TouchEvent) => boolean;
 };

package/dist/hooks/usePinchZoom.js

@@ -0,0 +1,60 @@
+import { zoomInRange, zoomLevelInRange } from "../utils/validation.js";
+import { onMounted } from "../r-html/dist/render/part/node/component/hooks.js";
+import { getZoomTransform, toScenePoint } from "../konva/scene/viewport.js";
+import { pinchZoomAction$ } from "../engine/modules/settings/generator.actions.js";
+import { useUnmounted } from "./useUnmounted.js";
+import { createPinch, isPinchWheel, pinchWheelScale } from "../utils/pinch.js";
+//#region src/hooks/usePinchZoom.ts
+function usePinchZoom({ app, root, source, enabled = () => true, interactive = () => true }) {
+	const { addUnsubscribe } = useUnmounted();
+	let reached = {
+		exact: 0,
+		stored: NaN
+	};
+	const transformOf = () => getZoomTransform(app().store.state, source);
+	const pointIn = (event) => {
+		const { x, y } = root.value.getBoundingClientRect();
+		return {
+			x: event.clientX - x,
+			y: event.clientY - y
+		};
+	};
+	const zoomTo = (zoomLevel, screen, scene) => {
+		app().store.dispatch(pinchZoomAction$({
+			zoomLevel,
+			screen,
+			scene
+		}, source));
+	};
+	const pinch = createPinch(() => root.value, (center) => {
+		if (!enabled()) return null;
+		const transform = transformOf();
+		const { zoomLevel } = transform;
+		const scene = toScenePoint(transform, center);
+		return ({ scale, center: now }) => zoomTo(zoomLevel * scale, now, scene);
+	}, { interactive });
+	const handleWheel = (event) => {
+		if (!isPinchWheel(event)) return false;
+		if (!interactive()) return true;
+		event.preventDefault();
+		if (!enabled()) return true;
+		const { zoomLevel } = transformOf();
+		const from = reached.stored === zoomLevel ? reached.exact : zoomLevel;
+		const exact = zoomInRange(from * pinchWheelScale(event));
+		reached = {
+			exact,
+			stored: zoomLevelInRange(exact)
+		};
+		zoomTo(exact, pointIn(event));
+		return true;
+	};
+	onMounted(() => {
+		addUnsubscribe(pinch.listen());
+	});
+	return {
+		handleWheel,
+		handleTouchstart: pinch.handleTouchstart
+	};
+}
+//#endregion
+export { usePinchZoom };

package/dist/hooks/useUnmounted.js

@@ -0,0 +1,16 @@
+import { onUnmounted } from "../r-html/dist/render/part/node/component/hooks.js";
+import { isFunction } from "es-toolkit";
+//#region src/hooks/useUnmounted.ts
+function useUnmounted() {
+	const unsubscribeSet = /* @__PURE__ */ new Set();
+	const addUnsubscribe = (...args) => {
+		args.forEach((unsubscribe) => unsubscribeSet.add(unsubscribe));
+	};
+	onUnmounted(() => {
+		Array.from(unsubscribeSet).forEach((unsubscribe) => isFunction(unsubscribe) ? unsubscribe() : unsubscribe.unsubscribe());
+		unsubscribeSet.clear();
+	});
+	return { addUnsubscribe };
+}
+//#endregion
+export { useUnmounted };

package/dist/hooks/useViewShortcut.d.ts

@@ -0,0 +1,14 @@
+import { Ctx } from '../internal-types';
+import { KeyBindingName } from '../utils/keyboard-shortcut';
+/**
+ * The chords a read-only view answers: the three zoom chords, and the palette's
+ * search and Escape, which the palette answers itself.
+ */
+export declare const VIEW_KEY_BINDINGS: ReadonlyArray<KeyBindingName>;
+/**
+ * The read-only view's keys. It narrows the app's map to VIEW_KEY_BINDINGS, so
+ * useKeyBindingMap binds those alone and every other press goes on to the page
+ * unprevented, and zooms on the zoom chords as the editor's canvas does.
+ */
+export declare function useViewShortcut(ctx: Ctx): void;
+//# sourceMappingURL=useViewShortcut.d.ts.map

package/dist/hooks/useViewShortcut.js

@@ -0,0 +1,34 @@
+import { KeyBindingName, pickKeyBindingMap } from "../utils/keyboard-shortcut/index.js";
+import { onBeforeMount, onMounted } from "../r-html/dist/render/part/node/component/hooks.js";
+import { Open } from "../constants/open.js";
+import { changeZoomLevelAction$, streamZoomLevelAction$ } from "../engine/modules/settings/generator.actions.js";
+import { useAppContext } from "../components/appContext.js";
+import { useUnmounted } from "./useUnmounted.js";
+import "../constants/zoom.js";
+//#region src/hooks/useViewShortcut.ts
+var VIEW_KEY_BINDINGS = [
+	KeyBindingName.zoomIn,
+	KeyBindingName.zoomOut,
+	KeyBindingName.zoomReset,
+	KeyBindingName.search,
+	KeyBindingName.stop
+];
+function useViewShortcut(ctx) {
+	const app = useAppContext(ctx);
+	const { addUnsubscribe } = useUnmounted();
+	const handleShortcut = ({ type }) => {
+		const { store } = app.value;
+		if (store.state.editor.openMap[Open.search]) return;
+		type === KeyBindingName.zoomIn && store.dispatch(streamZoomLevelAction$(.04));
+		type === KeyBindingName.zoomOut && store.dispatch(streamZoomLevelAction$(-.04));
+		type === KeyBindingName.zoomReset && store.dispatch(changeZoomLevelAction$(1));
+	};
+	onBeforeMount(() => {
+		pickKeyBindingMap(app.value.keyBindingMap, VIEW_KEY_BINDINGS);
+	});
+	onMounted(() => {
+		addUnsubscribe(app.value.shortcut$.subscribe(handleShortcut));
+	});
+}
+//#endregion
+export { VIEW_KEY_BINDINGS, useViewShortcut };

package/dist/i18n/loadMessages.d.ts

@@ -0,0 +1,12 @@
+import { LocaleCode } from './locales';
+import { Messages } from './translate';
+/** A display language the viewer loads once a page asks for it: every one but English, which it holds from the start. */
+export type LoadedLocaleCode = Exclude<LocaleCode, 'en'>;
+/**
+ * The dictionary of a language but English, loaded once for every viewer of
+ * the page. A load that fails is forgotten, so the next one asked tries again.
+ */
+export declare function loadMessages(code: LoadedLocaleCode): Promise<Messages>;
+/** The dictionary source the viewer hands its locale host: English at once, any other language as it loads. */
+export declare const lazyMessagesOf: (code: LocaleCode) => Messages | Promise<Messages>;
+//# sourceMappingURL=loadMessages.d.ts.map

package/dist/i18n/loadMessages.js

@@ -0,0 +1,40 @@
+import { en } from "./messages/en/index.js";
+//#region src/i18n/loadMessages.ts
+var LOADERS = {
+	"id-ID": () => import("./messages/id-ID.js").then((module) => module.idID),
+	"de-DE": () => import("./messages/de-DE.js").then((module) => module.deDE),
+	"es-ES": () => import("./messages/es-ES.js").then((module) => module.esES),
+	"eu-ES": () => import("./messages/eu-ES.js").then((module) => module.euES),
+	"fr-FR": () => import("./messages/fr-FR.js").then((module) => module.frFR),
+	"it-IT": () => import("./messages/it-IT.js").then((module) => module.itIT),
+	"nl-NL": () => import("./messages/nl-NL.js").then((module) => module.nlNL),
+	"pl-PL": () => import("./messages/pl-PL.js").then((module) => module.plPL),
+	"pt-PT": () => import("./messages/pt-PT.js").then((module) => module.ptPT),
+	"pt-BR": () => import("./messages/pt-BR.js").then((module) => module.ptBR),
+	"ro-RO": () => import("./messages/ro-RO.js").then((module) => module.roRO),
+	"sk-SK": () => import("./messages/sk-SK.js").then((module) => module.skSK),
+	"sl-SI": () => import("./messages/sl-SI.js").then((module) => module.slSI),
+	"sv-SE": () => import("./messages/sv-SE.js").then((module) => module.svSE),
+	"tr-TR": () => import("./messages/tr-TR.js").then((module) => module.trTR),
+	"ru-RU": () => import("./messages/ru-RU.js").then((module) => module.ruRU),
+	"uk-UA": () => import("./messages/uk-UA.js").then((module) => module.ukUA),
+	"he-IL": () => import("./messages/he-IL.js").then((module) => module.heIL),
+	"ar-SA": () => import("./messages/ar-SA.js").then((module) => module.arSA),
+	"fa-IR": () => import("./messages/fa-IR.js").then((module) => module.faIR),
+	"ja-JP": () => import("./messages/ja-JP.js").then((module) => module.jaJP),
+	"zh-CN": () => import("./messages/zh-CN.js").then((module) => module.zhCN),
+	"zh-TW": () => import("./messages/zh-TW.js").then((module) => module.zhTW),
+	"ko-KR": () => import("./messages/ko-KR.js").then((module) => module.koKR)
+};
+var loading = /* @__PURE__ */ new Map();
+function loadMessages(code) {
+	const known = loading.get(code);
+	if (known) return known;
+	const promise = LOADERS[code]();
+	loading.set(code, promise);
+	promise.catch(() => loading.delete(code));
+	return promise;
+}
+var lazyMessagesOf = (code) => code === "en" ? en : loadMessages(code);
+//#endregion
+export { lazyMessagesOf, loadMessages };