intor 2.3.29 → 2.3.30

package/dist/svelte-kit/src/routing/locale/get-locale-from-accept-language.js

@@ -0,0 +1,38 @@
+/**
+ * Get locale candidate from the `Accept-Language` header.
+ *
+ * Parses language priorities and returns the highest-priority
+ * language present in `supportedLocales`, without normalization.
+ *
+ * @example
+ * ```ts
+ * getLocaleFromAcceptLanguage("en-US,en;q=0.8,zh-TW;q=0.9", ["en-US", "zh-TW"])
+ * // => "en-US"
+ *
+ * getLocaleFromAcceptLanguage("fr,ja;q=0.9", ["en", "zh-TW"])
+ * // => undefined
+ * ```
+ */
+const getLocaleFromAcceptLanguage = (acceptLanguageHeader, supportedLocales) => {
+    if (!acceptLanguageHeader || supportedLocales.length === 0) {
+        return;
+    }
+    const supportedLocalesSet = new Set(supportedLocales);
+    // 1. Parse Accept-Language header into language + priority pairs
+    const parsedLanguages = acceptLanguageHeader.split(",").map((part) => {
+        const [rawLang, rawQ] = part.split(";");
+        const lang = rawLang.trim();
+        const q = rawQ ? Number.parseFloat(rawQ.split("=")[1]) : 1;
+        return {
+            lang,
+            q: Number.isNaN(q) ? 0 : q, // Invalid q values have lowest priority
+        };
+    });
+    // 2. Sort by priority (highest first)
+    const sortedByPriority = parsedLanguages.toSorted((a, b) => b.q - a.q);
+    // 3. Pick the first language explicitly supported
+    const preferred = sortedByPriority.find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
+    return preferred;
+};
+
+export { getLocaleFromAcceptLanguage };

package/dist/svelte-kit/src/routing/locale/get-locale-from-host.js

@@ -0,0 +1,32 @@
+/**
+ * Get locale candidate from hostname.
+ *
+ * Returns the left-most hostname label, without validation or normalization.
+ *
+ * @example
+ * ```ts
+ * getLocaleFromHost("en.example.com")
+ * // => "en"
+ *
+ * getLocaleFromHost("example.com")
+ * // => "example"
+ *
+ * getLocaleFromHost("api.jp.example.com")
+ * // => "api"
+ *
+ * getLocaleFromHost("localhost")
+ * // => undefined
+ * ```
+ */
+function getLocaleFromHost(host) {
+    if (!host)
+        return;
+    // Remove port (e.g. localhost:3000)
+    const hostname = host.split(":")[0];
+    const parts = hostname.split(".");
+    if (parts.length < 2)
+        return;
+    return parts[0];
+}
+
+export { getLocaleFromHost };

package/dist/svelte-kit/src/routing/locale/get-locale-from-pathname.js

@@ -0,0 +1,46 @@
+import '../../core/error/intor-error.js';
+import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
+import 'logry';
+import 'p-limit';
+
+/**
+ * Get locale from pathname.
+ *
+ * Extracts the first pathname segment (after basePath) as a locale
+ * if it exactly matches one of the supported locales.
+ *
+ * @example
+ * ```ts
+ * getLocaleFromPathname(config, "/en/about")
+ * // => "en"
+ * getLocaleFromPathname(config, "/zh-TW")
+ * // => "zh-TW"
+ * getLocaleFromPathname(config, "/about")
+ * // => undefined
+ *
+ * // config.routing.basePath: "/app"
+ * getLocaleFromPathname(config, "/app/en/dashboard")
+ * // => "en"
+ * ```
+ */
+function getLocaleFromPathname(pathname, config) {
+    const { routing, supportedLocales } = config;
+    const { basePath } = routing;
+    // 1. Normalize pathname
+    const normalizedPathname = normalizePathname(pathname);
+    // 2. Strip basePath
+    let prefixedPathname = normalizedPathname;
+    if (basePath && normalizedPathname === basePath) {
+        prefixedPathname = "/";
+    }
+    else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
+        prefixedPathname = normalizedPathname.slice(basePath.length);
+    }
+    // 3. Detect locale segment
+    const firstSegment = prefixedPathname.split("/").find(Boolean);
+    return firstSegment && supportedLocales.includes(firstSegment)
+        ? firstSegment
+        : undefined;
+}
+
+export { getLocaleFromPathname };

