@koine/i18n 2.0.0-beta.100

package/api.cjs.js

@@ -0,0 +1,4026 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var node_path = require('node:path');
+var node = require('@koine/node');
+var utils = require('@koine/utils');
+var formatRoutePathname = require('./formatRoutePathname.cjs.js');
+var t$2 = require('typescript');
+var minimatch = require('minimatch');
+var utils$1 = require('next/dist/shared/lib/utils');
+var promises = require('node:fs/promises');
+var glob = require('glob');
+var node_https = require('node:https');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var t__namespace = /*#__PURE__*/_interopNamespace(t$2);
+
+// /**
+//  * Adapter creator function, either _sync_ or _async_
+//  */
+// export type AdapterCreator<T extends AdaptersName> = (
+//   arg: AdapterArg<T>,
+// ) => Adapter<T> | Promise<Adapter<T>>;
+// /**
+//  * Adapter anatomy
+//  */
+// export type Adapter<T extends AdaptersName = AdaptersName> = {
+//   dependsOn?: AdaptersName[];
+//   files: AdapterFile<T>[];
+//   /**
+//    * Adapters like `next-translate` need the JSON file to be available
+//    */
+//   needsTranslationsFiles?: boolean;
+// };
+let createAdapter = (e, r)=>(o, p)=>r({
+            ...o,
+            adapterOptions: utils.objectMergeWithDefaults(e, p)
+        });
+
+const adapterJsOptions = {
+    modularized: !1
+}; /**
+   * - When `true` it outpus each function in a separate file with a `named` and a
+   * `default` export in order to fully support SWC modularizeImport optimization.
+   * You will use these functions with named exports from `@/i18n/t`, e.g.
+   * ```ts
+   * import { myMessage_key } from "@/i18n/t";
+   *
+   * myMessage_key();
+   * ```
+   * This import is transformed into `import myMessage_key from "@/i18n/t/myMessage_key";`
+   *
+   *
+   * - When `false` usage is:
+   * ```ts
+   * import { t } from "@/i18n";
+   *
+   * t.myMessage_key();
+   * ```
+   *
+   * @default false
+   */
+
+var o$8 = (({ config: e })=>`
+import { locales } from "./locales";
+import { defaultLocale } from "./defaultLocale";
+
+/**
+ */
+export const config = {
+  locales,
+  defaultLocale,
+  hideDefaultLocaleInUrl: ${e.hideDefaultLocaleInUrl},
+}
+
+export default config;
+`);
+
+var m$6 = (({ config: e })=>`
+const { locales } = require("./locales");
+const { defaultLocale } = require("./defaultLocale");
+
+const config = {
+  locales,
+  defaultLocale,
+  hideDefaultLocaleInUrl: ${e.hideDefaultLocaleInUrl},
+};
+
+exports.config = config;
+
+module.exports = config;
+`);
+
+/**
+ * TODO: maybe use `params` to determine the right type with some kind of special
+ * token used in the route id
+ *
+ * NB: wrap the output of this function, e.g. `type A = {${dataParamsToTsInterfaceBody(params)}}`
+ */ let dataParamsToTsInterfaceBody = (e)=>Object.keys(e).reduce((r, t)=>{
+        let a = e[t], s = "";
+        switch(a){
+            case "number":
+                s = "number";
+                break;
+            case "string":
+                s = "string";
+                break;
+            default:
+                s = "string | number";
+        }
+        return r.push(`${t}: ${s};`), r;
+    }, []).join(" ");
+let escapeEachChar = (e)=>e.split("").map((e)=>`\\${e}`).join("");
+
+var r$5 = (({ config: t, options: n })=>{
+    let { start: r, end: a } = n.translations.tokens.dynamicDelimiters;
+    return `
+import type { I18n } from "./types";
+import { defaultLocale } from "./defaultLocale";
+import { tInterpolateParams } from "./tInterpolateParams";
+
+// An optional parameter allowEmptyStrings - true as default.
+// If allowEmptyStrings parameter is marked as false,
+// it should log an error when an empty string is attempted to be translated
+// and return the namespace and key as result of the translation.
+const allowEmptyStrings = true;
+
+/**
+ * @see https://github.com/aralroca/next-translate/blob/master/src/transCore.tsx
+ */
+export function createT<TNamespace extends I18n.TranslateNamespace>(
+  dictionaries: I18n.Dictionaries,
+  pluralRules: Intl.PluralRules,
+  locale: string = defaultLocale,
+) {
+  const interpolateUnknown = (
+    value: unknown,
+    query?: I18n.TranslationQuery | null,
+  ): typeof value => {
+    if (Array.isArray(value)) {
+      return value.map((val) => interpolateUnknown(val, query));
+    }
+    if (value instanceof Object) {
+      return objectInterpolation(
+        value as Record<string, unknown>,
+        query,
+        locale,
+      );
+    }
+    return interpolation(value as string, query, locale);
+  };
+
+  return <
+    TPath extends I18n.TranslationsPaths<
+      I18n.TranslationsDictionary[TNamespace]
+    >,
+    TReturn = I18n.TranslationAtPathFromNamespace<TNamespace, TPath>,
+  >(
+    key: TPath,
+    query?: I18n.TranslationQuery,
+    options?: I18n.TranslationOptions,
+  ): TReturn => {
+    const k = Array.isArray(key) ? key[0] : key;
+    const [namespace, i18nKey] = k.split("${n.translations.tokens.namespaceDelimiter}");
+    const dic = (namespace && dictionaries[namespace]) || {};
+    const pluralisedKey = getPluralisedKey(pluralRules, dic, i18nKey, query, options);
+    const dicValue = getDicValue(dic, pluralisedKey, query, options);
+    const value =
+      typeof dicValue === "object"
+        ? JSON.parse(JSON.stringify(dicValue))
+        : dicValue;
+
+    const empty =
+      typeof value === "undefined" ||
+      (typeof value === "object" && !Object.keys(value).length) ||
+      (value === "" && !allowEmptyStrings);
+
+    // no need to try interpolation
+    if (empty) {
+      return query === "" ? "" : k;
+    }
+
+    // this can return an empty string if either value was already empty
+    // or it contained only an interpolation (e.g. "{{name}}") and the query param was empty
+    return interpolateUnknown(value, query) as TReturn;
+  };
+}
+
+// const Empty = new Symbol("Empty tranlsation message")
+
+/**
+ * Get value from key (allow nested keys as parent.children)
+ */
+function getDicValue(
+  dic: I18n.TranslationsDictionaryLoose,
+  key: string = "",
+  query?: I18n.TranslationQuery,
+  options?: I18n.TranslationOptions,
+): unknown | undefined {
+  const keySeparator = ".";
+  const keyParts = keySeparator ? key.split(keySeparator) : [key];
+  const returnObjects =
+    query === "obj" ||
+    options === "obj" ||
+    (options instanceof Object && options.returnObjects);
+
+  if (key === keySeparator && returnObjects) return dic;
+
+  const value: string | object = keyParts.reduce(
+    (val: I18n.TranslationsDictionaryLoose | string, key: string) => {
+      if (typeof val === "string") {
+        return {};
+      }
+
+      const res = val[key as keyof typeof val];
+
+      // pass all truthy values or (empty) strings
+      return res || (typeof res === "string" ? res : {});
+    },
+    dic,
+  );
+
+  if (
+    typeof value === "string" ||
+    (returnObjects && Object.keys(value).length > 0)
+  ) {
+    return value;
+  }
+
+  if (Array.isArray(value) && returnObjects) return value;
+  return undefined;
+}
+
+/**
+ * Control plural keys depending the {{count}} variable
+ */
+function getPluralisedKey(
+  pluralRules: Intl.PluralRules,
+  dic: I18n.TranslationsDictionaryLoose,
+  key: string,
+  query?: I18n.TranslationQuery | null,
+  options?: I18n.TranslationOptions,
+): string {
+  const count = query instanceof Object ? query.count : null;
+
+  if (!query || typeof count !== "number") return key;
+
+  const numKey = \`\${key}_\${count}\`;
+  if (getDicValue(dic, numKey, query, options) !== undefined) return numKey;
+
+  const pluralKey = \`\${key}_\${pluralRules.select(count)}\`;
+  if (getDicValue(dic, pluralKey, query, options) !== undefined) {
+    return pluralKey;
+  }
+
+  const nestedNumKey = \`\${key}.\${count}\`;
+  if (getDicValue(dic, nestedNumKey, query, options) !== undefined)
+    return nestedNumKey;
+
+  const nestedKey = \`\${key}.\${pluralRules.select(count)}\`;
+  if (getDicValue(dic, nestedKey, query, options) !== undefined)
+    return nestedKey;
+
+  return key;
+}
+
+/**
+ * Replace {{variables}} to query values
+ */
+function interpolation(
+  text?: string,
+  query?: I18n.TranslationQuery | null,
+  _locale?: string | undefined,
+): string {
+  if (!text || !query || query === "obj") return text || "";
+
+  return tInterpolateParams(text, query);
+  // return Object.keys(query).reduce((all, key) => {
+  //   // eslint-disable-next-line no-useless-escape
+  //   const regex = new RegExp(\`${escapeEachChar(r)}\\s*\${key}(?:[\\s,]+([\\w-]*))?\\s*\$${escapeEachChar(a)}\`, "gm");
+  //   return all.replace(regex, (_match) => query[key as keyof typeof query] as string);
+  // }, text);
+}
+
+function objectInterpolation(
+  obj: Record<string, string | unknown>,
+  query?: I18n.TranslationQuery | null,
+  locale?: string,
+) {
+  if (!query || Object.keys(query).length === 0) return obj;
+  Object.keys(obj).forEach((key) => {
+    if (obj[key] instanceof Object)
+      objectInterpolation(
+        obj[key] as Record<string, string | unknown>,
+        query,
+        locale,
+      );
+    if (typeof obj[key] === "string")
+      obj[key] = interpolation(obj[key] as string, query, locale);
+  });
+
+  return obj;
+}
+`;
+});
+
+var n$6 = (({})=>`
+import type { I18n } from "./types";
+
+/**
+ * @internal
+ */
+export const defaultI18nMetadata: I18n.Metadata = {
+  canonical: "",
+  alternates: {}
+}
+`);
+
+var a$7 = (({ config: e })=>`
+import type { I18n } from "./types";
+
+export const defaultLocale: I18n.Locale = "${e.defaultLocale}";
+
+export default defaultLocale;
+`);
+
+var f$4 = (({ config: { baseUrl: a, trailingSlash: e } })=>`
+/**
+ * @param pathname Normalised, always prepended with a locale (if needed) and a slash
+ */
+export const formatUrl = (pathname: string) => "${a}" + ${e ? "pathname" : '(pathname === "/" ? "" : pathname)'};
+
+export default formatUrl;
+`);
+
+var i$8 = (({})=>`
+import { defaultLocale } from "./defaultLocale";
+// import { loadTranslations } from "./loadTranslations";
+import type { I18n } from "./types";
+
+type GetI18nDictionariesOptions = {
+  locale?: I18n.Locale;
+  namespaces?: I18n.TranslateNamespace[];
+};
+
+export async function getI18nDictionaries({
+  locale = defaultLocale,
+  namespaces = [],
+}: GetI18nDictionariesOptions) {
+  const translations =
+    (await Promise.all(
+      namespaces.map((namespace) => 
+        // prettier-ignore
+        import(\`./translations/\${locale}/\${namespace}.json\`).then((m) => m.default)
+        // loadTranslations(locale, namespace)
+        .catch(() => ({}))),
+    )) || [];
+
+  return namespaces.reduce((dictionaries, ns, idx) => {
+    dictionaries[ns] =
+      translations[idx] ||
+      (null as unknown as I18n.TranslationsDictionaryLoose);
+    return dictionaries;
+  }, {} as I18n.Dictionaries);
+}
+
+export default getI18nDictionaries;
+`);
+
+var s$8 = (({})=>`
+import { defaultI18nMetadata } from "./defaultI18nMetadata";
+import { defaultLocale } from "./defaultLocale";
+import { formatUrl } from "./formatUrl";
+import { locales } from "./locales";
+import { type RouteIdError, isErrorRoute } from "./routesError";
+import { to } from "./to";
+import type { I18n } from "./types";
+
+/**
+ * - All localised variants should always be included (despite the current lang)
+ * - We use the defaultLocale's URL as the \`x-default\` alternate value
+ * 
+ * @internal
+ * @see https://developers.google.com/search/docs/specialty/international/localized-versions#html
+ */
+type GetI18nMetadataOptions<TRouteId extends I18n.RouteId | RouteIdError> =
+  {
+    locale: I18n.Locale;
+  } & I18n.RouteArgs<TRouteId>;
+
+export function getI18nMetadata<
+  TRouteId extends I18n.RouteId | RouteIdError,
+>({ locale: currentLocale, id, params }: GetI18nMetadataOptions<TRouteId>) {
+  if (isErrorRoute(id)) return defaultI18nMetadata;
+  const alternates: I18n.Alternates = {
+    "x-default": formatUrl(
+      params ? to(id, params, defaultLocale) : to(id, defaultLocale),
+    ),
+  };
+  locales
+    .forEach((locale) => {
+      alternates[locale] = formatUrl(
+        params ? to(id, params, locale) : to(id, locale),
+      );
+    });
+
+  return {
+    alternates,
+    canonical: formatUrl(
+      params ? to(id, params, currentLocale) : to(id, currentLocale)
+    )
+  };
+}
+
+export default getI18nMetadata;
+`);
+
+var p$5 = (({})=>`
+import { createT } from "./createT";
+// import { loadTranslations } from "./loadTranslations";
+import type { I18n } from "./types";
+
+export async function getT<TNamespace extends I18n.TranslateNamespace>(
+  locale: I18n.Locale,
+  namespace: TNamespace,
+) {
+  // prettier-ignore
+  const translations = await import(\`./translations/\${locale}/\${namespace}.json\`).then((m) => m.default);
+  // const translations = await loadTranslations(locale, namespace);
+  const pluralRules = new Intl.PluralRules(locale);
+
+  const t = createT({ [namespace]: translations }, pluralRules, locale);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return ((i18nKey: string, ...args: any[]) =>
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (t as any)(
+      \`\${namespace}:\${i18nKey}\`,
+      ...args,
+    )) as I18n.TranslateNamespaced<TNamespace>;
+}
+
+export default getT;
+
+`);
+
+var x$4 = (({})=>`
+import { locales } from "./locales";
+import type { I18n } from "./types";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isLocale = (payload: any): payload is I18n.Locale =>
+  locales.includes(payload);
+
+export default isLocale;
+`);
+
+var d$6 = (({})=>`
+import type { I18n } from "./types";
+
+/**
+ * @internal
+ */
+export const loadTranslations = (
+  locale: I18n.Locale,
+  namespace: I18n.TranslateNamespace,
+) =>
+  import(\`./translations/\${locale}/\${namespace}.json\`).then(
+    (m) => m.default,
+  );
+`);
+
+var l$4 = (({ config: e })=>{
+    let l = `[${e.locales.map((e)=>`"${e}"`).join(", ")}]`;
+    return `
+export const locales = ${l} as const;
+
+export default locales;
+`;
+});
+
+var c$3 = (({ options: t })=>{
+    let { idDelimiter: a, optionalCatchAll: r, catchAll: o } = t.routes.tokens;
+    return `
+/**
+ * Convert a URL like pathname to a "named route"
+ * E.g. it transforms:
+ * - \`/dashboard/user/[id]\` into \`dashboard.user.[id]\`
+ */
+export const pathnameToRouteId = (pathname: string) =>
+  pathname
+    .replace(/^\\//g, "")
+    .replace(/\\//g, "${a}")
+    .replace(/${utils.escapeRegExp(a)}${utils.escapeRegExp(r.start)}.+$/, "")
+    .replace(/${utils.escapeRegExp(a)}${utils.escapeRegExp(o.start)}.+$/, "")
+    .replace(/\\/index$/, "");
+
+export default pathnameToRouteId;
+`;
+});
+
+var u$2 = (({ routes: t })=>{
+    let e = JSON.stringify(Object.fromEntries(Object.entries(t.byId).map(([t, { pathnames: e }])=>[
+            t,
+            e
+        ]).sort()), null, 2);
+    return `
+/**
+ * @internal
+ */
+export const routes = ${e} as const;
+
+// export default routes;
+`;
+});
+
+var g$2 = (({})=>`
+
+export type RouteIdError = (typeof routesError)[number];
+
+/**
+ * @internal
+ */
+export const routesError = [
+  "404",
+  "500",
+  "403"
+] as const;
+
+/**
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isErrorRoute = (payload: any): payload is RouteIdError =>
+  routesError.includes(payload);
+
+// export default routesError;
+`);
+
+var I$3 = (({ routes: t })=>{
+    let e = JSON.stringify(Object.fromEntries(Object.entries(t.byId).map(([t, { pathnamesSlim: e, pathnames: r }])=>[
+            t,
+            e || r
+        ]).sort()), null, 2);
+    return `
+/**
+ * @internal
+ */
+export const routesSlim = ${e} as const;
+
+// export default routesSlim;
+`;
+});
+
+var T$2 = (({ routes: t })=>{
+    let e = JSON.stringify(Object.fromEntries(Object.entries(t.byId).filter(([, { pathnamesSpa: t }])=>!!t).map(([t, { pathnamesSpa: e }])=>[
+            t,
+            e
+        ]).sort()), null, 2);
+    return `
+/**
+ * @internal
+ */
+export const routesSpa = ${e} as const;
+
+export default routesSpa;
+`;
+});
+
+// /**
+//  * Control plural keys depending the {{count}} variable
+//  */
+// function plural(
+//   pluralRules: Intl.PluralRules,
+//   dic: I18nDictionary,
+//   key: string,
+//   config: I18nConfig,
+//   query?: TranslationQuery | null,
+//   options?: {
+//     returnObjects?: boolean
+//     fallback?: string | string[]
+//   }
+// ): string {
+//   if (!query || typeof query.count !== 'number') return key
+//   const numKey = `${key}_${query.count}`
+//   if (getDicValue(dic, numKey, config, options) !== undefined) return numKey
+//   const pluralKey = `${key}_${pluralRules.select(query.count)}`
+//   if (getDicValue(dic, pluralKey, config, options) !== undefined) {
+//     return pluralKey
+//   }
+//   const nestedNumKey = `${key}.${query.count}`
+//   if (getDicValue(dic, nestedNumKey, config, options) !== undefined)
+//     return nestedNumKey
+//   const nestedKey = `${key}.${pluralRules.select(query.count)}`
+//   if (getDicValue(dic, nestedKey, config, options) !== undefined)
+//     return nestedKey
+//   return key
+// }
+// const getP = (dic) => {
+//   return
+// }
+let i$7 = (t)=>utils.isString(t) || utils.isNumber(t) ? `"${t}"` : utils.isBoolean(t) ? `${t}` : utils.isArray(t) ? JSON.stringify(t) : `(${JSON.stringify(t)})`, s$7 = (e, r)=>utils.areEqual(e, r), p$4 = (t, e)=>{
+    let { defaultLocale: r } = t, l = "";
+    for(let t in e){
+        let o = e[t];
+        t === r || s$7(o, e[r]) || (l += `locale === "${t}" ? ${i$7(o)} : `);
+    }
+    return l + i$7(e[r]);
+};
+var S = (({ config: t, options: e, translations: r })=>{
+    let l = `
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-const */
+import type { I18n } from "./types";
+import { tInterpolateParams } from "./tInterpolateParams";
+import { tPluralise } from "./tPluralise";
+
+`, n = [], s = [];
+    for(let l in r){
+        let m = "", { values: u, params: f, plural: $ } = r[l], c = `${e.translations.fnsPrefix}${l}`;
+        $ && (f ? f.count = "number" : f = {
+            count: "number"
+        });
+        let P = [
+            f ? `params: { ${dataParamsToTsInterfaceBody(f)} }` : "",
+            // for ergonomy always allow the user to pass the locale
+            "locale?: I18n.Locale"
+        ].filter(Boolean).join(", ");
+        // const formatArgParams = params ? ", params" : "";
+        m += `export let ${c} = (${P}) => `;
+        let d = "";
+        utils.isPrimitive(u) ? d += i$7(u) : d += p$4(t, u), $ && (d = `tPluralise(${d}, params.count)`), m += d = f ? `tInterpolateParams(${d}, params);` : `${d};`, n.push(m), s.push(c);
+    }
+    return l + (n.join("\n") + // TODO: verify the impact of the following on bundle size, its relation to
+    // modularizeImports and maybe make this controllable through an adapter
+    // option
+    `\n\n` + `export const t = {\n  ${s.join(",\n  ")}\n};` + `\n\n`) + "export default t;";
+});
+
+var F = (({ options: a })=>{
+    let { start: t, end: r } = a.translations.tokens.dynamicDelimiters;
+    return `
+/**
+ * @internal
+ */
+/* eslint-disable prefer-const */
+export let tInterpolateParams = (
+  value: string,
+  params?: object,
+) =>
+  params ? value.replace(
+    /${escapeEachChar(t)}(.*?)${escapeEachChar(r)}/g,
+    (_, key) =>
+      params[key.trim() as keyof typeof params] + "",
+  ) : value;
+
+// export default tInterpolateParams;
+`;
+});
+
+var L = (({})=>`
+/* eslint-disable prefer-const */
+let pluralRules = new Intl.PluralRules();
+
+/**
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export let tPluralise = (values: any, count: number) =>
+  values[count] || values[pluralRules.select(count)] || (count === 0 ? values.zero : values["other"]);
+
+// export default tPluralise;
+`);
+
+var M = (({})=>`
+import { defaultLocale } from "./defaultLocale";
+import { isLocale } from "./isLocale";
+import { toFormat } from "./toFormat";
+import { routesSlim } from "./routesSlim";
+import type { I18n } from "./types";
+
+/**
+ * *To* route utility
+ * 
+ * @returns A localised relative URL based on your i18nCompiler configuration
+ */
+export function to<Id extends I18n.RouteId>(
+  id: Id,
+  ...args: Id extends I18n.RouteIdDynamic
+    ?
+        | [I18n.RouteParams[Id]]
+        | [I18n.RouteParams[Id], I18n.Locale]
+    : [] | [I18n.Locale]
+) {
+  const locale = (isLocale(args[0]) ? args[0] : args[1]) || defaultLocale;
+
+  return toFormat(
+    locale,
+    (routesSlim[id] as Record<string, string>)[locale] ??
+      (routesSlim[id] as Record<string, string>)[defaultLocale] ??
+      routesSlim[id],
+    isLocale(args[0]) ? undefined : args[0]
+  ) as I18n.RoutePathnames[Id];
+}
+
+export default to;
+`);
+
+let e = (t, o)=>{
+    let { defaultLocale: e } = t, r = "";
+    for(let t in o){
+        let l = o[t];
+        t !== e && l !== o[e] && (r += `locale === "${t}" ? "${l}" : `);
+    }
+    return r + ('"' + o[e]) + '"';
+};
+var P = (({ config: r, routes: l, options: n })=>{
+    let a = 1 === r.locales.length, s = `
+/* eslint-disable prefer-const */
+import { toFormat } from "./toFormat";
+import type { I18n } from "./types";
+
+`, $ = [], i = [];
+    for(let s in l.byId){
+        let p = "", { pathnames: m, params: f } = l.byId[s], u = `${n.routes.fnsPrefix}${utils.changeCaseSnake(s)}`, c = `I18n.RouteParams["${s}"]`, F = [
+            f ? `params: ${c}` : "",
+            a ? "" : "locale?: I18n.Locale"
+        ].filter(Boolean).join(", "), d = a ? '""' : "locale", x = f ? ", params" : "";
+        p += `export let ${u} = (${F}) => `, utils.isString(m) ? p += `toFormat(${d}, "${m}"${x});` : p += `toFormat(${d}, ${e(r, m)}${x});`, $.push(p), i.push(u);
+    }
+    return s + ($.join("\n") + // TODO: verify the impact of the following on bundle size, its relation to
+    // modularizeImports and maybe make this controllable through an adapter
+    // option
+    `\n\n` + `export const toFns = {\n  ${i.join(",\n  ")}\n};` + `\n\n`) + "export default toFns;";
+});
+
+var j = (({ config: a })=>`
+import { defaultLocale } from "./defaultLocale";
+
+/**
+ * @internal
+ */
+export function toFormat(
+  locale: string | undefined,
+  pathname: string,
+  params?: object,
+) {
+  locale = locale || defaultLocale;
+  if (process.env["NODE_ENV"] === "development") {
+    if (params) {
+      pathname.replace(/\\[(.*?)\\]/g, (_, dynamicKey) => {
+        const key = dynamicKey as Extract<keyof typeof params, string>;
+
+        if (!(key in params)) {
+          console.warn(
+            "[@koine/i18n]::toFormat, using '" +
+              pathname +
+              "' without param '" +
+              key +
+              "'",
+              { params }
+          );
+        }
+
+        if (!["string", "number"].includes(typeof params[key])) {
+          console.warn(
+            "[@koine/i18n]::toFormat, using '" +
+              pathname +
+              "' with unserializable param  '" +
+              key +
+              "' (type '" +
+              Object.prototype.toString.call((params[key])).slice(8, -1) +
+              "')",
+          );
+        }
+        return "";
+      });
+    }
+  }
+
+  if (params) {
+    pathname = pathname.replace(
+        /\\[(.*?)\\]/g,
+        (_, key) =>
+          params[key as keyof typeof params] + "",
+      )
+  }
+  ${a.hideDefaultLocaleInUrl ? `
+  if (locale !== defaultLocale) {
+    return "/" + locale + (pathname === "/" ? "" : pathname);
+  }
+  ` : ""}
+  return pathname;
+}
+
+// export default toFormat;
+`);
+
+var h$3 = (({ config: o, options: t })=>{
+    let { idDelimiter: e } = t.routes.tokens;
+    return `
+import { defaultLocale } from "./defaultLocale";
+import { isLocale } from "./isLocale";
+import { routesSpa } from "./routesSpa";
+import { toFormat } from "./toFormat";
+import type { I18n } from "./types";
+
+/**
+ * *To spa* route utility
+ *
+ * @returns A localised relative URL based on your i18nCompiler configuration
+ */
+export function toSpa<
+  Root extends keyof I18n.RouteSpa,
+  Path extends Extract<keyof I18n.RouteSpa[Root], string>,
+>(
+  rootId: Root,
+  pathId: Path,
+  ...args: I18n.RouteJoinedId<Root, Path> extends I18n.RouteIdDynamic
+    ?
+        | [I18n.RouteParams[I18n.RouteJoinedId<Root, Path>]]
+        | [I18n.RouteParams[I18n.RouteJoinedId<Root, Path>], I18n.Locale]
+    : [] | [I18n.Locale]
+) {
+  const locale = (isLocale(args[0]) ? args[0] : args[1]) || defaultLocale;
+  const fullId = \`\${rootId}${e}\${pathId}\` as I18n.RouteJoinedId<Root, Path>;
+  return toFormat(
+    // FIXME: actually the locale will be prepended if hideDefaultLocaleInUrl will be false
+    "", // do not pass the locale so that won't be prepended
+    (routesSpa[fullId] as Record<string, string>)[locale],
+    args.length === 2
+      ? args[0]
+      : args[0] && !isLocale(args[0])
+        ? args[0]
+        : void 0,
+  ) as I18n.RouteSpa[Root][Path];
+}
+
+export default toSpa;
+`;
+});
+
+/**
+ * @see https://github.com/aralroca/next-translate?tab=readme-ov-file#5-plurals
+ */ let s$6 = [
+    "zero",
+    "one",
+    "two",
+    "few",
+    "many",
+    "other"
+], i$6 = "other";
+/**
+ * Is the given string a valid plural suffix?
+ */ let isPluralSuffix = (e)=>s$6.includes(e) || utils.isNumericLiteral(e);
+/**
+ * Remove plural suffix from string
+ */ let removePluralSuffix = (e)=>{
+    let [l] = utils.splitReverse(e, "_");
+    return l ? e.replace(`_${l}`, "") : e;
+};
+/**
+ * Get plural suffix from string
+ */ let getPluralSuffix = (e)=>utils.splitReverse(e, "_")[0];
+/**
+ * Is the translation value object key a plural form?
+ *
+ * Using `splitReverse` ensures to get the last underscore prefixed suffix
+ * even in a string with multiple underscores.
+ */ let isPluralKey = (e)=>{
+    let [l] = utils.splitReverse(e, "_");
+    return isPluralSuffix(l);
+};
+let a$6 = (e)=>{
+    let l = {};
+    return e.forEach((e)=>{
+        let [r] = utils.split(e, "_");
+        l[r] = l[r] || [], l[r].push(e);
+    }), l;
+};
+/**
+ * Some translations keys won't be used directly and should be omitted
+ * from the generated types, e.g. the plural versions of the same string.
+ */ let transformKeysForPlurals = (l)=>{
+    // only transform if we have the required plural suffix in the keys
+    if (l.some(hasRequiredPluralSuffix) || l.includes(i$6)) {
+        let r = l.filter(isPluralKey);
+        if (r.length) {
+            let t = [
+                ...l
+            ];
+            return utils.forin(a$6(r), (e, r)=>{
+                // add the plural root
+                l.includes(e) || t.push(e), // remove the plurals variations
+                r.forEach((e)=>{
+                    l.includes(e) && (t = t.filter((l)=>l !== e));
+                });
+            }), t;
+        }
+    }
+    return l;
+};
+/**
+ * Check if the given key has the required plural suffix
+ */ let hasRequiredPluralSuffix = (e)=>isPluralKey(e) && getPluralSuffix(e) === i$6;
+/**
+ * Does the translation value object has plurals version?
+ *
+ * NB: here we check only for the **required** plural suffix,
+ */ let hasPlurals = (e)=>Object.keys(e).some(hasRequiredPluralSuffix) || Object.keys(e).includes(i$6);
+/**
+ * Is the translation value object only enumerating plurals version?
+ */ let hasOnlyPluralKeys = (e)=>!!hasPlurals(e) && 0 === pickNonPluralKeys(e).length;
+/**
+ * Pick the translation value object keys that _have no_ to do with pluralisation
+ */ let pickNonPluralKeys = (e)=>Object.keys(e).filter((e)=>!isPluralSuffix(e));
+/**
+ * Narrows the translation value object picking only keys that _have no_ to do
+ * with pluralisation
+ */ let pickNonPluralValue = (e)=>hasPlurals(e) ? utils.objectPick(e, pickNonPluralKeys(e)) : e;
+
+let c$2 = (e, a)=>!utils.isArray(a) && utils.isObject(a) && hasPlurals(a) ? hasOnlyPluralKeys(a) ? `"${e}": string;` : `"${e}": ${d$5(pickNonPluralValue(a))}` : `"${e}": ${d$5(a)}`, d$5 = (e)=>{
+    let o = "", r = "";
+    if (utils.isBoolean(e) ? r = "boolean" : utils.isString(e) && (r = "string"), r) o += r + ";";
+    else if (e) {
+        if (utils.isArray(e)) {
+            let t = e[0];
+            o += `${d$5(t)}[];`;
+        } else if (utils.isObject(e)) {
+            o += "{";
+            let t = transformKeysForPlurals(Object.keys(e));
+            for(let a = 0; a < t.length; a++){
+                let s = t[a], // fallback to a string otherwise plurals without root definition would
+                // not get a type otherwise, e.g. ` pluralNoDefault_...` in __mocks__
+                n = e[s] || "";
+                o += c$2(s, n);
+            }
+            o += "};";
+        }
+    } else o += "";
+    return(// adjust syntax
+    (o = o.replace(/;\[\];/g, "[];")).replace(/;+/g, ";"));
+}, u$1 = (e, t)=>{
+    let { translationFiles: a } = t, { defaultLocale: s } = e, n = a.filter((e)=>e.locale === s), o = [];
+    for(let e = 0; e < n.length; e++){
+        let { path: t, data: a } = n[e], s = t.replace(".json", "");
+        o.push(`"${s}": ${d$5(a)}`);
+    }
+    return o.sort();
+}, h$2 = (t)=>{
+    let a = [];
+    return utils.forin(t.byId, (e, { params: t })=>{
+        t && a.push(`"${e}": { ${dataParamsToTsInterfaceBody(t)} };`);
+    }), a;
+}, y$1 = (e)=>e.sort().map((e)=>`"${e}"`).join(" | "), T$1 = (e, t)=>y$1(Object.keys(e.byId).filter((a)=>t(a, e.byId[a]))), m$5 = (e)=>Object.keys(e.byId).reduce((t, a)=>{
+        if (e.byId[a].inWildcard) for(let s = 0; s < e.wildcardIds.length; s++){
+            let n = e.wildcardIds[s];
+            a.startsWith(n) && (t[n] = t[n] || [], t[n].push(a));
+        }
+        return t;
+    }, {}), f$3 = (e, t, a)=>{
+    let s = m$5(t), n = [];
+    for(let o in s){
+        let r = s[o].map(// remove the root id portion and the first character which is always
+        // the route `idDelimiter`
+        (e)=>e.split(o)[1].slice(1)), i = t.byId[o].pathnames[e.defaultLocale], l = [];
+        for(let s = 0; s < r.length; s++){
+            let n = r[s], p = `${o}${a.routes.tokens.idDelimiter}${n}`, c = t.byId[p].pathnames[e.defaultLocale].split(i)[1];
+            l.push(`"${n}": "${c}";`);
+        }
+        n.push(`"${o}": { ${l.join(" ")} }`);
+    }
+    return n;
+}, g$1 = (e, t)=>{
+    let a = [];
+    for(let s in t.byId){
+        let n = t.byId[s];
+        a.push(`"${n.id}": "${n.pathnames[e.defaultLocale]}";`);
+    }
+    return a;
+};
+// TODO: maybe move the Translate types into the various adapters unless we
+// will use the same api for all of them
+var y$2 = (({ config: e, input: t, routes: a, options: s })=>{
+    let n = T$1(a, (e, { params: t })=>!t), o = T$1(a, (e, { params: t })=>!!t), // const routeIdSpa = buildRoutesUnion(routes, (_, { inWildcard }) => inWildcard);
+    { idDelimiter: r } = s.routes.tokens;
+    return `
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/ban-types */
+import type { Split } from "@koine/utils";
+import type { I18nUtils } from "@koine/i18n";
+import type { RouteIdError } from "./routesError";
+
+export namespace I18n {
+  /**
+   * Any of the available locale code
+   */
+  export type Locale = ${e.locales.map((e)=>`"${e}"`).join(" | ")};
+ 
+  /**
+   * Utility to map values by all available locales
+   * 
+   * @usecase I need to map zendesk URLs to my project's locales
+   */
+  export type LocalesMap<T = any> = Record<Locale, T>;
+
+  /**
+   * Any of the available route id
+   */
+  export type RouteId = RouteIdStatic | RouteIdDynamic;
+
+  /**
+   * The static routes available ids
+   */
+  export type RouteIdStatic = ${n};
+
+  /**
+   * The dynamic routes available ids
+   */
+  export type RouteIdDynamic = ${o};
+
+  /**
+   * Map every SPA path divided by their roots to their actual pathname value for the default locale
+   */
+  export type RouteSpa = {
+    ${f$3(e, a, s).join("\n    ")}
+  }
+
+  /**
+   * Map every route id to its actual pathanem value for the default locale
+   */
+  export type RoutePathnames = {
+    ${g$1(e, a).join("\n    ")}
+  }
+
+  /**
+   * Route dynamic params dictionary for each dynamic route id
+   */
+  export type RouteParams = {
+    ${h$2(a).join("\n    ")}
+  }
+
+  /**
+   * Utility to join two route ids
+   */
+  export type RouteJoinedId<Root extends string, Tail extends string> = \`\${Root}${r}\${Tail}\` extends RouteId ? \`\${Root}${r}\${Tail}\` : never;
+
+  /**
+   * Extract all children routes that starts with the given string
+   *
+   * This is useful to get the subroutes of an application area, e.g. all subroutes
+   * of a dashboard, using it with: \` type DashboardRoutes = RoutesChildrenOf<"dashboard">;\`
+   */
+  export type RoutesChildrenOf<
+    TStarts extends string,
+    T extends string = RouteId,
+  > = T extends \`\${TStarts}.\${infer First}\` ? \`\${TStarts}.\${First}\` : never;
+
+  /**
+   * @internal
+   */
+  export type TranslationsDictionaryLoose = {
+    [key: string]: string | TranslationsDictionaryLoose;
+  };
+
+  /**
+   * The types extracted from the translations JSON files, this is a little
+   * more sophisticated than the type result of \`typeof "./en/messages.json"\`
+   */
+  export type TranslationsDictionary = {
+    ${u$1(e, t).join("\n    ")}
+  }
+
+  /**
+   * Any of the available translations namespaces
+   */
+  export type TranslateNamespace = Extract<keyof TranslationsDictionary, string>;
+
+  /**
+   * Translation **value** found at a specific _path_ in the given _namespace_
+   *
+   * \`TPath\` can be any of all possible paths:
+   * - \`myKey\` sub dictionaries within a namespace
+   * - \`myKey.nested\` whatever nested level of nesting within a namespace
+   */
+  export type TranslationAtPathFromNamespace<
+    TNamespace extends TranslateNamespace,
+    TPath extends TranslationsPaths<TranslationsDictionary[TNamespace]>,
+  > = TNamespace extends TranslateNamespace
+    ? TPath extends string // TranslationsPaths<TranslationsDictionary[TNamespace]>
+      ? I18nUtils.Get<TranslationsDictionary[TNamespace], TPath>
+      : TranslationsDictionary[TNamespace]
+    : never;
+
+  /**
+   * The generic type passed and to use with {@link TranslationAtPath} when you
+   * want to build a type extending that
+   */
+  export type TranslationAtPathGeneric =
+    | TranslateNamespace
+    | TranslationsAllPaths;
+
+  /**
+   * Translation **value** found at a _path_
+   *
+   * \`TPath\` can be any of all possible paths begininng with a namespace:
+   * - \`namespace\` only a namespace
+   * - \`namespace:myKey\` sub dictionaries within a namespace
+   * - \`namespace:myKey.nested\` whatever nested level of nesting
+   */
+  export type TranslationAtPath<TPath extends TranslationAtPathGeneric> =
+    TPath extends TranslateNamespace
+      ? TranslationsDictionary[TPath]
+      : TPath extends \`\${infer Namespace}:\${infer Path}\`
+        ? Namespace extends TranslateNamespace
+          ? I18nUtils.Get<TranslationsDictionary[Namespace], Path>
+          : never
+        : never;
+
+  /**
+   * All translations paths from the given _path_
+   *
+   * \`TPath\` can be any of all possible paths begininng with a namespace:
+   * - \`namespace\` only a namespace
+   * - \`namespace:myKey\` sub dictionaries within a namespace
+   * - \`namespace:myKey.nested\` whatever nested level of nesting
+   */
+  export type TranslationsPathsFrom<TPath extends TranslationAtPathGeneric> =
+    TPath extends TranslateNamespace
+      ? TranslationsPaths<TranslationsDictionary[TPath]>
+      : TPath extends \`\${infer Namespace}:\${infer Path}\`
+        ? Namespace extends TranslateNamespace
+          ? I18nUtils.Get<TranslationsDictionary[Namespace], Path> extends object
+            ? TranslationsPaths<I18nUtils.Get<TranslationsDictionary[Namespace], Path>>
+            : TranslationsPaths<TranslationsDictionary[Namespace]>
+          : never
+        : never;
+
+  /**
+   * All translations _paths_ of the given one, e.g. if \`TPath\` would be
+   * \`"dashboard.users.[id].edit"\` the generated type would be the union
+   * \`"dashboard.users.[id]" | "dashboard.users" | "dashboard"\`.
+   */
+  export type TranslationsPathsAncestors<
+    TPath extends string,
+    TSeparator extends string = ".",
+  > = I18nUtils.BuildRecursiveJoin<Split<TPath, TSeparator>, TSeparator>;
+
+  /**
+   * Recursive mapped type to extract all usable string paths from a translation
+   * definition object (usually from a JSON file).
+   */
+  export type TranslationsPaths<T, TAsObj extends boolean = true> = I18nUtils.Paths<T, TAsObj>;
+
+  /**
+   * Recursive mapped type of all usable string paths from the whole translations
+   * dictionary.
+   */
+  export type TranslationsAllPaths = I18nUtils.AllPaths<TranslationsDictionary>;
+
+  /**
+   * Unlike in \`next-translate\` we allow passing some predefined arguments as
+   * shortcuts for common use cases:
+   * - \`"obj"\` as a shortcut for \`{ returnObjects: true }\`
+   * - \`""\` as a shortcut for \`{ fallback: "" }\`
+   *
+   */
+  type TranslationShortcut = "obj" | "";
+
+  /**
+   * Query object to populate the returned translated string interpolating data
+   * or a TranslationShortcut.
+   *
+   * NOTE: when using a shortcut passing TranslationOptions to \`t()\` is not supported
+   * TODO: type safe this behaviour of the third argument (options).
+   */
+  type TranslationQuery =
+    | undefined
+    | null
+    | TranslationShortcut
+    | {
+        [key: string]: string | number | boolean;
+      };
+
+  /**
+   * Options of the translate function or a TranslationShortcut.
+   *
+   * NOTE: when using a shortcut passing TranslationOptions to \`t()\` is not supported
+   * TODO: type safe this behaviour of the third argument (options).
+   */
+  type TranslationOptions =
+    | undefined
+    | TranslationShortcut
+    | {
+        returnObjects?: boolean;
+        fallback?: string | string[];
+        default?: string;
+      };
+
+  /**
+   * Translate function which optionally accept a namespace as first argument
+   */
+  export type Translate<
+    TNamespace extends TranslateNamespace | undefined = TranslateNamespace,
+  > = TNamespace extends TranslateNamespace
+    ? TranslateNamespaced<TNamespace>
+    : TranslateDefault;
+
+  /**
+   * Translate function **without** namespace, it allows to select any of the all
+   * available strings in _all_ namespaces.
+   */
+  export type TranslateDefault = <
+    TPath extends TranslationsAllPaths,
+    TReturn = TranslationAtPath<TPath>,
+  >(
+    path: TPath,
+    query?: TranslationQuery,
+    options?: TranslationOptions,
+  ) => TReturn;
+
+  /**
+   * Translate function **with** namespace, it allows to select all available
+   * strings _only_ in the given namespace.
+   */
+  export type TranslateNamespaced<TNamespace extends TranslateNamespace> = <
+    TPath extends TranslationsPaths<TranslationsDictionary[TNamespace]>,
+    TReturn = TranslationAtPathFromNamespace<TNamespace, TPath>,
+  >(
+    path: TPath,
+    query?: TranslationQuery,
+    options?: TranslationOptions,
+  ) => TReturn;
+
+  /**
+   * Translate function _loose_ type, to use only in implementations that uses
+   * the \`t\` function indirectly without needng knowledge of the string it needs
+   * to output.
+   */
+  export type TranslateLoose<TReturn = string> = (
+    path?: any,
+    query?: TranslationQuery,
+    options?: TranslationOptions,
+  ) => TReturn;
+
+  /**
+   * Translate function _loosest_ type it allows to return string or object or array
+   * or whatever basically.
+   */
+  export type TranslateLoosest<TReturn = any> = (
+    path?: any,
+    query?: TranslationQuery,
+    options?: TranslationOptions,
+  ) => TReturn;
+
+  /**
+   * @internal
+   */
+  export type Dictionaries = Record<string, TranslationsDictionaryLoose>;
+
+  /**
+   * @internal
+   */
+  export type RouteArgs<TRouteId extends RouteId | RouteIdError> =
+    | {
+        id: TRouteId extends RouteIdDynamic ? TRouteId : never;
+        params: TRouteId extends RouteIdDynamic ? RouteParams[TRouteId] : never;
+      }
+    | {
+        id: TRouteId extends RouteIdStatic | RouteIdError ? TRouteId : never;
+        params?: undefined;
+      };
+
+  /**
+   * Params globally available from the URL/folder structure named accordingly
+   * to the \`localeParam\` option, e.g. \`lang\` for a typical folder structure
+   * such as \`/[lang]/my-route/page.tsx\`.
+   */
+  export type Params = {
+    ${s.routes.localeParamName}: Locale;
+  };
+
+  /**
+   * Props available to each page/layout when a root \`localeParam\` is in place (e.g. 
+   * in the typical _next.js_ folder structure \`/[lang]/my-route/page.tsx\`).
+   */
+  export type Props<TProps = {}> = TProps & {
+    params: Params;
+  };
+
+  /**
+   * Dictionary to generate SEO friendly alternate URLs \`<links>\` where:
+   * 
+   * - _key_: \`x-default\` or any valid locale code (see [Google docs](https://developers.google.com/search/docs/specialty/international/localized-versions#language-codes))
+   * - _value_: fully qualified and localised absolute URL
+   * 
+   * It can also be an empty object, for instance with error routes.
+   *
+   * NOTE: this type should satisfy the nextjs type too that is:
+   * TODO: maybe build a test for this
+   * \`\`\`ts
+   * import type { Metadata as NextMetadata } from "next";
+   * 
+   * type Alternates = NonNullable<NextMetadata["alternates"]>["languages"];
+   * \`\`\`
+   */
+  export type Alternates = Record<string, string>;
+
+  /**
+   * I18n/routing related SEO metadata:
+   *
+   * NOTE: this type should satisfy the nextjs type too that is:
+   * TODO: maybe build a test for this
+   * \`\`\`ts
+   * import type { Metadata as NextMetadata } from "next";
+   * 
+   * type Metadata = NonNullable<NextMetadata["alternates"]>;
+   * \`\`\`
+   */
+  export type Metadata = {
+    alternates: Alternates;
+    canonical: null | string;
+  }
+}
+`;
+});
+
+var t$1 = createAdapter(adapterJsOptions, ({})=>({
+        files: [
+            {
+                name: "config.cjs",
+                fn: m$6,
+                ext: "js"
+            },
+            {
+                name: "config",
+                fn: o$8,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "createT",
+                fn: r$5,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "defaultI18nMetadata",
+                fn: n$6,
+                ext: "ts"
+            },
+            {
+                name: "defaultLocale",
+                fn: a$7,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "formatUrl",
+                fn: f$4,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "getI18nMetadata",
+                fn: s$8,
+                ext: "ts",
+                index: !0
+            },
+            // TODO: probably remove it or move it to `i18n/client` public utils
+            // {
+            //   name: "getI18nAlternatesFromDom",
+            //   fn: getI18nAlternatesFromDom,
+            //   ext: "ts",
+            //   index: true,
+            // },
+            {
+                name: "getI18nDictionaries",
+                fn: i$8,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "getT",
+                fn: p$5,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "isLocale",
+                fn: x$4,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "loadTranslations",
+                fn: d$6,
+                ext: "ts"
+            },
+            {
+                name: "locales",
+                fn: l$4,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "pathnameToRouteId",
+                fn: c$3,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "routes",
+                fn: u$2,
+                ext: "ts"
+            },
+            {
+                name: "routesError",
+                fn: g$2,
+                ext: "ts"
+            },
+            {
+                name: "routesSlim",
+                fn: I$3,
+                ext: "ts"
+            },
+            {
+                name: "routesSpa",
+                fn: T$2,
+                ext: "ts"
+            },
+            {
+                name: "t",
+                fn: S,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "tInterpolateParams",
+                fn: F,
+                ext: "ts"
+            },
+            {
+                name: "to",
+                fn: M,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "toFns",
+                fn: P,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "toFormat",
+                fn: j,
+                ext: "ts"
+            },
+            {
+                name: "toSpa",
+                fn: h$3,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "tPluralise",
+                fn: L,
+                ext: "ts"
+            },
+            {
+                name: "types",
+                fn: y$2,
+                ext: "ts",
+                index: !0
+            }
+        ]
+    }));
+
+const adapterNextTranslateOptions = {};
+
+var t = (({})=>`
+"use client";
+
+import _DynamicNamespaces from "next-translate/DynamicNamespaces";
+
+export const DynamicNamespaces = _DynamicNamespaces;
+
+export default DynamicNamespaces;
+`);
+
+var r$4 = (({})=>`
+"use client";
+
+import _I18nProvider from "next-translate/I18nProvider";
+
+export const I18nProvider = _I18nProvider;
+
+export default I18nProvider;
+`);
+
+var m$4 = (({})=>`
+"use client";
+
+import type { TransProps } from "next-translate";
+import Trans from "next-translate/Trans";
+import type { I18n } from "./types";
+
+export type TProps<
+  TNamespace extends I18n.TranslateNamespace | undefined = undefined,
+> =
+  | (Omit<TransProps, "i18nKey" | "ns"> & {
+      i18nKey: I18n.TranslationsAllPaths;
+    })
+  | (Omit<TransProps, "i18nKey" | "ns"> & {
+      ns: TNamespace;
+      i18nKey: I18n.TranslationsPaths<TNamespace>;
+    });
+
+const TypedT = <
+  TNamespace extends I18n.TranslateNamespace | undefined = undefined,
+>(
+  props: TProps<TNamespace>,
+) =>
+  (<Trans {...(props as TransProps)} />) as React.ReactElement<
+    TProps<TNamespace>
+  >;
+
+export const T = Trans as typeof TypedT;
+
+export default T;
+`);
+
+var o$7 = (({})=>`
+"use client";
+
+import _TransText from "next-translate/TransText";
+
+export const TransText = _TransText;
+
+export default TransText;
+`);
+
+var s$5 = (({})=>`
+import _getT from "next-translate/getT";
+import type { I18n } from "./types";
+
+export type GetT = <
+  TNamespace extends I18n.TranslateNamespace | undefined = undefined,
+>(
+  locale?: I18n.Locale,
+  namespace?: TNamespace,
+) => Promise<I18n.Translate<TNamespace>>;
+
+export const getT = _getT as GetT;
+
+export default getT;
+`);
+
+var a$5 = (({ config: a, adapterOptions: e })=>{
+    let { loader: t } = e;
+    return `
+  /**
+   * Get 'next-translate' configuration
+   *
+   * @see https://github.com/vinissimus/next-translate#how-are-translations-loaded
+   * 
+   * @param {Omit<Partial<import("next-translate").I18nConfig>, "pages"> & { pages: Record<string, import("./types").I18n.TranslateNamespace[]> }} config
+   */
+  module.exports = (config = { pages: {} }) => {
+    return {
+      locales: [${a.locales.map((a)=>`"${a}"`).join(", ")}],
+      defaultLocale: "${a.defaultLocale}",
+      logBuild: false,${t ? "\n      loadLocaleFrom: (locale, namespace) => import(`./translations/${locale}/${namespace}.json`).then((m) => m.default)," : ""}
+      ...${JSON.stringify(e)},
+      ...config,
+    };
+  }
+  `;
+});
+
+var i$5 = (({ config: e })=>`
+import useTranslation from "next-translate/useTranslation";
+import { defaultLocale } from "./defaultLocale";
+import type { I18n } from "./types";
+
+export const useLocale = () => (useTranslation().lang as I18n.Locale) || defaultLocale;
+
+export default useLocale;
+`);
+
+var x$3 = (({})=>`
+"use client";
+
+import { useMemo } from "react";
+import useTranslation from "next-translate/useTranslation";
+import type { I18n } from "./types";
+
+/**
+ * Wrap next-translate useTranslations for type safety and adds TranslationShortcut
+ * as second/thir argument.
+ *
+ * @see https://github.com/vinissimus/next-translate/issues/513#issuecomment-779826418
+ *
+ * About the typescript support for translation strings see:
+ * - https://github.com/vinissimus/next-translate/issues/721
+ */
+export const useT = <TNamespace extends I18n.TranslateNamespace>(namespace: TNamespace) => {
+  const t = useTranslation().t;
+  const tMemoized = useMemo(
+    () =>
+      function <
+        TPath extends I18n.TranslationsPaths<I18n.TranslationsDictionary[TNamespace]>,
+        TReturn = I18n.TranslationAtPathFromNamespace<TNamespace, TPath>,
+      >(s: TPath, q?: I18n.TranslationQuery, o?: I18n.TranslationOptions): TReturn {
+        return t(
+          (namespace ? namespace + ":" + s : s) as string,
+          q === "obj" || q === "" ? null : q,
+          q === "obj" || o === "obj"
+            ? { returnObjects: true }
+            : q === "" || o === ""
+              ? { fallback: "" }
+              : o,
+        ) as TReturn;
+        // ) as TReturn extends (undefined | never | unknown) ? TranslateReturn<I18n.TranslationQuery, I18n.TranslationOptions> : TReturn;
+        // );
+      },
+    [t, namespace],
+  );
+  return tMemoized;
+};
+
+export default useT;
+`);
+
+var a$4 = createAdapter(adapterNextTranslateOptions, ({ adapterOptions: e })=>{
+    let n = [
+        {
+            name: "getT",
+            fn: s$5,
+            ext: "ts",
+            index: !0
+        },
+        {
+            name: "nextTranslateI18n",
+            fn: a$5,
+            ext: "js"
+        },
+        {
+            name: "T",
+            fn: m$4,
+            ext: "tsx",
+            index: !0
+        },
+        {
+            name: "TransText",
+            fn: o$7,
+            ext: "tsx",
+            index: !0
+        },
+        {
+            name: "useT",
+            fn: x$3,
+            ext: "ts",
+            index: !0
+        }
+    ];
+    return !1 === e.loader ? (n.push({
+        name: "useLocale",
+        fn: i$5,
+        ext: "ts",
+        index: !0
+    }), n.push({
+        name: "I18nProvider",
+        fn: r$4,
+        ext: "tsx",
+        index: !0
+    })) : // TODO: check, probably DynamicNamespaces does not work without the automatic loader?
+    n.push({
+        name: "DynamicNamespaces",
+        fn: t,
+        ext: "tsx",
+        index: !0
+    }), {
+        dependsOn: [
+            "next"
+        ],
+        needsTranslationsFiles: !0,
+        files: n
+    };
+});
+
+const adapterNextOptions = {
+    router: "app"
+}; /**
+   * @default "app"
+   */
+
+var n$5 = (({})=>`
+"use client";
+
+import type { AppProps } from "next/app";
+import { defaultI18nMetadata } from "./defaultI18nMetadata";
+import { defaultLocale } from "./defaultLocale";
+import { I18nProvider } from "./I18nProvider";
+import { I18nMetadataProvider } from "./I18nMetadataProvider";
+import { I18nEffects } from "./I18nEffects";
+import { I18nHead } from "./I18nHead";
+import type { I18n } from "./types";
+
+/**
+ * @internal
+ */
+export type I18nAppPropsData = {
+  i18n: {
+    locale: I18n.Locale;
+    dictionaries: I18n.Dictionaries;
+    metadata: I18n.Metadata;
+  }
+};
+
+const i18nDefaults: I18nAppPropsData["i18n"] = {
+  locale: defaultLocale,
+  dictionaries: {},
+  metadata: defaultI18nMetadata
+};
+
+type I18nAppProps =  React.PropsWithChildren<
+  AppProps<I18nAppPropsData>["pageProps"]
+>;
+
+/**
+ * To use in \`_app.tsx\` file wrapping your component
+ * 
+ * **For Pages Router only**
+ * 
+ * NB: Consider that when using ISR with \`fallback: true\` the first load
+ * will not have any useful i18n data (App's \`pageProps\` is an empty object),
+ * hence we provide a \`i18nDefaults\` object.
+ * 
+ * @usage
+ * \`\`\`ts
+ * export default function App(props: AppProps) {
+ *   const { Component, pageProps } = props;
+ *   
+ *   return (
+ *     <I18nApp {...pageProps}>
+ *       <Component {...pageProps} />
+ *     </I18nApp>
+ *   );
+ * }
+ * \`\`\`
+ */
+export const I18nApp = (props: I18nAppProps) => {
+  const { i18n, children } = props;
+  const { locale, dictionaries, metadata } = i18n || i18nDefaults;
+  
+  return (
+    <I18nProvider
+      locale={locale}
+      dictionaries={dictionaries}
+    >
+      <I18nHead metadata={metadata} />
+      <I18nMetadataProvider metadata={metadata}>
+        {children}
+      </I18nMetadataProvider>
+      <I18nEffects />
+    </I18nProvider>
+  );
+};
+
+export default I18nApp;
+`);
+
+/**
+ * We cannot re-use `I18nHeadTags` as NextHead component does needs HTML tags
+ * to be its immediate children.
+ *
+ * @see https://nextjs.org/docs/pages/api-reference/components/head#use-minimal-nesting
+ */ var r$3 = (({})=>`
+"use client";
+
+import Head from "next/head";
+import { defaultI18nMetadata } from "./defaultI18nMetadata";
+import type { I18nHeadTagsProps } from "./I18nHeadTags";
+
+export type I18nHeadProps = I18nHeadTagsProps;
+
+/**
+ * **For Pages Router only**
+ *
+ * @internal
+ */
+export const I18nHead = (props: I18nHeadProps) => {
+  const { metadata = defaultI18nMetadata } = props;
+  const { alternates, canonical } = metadata;
+
+  return (
+    <Head key="I18nHead">
+      {canonical && (
+        <link
+          rel="canonical"
+          href={canonical}
+          key="canonical"
+        />
+      )}
+      {Object.keys(alternates).map((locale) => (
+        <link
+          rel="alternate"
+          hrefLang={locale}
+          href={alternates[locale]}
+          key={"alternate-" + locale}
+        />
+      ))}
+    </Head>
+  );
+};
+
+// export default I18nHead;
+`);
+
+var o$6 = (({})=>`
+import { I18nProvider } from "./I18nProvider";
+import { defaultLocale } from "./defaultLocale";
+import { getI18nDictionaries } from "./getI18nDictionaries";
+import type { I18n } from "./types";
+
+export type I18nLayoutProps = React.PropsWithChildren<{
+  locale?: I18n.Locale;
+  namespaces?: I18n.TranslateNamespace[];
+}>;
+
+/**
+ * Optionally use this _in each_ \`layout.tsx\` where you have some translations
+ * specific to that layout and its descendant layouts and pages
+ * 
+ * **For App Router only**
+ */
+export const I18nLayout = async ({
+  locale = defaultLocale,
+  namespaces = [],
+  children,
+}: I18nLayoutProps) => {
+  const dictionaries = await getI18nDictionaries({ locale, namespaces });
+
+  return (
+    <I18nProvider
+      locale={locale}
+      dictionaries={dictionaries}
+    >
+      {children}
+    </I18nProvider>
+  );
+};
+
+export default I18nLayout;
+`);
+
+var m$3 = (({ config: { single: e }, options: { routes: { localeParamName: t } } })=>`
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { notFound } from "next/navigation";
+import { I18nMetadataSetter } from "./I18nMetadataSetter";
+import { I18nProvider } from "./I18nProvider";
+import { I18nRouteSetter } from "./I18nRouteSetter";
+import { defaultLocale } from "./defaultLocale";
+import { getI18nDictionaries } from "./getI18nDictionaries";
+import { getI18nMetadata } from "./getI18nMetadata";
+import { isLocale } from "./isLocale";
+import type { I18n } from "./types";
+
+export type I18nPageProps<TRouteId extends I18n.RouteId> =
+  React.PropsWithChildren<
+    {
+      locale${e ? "?" : ""}: I18n.Locale;
+      namespaces?: I18n.TranslateNamespace[];
+    } & I18n.RouteArgs<TRouteId>
+  >;
+
+/**
+ * Use this _in each_ \`page.tsx\` render function
+ *
+ * **For App Router only**
+ */
+export const I18nPage = async <TRouteId extends I18n.RouteId>(
+  props: I18nPageProps<TRouteId>,
+) => {
+  const {
+    locale = defaultLocale,
+    namespaces = [],
+    id,
+    params,
+    children,
+  } = props;
+  // @ts-expect-error FIXME: route conditional type
+  const metadata = getI18nMetadata({ locale, id, params });
+  const dictionaries = await getI18nDictionaries({ locale, namespaces });
+
+  return (
+    <>
+      <I18nRouteSetter id={id} />
+      <I18nMetadataSetter metadata={metadata} />
+      <I18nProvider
+        locale={locale}
+        dictionaries={dictionaries}
+      >
+        {children}
+      </I18nProvider>
+    </>
+  );
+};
+
+function locale(props: any): I18n.Locale;
+function locale(params: I18n.Props["params"]): I18n.Locale;
+function locale(props: I18n.Props): I18n.Locale;
+function locale(paramsOrProps: I18n.Props["params"] | I18n.Props) {
+  const params = (paramsOrProps as any)?.params || paramsOrProps;
+  if (params) {
+    const locale = (params as any).${t};
+
+    if (isLocale(locale)) {
+      return locale;
+    }
+  }
+
+  notFound();
+}
+
+/**
+ * Use this _in each_ \`page.tsx\` to get the current _locale_ from the page props
+ *
+ * It automatically 404s with next.js's \`notFound\` if the locale does not exists.
+ *
+ * **For App Router only**
+ */
+I18nPage.locale = locale;
+
+/**
+ * Use this _in each_ \`page.tsx\` -> \`generateMetadata\` function
+ *
+ * **For App Router only**
+ */
+I18nPage.metadata = <TRouteId extends I18n.RouteId>(
+  options: Omit<I18nPageProps<TRouteId>, "namespaces">,
+) => {
+  // @ts-expect-error FIXME: route conditional type
+  const { alternates, canonical } = getI18nMetadata(options);
+
+  return {
+    alternates: {
+      canonical,
+      languages: alternates,
+    },
+  };
+};
+
+export default I18nPage;
+`);
+
+var i$4 = (({})=>`
+import { defaultI18nMetadata } from "./defaultI18nMetadata";
+import { I18nMetadataProvider } from "./I18nMetadataProvider";
+import { I18nRouteProvider } from "./I18nRouteProvider";
+import type { I18n } from "./types";
+
+type I18nRootProps = React.PropsWithChildren;
+
+/**
+ * Use this _only once_ in the root \`layout.tsx\` at root folder of your app
+ * directory (one up than the \`[lang]\` folder).
+ *
+ * **For App Router only**
+ */
+export const I18nRoot = ({ children }: I18nRootProps) => {
+  return (
+    <I18nRouteProvider id={"" as I18n.RouteId}>
+      <I18nMetadataProvider metadata={defaultI18nMetadata}>
+        {children}
+      </I18nMetadataProvider>
+    </I18nRouteProvider>
+  );
+};
+
+export default I18nRoot;
+`);
+
+var x$2 = (({ config: { single: t } })=>`
+"use client";
+
+import { useContext, useEffect } from "react";
+import { I18nMetadataContext } from "./I18nMetadataContext";
+import { I18nHead } from "./I18nHead";
+import { formatUrl } from "./formatUrl";
+import { getI18nMetadata } from "./getI18nMetadata";
+import { to } from "./to";
+import type { I18n } from "./types";
+import { useLocale } from "./useLocale";
+
+export type I18nSetterProps<TRouteId extends I18n.RouteId> =
+  I18n.RouteArgs<TRouteId>;
+
+/**
+ * **For Pages Router only**
+ * 
+ * Use this in in order to update the alternates and canonical URLs.
+ * This is _required_ in all pages in order to update the data during navigation.
+ * 
+ * This need is particularly evident with dynamic routes pages that use
+ * \`fallback: true\` as the initial SSR does not have any useful i18n information
+ * available. In those page be sure to render this component when the dynamic
+ * data is ready, in other words when the pages router is not in fallback state
+ * anymore: \`useRouter().isFallback === false\`.
+ */
+export const I18nSetter = <TRouteId extends I18n.RouteId>(
+  props: I18nSetterProps<TRouteId>,
+) => {
+  const { id, params } = props;
+  const locale = useLocale();
+  const [metadata, setMetadata] = useContext(I18nMetadataContext);
+
+  useEffect(() => {
+    // @ts-expect-error FIXME: route conditional type
+    setMetadata(getI18nMetadata({ locale, id, params }));
+  }, [id, params, locale, setMetadata]);
+
+  return (
+    <I18nHead metadata={metadata} />
+  );
+};
+
+export default I18nSetter;
+`);
+
+var a$3 = (({ options: { routes: { localeParamName: t } } })=>`
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { GetStaticPathsContext, GetStaticPropsContext } from "next";
+import type { I18nAppPropsData } from "./I18nApp";
+import { defaultI18nMetadata} from "./defaultI18nMetadata";
+import { getI18nMetadata } from "./getI18nMetadata";
+import { getI18nDictionaries } from "./getI18nDictionaries";
+import { isLocale } from "./isLocale";
+import { locales } from "./locales";
+import { type RouteIdError, isErrorRoute } from "./routesError";
+import type { I18n } from "./types";
+
+/**
+ * Get current _locale_ from \`getStaticProps\` context data (its first argument)
+ */
+function locale(params: GetStaticPropsContext["params"]): I18n.Locale | undefined;
+function locale(ctx: GetStaticPropsContext): I18n.Locale | undefined;
+function locale(
+  ctxOrParams: GetStaticPropsContext["params"] | GetStaticPropsContext,
+) {
+  const params = ctxOrParams?.params || ctxOrParams;
+  if (params) {
+    const locale = (params as any).${t};
+
+    if (isLocale(locale)) {
+      return locale;
+    }
+  }
+
+  return; // defaultLocale;
+}
+
+/**
+ * Get localised paths to feed into \`getStaticPaths\`
+ */
+const paths = <P extends { [key: string]: any }>(params?: P) =>
+  locales.map((l) => ({
+    params: { ${t}: l, ...(params || {}) },
+    // locale: l,
+  })) as Array<string | { params: P & { ${t}: I18n.Locale }; locale?: string }>;
+
+/**
+ * Function to use as \`getStaticPaths\` with \`fallback: false\`
+ */
+const staticPaths = (_context?: GetStaticPathsContext) => ({
+  paths: paths(),
+  fallback: false,
+});
+
+type I18nPropsOptions<
+  TRouteId extends I18n.RouteId | RouteIdError,
+  TParams,
+  TData,
+> = {
+  namespaces: I18n.TranslateNamespace[];
+  // routeId: TRouteId;
+  // routeParams?: TRouteId extends I18n.RouteIdDynamic
+  //   ? I18n.RouteParams[TRouteId]
+  //   : never;
+  params?: TParams;
+  data?: TData;
+} & (
+  // as in I18n.RouteArgs
+  | {
+      routeId: TRouteId extends I18n.RouteIdDynamic ? TRouteId : never;
+      routeParams: TRouteId extends I18n.RouteIdDynamic
+        ? I18n.RouteParams[TRouteId]
+        : never;
+    }
+  | {
+      routeId: TRouteId extends I18n.RouteIdStatic | RouteIdError
+        ? TRouteId
+        : never;
+      routeParams?: undefined;
+    }
+);
+
+/**
+ * Get page props data feed into \`getStaticProps\`'s return
+ */
+const props = async <
+  TRouteId extends I18n.RouteId | RouteIdError,
+  TParams,
+  TData,
+>({
+  locale,
+  namespaces,
+  routeId,
+  routeParams,
+  params,
+  data,
+}: {
+  locale: I18n.Locale;
+} & I18nPropsOptions<TRouteId, TParams, TData>) => {
+  const props: I18nAppPropsData = {
+    i18n: {
+      locale: locale,
+      metadata: isErrorRoute(routeId)
+        ? defaultI18nMetadata
+        : // @ts-expect-error FIXME: route conditional type
+        getI18nMetadata({ locale, id: routeId, params: routeParams }),
+      dictionaries: await getI18nDictionaries({ locale, namespaces }),
+    },
+  };
+
+  return {
+    ...props,
+    params: { ${t}: locale, ...(params || ({} as TParams)) },
+    data: data || ({} as TData),
+  };
+};
+
+/**
+ * Get page props data to use as immediate return of \`getStaticProps\`
+ */
+const staticProps = async <
+  TRouteId extends I18n.RouteId | RouteIdError,
+  TParams,
+  TData,
+>({
+  ctx,
+  revalidate,
+  ...options
+}: {
+  ctx: GetStaticPropsContext;
+  revalidate?: number;
+} & I18nPropsOptions<TRouteId, TParams, TData>) => {
+  const locale = ctx.params?.${t} as I18n.Locale;
+
+  return {
+    // @ts-expect-error FIXME: route conditional type
+    props: await props({ locale, ...options }),
+    revalidate,
+  };
+};
+
+/**
+ * **For Pages Router only**
+ */
+export const i18nGet = {
+  locale,
+  paths,
+  staticPaths,
+  props,
+  staticProps,
+};
+
+export default i18nGet;
+`);
+
+/**
+ * Transform the route translated either into a `pathname` or a `template`.
+ *
+ * Here we add the wildcard flag maybe found in the pathname to the template
+ * name too.
+ *
+ * @see https://nextjs.org/docs/messages/invalid-multi-match
+ */ function transformPathname(e, t) {
+    return "/" + e.split("/").filter(Boolean).map((e)=>e.startsWith("[[...") ? `:${encodeURIComponent(e.slice(5, -2))}` : e.startsWith("[[") ? `:${encodeURIComponent(e.slice(2, -2))}` : e.startsWith("[") ? `:${encodeURIComponent(e.slice(1, -1))}` : `${encodeURIComponent(e)}`).join("/") + (t ? "/:wildcard*" : "");
+}
+
+function a$2(e) {
+    let { localeSource: t, localeDestination: o, template: a, pathname: l, permanent: n } = e, i = formatRoutePathname.formatRoutePathname((t ? `${t}/` : "") + a), c = formatRoutePathname.formatRoutePathname((o ? `${o}/` : "") + l);
+    // console.log(`redirect template "${source}" to pathname "${destination}"`);
+    if (i !== c) return {
+        source: i,
+        destination: c,
+        permanent: !!n
+    };
+}
+function generateRedirectForPathname(e, t, r, o, l) {
+    let { defaultLocale: n, hideDefaultLocaleInUrl: i, localeParamName: c, permanentRedirects: s } = e, p = t === n, u = p && !i, m = {
+        template: r,
+        pathname: o,
+        permanent: s
+    };
+    c ? // app router:
+    u ? l.push(a$2({
+        ...m,
+        localeDestination: t
+    })) : p && i ? l.push(a$2({
+        ...m,
+        localeSource: t
+    })) : p ? l.push(a$2(m)) : l.push(a$2({
+        ...m,
+        localeSource: t,
+        localeDestination: t
+    })) : // pages router:
+    o !== r && (u ? l.push(a$2({
+        ...m,
+        localeDestination: t
+    })) : p ? l.push(a$2(m)) : l.push(a$2({
+        ...m,
+        localeSource: t,
+        localeDestination: t
+    })));
+}
+/**
+ * TODO: maybe write directly the vercel configuration?
+ *
+ * @see
+ * - https://nextjs.org/docs/pages/api-reference/next-config-js/redirects
+ * - https://vercel.com/docs/projects/project-configuration#redirects
+ */ let generateRedirects = (r, { localeParamName: a, permanentRedirects: l, tokens: n }, i)=>{
+    let c = {
+        ...r,
+        localeParamName: a,
+        permanentRedirects: l
+    }, s = RegExp(utils.escapeRegExp(n.idDelimiter), "g"), p = [];
+    for(let e in i){
+        let t = i[e], r = i[e].pathnames;
+        for(let a in r){
+            let l = r[a], // prettier-ignore
+            n = transformPathname(e.replace(s, "/"), t.wildcard), i = transformPathname(l, t.wildcard);
+            // we do not redirect urls children of wildcard urls
+            if (t.inWildcard) break;
+            generateRedirectForPathname(c, a, n, i, p);
+        }
+    }
+    return utils.arrayUniqueByProperties(p.filter(Boolean), [
+        "source",
+        "destination"
+    ]).sort((e, t)=>e.source.localeCompare(t.source)).map((e)=>a ? e : {
+            ...e,
+            locale: !1
+        });
+};
+
+var p$3 = (({ config: e, options: t, routes: o })=>{
+    let l = JSON.stringify(generateRedirects(e, t.routes, o.byId), null, 2);
+    return `module.exports = ${l}`;
+});
+
+function o$5(e) {
+    let { localeSource: t, localeDestination: a, template: o, pathname: l, passLocale: i } = e, n = "";
+    t && (n = `/${t}`);
+    let c = formatRoutePathname.formatRoutePathname(n + l), s = "";
+    a && (s = `/${a}`);
+    let p = formatRoutePathname.formatRoutePathname(s + o);
+    // console.log(`rewrite pathname "${source}" to template "${destination}"`);
+    if (c === p) return;
+    let m = {
+        source: c,
+        destination: p
+    };
+    return !1 === i && (m.locale = !1), m;
+}
+const generateRewriteForPathname = (e, t, r, a, l)=>{
+    let { defaultLocale: i, hideDefaultLocaleInUrl: n, localeParamName: c } = e, s = t === i && n, // TODO: maybe support other locales to be hidden in the URL other than the default?
+    p = {
+        template: r,
+        pathname: a
+    };
+    c ? // app router:
+    s ? l.push(o$5({
+        ...p,
+        localeDestination: t,
+        passLocale: !1
+    })) : l.push(// prettier-ignore
+    o$5({
+        ...p,
+        localeSource: t,
+        localeDestination: t,
+        passLocale: !1
+    })) : // pages router:
+    // this condition only applies to the pages router as with the app one
+    // even if the template matches the pathname we always need to rewrite
+    // as the localeParam is always needed in the rewrite destination
+    a !== r && (s ? l.push(o$5(p)) : l.push(// `passLocale` must be `false` or the locale prefixed rewrite won't
+    // be applied and does not forward the locale to the route context
+    // when the locale is included in the URL. In fact we explicitly
+    // add the locale to the rewrite rule in order to get the least
+    // amount of existing URLs which is a good SEO practice
+    o$5({
+        ...p,
+        localeSource: t,
+        passLocale: !1
+    })));
+};
+/**
+ * TODO: maybe write directly the vercel configuration?
+ *
+ * @see
+ * - https://nextjs.org/docs/pages/api-reference/next-config-js/rewrites
+ * - https://vercel.com/docs/projects/project-configuration#rewrites
+ */ let generateRewrites = (r, { tokens: o, localeParamName: l, permanentRedirects: i }, n)=>{
+    let c = {
+        ...r,
+        localeParamName: l,
+        permanentRedirects: i
+    }, s = RegExp(utils.escapeRegExp(o.idDelimiter), "g"), p = [];
+    for(let e in n){
+        let t = n[e], r = n[e].pathnames;
+        for(let o in r){
+            let l = r[o], i = e.replace(s, "/");
+            // we do not rewrite urls children of wildcard urls
+            if (t.inWildcard) break;
+            // we need to rewrite both the root path...
+            generateRewriteForPathname(c, o, transformPathname(i), transformPathname(l), p), t.wildcard && // and for wildcard routes the ones with the `/:segment*` portion
+            generateRewriteForPathname(c, o, transformPathname(i, t.wildcard), transformPathname(l, t.wildcard), p);
+        }
+    }
+    // simple sort by destination:
+    // return a.destination.localeCompare(b.destination);
+    // sort by locale
+    // return a.
+    return utils.arrayUniqueByProperties(p.filter(Boolean), [
+        "source",
+        "destination"
+    ]).sort((e, t)=>// simple sort by source:
+        e.source.localeCompare(t.source));
+};
+
+var f$2 = (({ config: e, routes: t, options: o })=>{
+    let l = JSON.stringify(generateRewrites(e, o.routes, t.byId), null, 2);
+    return `module.exports = ${l}`;
+});
+
+var s$4 = (({ options: { routes: { localeParamName: t } }, adapterOptions: { router: e } })=>{
+    let o = t ? `.replace("[${t}]/", "")` : "";
+    switch(e){
+        case "app":
+            return `
+"use client";
+
+import { useContext } from "react";
+import { I18nRouteContext } from "./I18nRouteContext";
+
+export const useRouteId = () => useContext(I18nRouteContext)[0];
+  
+export default useRouteId;
+`;
+        case "pages":
+            return `
+import { useRouter } from "next/router";
+import { pathnameToRouteId } from "./pathnameToRouteId";
+import type { I18n } from "./types";
+
+export const useRouteId = () => 
+  pathnameToRouteId(useRouter().pathname${o}) as I18n.RouteId;
+
+export default useRouteId;
+`;
+        default:
+            return `
+"use client";
+
+import { useContext } from "react";
+import { usePathname } from "next/navigation";
+import { useRouter } from "next/router";
+import { I18nRouteContext } from "./I18nRouteContext";
+import { pathnameToRouteId } from "./pathnameToRouteId";
+import type { I18n } from "./types";
+
+export const useRouteId = () => {
+  const fromCtx = useContext(I18nRouteContext)[0];
+  let fromPages = "";
+  let fromApp = "";
+
+  try {
+    fromPages = pathnameToRouteId(
+      useRouter().pathname${o},
+    ) as I18n.RouteId;
+  } catch (e) {
+    fromApp = pathnameToRouteId(
+      (usePathname() || "")${o},
+    ) as I18n.RouteId;
+  }
+
+  return fromCtx || fromPages || fromApp;
+};
+
+export default useRouteId;
+`;
+    }
+});
+
+var d$4 = (({})=>`
+"use client";
+
+import { to } from "./to";
+import type { I18n } from "./types";
+import { useLocale } from "./useLocale";
+
+export type UseToReturn = ReturnType<typeof useTo>;
+
+export const useTo = () => {
+  const locale = useLocale();
+  return <Id extends I18n.RouteId>(
+    routeId: Id,
+    ...args: Id extends I18n.RouteIdDynamic
+      ? [params: I18n.RouteParams[Id]]
+      : []
+  ) =>
+    args[0]
+      ? // @ts-expect-error nevermind
+        (to(routeId, args[0], locale) as I18n.RoutePathnames[Id])
+      : // @ts-expect-error nevermind
+        (to(routeId, locale) as I18n.RoutePathnames[Id]);
+};
+
+export default useTo;
+`);
+
+var I$2 = (({})=>`
+"use client";
+
+import { toSpa } from "./toSpa";
+import type { I18n } from "./types";
+import { useLocale } from "./useLocale";
+
+export type UseToSpaReturn = ReturnType<typeof useToSpa>;
+
+export const useToSpa = () => {
+  const locale = useLocale();
+  return <
+    Root extends keyof I18n.RouteSpa,
+    Path extends Extract<keyof I18n.RouteSpa[Root], string>,
+  >(
+    root: Root,
+    path: Path,
+    ...args: I18n.RouteJoinedId<Root, Path> extends I18n.RouteIdDynamic
+      ? [params: I18n.RouteParams[I18n.RouteJoinedId<Root, Path>]]
+      : I18n.RouteJoinedId<Root, Path> extends I18n.RouteIdStatic
+        ? []
+        : never
+  ) => {
+    const [params] = args;
+    return (
+      // prettier-ignore
+      // @ts-expect-error FIXME: types
+      (params ? toSpa(root, path, params, locale) : toSpa(root, path, locale)) as I18n.RouteSpa[Root][Path]
+    );
+  };
+};
+
+export default useToSpa;
+`);
+
+var n$4 = createAdapter(adapterNextOptions, ({ adapterOptions: e })=>{
+    let { router: t } = e, u = [
+        // TODO: maybe remove these files, they are useful for debugging for now
+        // but probably will be useless
+        {
+            name: "next-redirects",
+            fn: p$3,
+            ext: "js"
+        },
+        {
+            name: "next-rewrites",
+            fn: f$2,
+            ext: "js"
+        },
+        {
+            name: "useRouteId",
+            fn: s$4,
+            ext: "ts",
+            index: !0
+        },
+        {
+            name: "useTo",
+            fn: d$4,
+            ext: "ts",
+            index: !0
+        },
+        {
+            name: "useToSpa",
+            fn: I$2,
+            ext: "ts",
+            index: !0
+        }
+    ];
+    return ("app" === t || "migrating" === t) && (u = u.concat([
+        {
+            name: "I18nLayout",
+            fn: o$6,
+            ext: "tsx",
+            index: !0
+        },
+        {
+            name: "I18nPage",
+            fn: m$3,
+            ext: "tsx",
+            index: !0
+        },
+        {
+            name: "I18nRoot",
+            fn: i$4,
+            ext: "tsx",
+            index: !0
+        }
+    ])), ("pages" === t || "migrating" === t) && (u = u.concat([
+        {
+            name: "I18nSetter",
+            fn: x$2,
+            ext: "tsx",
+            index: !0
+        },
+        {
+            name: "I18nApp",
+            fn: n$5,
+            ext: "tsx",
+            index: !0
+        },
+        {
+            name: "I18nHead",
+            fn: r$3,
+            ext: "tsx"
+        },
+        {
+            name: "i18nGet",
+            fn: a$3,
+            ext: "ts",
+            index: !0
+        }
+    ])), {
+        dependsOn: [
+            "react"
+        ],
+        files: u
+    };
+});
+
+const adapterReactOptions = {};
+
+var n$3 = (({})=>`
+import React from "react";
+import { defaultLocale } from "./defaultLocale";
+import type { I18n } from "./types";
+
+export type I18nContextValue = {
+  t: I18n.Translate;
+  locale: I18n.Locale;
+};
+
+let _I18nContext;
+
+// For serverComponents (app-dir), the context cannot be used and
+// this makes that all the imports to here don't break the build.
+// The use of this context is inside each util, depending pages-dir or app-dir.
+if (typeof React.createContext === "function") {
+  _I18nContext = React.createContext<I18nContextValue>({
+    t: ((key: string) => key) as I18n.Translate,
+    locale: defaultLocale,
+  });
+}
+
+/**
+ * @internal
+ */
+export const I18nContext = _I18nContext as React.Context<I18nContextValue>;
+
+// export default I18nContext;
+`);
+
+var o$4 = (({})=>`
+"use client";
+
+import { useEffect } from "react";
+import { dom } from "@koine/dom";
+import { useLocale } from "./useLocale";
+
+/**
+ * @internal
+ */
+export const I18nEffects = () => {
+  const currentLocale = useLocale();
+
+  useEffect(() => {
+    if (currentLocale) {
+      const html = dom("html");
+      if (html) html.lang = currentLocale;
+    }
+  }, [currentLocale]);
+
+  return null;
+};
+
+// export default I18nEffects;
+`);
+
+var r$2 = (({})=>`
+"use client";
+
+import { defaultI18nMetadata } from "./defaultI18nMetadata";
+import type { I18n } from "./types";
+
+export type I18nHeadTagsProps = {
+  metadata?: I18n.Metadata;
+};
+
+/**
+ * Renders the HTML tags to use in the \`<head>\`
+ */
+export const I18nHeadTags = (props: I18nHeadTagsProps) => {
+  const { metadata = defaultI18nMetadata } = props;
+  const { alternates, canonical } = metadata;
+
+  return (
+    <>
+      {canonical && (
+        <link
+          rel="canonical"
+          href={canonical}
+          key="canonical"
+        />
+      )}
+      {Object.keys(alternates).map((locale) => (
+        <link
+          rel="alternate"
+          hrefLang={locale}
+          href={alternates[locale]}
+          key={"alternate-" + locale}
+        />
+      ))}
+    </>
+  );
+};
+
+export default I18nHeadTags;
+`);
+
+var m$2 = (({})=>`
+"use client";
+
+import { createContext } from "react";
+import { defaultI18nMetadata } from "./defaultI18nMetadata";
+import type { I18n } from "./types";
+
+type I18nMetadataContextValue = readonly [
+  /** metadata */
+  I18n.Metadata,
+  /** setMetadata */
+  React.Dispatch<React.SetStateAction<I18n.Metadata>>,
+];
+
+/**
+ * @internal
+ */
+export const I18nMetadataContext = createContext<I18nMetadataContextValue>([
+  defaultI18nMetadata,
+  () => (defaultI18nMetadata),
+]);
+
+// export default I18nMetadataContext;
+`);
+
+var a$1 = (({})=>`
+"use client";
+
+import { useMemo, useState } from "react";
+import type { I18n } from "@/i18n";
+import { I18nMetadataContext } from "./I18nMetadataContext";
+
+type I18nMetadataProviderProps = React.PropsWithChildren<{
+  metadata?: I18n.Metadata;
+}>;
+
+/**
+ * @internal
+ */
+export function I18nMetadataProvider(props: I18nMetadataProviderProps) {
+  const { children } = props;
+  const [metadata, setMetadata] = useState<I18n.Metadata>(
+    props.metadata || ({} as I18n.Metadata),
+  );
+  const value = useMemo(
+    () => [metadata, setMetadata] as const,
+    [metadata],
+  );
+
+  return (
+    <I18nMetadataContext.Provider value={value}>
+      {children}
+    </I18nMetadataContext.Provider>
+  );
+}
+
+// export default I18nMetadataProvider;
+`);
+
+var x$1 = (({})=>`
+"use client";
+
+import { useContext, useEffect } from "react";
+import { I18nMetadataContext } from "./I18nMetadataContext";
+import type { I18n } from "./types";
+
+type I18nMetadataSetterProps = {
+  metadata: I18n.Metadata;
+};
+
+/**
+ * NB: Do not use it next.js Pages router
+ * 
+ * @internal
+ */
+export const I18nMetadataSetter = (props: I18nMetadataSetterProps) => {
+  const { metadata } = props;
+  const [, setMetadata] = useContext(I18nMetadataContext);
+
+  useEffect(() => {
+    setMetadata(metadata);
+  }, [metadata, setMetadata]);
+
+  return null;
+};
+
+// export default I18nMetadataSetter;
+`);
+
+var f$1 = (({})=>`
+"use client";
+
+import { I18nContext } from "./I18nContext";
+import { defaultLocale } from "./defaultLocale";
+import { createT } from "./createT";
+import type { I18n } from "./types";
+
+export type I18nProviderProps = React.PropsWithChildren<{
+  locale?: I18n.Locale;
+  dictionaries?: I18n.Dictionaries;
+}>;
+
+export const I18nProvider = ({
+  locale = defaultLocale,
+  dictionaries = {},
+  children,
+}: I18nProviderProps) => {
+  const pluralRules = new Intl.PluralRules(locale);
+  const t = createT(dictionaries, pluralRules, locale) as I18n.Translate;
+
+  return (
+    <I18nContext.Provider value={{ locale, t }}>{children}</I18nContext.Provider>
+  );
+};
+
+export default I18nProvider;
+`);
+
+var i$3 = (({})=>`
+"use client";
+
+import { createContext } from "react";
+import type { I18n } from "./types";
+
+type I18nRouteContextValue = readonly [
+  /** routeId */
+  I18n.RouteId,
+  /** setRouteId */
+  React.Dispatch<React.SetStateAction<I18n.RouteId>>,
+];
+
+export const I18nRouteContext = createContext<I18nRouteContextValue>([
+  "" as I18n.RouteId,
+  () => "",
+]);
+
+// export default I18nRouteContext;
+`);
+
+var s$3 = (({})=>`
+"use client";
+
+import { useMemo, useState } from "react";
+import type { I18n } from "@/i18n";
+import { I18nRouteContext } from "./I18nRouteContext";
+
+type I18nRouteProviderProps = React.PropsWithChildren<{
+  id: I18n.RouteId;
+}>;
+
+/**
+ * @internal
+ */
+export function I18nRouteProvider(props: I18nRouteProviderProps) {
+  const { children } = props;
+  const [id, setId] = useState<I18n.RouteId>(
+    props.id || ("" as I18n.RouteId),
+  );
+  const value = useMemo(
+    () => [id, setId] as const,
+    [id],
+  );
+
+  return (
+    <I18nRouteContext.Provider value={value}>
+      {children}
+    </I18nRouteContext.Provider>
+  );
+}
+
+// export default I18nRouteProvider;
+`);
+
+var d$3 = (({})=>`
+"use client";
+
+import { useContext, useEffect } from "react";
+import { I18nRouteContext } from "./I18nRouteContext";
+import type { I18n } from "./types";
+
+type I18nRouteSetterProps = {
+  id: I18n.RouteId;
+};
+
+/**
+ * NB: Do not use it next.js Pages router
+ *
+ * @internal
+ */
+export const I18nRouteSetter = (props: I18nRouteSetterProps) => {
+  const { id } = props;
+  const [, setRouteId] = useContext(I18nRouteContext);
+
+  useEffect(() => {
+    setRouteId(id);
+  }, [id, setRouteId]);
+
+  return null;
+};
+
+// export default I18nRouteSetter;
+`);
+
+var p$2 = (({})=>`
+"use client";
+
+import { useMemo } from "react";
+import { formatElements } from "./formatElements";
+import type { I18n } from "./types";
+import { useT } from "./useT";
+
+export type TProps = {
+  i18nKey: I18n.TranslationsAllPaths;
+  components?: React.ReactElement[] | Record<string, React.ReactElement>;
+  values?: I18n.TranslationQuery;
+  returnObjects?: boolean;
+};
+
+/**
+ * Translate transforming:
+ * <0>This is an <1>example</1><0>
+ * to -> <h1>This is an <b>example</b><h1>
+ */
+export const T = ({
+  i18nKey,
+  values,
+  components,
+  returnObjects,
+}: TProps) => {
+  const [namespace, path] = (i18nKey as string).split(":");
+  const t = useT(namespace as I18n.TranslateNamespace) as I18n.TranslateLoose;
+  const result = useMemo(() => {
+    const text = t(path, values, {
+      returnObjects,
+    });
+
+    if (!text) return text;
+
+    if (!components || components.length === 0)
+      return Array.isArray(text) ? text.map((item) => item) : text;
+
+    if (Array.isArray(text))
+      return text.map((item) => formatElements(item, components));
+
+    return formatElements(text, components);
+  }, [t, path, values, components, returnObjects]) as string;
+
+  return result;
+};
+
+export default T;
+`);
+
+var I$1 = (({})=>`
+"use client";
+
+import { useMemo } from "react";
+import type { TProps } from "./T";
+import { formatElements } from "./formatElements";
+
+export type TransTextProps = Pick<TProps, "components"> & {
+  text: string;
+};
+
+export const TransText = ({ text, components }: TransTextProps) => {
+  return useMemo(
+    () =>
+      !components || components.length === 0
+        ? text
+        : formatElements(text, components),
+    [text, components],
+  ) as string;
+};
+
+export default TransText;
+`);
+
+var u = (({})=>`
+import { Fragment, cloneElement } from "react";
+
+const tagParsingRegex = /<(\\w+) *>(.*?)<\\/\\1 *>|<(\\w+) *\\/>/;
+
+const nlRe = /(?:\\r\\n|\\r|\\n)/g;
+
+function getElements(
+  parts: Array<string | undefined>,
+): Array<string | undefined>[] {
+  if (!parts.length) return [];
+
+  const [paired, children, unpaired, after] = parts.slice(0, 4);
+
+  return [
+    [(paired || unpaired) as string, children || ("" as string), after],
+  ].concat(getElements(parts.slice(4, parts.length)));
+}
+
+/**
+ * @internal
+ * @see https://github.com/aralroca/next-translate/blob/master/src/formatElements.tsx
+ */
+export function formatElements(
+  value: string,
+  elements: React.ReactElement[] | Record<string, React.ReactElement> = [],
+): string | React.ReactNode[] {
+  const parts = value.replace(nlRe, "").split(tagParsingRegex);
+
+  if (parts.length === 1) return value;
+
+  const tree: React.ReactNode[] = [];
+
+  const before = parts.shift();
+  if (before) tree.push(before);
+
+  getElements(parts).forEach(([key, children, after], realIndex: number) => {
+    const element = (elements as Record<string, React.ReactElement>)[
+      key as string
+    // eslint-disable-next-line react/jsx-no-useless-fragment
+    ] || <Fragment />;
+
+    tree.push(
+      cloneElement(
+        element,
+        { key: realIndex },
+
+        // format children for pair tags
+        // unpaired tags might have children if it's a component passed as a variable
+        children ? formatElements(children, elements) : element.props.children,
+      ),
+    );
+
+    if (after) tree.push(after);
+  });
+
+  return tree;
+}
+
+// export default formatElements;
+`);
+
+var T = (({})=>`
+"use client";
+
+import { useContext } from "react";
+import { I18nMetadataContext } from "./I18nMetadataContext";
+
+export const useI18nSwitch = (
+  absolute?: boolean,
+  includeSearch?: boolean,
+  includeHash?: boolean
+) => {
+  const { alternates: urls } = useContext(I18nMetadataContext)[0];
+
+  if (!absolute) {
+    try {
+      for (const locale in urls) {
+        const absoluteUrl = urls[locale];
+        if (absoluteUrl) {
+          const url = new URL(absoluteUrl);
+          urls[locale] = url.pathname;
+          if (includeSearch) urls[locale] += url.search;
+          if (includeHash) urls[locale] += url.hash;
+        }
+      }
+    } catch(e) {
+      // TODO: verify this: we could have empty/invalid languages URLs here?
+    }
+  }
+  
+  return urls;
+}
+
+export default useI18nSwitch;
+`);
+
+var c$1 = (({})=>`
+"use client";
+
+import { useContext } from "react";
+import { defaultLocale } from "./defaultLocale";
+import { I18nContext } from "./I18nContext";
+
+export const useLocale = () => useContext(I18nContext).locale || defaultLocale;
+
+export default useLocale;
+`);
+
+var R = (({})=>`
+"use client";
+
+import { useContext } from "react";
+import { I18nRouteContext } from "./I18nRouteContext";
+
+export const useRouteId = () => useContext(I18nRouteContext)[0];
+  
+export default useRouteId;
+`);
+
+var l$3 = (({})=>`
+"use client";
+
+import { useContext, useMemo } from "react";
+import { I18nContext } from "./I18nContext";
+import type { I18n } from "./types";
+
+export const useT = <T extends I18n.TranslateNamespace>(namespace: T) => {
+  const t = useContext(I18nContext).t;
+  return useMemo(
+    () =>
+      (key: string, ...args) =>
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (t as any)(\`\${namespace}:\${key}\`, ...args),
+    [t],
+  ) as I18n.TranslateNamespaced<T>;
+};
+
+export default useT;
+
+`);
+
+var r$1 = createAdapter(adapterReactOptions, ({})=>({
+        dependsOn: [
+            "js"
+        ],
+        files: [
+            {
+                name: "formatElements",
+                fn: u,
+                ext: "tsx"
+            },
+            {
+                name: "I18nContext",
+                fn: n$3,
+                ext: "tsx"
+            },
+            {
+                name: "I18nEffects",
+                fn: o$4,
+                ext: "tsx"
+            },
+            {
+                name: "I18nHeadTags",
+                fn: r$2,
+                ext: "tsx",
+                index: !0
+            },
+            {
+                name: "I18nMetadataContext",
+                fn: m$2,
+                ext: "tsx"
+            },
+            {
+                name: "I18nMetadataProvider",
+                fn: a$1,
+                ext: "tsx"
+            },
+            {
+                name: "I18nMetadataSetter",
+                fn: x$1,
+                ext: "tsx"
+            },
+            {
+                name: "I18nProvider",
+                fn: f$1,
+                ext: "tsx",
+                index: !0
+            },
+            {
+                name: "I18nRouteContext",
+                fn: i$3,
+                ext: "tsx"
+            },
+            {
+                name: "I18nRouteProvider",
+                fn: s$3,
+                ext: "tsx"
+            },
+            {
+                name: "I18nRouteSetter",
+                fn: d$3,
+                ext: "tsx"
+            },
+            {
+                name: "T",
+                fn: p$2,
+                ext: "tsx",
+                index: !0
+            },
+            {
+                name: "TransText",
+                fn: I$1,
+                ext: "tsx",
+                index: !0
+            },
+            {
+                name: "useI18nSwitch",
+                fn: T,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "useLocale",
+                fn: c$1,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "useRouteId",
+                fn: R,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "useT",
+                fn: l$3,
+                ext: "ts",
+                index: !0
+            }
+        ]
+    }));
+
+let o$3 = (e)=>{
+    let t = "";
+    return e.filter((e)=>e.index).sort((e, t)=>e.name.localeCompare(t.name)).forEach((e)=>{
+        t += `export * from "./${e.name}";\n`;
+    }), t;
+}, s$2 = (e)=>{
+    switch(e){
+        case "js":
+            break;
+        case "next":
+            return n$4;
+        case "next-translate":
+            return a$4;
+        case "react":
+            return r$1;
+    }
+    return t$1;
+}, /**
+ * Recursively builds a list of adapters to use based on the `dependsOn` array
+ * of the choosen adapter
+ */ p$1 = async (t, { name: a, options: n = {} }, r = [])=>{
+    let o = s$2(a)(t, n || {}), c = utils.isPromise(o) ? await o : o;
+    return r = r.concat([
+        c
+    ]), c.dependsOn && await Promise.all(c.dependsOn.map(async (e)=>{
+        r = r.concat(await p$1(t, {
+            name: e
+        }));
+    })), r;
+}, i$2 = (e, t)=>{
+    let { outputFiles: a } = e.options, // TODO: prettier does probably not make sense unless one wants to keep the
+    // auto-generated files on git, maybe allow this as an option?
+    // // prettier breaks jest, @see https://jestjs.io/docs/ecmascript-modules
+    // // https://github.com/jestjs/jest/issues/14305
+    // if (!process.env["JEST_WORKER_ID"]) {
+    //   const { format } = await import("prettier");
+    //   out = await format(out, {
+    //     parser: "typescript",
+    //   });
+    // }
+    n = t.reduce((e, t)=>{
+        // NOTE: we allow adapters to produce the same files as their dependent's
+        // parent adapters (defined with `dependsOn`), here we ensure the parent
+        // adapters files do not override their children same-named ones which
+        // should get the priority
+        let a = e.map((e)=>e.name + e.ext);
+        return [
+            ...e,
+            ...t.files.filter((e)=>!a.includes(e.name + e.ext))
+        ];
+    }, []).map((t)=>{
+        let { fn: n, ...r } = t, o = a?.[r.name] || r.name;
+        return {
+            ...r,
+            name: o,
+            content: n({
+                ...e,
+                adapterOptions: e.options.adapter.options || {}
+            })
+        };
+    });
+    return(// automatically create an index file if the adapters want it
+    o$3(n) && n.push({
+        name: "index",
+        ext: "ts",
+        content: o$3(n)
+    }), {
+        files: n,
+        // it is enough that just one adapter requires this
+        needsTranslationsFiles: t.some((e)=>e.needsTranslationsFiles)
+    });
+};
+let generateCode = async (e)=>i$2(e, await p$1(e, e.options.adapter));
+
+let tsCompile = (o, i, s, // Set<string>,
+r)=>{
+    let l = Array.from(s).filter((e)=>e.endsWith(".ts") || e.endsWith(".tsx")).map((t)=>node_path.join(o, i, t)), n = {
+        noEmitOnError: !0,
+        noImplicitAny: !0,
+        declaration: !0,
+        // target: ts.ScriptTarget.ES5,
+        target: t__namespace.ScriptTarget.ESNext,
+        // module: ts.ModuleKind.CommonJS,
+        module: t__namespace.ModuleKind.ESNext,
+        moduleResolution: t__namespace.ModuleResolutionKind.Bundler,
+        resolveJsonModule: !0,
+        allowJs: !1,
+        esModuleInterop: !0,
+        jsx: t__namespace.JsxEmit.ReactJSX,
+        outDir: node_path.join(o, i),
+        skipLibCheck: !0,
+        noEmitHelpers: !0,
+        importHelpers: !0,
+        ...r || {}
+    }, // Create a Program with an in-memory emit
+    // const createdFiles: Record<string, string> = {};
+    // const host = ts.createCompilerHost(compilerOptions);
+    // host.writeFile = (fileName: string, contents: string) => createdFiles[fileName] = contents;
+    a = t__namespace.createProgram(l, n), /* , host */ m = a.emit();
+    return(// .concat(emitResultCjs.diagnostics);
+    // const programCjs = ts.createProgram(rootNames, {
+    //   ...compilerOptions,
+    //   module: ts.ModuleKind.CommonJS,
+    //   moduleResolution: ts.ModuleResolutionKind.Classic,
+    //   declaration: false,
+    // });
+    // const emitResultCjs = programCjs.emit();
+    t__namespace.getPreEmitDiagnostics(a).concat(m.diagnostics).forEach((e)=>{
+        if (e.file) {
+            let { line: o, character: i } = t__namespace.getLineAndCharacterOfPosition(e.file, // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            e.start), s = t__namespace.flattenDiagnosticMessageText(e.messageText, "\n");
+            console.log(`${e.file.fileName} (${o + 1},${i + 1}): ${s}`);
+        } else console.log(t__namespace.flattenDiagnosticMessageText(e.messageText, "\n"));
+    }), m);
+};
+
+let n$2 = async (e, r, s, i)=>Promise.all(s.files.map(async ({ name: s, ext: o, content: n })=>{
+        let l = `${s}.${o}`, d = node_path.join(e, r, l);
+        await node.fsWrite(d, n), i.add(l);
+    })), d$2 = (a, r, s)=>{
+    let i = Array.from(s).filter((e)=>e.endsWith(".ts") || e.endsWith(".tsx"));
+    tsCompile(a, r, i), i.forEach((i)=>{
+        s.add(i.replace(/\.tsx?$/, ".js")), s.add(i.replace(/\.tsx?$/, ".d.ts")), // remove TypeScript files
+        s.delete(i), node_fs.rmSync(node_path.join(a, r, i), {
+            force: !0
+        });
+    });
+}, m$1 = async (e, r, { translationFiles: s }, i)=>Promise.all(s.map(async ({ data: s, locale: o, path: n })=>{
+        let l = node_path.join("translations", o);
+        await node.fsWrite(node_path.join(e, r, l, n), JSON.stringify(s)), i.add(l);
+    })), f = (e, a, r, s)=>[
+        node_path.join(e, a, ".gitignore"),
+        Array.from(new Set([
+            ...r,
+            ...s
+        ])).sort().map((e)=>`/${e}`).join(`\n`)
+    ];
+/**
+   * @default process.cwd()
+   */ /**
+   * Relative to the given `cwd`.
+   *
+   * Use a _dot_ named folder in order to be automatically ignored when your
+   * i18n source files live in the same folder as the generated code
+   */ let writeCode = async (e, t)=>{
+    let { cwd: r = process.cwd(), output: i, skipTsCompile: o, skipGitignore: l, skipTranslations: p } = e, c = await generateCode(t), w = new Set(), y = new Set();
+    await n$2(r, i, c, w), o || d$2(r, i, w), c.needsTranslationsFiles && !p && await m$1(r, i, t.input, y), l || await node.fsWrite(...f(r, i, y, w));
+};
+
+const codeDataRoutesOptions = {
+    /**
+   * Set this to true once your routing setup is ready for production.
+   *
+   * @default false
+   */ permanentRedirects: !1,
+    /**
+   * The name of the locale dynamic segment in the URL usually represented as
+   * `[lang]/my-slugs` but without neither brackets nor slashes, so just `lang`
+   *
+   * @default "lang"
+   */ localeParamName: "lang",
+    /** @default  "~.json" */ translationJsonFileName: "~.json",
+    /**
+   * Generated `route_id()` functions prefix, prepended to the automatically
+   * generated function names.
+   *
+   * @default ""
+   */ fnsPrefix: "",
+    tokens: {
+        /** @default  "^" */ parentReference: "^",
+        /** @default  "." */ idDelimiter: ".",
+        /**
+     * @see https://nextjs.org/docs/pages/building-your-application/routing/dynamic-routes#catch-all-segments
+     */ catchAll: {
+            /** @default  "[..." */ start: "[...",
+            /** @default  "]" */ end: "]"
+        },
+        /**
+     * @see https://nextjs.org/docs/pages/building-your-application/routing/dynamic-routes#optional-catch-all-segments
+     */ optionalCatchAll: {
+            /** @default  "[[..." */ start: "[[...",
+            /** @default  "]]" */ end: "]]"
+        }
+    }
+};
+let r = (t, a)=>{
+    let { idDelimiter: l, parentReference: n, catchAll: r, optionalCatchAll: d } = a.tokens;
+    return {
+        ...t,
+        ...a,
+        reg: {
+            trailingDelimiter: RegExp(`${utils.escapeRegExp(l)}+$`),
+            indexEnd: RegExp(`${utils.escapeRegExp(l)}index$`),
+            parentReference: RegExp(`^/${utils.escapeRegExp(n)}`),
+            catchAll: RegExp(`${utils.escapeRegExp(r.start)}(.+)${utils.escapeRegExp(r.end)}$`),
+            optionalCatchAll: RegExp(`${utils.escapeRegExp(d.start)}(.+)${utils.escapeRegExp(d.end)}$`)
+        }
+    };
+}, /**
+ * Normalise user defined route id
+ *
+ * 1) remove ending `.index`
+ */ d$1 = (e, { reg: t })=>{
+    let a = e.replace(t.indexEnd, ""), l = t.optionalCatchAll.test(e), n = t.catchAll.test(e);
+    return l && (a = a.replace(t.optionalCatchAll, "")), n && (a = a.replace(t.catchAll, "")), {
+        routeId: a = a.replace(t.trailingDelimiter, ""),
+        isCatchAll: n,
+        isOptionalCatchAll: l
+    };
+}, /**
+ * Normalise user defined route pathname
+ *
+ * - ensures beginning slash
+ * - replaces too many consecutive slashes
+ * - removes the trailing slash
+ * - removes `*` wildcard token
+ * - normalises to `/my/[id]` dynamic params defined in any of these shapes:
+ *   - `/my/{{id}}`
+ *   - `/my/{{ id }}`
+ *   - `/my/[id]`
+ *   - `/my/[ id ]`
+ *   - `/my/{id}`
+ *   - `/my/{ id }`
+ *
+ * TODO: support also `/my/:id` syntax?
+ */ i$1 = (e, t)=>formatRoutePathname.formatRoutePathname(e.replace(/\*/g, "").replace(/[[{]{1,2}(.*?)[\]}]{1,2}/g, (e, t)=>`[${t.trim()}]`), t), /**
+ * Gathers a dictionary with the params extracted from the given (normalised)
+ * route id
+ */ s$1 = (e)=>{
+    let t = e.match(/\[.*?\]/g);
+    if (t) return t.map((e)=>e.slice(1, -1).trim()).reduce((e, t)=>(// TODO: maybe determine the more specific type with some kind of special
+        // token used in the route id `[dynamicParam]` portion
+        e[t] = "stringOrNumber", e), {});
+}, /**
+ * Recursively replace `/^` references with the parent route value
+ */ p = (e, t, a, l, n)=>{
+    let { tokens: { parentReference: r, idDelimiter: d }, reg: i } = t, s = e.byId[l], o = s.pathnames[a];
+    // beginning slash is always present here as the route value is already
+    // normalised at this point
+    if (o.startsWith(`/${r}`)) {
+        // removes the slash + token
+        o = o.replace(i.parentReference, "");
+        // grab the parent id
+        let r = l.split(d).slice(0, -1).join(d);
+        if (!n || n && n(s, r)) {
+            if (r) o = p(e, t, a, r, n) + o;
+            else throw Error("Used a parent route token reference without a matching parent route");
+        }
+    }
+    return o;
+}, /**
+ * Mutate the routes data replacing the parent route tokens
+ * NB: it mutates the data
+ */ o$2 = (e, t)=>{
+    for(let a in e.byId)for(let l in e.byId[a].pathnames)e.byId[a].pathnames[l] = p(e, t, l, a);
+}, /**
+ * Mutate the routes data replacing the parent route tokens
+ * NB: it mutates the data
+ */ c = (e, t)=>{
+    let a = (t, a)=>t.inWildcard && !e.wildcardIds.includes(a);
+    for(let l in e.byId){
+        let { inWildcard: n } = e.byId[l];
+        if (n && e.byId[l].pathnamesSpa) for(let n in e.byId[l].pathnamesSpa)// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        e.byId[l].pathnamesSpa[n] = p(e, t, n, l, a);
+        else // discard unneeded data
+        delete e.byId[l].pathnamesSpa;
+    }
+}, /**
+ * Optimize the route map by collapsing pathnames that are equal to the one for
+ * the default locale
+ *
+ * NB: It mutates the data
+ *
+ * ```json
+ * {
+ *   // from
+ *   "about": {
+ *     "en": "/about",
+ *     "nl": "/about"
+ *   },
+ *   "account.user.[id]": {
+ *     "en": "/account/user/{{ id }}",
+ *     "fi": "/account/user/{{ id }}",
+ *     "nl": "/rekening/gebruiker/{{ id }}"
+ *   },
+ *   // to
+ *   "about": "/about",
+ *   "account.user.[id]": {
+ *     "en": "/account/user/{{ id }}",
+ *     "nl": "/rekening/gebruiker/{{ id }}"
+ *   }
+ * }
+ * ```
+ */ m = (e, t)=>{
+    let { defaultLocale: a, locales: n } = t;
+    for(let t in e.byId){
+        let r = e.byId[t].pathnames, d = r[a], i = {};
+        for(let e in r){
+            let t = r[e];
+            t !== d && (i[e] = t);
+        }
+        Object.keys(i).length === n.length - 1 || (// if we have the same number of optimized/non-optimized pathnames we do
+        // not add the data
+        Object.keys(i).length >= 1 ? (// if we have more than one optimized pathnames we do add the default locale one
+        i[a] = d, e.byId[t].pathnamesSlim = utils.objectSortByKeysMatching(i, a)) : // otherwise it means that the pathname is the same for all locales
+        e.byId[t].pathnamesSlim = d);
+    }
+}, /**
+ * Flag routes that are children of wildcards, a.k.a. child SPA routes
+ *
+ * NB: It mutates the data
+ */ h$1 = (e)=>{
+    if (e.wildcardIds.length) for(let t in e.byId)e.wildcardIds.some((e)=>t.startsWith(e) && e !== t) && (e.byId[t].inWildcard = !0);
+}, I = (e, n, r, p)=>{
+    let o = utils.objectFlat(e, r.tokens.idDelimiter);
+    for(let e in o){
+        let t = o[e], // as I18nCompiler.RoutePathname;
+        { routeId: a, isCatchAll: c, isOptionalCatchAll: m } = d$1(e, r);
+        // if (isCatchAll || isOptionalCatchAll) console.log({ routeId, key });
+        // if is the first pass for this routeId
+        if (!p.byId[a]) {
+            p.byId[a] = p.byId[a] || {};
+            let e = s$1(a);
+            p.byId[a].id = a, e && (p.byId[a].params = e), (c || m) && (p.byId[a].wildcard = !0, p.wildcardIds.push(a));
+        }
+        p.byId[a].pathnames = p.byId[a].pathnames || {}, // prettier-ignore
+        p.byId[a].pathnames[n] = i$1(t, r), // prettier-ignore
+        p.byId[a].pathnames = utils.objectSortByKeysMatching(p.byId[a].pathnames, r.defaultLocale), // just copy them for now, the difference treatment happens when resolving
+        // the parent tokens
+        p.byId[a].pathnamesSpa = {
+            ...p.byId[a].pathnames
+        };
+    }
+    // sort by route name
+    p.byId = utils.objectSort(p.byId);
+};
+/**
+ * Get routes data
+ */ let getCodeDataRoutes = (e, t, { translationFiles: a })=>{
+    let l = {
+        byId: {},
+        wildcardIds: []
+    }, n = r(e, t);
+    for(let e = 0; e < a.length; e++){
+        let { path: r, locale: d, data: i } = a[e];
+        r === t.translationJsonFileName && I(i, d, n, l);
+    }
+    return(// the order in which these mutations run matters!
+    h$1(l), c(l, n), o$2(l, n), m(l, n), l);
+}; // /**
+ //  * Route id to TypeScript valid type/interface name
+ //  *
+ //  * @deprecated
+ //  */
+ // const routeIdToTypeName = (routeId: string) =>
+ //   capitalize(changeCaseCamel(routeId));
+
+const codeDataTranslationsOptions = {
+    /**
+   * A list of globs to run against source files, those that are matched will be
+   * ignored
+   *
+   * @see https://www.npmjs.com/package/minimatch
+   */ ignorePaths: [],
+    /**
+   * Given a translation value as `"myKey": ["two", "words"]`:
+   * - when `true`: it outputs `t_myKey_0`  and `t_myKey_1` functions
+   * - when `false`: if `fnsAsDataCodes` is `true` it outputs `t_myKey` otherwise
+   * it outputs nothing (TODO: maybe we could log this info in this case)
+   *
+   * NB: It is quite unlikely that you want to set this to `true`.
+   *
+   * @default false
+   */ createArrayIndexBasedFns: !1,
+    // TODO: add pluralisation config
+    /**
+   * It creates `t_` functions that returns objects and arrays to use as
+   * data source.
+   *
+   * NB: this greatly increased the generated code, tree shaking will still
+   * apply though.
+   *
+   * @default true
+   */ fnsAsDataCodes: !0,
+    /**
+   * Generated `namespace_tKey()` functions prefix, prepended to the automatically
+   * generated function names.
+   *
+   * @default ""
+   */ fnsPrefix: "",
+    tokens: {
+        /** @default ":" */ namespaceDelimiter: ":",
+        dynamicDelimiters: {
+            /** @default "{{" */ start: "{{",
+            /** @default "}}" */ end: "}}"
+        }
+    }
+};
+let g = RegExp(node_path.sep, "g"), /**
+ * Normalise translation key
+ */ v = (e)=>{
+    let t = e.// replace tilde with dollar
+    replace(/~/g, "$").// replace dash with underscore
+    replace(/-/g, "_").replace(g, "_").// collapse consecutive underscores
+    replace(/_+/g, "_").// ensure valid js identifier, allow only alphanumeric characters and few symbols
+    replace(/[^a-zA-Z0-9_$]/gi, "");
+    // ensure the key does not start with a number (invalid js)
+    return /^[0-9]/.test(t) ? "$" + t : t;
+}, h = (e, t)=>{
+    if (utils.isString(t)) {
+        let { start: r, end: a } = e.tokens.dynamicDelimiters, l = RegExp(`${r}(.*?)${a}`, "gm"), s = t.match(l);
+        if (s) return s.map((e)=>e.replace(r, "").replace(a, "").trim()).reduce((e, t)=>(// TODO: maybe determine the more specific type with some kind of special
+            // token used in the route id `[dynamicParam]` portion
+            e[t] = "stringOrNumber", e), {});
+    }
+}, /**
+ * This was an experiment to extract params to interpolate from non-flat
+ * translations values, but that does not seem really needed as one
+ * can always use `tInterpolateParams` directly on whatever string
+ *
+ * @deprecated
+ */ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+y = (e, t, r = {})=>{
+    if (utils.isPrimitive(t)) {
+        let a = h(e, t);
+        return a && (r = {
+            ...r,
+            ...a
+        }), r;
+    }
+    if (utils.isArray(t)) for(let a = 0; a < t.length; a++){
+        let l = h(e, t[a]);
+        l && (r = {
+            ...r,
+            ...l
+        });
+    }
+    else for(let a in t){
+        let l = y(e, t[a], r);
+        l && (r = {
+            ...r,
+            ...l
+        });
+    }
+    return {};
+}, // const addDataTranslationEntryForObjectValue = (
+//   options: CodeDataTranslationsOptions,
+//   id: string,
+//   locale: I18nCompiler.Locale,
+//   value: Exclude<Extract<I18nCompiler.DataTranslationValue, object>, string[]>,
+//   dataTranslations: I18nCompiler.DataTranslations,
+// ) => {
+//   // if (hasOnlyPluralKeys(value)) {
+//   //   return `'${key}': string;`;
+//   // }
+//   // if (!isArray(value) && isObject(value)) {
+//   //   if (hasOnlyPluralKeys(value)) {
+//   //     return `'${key}': string;`;
+//   //   }
+//   //   if (hasPlurals(value)) {
+//   //     return `'${key}': string | ${buildTypeForValue(pickNonPluralValue(value))}`;
+//   //   }
+//   // }
+//   // return `'${key}': ${buildTypeForValue(value)}`;
+// };
+/**
+ * At this point the data translations have been calculated, this happens in a
+ * second pass as we need to know all the translations keys to look for plural
+ * variations.
+ *
+ * NB: we mutate the `dataTranslations`
+ */ _ = (e, t)=>(Object.keys(t).filter(isPluralKey).forEach((r)=>{
+        let a = removePluralSuffix(r), l = getPluralSuffix(r);
+        // we only need to rearrange plurals defined as `x_one`, `x_other`, if plurals
+        // are instead defined as objects `{ one: "", other: "" }` we just keep that
+        // object structure for `values`
+        if (// we need to create it if we only have `x_one` `x_other` but not `x`
+        t[a] = t[a] || {}, t[r]) {
+            let s = t[a].values || {};
+            utils.forin(t[r].values, (r, i)=>{
+                // we need to ensure the value is an object for pluralisation, so if
+                // we encounter this structure:
+                // { "plural": "Plural", "plural_one": "One", "plural_other": "Some" }
+                // we just remove the first `plural` value as that key is instead used
+                // to grab the right pluralised version from the object value we build
+                // from the other plural-suffixed keys. TODO: maybe we could warn the
+                // developer of improper usage of `plural` translation key, which is
+                // simply useless
+                // prettier-ignore
+                s[r] = utils.isObject(s[r]) ? s[r] : {}, // prettier-ignore
+                s[r][l] = i;
+                let n = y(e, i);
+                n && (t[a].params = {
+                    ...t[a].params || {},
+                    ...n
+                });
+            }), Object.keys(s).length && (t[a].values = s, t[a].plural = !0), // TODO: probaly here we should remove the non-plural keys from `values`
+            // as they are anyway accessible from "deeper" functions e.g.
+            // `withPluralAndOtherKeys({ count: 3 }) => "One" | "Many"`
+            // `withPluralAndOtherKeys_nonPluralKey()` => "Yes"
+            // delete ids that we re-arranged in the plural-ready object value
+            delete t[r];
+        }
+    }), t), /**
+ * Add entry to translations data
+ */ x = (e, t, r, a, l)=>{
+    if (utils.isPrimitive(a)) {
+        l[t] = l[t] || {}, l[t].values = l[t].values || {}, l[t].values[r] = a, l[t].typeValue = "Primitive";
+        let s = h(e, a);
+        s && (l[t].params = s);
+    } else {
+        if (e.fnsAsDataCodes) {
+            let e = utils.isArray(a) ? "Array" : "Object";
+            l[t] = l[t] || {}, l[t].values = l[t].values || {}, l[t].values[r] = a, l[t].typeValue = e;
+        }
+        // @see comment on `extractTranslationParamsFromValue`
+        // const params = extractTranslationParamsFromValue(options, value);
+        // if (params) dataTranslations[id].params = params;
+        if (utils.isArray(a)) {
+            if (e.createArrayIndexBasedFns) for(let s = 0; s < a.length; s++)x(e, t + "_" + s, r, a[s], l);
+        } else for(let s in a)x(e, t + "_" + v(s), r, a[s], l);
+    }
+    return l;
+}, /**
+ * Get translation data recursively starting from a specific file
+ */ D = (l, s, i)=>{
+    let { locale: n, path: o } = s, p = node_path.join(node_path.dirname(o), node_path.basename(o, node_path.extname(o)));
+    for(let e in s.data){
+        let t = s.data[e];
+        x(l, v(p + (e ? "_" + e : "")), n, t, i);
+    }
+    return i;
+};
+/**
+ * Get translations data
+ */ let getCodeDataTranslations = (e, t, { translationFiles: r })=>{
+    let { ignorePaths: a } = t, l = {};
+    for(let e = 0; e < r.length; e++)(!a || a && a.every((t)=>!minimatch.minimatch(r[e].path, t))) && D(t, r[e], l);
+    // console.log("generateTypes: outputDir", outputDir, "outputPath", outputPath);
+    return(// sort
+    utils.objectSort(l = _(t, l)));
+};
+
+let l$2 = {
+    adapter: {
+        name: "js",
+        options: adapterJsOptions
+    },
+    outputFiles: {},
+    routes: codeDataRoutesOptions,
+    translations: codeDataTranslationsOptions
+};
+// TODO: make this works with generics based on chosen adapter?
+// defaultLocale: string;
+// index: string;
+// isLocale: string;
+// locales: string;
+// routes: string;
+// routesSlim: string;
+// to: string;
+// toFns: string;
+// toFormat: string;
+// types: string;
+let getCodeData = (o, a, r)=>{
+    let n = utils.objectMergeWithDefaults(l$2, a);
+    return n.translations.ignorePaths.push(n.routes.translationJsonFileName), // order locales
+    r = {
+        ...r,
+        localesFolders: r.localesFolders.sort((t, a)=>o.defaultLocale ? -1 : t.localeCompare(a))
+    }, {
+        config: o,
+        // TODO: types, remove this assertion
+        options: n,
+        input: r,
+        routes: getCodeDataRoutes(o, n.routes, r),
+        translations: getCodeDataTranslations(o, n.translations, r)
+    };
+};
+
+/**
+   * Used to generate SEO optimized alternate URLs
+   *
+   * NB: It will be normalised and trailing slash stripped out in order to ease
+   * and make consistent a simple concatenation with relative URLs.
+   */ /**
+   * Whether we have only a single locale.
+   *
+   * @computed
+   */ const configDefaults = {
+    baseUrl: "https://example.com",
+    locales: [
+        "en"
+    ],
+    defaultLocale: "en",
+    hideDefaultLocaleInUrl: !0,
+    trailingSlash: !1,
+    single: !0
+};
+/**
+ * Get basic i18n compiler config with defaults and automatic inference from
+ * input data
+ */ let getConfig = (a, o)=>{
+    o && (o.baseUrl = utils.normaliseUrl(o.baseUrl), // dynamically define locales
+    o.locales = o.locales || a.localesFolders, // ensure defaultLocale
+    o.defaultLocale = o.defaultLocale || o.locales?.[0], // ensure boolean value
+    o.hideDefaultLocaleInUrl = !!o.hideDefaultLocaleInUrl);
+    let t = utils.objectMergeWithDefaults(configDefaults, o);
+    return(// ensure sorted locales
+    t.locales = t.locales.sort((l, e)=>t.defaultLocale ? -1 : l.localeCompare(e)), // compute single
+    t.single = 1 === t.locales.length, t);
+};
+
+/**
+   * @default process.cwd()
+   */ /**
+   * @default undefined
+   */ let n$1 = (e, r)=>{
+    let { cwd: n = process.cwd(), output: i, pretty: o } = e;
+    return [
+        node_path.join(n, i),
+        o ? JSON.stringify(r, null, 2) : JSON.stringify(r)
+    ];
+};
+let writeInput = async (t, r)=>{
+    await node.fsWrite(...n$1(t, r));
+};
+
+let l$1 = (e)=>{
+    let { cwd: t, ignore: a } = e;
+    return glob.glob.sync("*", {
+        cwd: t,
+        withFileTypes: !0,
+        ignore: [
+            ...a,
+            "node_modules/**"
+        ]
+    }).// onlyDirectories: true,
+    // @see defaults https://www.npmjs.com/package/glob#dots
+    // dot: false,
+    filter((e)=>e.isDirectory()).map((e)=>e.relative()).sort((e, t)=>e.localeCompare(t));
+};
+let getInputDataLocal = async (e)=>{
+    let { cwd: r = process.cwd(), ignore: s = [], source: p } = e, i = node_path.join(r, p), c = l$1({
+        cwd: i,
+        ignore: s
+    }), n = [];
+    return await Promise.all(c.map(async (r)=>{
+        let l = await glob.glob("**/*.json", {
+            cwd: node_path.join(i, r),
+            ignore: e.ignore
+        });
+        await Promise.all(l.map(async (e)=>{
+            let o = node_path.join(i, r, e), l = await promises.readFile(o, "utf8");
+            l && n.push({
+                path: e,
+                data: JSON.parse(l),
+                locale: r
+            });
+        }));
+    })), {
+        localesFolders: c,
+        translationFiles: n
+    };
+};
+
+/**
+ * Our github action `knitkode/koine/actions/i18n` creates a JSON file we can
+ * read here, github serves it as text
+ */ let getInputDataRemote = async (r)=>new Promise((l, o)=>{
+        let { ignore: a = [], source: s } = r, n = s.startsWith(// import requestSync from "sync-request-curl";
+        "https://raw.githubusercontent.com"), i = "", c = node_https.request(s, n ? {} : {
+            headers: {
+                Accept: "application/json"
+            }
+        }, (e)=>{
+            e.setEncoding("utf8"), e.on("data", (e)=>{
+                i += e;
+            }), e.on("end", ()=>{
+                try {
+                    let e = n ? JSON.parse(i) : i;
+                    l({
+                        ...e,
+                        localesFolders: a.length ? e.localesFolders.filter((e)=>a.every((r)=>!minimatch.minimatch(e, r))) : e.localesFolders,
+                        translationFiles: a.length ? e.translationFiles.filter((e)=>a.every((r)=>!minimatch.minimatch(e.path, r))) : e.translationFiles
+                    });
+                } catch (e) {
+                    throw Error(`Failed to parse JSON from ${s}`);
+                }
+            });
+        });
+        c.on("error", (e)=>{
+            console.error(e), o("");
+        }), c.end();
+    });
+
+let getInputData = async (e)=>{
+    let { source: o } = e;
+    return utils$1.isAbsoluteUrl(o) ? await getInputDataRemote(e) : await getInputDataLocal(e);
+};
+
+let o$1 = (e, t = {})=>{
+    let r = "";
+    if (e && "string" == typeof e) r += " " + e.trim();
+    else if (Array.isArray(e)) for(let l = 0; l < e.length; l++)r += o$1(e[l], t);
+    else if ("object" == typeof e) for(let l in e)r += o$1(e[l], t);
+    return r;
+}, s = (e, t)=>{
+    let { locale: r, path: l } = t, s = `${e}/${r}/${l}`, a = o$1(t.data), i = a.split(" ").filter(Boolean).length;
+    return {
+        characters: a.split(" ").filter(Boolean).join("").length,
+        locale: r,
+        path: l,
+        url: s,
+        words: i
+    };
+};
+const summaryDataOptions = {};
+/**
+   * Usually this is an absolute URL where to view the translation file
+   */ let getSummaryData = (o, a, { translationFiles: i })=>{
+    let { defaultLocale: f } = o, n = {};
+    for(let e = 0; e < i.length; e++){
+        let t = i[e], { locale: r } = t, l = s(a.sourceUrl, t);
+        n[r] = n[r] || {}, n[r].files = n[r].files || [], n[r].files.push(l);
+    }
+    return utils.forin(// sort by default locale
+    n = utils.objectSortByKeysMatching(n, f), (t, l)=>{
+        n[t].characters = utils.arraySum(l.files.map((e)=>e.characters)), // sort files by path
+        n[t].files = n[t].files.sort((e, t)=>e.path.localeCompare(t.path)), n[t].words = utils.arraySum(l.files.map((e)=>e.words)), // sort object keys
+        n[t] = utils.objectSort(n[t]);
+    }), n;
+};
+
+let l = (e)=>{
+    let h = {};
+    return utils.forin(e, (t, e)=>{
+        let { files: r } = e;
+        for(let e = 0; e < r.length; e++){
+            let l = r[e], { path: d } = l;
+            h[d] = h[d] || {}, h[d][t] = l;
+        }
+    }), h = utils.objectSort(h);
+}, d = (e)=>{
+    let r = l(e), h = "", d = "", a = [], o = 'style="border-right:1px solid grey"';
+    return utils.forin(r, (e, r)=>{
+        d += `<tr><td ${o}>${e}</td>`, utils.forin(r, (t, e)=>{
+            let { characters: r, words: h, url: l } = e;
+            a.includes(t) || a.push(t), d += `<td><a href="${l}">${t}</a></td><td>${h}</td><td ${o}>${r}</td>`;
+        }), d += "</tr>";
+    }), h += `<table><thead><tr><th ${o}>file path</th>` + a.map(()=>`<th>lang</th><th>words</th><th ${o}>chars</th>`).join("") + `</tr></thead><tbody>${d}</tbody></table>\n`;
+}, a = (e, r)=>{
+    let h = "", l = "";
+    return utils.forin(e, (t, e)=>{
+        let { files: h, characters: d, words: a } = e, o = `${r.sourceUrl}/${t}`;
+        l += `<tr><th><a href="${o}">${t}</a></th><td>${h.length}</td><td>${a}</td><td>${d}</td></tr>`;
+    }), h += `<table><thead><tr><th>locale</th><th>files</th><th>words</th><th>chars</th></tr></thead><tbody>${l}</tbody></table>\n`;
+}, o = (t, e)=>"# Summary\n" + ("\n### By locale\n\n" + a(t, e) + "\n### By file path\n\n") + d(t);
+let generateSummary = (t, r)=>o(t, utils.objectMergeWithDefaults(summaryDataOptions, r));
+
+/**
+   * @default process.cwd()
+   */ /**
+   * Relative to the given `cwd`.
+   */ /**
+   * Relative to the given `cwd`.
+   */ /**
+   * @default undefined
+   */ let i = (t, e, o, i)=>[
+        node_path.join(o, i),
+        t.pretty ? JSON.stringify(e, null, 2) : JSON.stringify(e)
+    ], n = (t, e, i, n)=>[
+        node_path.join(i, n),
+        generateSummary(e, t)
+    ];
+let writeSummary = async (r, e)=>{
+    let { cwd: o = process.cwd(), outputJson: m, outputMarkdown: a, ...p } = r;
+    return m && await node.fsWrite(...i(r, e, o, m)), a && await node.fsWrite(...n(p, e, o, a)), e;
+};
+
+/**
+ * i18nCompiler async api
+ *
+ * @public
+ */ let i18nCompiler = async (a)=>{
+    let { input: u, code: w, summary: s, ...n } = a, f = [], l = await getInputData(u), c = getConfig(l, n), // it would be easy to make this optional but it's nice to be able to always
+    // predictably return data
+    h = getCodeData(c, w, l);
+    return u?.write && f.push(writeInput(u.write, l)), w?.write && f.push(writeCode({
+        ...w,
+        ...w.write
+    }, h)), s?.write && f.push(writeSummary({
+        ...s,
+        ...s.write
+    }, getSummaryData(c, s, l))), await Promise.all(f), {
+        config: c,
+        input: l,
+        code: h
+    };
+}; // /**
+ //  * i18nCompiler sync api
+ //  *
+ //  * @public
+ //  */
+ // export let i18nCompilerSync = (options: I18nCompilerOptions) => {
+ //   const {
+ //     input: optsInput,
+ //     code: optsCode,
+ //     summary: optsSummary,
+ //     ...configOptions
+ //   } = options;
+ //   const input = getInputDataSync(optsInput);
+ //   const config = getConfig(input, configOptions);
+ //   // it would be easy to make this optional but it's nice to be able to always
+ //   // predictably return data
+ //   const code = getCodeData(config, optsCode, input);
+ //   if (optsInput?.write) {
+ //     writeInputSync(optsInput.write, input);
+ //   }
+ //   if (optsCode?.write) {
+ //     writeCodeSync({ ...optsCode, ...optsCode.write }, code);
+ //   }
+ //   if (optsSummary?.write) {
+ //     writeSummarySync(
+ //       { ...optsSummary, ...optsSummary.write },
+ //       getSummaryData(config, optsSummary, input),
+ //     );
+ //   }
+ //   return { config, input, code };
+ // };
+
+exports.generateRedirectForPathname = generateRedirectForPathname;
+exports.generateRedirects = generateRedirects;
+exports.generateRewriteForPathname = generateRewriteForPathname;
+exports.generateRewrites = generateRewrites;
+exports.i18nCompiler = i18nCompiler;