@riducms/admin 0.1.0

package/src/core/i18n/admin-i18n.svelte.ts

@@ -0,0 +1,364 @@
+import type { PluginMessageCatalog, TranslationLanguage } from "@riducms/translations";
+import {
+	createAdminI18n,
+	en,
+	resolvePreferredLanguage,
+	type AdminI18n,
+	type AdminTranslationKey,
+	type TranslationVariables,
+} from "@riducms/translations";
+import type {
+	AuthSession,
+	SchemaAdminLanguage,
+	SchemaAdminLocalizationSettings,
+} from "@riducms/protocol";
+import { RiduError } from "@riducms/sdk";
+
+import type { AdminClient } from "@admin/core/api/admin-client";
+import {
+	getPreferenceWriteQueue,
+	preferenceOwnerID,
+} from "@admin/core/preferences/preference-write-queue";
+import type { AdminDocument } from "@admin/core/api/admin-client";
+
+const languagePreferenceKey = "admin-language";
+const timeZonePreferenceKey = "admin-timezone";
+const browserLanguageKey = "ridu:admin-language";
+const browserTimeZoneKey = "ridu:admin-timezone";
+
+export class AdminI18nController implements AdminI18n {
+	#language = $state("en");
+	#timeZone = $state<string>();
+	#settings = $state.raw<SchemaAdminLocalizationSettings>();
+	#catalogs: readonly TranslationLanguage[];
+	#catalogByCode: ReadonlyMap<string, TranslationLanguage>;
+	#messages: Readonly<Record<string, PluginMessageCatalog>>;
+	#translatorCache: AdminI18n | undefined;
+	#translatorRevision = $state(0);
+	#preferenceRequest = 0;
+	#languageWrite = 0;
+	#timeZoneWrite = 0;
+	#confirmedLanguage = "en";
+	#confirmedTimeZone: string | undefined;
+
+	constructor(
+		private readonly client: AdminClient,
+		private readonly session: () => AuthSession<AdminDocument> | undefined,
+		catalogs: readonly TranslationLanguage[] = [en],
+		messages: Readonly<Record<string, PluginMessageCatalog>> = {}
+	) {
+		this.#catalogs = catalogs.length === 0 ? [en] : [...catalogs];
+		this.#catalogByCode = new Map(this.#catalogs.map((catalog) => [catalog.code, catalog]));
+		this.#messages = messages;
+		const stored = readBrowserPreference(browserLanguageKey);
+		this.#language = resolvePreferredLanguage(
+			[
+				...(stored === undefined ? [] : [stored]),
+				...(typeof navigator === "undefined" ? [] : navigator.languages),
+			],
+			this.#catalogs.map((catalog) => catalog.code),
+			this.#catalogByCode.has("en") ? "en" : (this.#catalogs[0]?.code ?? "en")
+		);
+		this.#confirmedLanguage = this.#language;
+		this.#applyDocumentLanguage();
+	}
+
+	get language() {
+		return this.#language;
+	}
+
+	get direction(): "ltr" | "rtl" {
+		return (this.languages.find((language) => language.code === this.#language)?.rtl ??
+			this.#catalogByCode.get(this.#language)?.rtl) === true
+			? "rtl"
+			: "ltr";
+	}
+
+	get timeZone() {
+		return this.#timeZone;
+	}
+
+	get languages(): readonly SchemaAdminLanguage[] {
+		return (
+			this.#settings?.languages ??
+			this.#catalogs.map(({ code, label, rtl }) => ({ code, label, ...(rtl ? { rtl } : {}) }))
+		);
+	}
+
+	get timeZones() {
+		return this.#settings?.timeZones ?? [];
+	}
+
+	get #translator() {
+		// Components may first call t() after a translator was prepared during bootstrap. Reading an
+		// explicit revision keeps those calls reactive even when the cached translator itself does not
+		// need to read #language or #timeZone again.
+		void this.#translatorRevision;
+		return (this.#translatorCache ??= createAdminI18n({
+			languages: this.#configuredCatalogsFor(this.languages),
+			language: this.#language,
+			fallbackLanguage: this.#fallbackLanguage,
+			...(this.#timeZone === undefined ? {} : { timeZone: this.#timeZone }),
+			pluginMessages: this.#messages,
+		}));
+	}
+
+	get #fallbackLanguage() {
+		return (
+			this.#settings?.defaultLanguage ??
+			(this.#catalogByCode.has("en") ? "en" : (this.#catalogs[0]?.code ?? "en"))
+		);
+	}
+
+	#configuredCatalogsFor(languages: readonly SchemaAdminLanguage[]) {
+		return languages.map((language) => {
+			const catalog = this.#catalogByCode.get(language.code);
+			if (catalog === undefined) {
+				throw new Error(
+					`Admin language ${language.code} is configured in Go but no matching static catalog was passed to mountAdmin.`
+				);
+			}
+			if ((catalog.rtl === true) !== (language.rtl === true)) {
+				throw new Error(
+					`Admin language ${language.code} has conflicting RTL settings in Go and its static catalog.`
+				);
+			}
+			return { ...catalog, label: language.label, rtl: language.rtl === true };
+		});
+	}
+
+	text = (canonical: string, translations?: Readonly<Record<string, string>>) =>
+		this.#translator.text(canonical, translations);
+
+	t = (key: AdminTranslationKey, variables?: TranslationVariables) =>
+		this.#translator.t(key, variables);
+
+	formatDate = (value: Date | string | number, options?: Intl.DateTimeFormatOptions) =>
+		this.#translator.formatDate(value, options);
+
+	formatNumber = (value: number, options?: Intl.NumberFormatOptions) =>
+		this.#translator.formatNumber(value, options);
+
+	formatRelativeTime = (value: number, unit: Intl.RelativeTimeFormatUnit) =>
+		this.#translator.formatRelativeTime(value, unit);
+
+	formatList = (values: readonly string[], options?: Intl.ListFormatOptions) =>
+		this.#translator.formatList(values, options);
+
+	configure(settings: SchemaAdminLocalizationSettings | undefined) {
+		const languages =
+			settings?.languages ??
+			this.#catalogs.map(({ code, label, rtl }) => ({ code, label, ...(rtl ? { rtl } : {}) }));
+		const fallbackLanguage =
+			settings?.defaultLanguage ??
+			(this.#catalogByCode.has("en") ? "en" : (this.#catalogs[0]?.code ?? "en"));
+		const supported = languages.map((language) => language.code);
+		const stored = readBrowserPreference(browserLanguageKey);
+		const preferences = [
+			...(stored === undefined ? [] : [stored]),
+			...(typeof navigator === "undefined" ? [] : navigator.languages),
+		];
+		const language = resolvePreferredLanguage(preferences, supported, fallbackLanguage);
+		const browserTimeZone = readBrowserPreference(browserTimeZoneKey) ?? detectedTimeZone();
+		const timeZone = this.#resolvedTimeZone(browserTimeZone, settings);
+		const translator = createAdminI18n({
+			languages: this.#configuredCatalogsFor(languages),
+			language,
+			fallbackLanguage,
+			...(timeZone === undefined ? {} : { timeZone }),
+			pluginMessages: this.#messages,
+		});
+
+		// Commit only after every catalog, direction, locale, and timezone validates.
+		this.#settings = settings;
+		this.#language = language;
+		this.#timeZone = timeZone;
+		this.#confirmedLanguage = language;
+		this.#confirmedTimeZone = timeZone;
+		this.#translatorCache = translator;
+		this.#translatorRevision += 1;
+		this.#languageWrite += 1;
+		this.#timeZoneWrite += 1;
+		this.#applyDocumentLanguage();
+	}
+
+	async loadPreferences() {
+		const request = ++this.#preferenceRequest;
+		this.#languageWrite += 1;
+		this.#timeZoneWrite += 1;
+		const sessionID = this.session()?.id;
+		if (sessionID === undefined) return;
+		const [language, timeZone] = await Promise.all([
+			this.#readPreference(languagePreferenceKey),
+			this.#readPreference(timeZonePreferenceKey),
+		]);
+		if (request !== this.#preferenceRequest || this.session()?.id !== sessionID) return;
+		if (typeof language === "string" && this.languages.some((item) => item.code === language)) {
+			this.#language = language;
+			this.#confirmedLanguage = language;
+			writeBrowserPreference(browserLanguageKey, language);
+		}
+		if (typeof timeZone === "string" && this.timeZones.some((item) => item.id === timeZone)) {
+			this.#timeZone = timeZone;
+			this.#confirmedTimeZone = timeZone;
+			writeBrowserPreference(browserTimeZoneKey, timeZone);
+		}
+		this.#invalidateTranslator();
+		this.#applyDocumentLanguage();
+	}
+
+	async setLanguage(language: string) {
+		if (!this.languages.some((item) => item.code === language)) {
+			throw new Error(`Admin language ${language} is not configured.`);
+		}
+		this.#preferenceRequest += 1;
+		const write = ++this.#languageWrite;
+		const sessionID = this.session()?.id;
+		const ownerID = preferenceOwnerID(this.session());
+		this.#language = language;
+		this.#invalidateTranslator();
+		this.#applyDocumentLanguage();
+		writeBrowserPreference(browserLanguageKey, language);
+		try {
+			await this.#writePreference(languagePreferenceKey, language);
+			if (this.session()?.id !== sessionID || preferenceOwnerID(this.session()) !== ownerID) {
+				throw new Error("The signed-in session changed before the preference was saved.");
+			}
+			this.#confirmedLanguage = language;
+		} catch (error) {
+			if (
+				write === this.#languageWrite &&
+				this.session()?.id === sessionID &&
+				preferenceOwnerID(this.session()) === ownerID
+			) {
+				this.#language = this.#confirmedLanguage;
+				this.#invalidateTranslator();
+				this.#applyDocumentLanguage();
+				writeBrowserPreference(browserLanguageKey, this.#confirmedLanguage);
+			}
+			throw error;
+		}
+	}
+
+	async setTimeZone(timeZone: string) {
+		if (!this.timeZones.some((item) => item.id === timeZone)) {
+			throw new Error(`Admin timezone ${timeZone} is not configured.`);
+		}
+		this.#preferenceRequest += 1;
+		const write = ++this.#timeZoneWrite;
+		const sessionID = this.session()?.id;
+		const ownerID = preferenceOwnerID(this.session());
+		this.#timeZone = timeZone;
+		this.#invalidateTranslator();
+		writeBrowserPreference(browserTimeZoneKey, timeZone);
+		try {
+			await this.#writePreference(timeZonePreferenceKey, timeZone);
+			if (this.session()?.id !== sessionID || preferenceOwnerID(this.session()) !== ownerID) {
+				throw new Error("The signed-in session changed before the preference was saved.");
+			}
+			this.#confirmedTimeZone = timeZone;
+		} catch (error) {
+			if (
+				write === this.#timeZoneWrite &&
+				this.session()?.id === sessionID &&
+				preferenceOwnerID(this.session()) === ownerID
+			) {
+				this.#timeZone = this.#confirmedTimeZone;
+				this.#invalidateTranslator();
+				if (this.#confirmedTimeZone === undefined) removeBrowserPreference(browserTimeZoneKey);
+				else writeBrowserPreference(browserTimeZoneKey, this.#confirmedTimeZone);
+			}
+			throw error;
+		}
+	}
+
+	reset() {
+		this.#preferenceRequest += 1;
+		this.#languageWrite += 1;
+		this.#timeZoneWrite += 1;
+		removeBrowserPreference(browserLanguageKey);
+		removeBrowserPreference(browserTimeZoneKey);
+		this.configure(this.#settings);
+	}
+
+	async #readPreference(key: string): Promise<unknown> {
+		try {
+			return await this.client.preference<unknown>(key);
+		} catch (error) {
+			if (error instanceof RiduError && error.code === "not_found") return undefined;
+			return undefined;
+		}
+	}
+
+	async #writePreference(key: string, value: string) {
+		const owner = preferenceOwnerID(this.session());
+		if (owner === "") {
+			await this.client.setPreference(key, value);
+			return;
+		}
+		const sessionID = this.session()?.id;
+		const result = await getPreferenceWriteQueue().enqueue(
+			JSON.stringify([owner, key]),
+			owner,
+			() => this.session()?.id === sessionID,
+			() => this.client.setPreference(key, value)
+		);
+		if (!result.dispatched)
+			throw new Error("The signed-in session changed before the preference was saved.");
+	}
+
+	#resolvedTimeZone(
+		candidate: string | undefined,
+		settings: SchemaAdminLocalizationSettings | undefined = this.#settings
+	) {
+		const configured = settings?.timeZones ?? [];
+		if (configured.length === 0) return undefined;
+		if (candidate !== undefined && configured.some((item) => item.id === candidate))
+			return candidate;
+		return settings?.defaultTimeZone ?? configured[0]?.id;
+	}
+
+	#invalidateTranslator() {
+		this.#translatorCache = undefined;
+		this.#translatorRevision += 1;
+	}
+
+	#applyDocumentLanguage() {
+		if (typeof document === "undefined") return;
+		document.documentElement.lang = this.#language;
+		document.documentElement.dir = this.direction;
+		document.documentElement.dataset.adminLanguage = this.#language;
+	}
+}
+
+function readBrowserPreference(key: string) {
+	try {
+		return globalThis.localStorage?.getItem(key) ?? undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function writeBrowserPreference(key: string, value: string) {
+	try {
+		globalThis.localStorage?.setItem(key, value);
+	} catch {
+		// Browser persistence is an enhancement; the server preference remains authoritative.
+	}
+}
+
+function removeBrowserPreference(key: string) {
+	try {
+		globalThis.localStorage?.removeItem(key);
+	} catch {
+		// Browser persistence is an enhancement; the server preference remains authoritative.
+	}
+}
+
+function detectedTimeZone() {
+	try {
+		return Intl.DateTimeFormat().resolvedOptions().timeZone;
+	} catch {
+		return undefined;
+	}
+}

package/src/core/i18n/localized-schema.ts

@@ -0,0 +1,111 @@
+import type { AdminI18n } from "@riducms/plugin";
+import type { SchemaCollection, SchemaField } from "@riducms/protocol";
+
+/** Returns detached display metadata for the active interface language. */
+export function localizeSchemaField(field: SchemaField, i18n: AdminI18n): SchemaField {
+	return {
+		...field,
+		admin: {
+			...field.admin,
+			label: i18n.text(field.admin.label, field.admin.labelTranslations),
+			...(field.admin.description === undefined
+				? {}
+				: {
+						description: i18n.text(field.admin.description, field.admin.descriptionTranslations),
+					}),
+			...(field.admin.placeholder === undefined
+				? {}
+				: {
+						placeholder: i18n.text(field.admin.placeholder, field.admin.placeholderTranslations),
+					}),
+			...(field.admin.collapsible === undefined
+				? {}
+				: {
+						collapsible: {
+							...field.admin.collapsible,
+							label: i18n.text(
+								field.admin.collapsible.label,
+								field.admin.collapsible.labelTranslations
+							),
+						},
+					}),
+		},
+		...(field.select === undefined
+			? {}
+			: {
+					select: {
+						...field.select,
+						choices: field.select.choices.map((choice) => ({
+							...choice,
+							label: i18n.text(choice.label, choice.labelTranslations),
+						})),
+					},
+				}),
+		...(field.nested === undefined
+			? {}
+			: {
+					nested: {
+						...field.nested,
+						fields: field.nested.fields.map((child) => localizeSchemaField(child, i18n)),
+						...(field.nested.rowLabels === undefined
+							? {}
+							: {
+									rowLabels: {
+										...field.nested.rowLabels,
+										singular: i18n.text(
+											field.nested.rowLabels.singular,
+											field.nested.rowLabels.singularTranslations
+										),
+										plural: i18n.text(
+											field.nested.rowLabels.plural,
+											field.nested.rowLabels.pluralTranslations
+										),
+									},
+								}),
+					},
+				}),
+		...(field.blocks === undefined
+			? {}
+			: {
+					blocks: {
+						...field.blocks,
+						types: field.blocks.types.map((block) => ({
+							...block,
+							label: i18n.text(block.label, block.labelTranslations),
+							fields: block.fields.map((child) => localizeSchemaField(child, i18n)),
+						})),
+					},
+				}),
+	};
+}
+
+export function localizeSchemaCollection(
+	collection: SchemaCollection,
+	i18n: AdminI18n
+): SchemaCollection {
+	return {
+		...collection,
+		labels: {
+			...collection.labels,
+			singular: i18n.text(collection.labels.singular, collection.labels.singularTranslations),
+			plural: i18n.text(collection.labels.plural, collection.labels.pluralTranslations),
+		},
+		admin: {
+			...collection.admin,
+			...(collection.admin.group === undefined
+				? {}
+				: {
+						group: i18n.text(collection.admin.group, collection.admin.groupTranslations),
+					}),
+			...(collection.admin.description === undefined
+				? {}
+				: {
+						description: i18n.text(
+							collection.admin.description,
+							collection.admin.descriptionTranslations
+						),
+					}),
+		},
+		fields: collection.fields.map((field) => localizeSchemaField(field, i18n)),
+	};
+}

package/src/core/notifications/notification-center.svelte.ts

@@ -0,0 +1,69 @@
+import { createContext } from "svelte";
+import { toast } from "svelte-sonner";
+
+import ValidationToast from "@admin/core/notifications/validation-toast.svelte";
+
+export type NotificationTone = "success" | "warning" | "error";
+
+export interface NotificationInput {
+	title: string;
+	message?: string;
+	duration?: number;
+}
+
+export interface ValidationNotificationInput {
+	labels: readonly string[];
+}
+
+export class NotificationCenter {
+	#ids = new Set<number | string>();
+
+	success = (input: NotificationInput) => this.#show("success", input);
+
+	warning = (input: NotificationInput) => this.#show("warning", input);
+
+	error = (input: NotificationInput) => this.#show("error", input);
+
+	validation = ({ labels }: ValidationNotificationInput) => {
+		let id: number | string;
+		const uniqueLabels = [...new Set(labels)];
+		id = toast.error(ValidationToast, {
+			componentProps: { labels: uniqueLabels },
+			duration: 7_000,
+			important: true,
+			icon: null,
+			onDismiss: () => this.#ids.delete(id),
+			onAutoClose: () => this.#ids.delete(id),
+		});
+		this.#ids.add(id);
+		return id;
+	};
+
+	dismiss = (id: number | string) => {
+		toast.dismiss(id);
+		this.#ids.delete(id);
+	};
+
+	destroy() {
+		for (const id of this.#ids) toast.dismiss(id);
+		this.#ids.clear();
+	}
+
+	#show(tone: NotificationTone, input: NotificationInput) {
+		let id: number | string;
+		const options = {
+			description: input.message,
+			duration: input.duration ?? (tone === "success" ? 4_500 : 7_000),
+			important: tone === "error",
+			onDismiss: () => this.#ids.delete(id),
+			onAutoClose: () => this.#ids.delete(id),
+		};
+		id = toast[tone](input.title, options);
+		this.#ids.add(id);
+		return id;
+	}
+}
+
+const [getNotificationCenter, setNotificationCenter] = createContext<NotificationCenter>();
+
+export { getNotificationCenter, setNotificationCenter };

package/src/core/notifications/validation-toast.svelte

@@ -0,0 +1,18 @@
+<script lang="ts">
+	let { labels }: { labels: readonly string[] } = $props();
+</script>
+
+{#if labels.length === 1}
+	<span>
+		The following field is invalid: <strong>{labels[0]}</strong>
+	</span>
+{:else}
+	<div>
+		<p>The following fields are invalid ({labels.length}):</p>
+		<ul class="mt-1 list-[circle] space-y-0.5 ps-5">
+			{#each labels as label (label)}
+				<li class="ps-0.5">{label}</li>
+			{/each}
+		</ul>
+	</div>
+{/if}

package/src/core/plugins/field-registry.ts

@@ -0,0 +1,60 @@
+import type { FieldPlugin } from "@riducms/plugin";
+import type { SchemaField } from "@riducms/protocol";
+
+export class FieldRegistry {
+	#plugins = new Map<string, FieldPlugin>();
+
+	register(plugin: FieldPlugin) {
+		const identity = pluginIdentity(plugin);
+		if (this.#plugins.has(identity))
+			throw new Error(`Field plugin ${identity} is already registered`);
+		this.#plugins.set(identity, plugin);
+	}
+
+	resolve(field: SchemaField) {
+		const component = field.admin.component;
+		const identity =
+			component !== undefined
+				? `${field.type}:${component.plugin}:${component.component}`
+				: field.plugin === undefined
+					? field.type
+					: `${field.type}:${field.plugin.key}`;
+		const plugin = this.#plugins.get(identity);
+		if (plugin === undefined || !plugin.canRender(field)) {
+			throw new Error(`No admin field plugin can render ${field.path} (${identity})`);
+		}
+		return plugin;
+	}
+}
+
+function pluginIdentity(plugin: FieldPlugin) {
+	if (plugin.componentKey !== undefined)
+		return `${plugin.type}:${plugin.key ?? "<missing>"}:${plugin.componentKey}`;
+	return plugin.key === undefined ? plugin.type : `${plugin.type}:${plugin.key}`;
+}
+
+export function createCoreFieldRegistry(plugins: readonly FieldPlugin[] = []): FieldRegistry {
+	const registry = new FieldRegistry();
+	registry.register({ type: "text", canRender: (field) => field.text !== undefined });
+	registry.register({ type: "code", canRender: (field) => field.code !== undefined });
+	registry.register({ type: "select", canRender: (field) => field.select !== undefined });
+	registry.register({ type: "radio", canRender: (field) => field.select !== undefined });
+	registry.register({ type: "point", canRender: (field) => field.point !== undefined });
+	registry.register({ type: "ui", canRender: (field) => field.ui !== undefined });
+	registry.register({ type: "join", canRender: (field) => field.join !== undefined });
+	registry.register({ type: "virtual", canRender: (field) => field.virtual !== undefined });
+	for (const type of ["textarea", "email", "date", "number", "checkbox", "json"] as const) {
+		registry.register({ type, canRender: () => true });
+	}
+	for (const type of ["group", "array"] as const) {
+		registry.register({ type, canRender: (field) => field.nested !== undefined });
+	}
+	registry.register({ type: "blocks", canRender: (field) => field.blocks !== undefined });
+	registry.register({
+		type: "relationship",
+		canRender: (field) => field.relationship !== undefined,
+	});
+	registry.register({ type: "upload", canRender: (field) => field.upload !== undefined });
+	for (const plugin of plugins) registry.register(plugin);
+	return registry;
+}

package/src/core/plugins/row-label-registry.ts

@@ -0,0 +1,62 @@
+import type { RowLabelPlugin, RowLabelSnapshot, RowLabelValue } from "@riducms/plugin";
+import type { SchemaField } from "@riducms/protocol";
+
+export class RowLabelRegistry {
+	#plugins = new Map<string, RowLabelPlugin>();
+
+	register(plugin: RowLabelPlugin) {
+		const identity = rowLabelIdentity(plugin.key, plugin.componentKey);
+		if (this.#plugins.has(identity)) {
+			throw new Error(`Admin row label component ${identity} is already registered`);
+		}
+		this.#plugins.set(identity, plugin);
+	}
+
+	resolve(field: SchemaField): RowLabelPlugin | undefined {
+		const component = field.nested?.rowLabelComponent;
+		if (component === undefined) return undefined;
+		const identity = rowLabelIdentity(component.plugin, component.component);
+		const plugin = this.#plugins.get(identity);
+		if (plugin === undefined) {
+			throw new Error(
+				`No admin row label component can render field ${field.path} (plugin "${component.plugin}", component "${component.component}")`
+			);
+		}
+		return plugin;
+	}
+}
+
+export function createRowLabelRegistry(plugins: readonly RowLabelPlugin[] = []): RowLabelRegistry {
+	const registry = new RowLabelRegistry();
+	for (const plugin of plugins) registry.register(plugin);
+	return registry;
+}
+
+export function immutableRowLabelSnapshot(row: Record<string, unknown>): RowLabelSnapshot {
+	return cloneRowLabelObject(row);
+}
+
+function rowLabelIdentity(plugin: string, component: string) {
+	return `${plugin}:${component}`;
+}
+
+function cloneRowLabelObject(value: Record<string, unknown>): RowLabelSnapshot {
+	const cloned: Record<string, RowLabelValue> = {};
+	for (const [key, child] of Object.entries(value)) cloned[key] = cloneRowLabelValue(child);
+	return Object.freeze(cloned);
+}
+
+function cloneRowLabelValue(value: unknown): RowLabelValue {
+	if (
+		value === undefined ||
+		value === null ||
+		typeof value === "string" ||
+		typeof value === "number" ||
+		typeof value === "boolean"
+	) {
+		return value;
+	}
+	if (Array.isArray(value)) return Object.freeze(value.map(cloneRowLabelValue));
+	if (typeof value === "object") return cloneRowLabelObject(value as Record<string, unknown>);
+	return undefined;
+}