package/dist/svelte-kit/src/routing/locale/get-locale-from-query.js

@@ -0,0 +1,29 @@
+/**
+ * Get locale candidate from URL query parameters.
+ *
+ * Extracts the value of the configured query key, without
+ * validation or normalization.
+ *
+ * @example
+ * ```ts
+ * getLocaleFromQuery({ locale: "en" }, "locale")
+ * // => "en"
+ *
+ * getLocaleFromQuery({}, "locale")
+ * // => undefined
+ *
+ * getLocaleFromQuery({ locale: ["zh-TW"] }, "locale")
+ * // => "zh-TW"
+ * ```
+ */
+function getLocaleFromQuery(query, queryKey) {
+    if (!query)
+        return;
+    const raw = query[queryKey];
+    if (!raw)
+        return;
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    return value;
+}
+
+export { getLocaleFromQuery };

package/dist/{react → svelte-kit}/src/routing/pathname/canonicalize-pathname.js

@@ -1,3 +1,4 @@
+import { PREFIX_PLACEHOLDER } from '../../core/constants/prefix-placeholder.js';
 import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
@@ -6,6 +7,8 @@ import 'p-limit';
 /**
  * Returns a canonical, locale-agnostic pathname.
  *
+ * Accepts `{locale}` as a locale placeholder segment.
+ *
  * @example
  * ```ts
  * // config.supportedLocales: ["en-US"]
@@ -18,9 +21,8 @@ import 'p-limit';
 function canonicalizePathname(rawPathname, config) {
     const { routing, supportedLocales } = config;
     const { basePath } = routing;
-    // 1. Normalize pathname
     const normalizedPathname = normalizePathname(rawPathname);
-    // 2. Strip basePath
+    // Strip basePath
     let prefixedPathname = normalizedPathname;
     if (basePath && normalizedPathname === basePath) {
         prefixedPathname = "/";
@@ -28,12 +30,14 @@ function canonicalizePathname(rawPathname, config) {
     else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
         prefixedPathname = normalizedPathname.slice(basePath.length);
     }
-    // 3. Detect locale segment
+    // Detect locale segment
     const firstSegment = prefixedPathname.split("/").find(Boolean);
-    const locale = firstSegment && supportedLocales.includes(firstSegment)
-        ? firstSegment
-        : undefined;
-    // 4. Strip locale segment
+    const locale = firstSegment === PREFIX_PLACEHOLDER
+        ? PREFIX_PLACEHOLDER
+        : firstSegment && supportedLocales.includes(firstSegment)
+            ? firstSegment
+            : undefined;
+    // Strip locale segment
     return locale
         ? prefixedPathname.slice(locale.length + 1) || "/"
         : prefixedPathname;

package/dist/svelte-kit/src/server/intor/intor.js

@@ -0,0 +1,31 @@
+import '../../core/error/intor-error.js';
+import { getLogger } from '../../core/logger/get-logger.js';
+import 'p-limit';
+import { initTranslator } from '../translator/init-translator.js';
+
+/**
+ * Initializes Intor for the current execution context.
+ *
+ * Produces a server-side snapshot for SSR and
+ * full-stack rendering environments.
+ */
+async function intor(config, locale, options) {
+    const baseLogger = getLogger(config.logger);
+    const logger = baseLogger.child({ scope: "intor" });
+    logger.info("Start Intor initialization.");
+    logger.debug(`Initializing Intor with locale "${locale}".`);
+    // Initialize a locale-bound translator snapshot with messages loaded
+    const translator = await initTranslator(config, locale, {
+        readers: options?.readers,
+        allowCacheWrite: options?.allowCacheWrite,
+        fetch: options?.fetch || globalThis.fetch,
+    });
+    logger.info("Intor initialized.");
+    return {
+        config,
+        locale: translator.locale,
+        messages: translator.messages,
+    };
+}
+
+export { intor };

package/dist/svelte-kit/src/server/messages/load-local-messages/cache/messages-pool.js

@@ -0,0 +1,11 @@
+/**
+ * Get the messages pool.
+ */
+function getMessagesPool() {
+    if (!globalThis.__INTOR_MESSAGES_POOL__) {
+        globalThis.__INTOR_MESSAGES_POOL__ = new Map();
+    }
+    return globalThis.__INTOR_MESSAGES_POOL__;
+}
+
+export { getMessagesPool };

package/dist/svelte-kit/src/server/messages/load-local-messages/load-local-messages.js

@@ -0,0 +1,107 @@
+import path from 'node:path';
+import pLimit from 'p-limit';
+import '../../../core/error/intor-error.js';
+import { normalizeCacheKey } from '../../../core/utils/normalizers/normalize-cache-key.js';
+import { getLogger } from '../../../core/logger/get-logger.js';
+import { getMessagesPool } from './cache/messages-pool.js';
+import { readLocaleMessages } from './read-locale-messages/read-locale-messages.js';
+
+/**
+ * Load locale messages from the local file system.
+ *
+ * This function serves as the orchestration layer for local message loading.
+ * It coordinates:
+ *
+ * - Locale resolution with fallbacks
+ * - Concurrency control for file system access
+ * - Process-level memoization (read by default, write by ownership)
+ *
+ * Local messages are cached for the lifetime of the process.
+ * Cache writes are restricted to the primary initialization flow.
+ *
+ * File traversal, parsing, and validation are delegated to lower-level utilities.
+ */
+const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readers, pool = getMessagesPool(), allowCacheWrite = false, loggerOptions, }) => {
+    const baseLogger = getLogger(loggerOptions);
+    const logger = baseLogger.child({ scope: "load-local-messages" });
+    const start = performance.now();
+    logger.debug("Loading local messages.", {
+        rootDir,
+        resolvedRootDir: path.resolve(rootDir),
+    });
+    // ---------------------------------------------------------------------------
+    // Cache key resolution
+    // ---------------------------------------------------------------------------
+    const cacheKey = normalizeCacheKey([
+        id,
+        "loaderType:local",
+        rootDir,
+        locale,
+        fallbackLocales?.toSorted().join(","),
+        namespaces?.toSorted().join(","),
+    ].filter(Boolean));
+    // ---------------------------------------------------------------------------
+    // Cache read
+    // ---------------------------------------------------------------------------
+    if (cacheKey) {
+        const cached = pool.get(cacheKey);
+        if (cached) {
+            logger.debug("Messages cache hit.", { key: cacheKey });
+            return cached;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Resolve locale messages with ordered fallback strategy
+    // ---------------------------------------------------------------------------
+    const limit = pLimit(concurrency);
+    const candidateLocales = [locale, ...(fallbackLocales || [])];
+    let messages;
+    for (let i = 0; i < candidateLocales.length; i++) {
+        const candidateLocale = candidateLocales[i];
+        const isLast = i === candidateLocales.length - 1;
+        try {
+            const result = await readLocaleMessages({
+                locale: candidateLocale,
+                namespaces,
+                rootDir,
+                limit,
+                readers,
+                loggerOptions,
+            });
+            // Stop at the first locale that yields non-empty messages
+            if (Object.values(result[candidateLocale] || {}).length > 0) {
+                messages = result;
+                break;
+            }
+        }
+        catch {
+            if (isLast) {
+                logger.warn("Failed to load messages for all candidate locales.", {
+                    locale,
+                    fallbackLocales,
+                });
+            }
+            else {
+                logger.warn(`Failed to load locale messages for "${candidateLocale}", trying next fallback.`);
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Cache write (explicitly permitted)
+    // ---------------------------------------------------------------------------
+    const isProd = process.env.NODE_ENV === "production";
+    const canWriteCache = isProd && allowCacheWrite;
+    if (canWriteCache && cacheKey && messages) {
+        pool.set(cacheKey, messages);
+    }
+    // Final success log with resolved locale and timing
+    if (messages) {
+        logger.trace("Finished loading local messages.", {
+            loadedLocale: Object.keys(messages)[0],
+            duration: `${Math.round(performance.now() - start)} ms`,
+        });
+    }
+    return messages;
+};
+
+export { loadLocalMessages };

package/dist/svelte-kit/src/server/messages/load-local-messages/read-locale-messages/collect-file-entries/collect-file-entries.js

@@ -0,0 +1,90 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import '../../../../../core/error/intor-error.js';
+import { getLogger } from '../../../../../core/logger/get-logger.js';
+import 'p-limit';
+
+/**
+ * Recursively collects message file metadata under a given locale root.
+ *
+ * - Traverses directories and collects matching message files
+ * - Supports filtering by file extensions and optional namespaces
+ *
+ * @example
+ * ```ts
+ * [{
+ *     namespace: "auth", // If messages under locale root (no namespace) -> "index"
+ *     fullPath: "/Users/john/my-app/messages/en-US/auth/login.json",
+ *     relativePath: "auth/login.json",
+ *     segments: ["auth", "login"],
+ *     basename: "login",
+ * }, ... ];
+ * ```
+ */
+async function collectFileEntries({ readdir = fs.readdir, namespaces, rootDir, limit, exts = [], loggerOptions, }) {
+    const baseLogger = getLogger(loggerOptions);
+    const logger = baseLogger.child({ scope: "collect-file-entries" });
+    const supportedExts = new Set(["json", ...exts]);
+    const fileEntries = [];
+    // Recursive directory walk
+    const walk = async (currentDir) => {
+        // -------------------------------------------------------------------------
+        // Read directory entries
+        // -------------------------------------------------------------------------
+        let entries = [];
+        try {
+            entries = await readdir(currentDir, { withFileTypes: true });
+        }
+        catch {
+            logger.debug("Locale directory not found, skipping locale.", {
+                localeDir: currentDir,
+            });
+            return;
+        }
+        // -------------------------------------------------------------------------
+        // 1. Recurse into sub-directories (control flow, no limit)
+        // -------------------------------------------------------------------------
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            await walk(path.join(currentDir, entry.name));
+        }
+        // -------------------------------------------------------------------------
+        // 2. Process files (IO-bound, concurrency-limited)
+        // -------------------------------------------------------------------------
+        const tasks = entries
+            .filter((entry) => entry.isFile())
+            .map((entry) => limit(async () => {
+            const fullPath = path.join(currentDir, entry.name);
+            const ext = path.extname(entry.name).slice(1);
+            if (!ext || !supportedExts.has(ext))
+                return;
+            const relativePath = path.relative(rootDir, fullPath);
+            const withoutExt = relativePath.slice(0, relativePath.length - (ext.length + 1));
+            const segments = withoutExt.split(path.sep).filter(Boolean);
+            const namespace = segments.at(0);
+            if (!namespace)
+                return;
+            // Apply namespace filter (always allow "index")
+            if (namespaces && namespace !== "index") {
+                if (!namespaces.includes(namespace))
+                    return;
+            }
+            fileEntries.push({
+                namespace,
+                fullPath,
+                relativePath,
+                segments,
+                basename: path.basename(entry.name, `.${ext}`),
+            });
+        }));
+        await Promise.all(tasks);
+    };
+    await walk(rootDir);
+    if (fileEntries.length > 0) {
+        logger.trace(`Collected ${fileEntries.length} local message files for locale "${path.basename(rootDir)}".`);
+    }
+    return fileEntries;
+}
+
+export { collectFileEntries };

package/dist/svelte-kit/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/parse-file-entries.js

@@ -0,0 +1,102 @@
+import path from 'node:path';
+import '../../../../../core/error/intor-error.js';
+import { deepMerge } from '../../../../../core/utils/deep-merge.js';
+import { getLogger } from '../../../../../core/logger/get-logger.js';
+import 'p-limit';
+import { isValidMessages } from '../../../../../core/messages/utils/is-valid-messages.js';
+import { nestObjectFromPath } from '../../../../../core/messages/utils/nest-object-from-path.js';
+import { jsonReader } from './utils/json-reader.js';
+
+/**
+ * Parse locale message files into a unified Messages object (single-locale).
+ *
+ * - Reads JSON or custom formats (via `messagesReader`)
+ * - Validates message structure
+ * - Builds nested objects based on file path segments
+ * - Deep-merges entries by namespace
+ *
+ * @example
+ * ```plain
+ * File paths:
+ *   - en/index.json        = { a: "A" }
+ *   - en/ui.json           = { b: "B" }
+ *   - en/auth/index.json   = { c: "C" }
+ *   - en/auth/verify.json  = { d: "D" }
+ *```
+
+ * The final return value is a `Messages` object:
+ * ```ts
+ * {
+ *   a: "A",
+ *   ui: { b: "B" },
+ *   auth: {
+ *     c: "C",
+ *     verify: { d: "D" },
+ *   },
+ * }
+ * ```
+ */
+async function parseFileEntries({ fileEntries, limit, readers, loggerOptions, }) {
+    const baseLogger = getLogger(loggerOptions);
+    const logger = baseLogger.child({ scope: "parse-file-entries" });
+    // Read and parse all file entries
+    const parsedFileEntries = [];
+    const tasks = fileEntries.map(({ namespace, segments, basename, fullPath }) => limit(async () => {
+        try {
+            // -------------------------------------------------------------------
+            // Read and validate file content
+            // -------------------------------------------------------------------
+            const ext = path.extname(fullPath).slice(1); // remove dot
+            let raw;
+            if (ext === "json") {
+                raw = await jsonReader(fullPath);
+            }
+            else {
+                const reader = readers?.[ext];
+                if (!reader) {
+                    throw new Error(`No message reader registered for .${ext} files. ` +
+                        `Please register a reader for the "${ext}" extension.`);
+                }
+                raw = await reader(fullPath);
+            }
+            // Validate messages structure
+            if (!isValidMessages(raw)) {
+                throw new Error("Parsed content does not match expected Messages structure");
+            }
+            // -------------------------------------------------------------------
+            // Build nested message object from path segments
+            // -------------------------------------------------------------------
+            const segmentsWithoutNamespace = segments.slice(1);
+            const isIndexFile = basename === "index";
+            const keyPath = isIndexFile
+                ? segmentsWithoutNamespace.slice(0, -1)
+                : segmentsWithoutNamespace;
+            // Nest the parsed content based on the path segments
+            const nestedMessages = nestObjectFromPath(keyPath, raw);
+            parsedFileEntries.push({ namespace, messages: nestedMessages });
+        }
+        catch (error) {
+            logger.warn("Failed to read or parse file.", {
+                path: fullPath,
+                error,
+            });
+        }
+    }));
+    await Promise.all(tasks);
+    // ---------------------------------------------------------------------------
+    // Merge parsed entries by namespace
+    // ---------------------------------------------------------------------------
+    const result = {};
+    for (const { namespace, messages } of parsedFileEntries) {
+        // Root-level namespace (e.g. [locale]/index.json)
+        if (namespace === "index") {
+            Object.assign(result, deepMerge(result, messages));
+        }
+        else {
+            result[namespace] = deepMerge(result[namespace], messages);
+        }
+    }
+    return result;
+}
+
+export { parseFileEntries };

package/dist/svelte-kit/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/utils/json-reader.js

@@ -0,0 +1,12 @@
+import fs from 'node:fs/promises';
+
+/**
+ *  Read & parse a JSON file
+ */
+async function jsonReader(filePath, readFile = fs.readFile) {
+    const raw = await readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+}
+
+export { jsonReader };

package/dist/svelte-kit/src/server/messages/load-local-messages/read-locale-messages/read-locale-messages.js

@@ -0,0 +1,42 @@
+import path from 'node:path';
+import { collectFileEntries } from './collect-file-entries/collect-file-entries.js';
+import { parseFileEntries } from './parse-file-entries/parse-file-entries.js';
+
+/**
+ * Read and assemble messages for a single locale from the file system.
+ *
+ * This function acts as a thin orchestration layer:
+ * - Collects message file metadata for the locale
+ * - Parses files into a single Messages object
+ * - Wraps the result under the locale key
+ *
+ * It does not perform validation or transformation itself.
+ */
+const readLocaleMessages = async ({ locale, namespaces, rootDir = "messages", limit, readers, loggerOptions, }) => {
+    // ---------------------------------------------------------------------------
+    // Collect message file entries for the locale
+    // ---------------------------------------------------------------------------
+    const fileEntries = await collectFileEntries({
+        namespaces,
+        rootDir: path.resolve(rootDir, locale),
+        limit,
+        exts: Object.keys(readers || {}),
+        loggerOptions,
+    });
+    // ---------------------------------------------------------------------------
+    // Parse collected files into a Messages object (single-locale)
+    // ---------------------------------------------------------------------------
+    const messages = await parseFileEntries({
+        fileEntries,
+        limit,
+        readers,
+        loggerOptions,
+    });
+    // ---------------------------------------------------------------------------
+    // Wrap parsed messages under the locale key
+    // ---------------------------------------------------------------------------
+    const localeMessages = { [locale]: messages };
+    return localeMessages;
+};
+
+export { readLocaleMessages };

package/dist/svelte-kit/src/server/messages/load-messages.js

@@ -0,0 +1,77 @@
+import '../../core/error/intor-error.js';
+import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
+import { getLogger } from '../../core/logger/get-logger.js';
+import { loadRemoteMessages } from '../../core/messages/load-remote-messages/load-remote-messages.js';
+import { loadLocalMessages } from './load-local-messages/load-local-messages.js';
+
+/**
+ * Load locale messages according to the resolved Intor loader configuration.
+ *
+ * This function is the top-level orchestration entry for message loading.
+ * It is responsible for:
+ *
+ * - Resolving the active loader strategy (local or remote)
+ * - Dispatching to the appropriate loader implementation
+ * - Passing through cache and read-related options
+ *
+ * Message traversal, parsing, fallback resolution, and caching logic
+ * are delegated to the selected loader.
+ */
+const loadMessages = async ({ config, locale, readers, allowCacheWrite = false, fetch, }) => {
+    const baseLogger = getLogger(config.logger);
+    const logger = baseLogger.child({ scope: "load-messages" });
+    // ---------------------------------------------------------------------------
+    // Resolve loader configuration
+    // ---------------------------------------------------------------------------
+    const loader = resolveLoaderOptions(config, "server");
+    if (!loader) {
+        logger.warn("No loader options have been configured in the current config.");
+        return;
+    }
+    const { type, namespaces, concurrency } = loader;
+    const fallbackLocales = config.fallbackLocales[locale] || [];
+    logger.info(`Loading messages for locale "${locale}".`);
+    logger.trace("Starting to load messages with runtime context.", {
+        loaderType: type,
+        ...(type === "local" ? { rootDir: loader.rootDir } : {}),
+        locale,
+        fallbackLocales: fallbackLocales.join(", "),
+        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
+    });
+    // ---------------------------------------------------------------------------
+    // Dispatch to loader implementation
+    // ---------------------------------------------------------------------------
+    let loadedMessages;
+    if (type === "local") {
+        loadedMessages = await loadLocalMessages({
+            id: config.id,
+            locale,
+            fallbackLocales,
+            namespaces,
+            rootDir: loader.rootDir,
+            concurrency,
+            readers,
+            allowCacheWrite,
+            loggerOptions: config.logger,
+        });
+    }
+    else if (type === "remote") {
+        loadedMessages = await loadRemoteMessages({
+            locale,
+            fallbackLocales,
+            namespaces,
+            concurrency,
+            fetch,
+            url: loader.url,
+            headers: loader.headers,
+            loggerOptions: config.logger,
+        });
+    }
+    // Final sanity check
+    if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
+        logger.warn("No messages found.", { locale, fallbackLocales, namespaces });
+    }
+    return loadedMessages;
+};
+
+export { loadMessages };