@koine/i18n 2.0.0-beta.76 → 2.0.0-beta.78

package/api.cjs.js

@@ -0,0 +1,2203 @@
+'use strict';
+
+var utils = require('@koine/utils');
+var node_fs = require('node:fs');
+var node_path = require('node:path');
+var node = require('@koine/node');
+var formatRoutePathname = require('./formatRoutePathname.cjs.js');
+var ts = 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');
+require('node:child_process');
+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 ts__namespace = /*#__PURE__*/_interopNamespace(ts);
+
+var config = ({ config }) => `
+import { locales } from "./locales";
+import { defaultLocale } from "./defaultLocale";
+
+/**
+ */
+export const config = {
+  locales,
+  defaultLocale,
+  hideDefaultLocaleInUrl: ${config.hideDefaultLocaleInUrl},
+}
+
+export default config;
+`;
+
+var configCjs = ({ config }) => `
+const { locales } = require("./locales");
+const { defaultLocale } = require("./defaultLocale");
+
+const config = {
+  locales,
+  defaultLocale,
+  hideDefaultLocaleInUrl: ${config.hideDefaultLocaleInUrl},
+};
+
+exports.config = config;
+
+module.exports = config;
+`;
+
+var defaultLocale = ({ config }) => `
+import type { I18n } from "./types";
+
+export const defaultLocale: I18n.Locale = "${config.defaultLocale}";
+
+export default defaultLocale;
+`;
+
+var deriveLocalisedPathnames = () => `
+import { locales } from "./locales";
+import { to } from "./to";
+import type { I18n } from "./types";
+
+function getPathnameDynamicPortionName(pathname: string) {
+  const res = pathname.match(/\\[(.+)\\]/);
+  return res ? res[1] : false;
+}
+
+function isStaticPathname(pathname: string) {
+  return !/\\[/.test(pathname);
+}
+
+// e.g. ['my', 'path', 'id', 'view'] or ['nl' 'my', 'path', 'id', 'view']
+// where the first might be the locale (depending on hideDefaultLocaleInUrl)
+function getPathnameParts(pathname: string) {
+  return pathname
+    .split("/")
+    .slice(1)
+    .filter((p, i) => (i === 0 ? !locales.includes(p as I18n.Locale) : true));
+}
+
+function localisePathname(
+  locale: I18n.Locale,
+  // e.g. "my.path.[id].view"
+  routeId: I18n.RouteIdDynamic | I18n.RouteIdStatic,
+  locationLike: LocationLike
+) {
+  const toPathname = to(routeId as I18n.RouteIdStatic, locale);
+
+  if (isStaticPathname(toPathname)) {
+    return toPathname;
+  }
+  // e.g. ['my', 'path', '[id]', 'view']
+  const toPathnameParts = getPathnameParts(toPathname);
+  // e.g. "my.path.[id].view"
+  const routeIdDynamic = routeId as I18n.RouteIdDynamic;
+  // e.g. /my/path/123/view
+  const currentPathname = locationLike.pathname;
+  // e.g. ['my', 'path', '123', 'view']
+  const currentPathnameParts = getPathnameParts(currentPathname);
+  // e.g. { id: "123" }
+  const params: Record<string, string> = {};
+
+  for (let i = 0; i < toPathnameParts.length; i++) {
+    // e.g. "my" or "[id]"
+    const part = toPathnameParts[i];
+    // e.g. "id"
+    const name = getPathnameDynamicPortionName(part);
+    if (name) {
+      // e.g. "123"
+      const value = currentPathnameParts[i];
+      if (value) {
+        params[name] = value;
+      }
+    }
+  }
+
+  return (
+    to(routeIdDynamic, params as never, locale) +
+    location?.search || "" +
+    location?.hash || ""
+  );
+}
+
+type LocationLike = { pathname: string; search?: string; hash?: string; };
+
+export type LocalisedPathnames = Record<I18n.Locale, string>;
+
+export const deriveLocalisedPathnames = (routeId: I18n.RouteId, locationLike: LocationLike) =>
+  locales.reduce((pathnames, locale) => {
+    pathnames[locale] = localisePathname(locale, routeId, locationLike);
+    return pathnames;
+  }, {} as LocalisedPathnames);
+
+export default deriveLocalisedPathnames;
+`;
+
+var isLocale = () => `
+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 locales = ({ config }) => {
+    const value = `[${config.locales.map((l) => `"${l}"`).join(", ")}]`;
+    return `
+export const locales = ${value} as const;
+
+export default locales;
+`;
+};
+
+var pathnameToRouteId = ({ options }) => {
+    const { idDelimiter, optionalCatchAll, catchAll } = options.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, "${idDelimiter}")
+    .replace(/${utils.escapeRegExp(idDelimiter)}${utils.escapeRegExp(optionalCatchAll.start)}.+$/, "")
+    .replace(/${utils.escapeRegExp(idDelimiter)}${utils.escapeRegExp(catchAll.start)}.+$/, "")
+    .replace(/\\/index$/, "");
+
+export default pathnameToRouteId;
+`;
+};
+
+var routes = ({ routes }) => {
+    const value = JSON.stringify(Object.fromEntries(Object.entries(routes.byId)
+        .map(([routeId, { pathnames }]) => [routeId, pathnames])
+        .sort()), null, 2);
+    return `
+export const routes = ${value} as const;
+
+export default routes;
+`;
+};
+
+var routesSlim = ({ routes }) => {
+    const value = JSON.stringify(Object.fromEntries(Object.entries(routes.byId)
+        .map(([routeId, { pathnamesSlim, pathnames }]) => [
+        routeId,
+        pathnamesSlim || pathnames,
+    ])
+        .sort()), null, 2);
+    return `
+export const routesSlim = ${value} as const;
+
+export default routesSlim;
+`;
+};
+
+var routesSpa = ({ routes }) => {
+    const value = JSON.stringify(Object.fromEntries(Object.entries(routes.byId)
+        .filter(([, { pathnamesSpa }]) => !!pathnamesSpa)
+        .map(([routeId, { pathnamesSpa }]) => [routeId, pathnamesSpa])
+        .sort()), null, 2);
+    return `
+export const routesSpa = ${value} as const;
+
+export default routesSpa;
+`;
+};
+
+let dataParamsToTsInterfaceBody = (params) => Object.keys(params)
+    .reduce((pairs, paramName) => {
+    const value = params[paramName];
+    let type = "";
+    switch (value) {
+        case "number":
+            type = "number";
+            break;
+        case "string":
+            type = "string";
+            break;
+        default:
+            type = "string | number";
+            break;
+    }
+    pairs.push(`${paramName}: ${type};`);
+    return pairs;
+}, [])
+    .join(" ");
+
+const getTranslationValueOutput = (value) => {
+    if (utils.isString(value) || utils.isNumber(value)) {
+        return `"${value}"`;
+    }
+    else if (utils.isBoolean(value)) {
+        return `${value}`;
+    }
+    else if (utils.isArray(value)) {
+        return JSON.stringify(value);
+    }
+    return `(${JSON.stringify(value)})`;
+};
+const areEqualTranslationsValues = (a, b) => utils.areEqual(a, b);
+const getFunctionBodyWithLocales$1 = (config, perLocaleValues) => {
+    const { defaultLocale } = config;
+    let output = "";
+    for (const locale in perLocaleValues) {
+        const value = perLocaleValues[locale];
+        if (locale !== defaultLocale &&
+            !areEqualTranslationsValues(value, perLocaleValues[defaultLocale])) {
+            output += `locale === "${locale}" ? ${getTranslationValueOutput(value)} : `;
+        }
+    }
+    output += getTranslationValueOutput(perLocaleValues[defaultLocale]);
+    return output;
+};
+var tFns = ({ config, options, translations }) => {
+    let output = `
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-const */
+import type { I18n } from "./types";
+import { tInterpolateParams } from "./tInterpolateParams";
+import { tPluralise } from "./tPluralise";
+
+`;
+    for (const translationId in translations) {
+        let { values, params, plural } = translations[translationId];
+        const name = `${options.translations.fnsPrefix}${translationId}`;
+        if (plural) {
+            if (params) {
+                params["count"] = "number";
+            }
+            else {
+                params = { count: "number" };
+            }
+        }
+        const argParam = params
+            ? `params: { ${dataParamsToTsInterfaceBody(params)} }`
+            : "";
+        const argLocale = "locale?: I18n.Locale";
+        const args = [argParam, argLocale].filter(Boolean).join(", ");
+        output += `export let ${name} = (${args}) => `;
+        let outputFnReturn = "";
+        if (utils.isPrimitive(values)) {
+            outputFnReturn += getTranslationValueOutput(values);
+        }
+        else {
+            outputFnReturn += getFunctionBodyWithLocales$1(config, values);
+        }
+        if (plural) {
+            outputFnReturn = `tPluralise(${outputFnReturn}, params.count)`;
+        }
+        if (params) {
+            outputFnReturn = `tInterpolateParams(${outputFnReturn}, params);`;
+        }
+        else {
+            outputFnReturn = `${outputFnReturn};`;
+        }
+        output += outputFnReturn;
+        output += `\n`;
+    }
+    return output;
+};
+
+const escapeEachChar = (input) => input
+    .split("")
+    .map((v) => `\\${v}`)
+    .join("");
+var tInterpolateParams = ({ options }) => {
+    const { start, end } = options.translations.dynamicDelimiters;
+    return `
+/* eslint-disable prefer-const */
+export let tInterpolateParams = (
+  value: string,
+  params?: object,
+) =>
+  params ? value.replace(
+    /${escapeEachChar(start)}(.*?)${escapeEachChar(end)}/g,
+    (_, key) =>
+      params[key.trim() as keyof typeof params] + "",
+  ) : value;
+
+export default tInterpolateParams;
+`;
+};
+
+var tPluralise = () => {
+    return `
+/* eslint-disable prefer-const */
+let pluralRules = new Intl.PluralRules();
+
+// 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 to = ({ config }) => `
+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]) || "${config.defaultLocale}";
+
+  return toFormat(
+    locale,
+    (routesSlim[id] as Record<string, string>)[locale] ??
+      (routesSlim[id] as Record<string, string>)["${config.defaultLocale}"] ??
+      routesSlim[id],
+    isLocale(args[0]) ? undefined : args[0]
+  ) as I18n.RoutePathnames[Id];
+}
+
+export default to;
+`;
+
+const getFunctionBodyWithLocales = (config, perLocaleValues) => {
+    const { defaultLocale } = config;
+    let output = "";
+    for (const locale in perLocaleValues) {
+        const value = perLocaleValues[locale];
+        if (locale !== defaultLocale && value !== perLocaleValues[defaultLocale]) {
+            output += `locale === "${locale}" ? "${value}" : `;
+        }
+    }
+    output += '"' + perLocaleValues[defaultLocale] + '"';
+    return output;
+};
+var toFns = ({ config, routes, options }) => {
+    const hasOneLocale = config.locales.length === 1;
+    let output = `
+/* eslint-disable prefer-const */
+import { toFormat } from "./toFormat";
+import type { I18n } from "./types";
+
+`;
+    for (const routeId in routes.byId) {
+        const { pathnames, params } = routes.byId[routeId];
+        const name = `${options.routes.fnsPrefix}${utils.changeCaseSnake(routeId)}`;
+        const paramsType = `I18n.RouteParams["${routeId}"]`;
+        const argParam = params ? `params: ${paramsType}` : "";
+        const argLocale = hasOneLocale ? "" : "locale?: I18n.Locale";
+        const args = [argParam, argLocale].filter(Boolean).join(", ");
+        const formatArgLocale = hasOneLocale ? `""` : "locale";
+        const formatArgParams = params ? ", params" : "";
+        output += `export let ${name} = (${args}) => `;
+        if (utils.isString(pathnames)) {
+            output += `toFormat(${formatArgLocale}, "${pathnames}"${formatArgParams});`;
+        }
+        else {
+            output += `toFormat(${formatArgLocale}, ${getFunctionBodyWithLocales(config, pathnames)}${formatArgParams});`;
+        }
+        output += `\n`;
+    }
+    return output;
+};
+
+var toFormat = ({ config }) => `
+export function toFormat(
+  locale: string | undefined,
+  pathname: string,
+  params?: object,
+) {
+  locale = locale || "${config.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]::interpolateTo, 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] + "",
+      )
+  }
+  ${config.hideDefaultLocaleInUrl
+    ? `
+  if (locale !== "${config.defaultLocale}") {
+    return "/" + locale + pathname;
+  }
+  `
+    : ``}
+  return pathname;
+}
+
+export default toFormat;
+`;
+
+var toSpa = ({ config, options }) => {
+    const { idDelimiter } = options.routes.tokens;
+    return `
+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]) || "${config.defaultLocale}";
+  const fullId = \`\${rootId}${idDelimiter}\${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;
+`;
+};
+
+const pluralSuffixes = ["zero", "one", "two", "few", "many", "other"];
+const requiredPluralSuffix = "other";
+let isPluralSuffix = (suffix) => pluralSuffixes.includes(suffix) ||
+    utils.isNumericLiteral(suffix);
+let removePluralSuffix = (key) => {
+    const [suffix] = utils.splitReverse(key, "_");
+    return suffix ? key.replace(`_${suffix}`, "") : key;
+};
+let getPluralSuffix = (key) => utils.splitReverse(key, "_")[0];
+let isPluralKey = (key) => {
+    const [suffix] = utils.splitReverse(key, "_");
+    return isPluralSuffix(suffix);
+};
+const groupPluralsKeysByRoot = (pluralKeys) => {
+    const map = {};
+    pluralKeys.forEach((key) => {
+        const [root] = utils.split(key, "_");
+        map[root] = map[root] || [];
+        map[root].push(key);
+    });
+    return map;
+};
+let transformKeysForPlurals = (keys) => {
+    if (keys.some(hasRequiredPluralSuffix) ||
+        keys.includes(requiredPluralSuffix)) {
+        const pluralKeys = keys.filter(isPluralKey);
+        if (pluralKeys.length) {
+            let transformedKeys = [...keys];
+            const groupedPlurals = groupPluralsKeysByRoot(pluralKeys);
+            utils.forin(groupedPlurals, (pluralRoot, pluralKeys) => {
+                if (!keys.includes(pluralRoot)) {
+                    transformedKeys.push(pluralRoot);
+                }
+                pluralKeys.forEach((pluralKey) => {
+                    if (keys.includes(pluralKey)) {
+                        transformedKeys = transformedKeys.filter((k) => k !== pluralKey);
+                    }
+                });
+            });
+            return transformedKeys;
+        }
+    }
+    return keys;
+};
+let hasRequiredPluralSuffix = (key) => isPluralKey(key) && getPluralSuffix(key) === requiredPluralSuffix;
+let hasPlurals = (value) => Object.keys(value).some(hasRequiredPluralSuffix) ||
+    Object.keys(value).includes(requiredPluralSuffix);
+let hasOnlyPluralKeys = (value) => hasPlurals(value) ? pickNonPluralKeys(value).length === 0 : false;
+let pickNonPluralKeys = (value) => Object.keys(value).filter((k) => !isPluralSuffix(k));
+let pickNonPluralValue = (value) => (hasPlurals(value) ? utils.objectPick(value, pickNonPluralKeys(value)) : value);
+
+const buildTypeForObjectValue = (key, value) => {
+    if (!utils.isArray(value) && utils.isObject(value)) {
+        if (hasPlurals(value)) {
+            return hasOnlyPluralKeys(value)
+                ? `"${key}": string;`
+                : `"${key}": ${buildTypeForValue(pickNonPluralValue(value))}`;
+        }
+    }
+    return `"${key}": ${buildTypeForValue(value)}`;
+};
+const buildTypeForValue = (value) => {
+    let out = "";
+    let primitiveType = "";
+    if (utils.isBoolean(value)) {
+        primitiveType = "boolean";
+    }
+    else if (utils.isString(value)) {
+        primitiveType = "string";
+    }
+    if (primitiveType) {
+        out += primitiveType + ";";
+    }
+    else if (!value) {
+        out += "";
+    }
+    else if (utils.isArray(value)) {
+        const firstValue = value[0];
+        out += `${buildTypeForValue(firstValue)}[];`;
+    }
+    else if (utils.isObject(value)) {
+        out += "{";
+        const keys = transformKeysForPlurals(Object.keys(value));
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const single = value[key] || "";
+            out += buildTypeForObjectValue(key, single);
+        }
+        out += "};";
+    }
+    out = out.replace(/;\[\];/g, "[];");
+    out = out.replace(/;+/g, ";");
+    return out;
+};
+const buildTranslationsDictionary = (config, dataInput) => {
+    const { translationFiles } = dataInput;
+    const { defaultLocale } = config;
+    const defaultLocaleFiles = translationFiles.filter((f) => f.locale === defaultLocale);
+    const out = [];
+    for (let i = 0; i < defaultLocaleFiles.length; i++) {
+        const { path, data } = defaultLocaleFiles[i];
+        const namespace = path.replace(".json", "");
+        out.push(`"${namespace}": ${buildTypeForValue(data)}`);
+    }
+    return out.sort();
+};
+const buildRouteParams = (routes) => {
+    const out = [];
+    utils.forin(routes.byId, (routeId, { params }) => {
+        if (params) {
+            out.push(`"${routeId}": { ${dataParamsToTsInterfaceBody(params)} };`);
+        }
+    });
+    return out;
+};
+const buildUnionType = (values) => values
+    .sort()
+    .map((routeId) => `"${routeId}"`)
+    .join(" | ");
+const buildRoutesUnion = (routes, filterFn) => buildUnionType(Object.keys(routes.byId).filter((routeId) => filterFn(routeId, routes.byId[routeId])));
+const groupRoutesSpa = (routes) => Object.keys(routes.byId).reduce((map, routeId) => {
+    const route = routes.byId[routeId];
+    if (route.inWildcard) {
+        for (let I = 0; I < routes.wildcardIds.length; I++) {
+            const spaRootRouteId = routes.wildcardIds[I];
+            if (routeId.startsWith(spaRootRouteId)) {
+                map[spaRootRouteId] = map[spaRootRouteId] || [];
+                map[spaRootRouteId].push(routeId);
+            }
+        }
+    }
+    return map;
+}, {});
+const buildRoutesSpa = (config, routes, options) => {
+    const map = groupRoutesSpa(routes);
+    const output = [];
+    for (const rootRouteId in map) {
+        const pathRoutesIds = map[rootRouteId].map((fullRouteId) => fullRouteId.split(rootRouteId)[1].slice(1));
+        const rootPathname = routes.byId[rootRouteId].pathnames[config.defaultLocale];
+        const pathnames = [];
+        for (let i = 0; i < pathRoutesIds.length; i++) {
+            const subRouteId = pathRoutesIds[i];
+            const fullRouteId = `${rootRouteId}${options.routes.tokens.idDelimiter}${subRouteId}`;
+            const fullPathname = routes.byId[fullRouteId].pathnames[config.defaultLocale];
+            const pathPathname = fullPathname.split(rootPathname)[1];
+            pathnames.push(`"${subRouteId}": "${pathPathname}";`);
+        }
+        output.push(`"${rootRouteId}": { ${pathnames.join(" ")} }`);
+    }
+    return output;
+};
+const buildRoutesPathnames = (config, routes) => {
+    const output = [];
+    for (const routeId in routes.byId) {
+        const route = routes.byId[routeId];
+        output.push(`"${route.id}": "${route.pathnames[config.defaultLocale]}";`);
+    }
+    return output;
+};
+var types = ({ config, input, routes, options, }) => {
+    const routeIdStatic = buildRoutesUnion(routes, (_, { params }) => !params);
+    const routeIdDynamic = buildRoutesUnion(routes, (_, { params }) => !!params);
+    const { idDelimiter } = options.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";
+
+export namespace I18n {
+  /**
+   * Any of the available locale code
+   */
+  export type Locale = ${config.locales.map((l) => `"${l}"`).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 = ${routeIdStatic};
+
+  /**
+   * The dynamic routes available ids
+   */
+  export type RouteIdDynamic = ${routeIdDynamic};
+
+  /**
+   * SPA routes ids map
+   */
+  /**
+   * Map every SPA path divided by their roots to their actual pathname value for the default locale
+   */
+  export type RouteSpa = {
+    ${buildRoutesSpa(config, routes, options).join("\n    ")}
+  }
+
+  /**
+   * Map every route id to its actual pathanem value for the default locale
+   */
+  export type RoutePathnames = {
+    ${buildRoutesPathnames(config, routes).join("\n    ")}
+  }
+
+  /**
+   * Route dynamic params dictionary for each dynamic route id
+   */
+  export type RouteParams = {
+    ${buildRouteParams(routes).join("\n    ")}
+  }
+
+  /**
+   * Utility to join two route ids
+   */
+  export type RouteJoinedId<Root extends string, Tail extends string> = \`\${Root}${idDelimiter}\${Tail}\` extends RouteId ? \`\${Root}${idDelimiter}\${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;
+
+  /**
+   * 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 = {
+    ${buildTranslationsDictionary(config, input).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: "" }\`
+   *
+   */
+  export 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).
+   */
+  export type TranslationQuery =
+    | undefined
+    | null
+    | TranslationShortcut
+    | {
+        [key: string]: string | number | boolean;
+      };
+
+  /**
+   * Opions 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).
+   */
+  export 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>,
+  >(
+    s: TPath,
+    q?: TranslationQuery,
+    o?: 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>,
+  >(
+    s: TPath,
+    q?: TranslationQuery,
+    o?: 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> = (
+    s?: any,
+    q?: TranslationQuery,
+    o?: TranslationOptions,
+  ) => TReturn;
+
+  /**
+   * Translate function _loosest_ type it allows to return string or object or array
+   * or whatever basically.
+   */
+  export type TranslateLoosest<TReturn = any> = (
+    s?: any,
+    q?: TranslationQuery,
+    o?: TranslationOptions,
+  ) => TReturn;
+}
+`;
+};
+
+const adapter$2 = () => {
+    return {
+        files: [
+            { name: "config.cjs", fn: configCjs, ext: "js" },
+            { name: "config", fn: config, ext: "ts", index: true },
+            { name: "defaultLocale", fn: defaultLocale, ext: "ts", index: true },
+            {
+                name: "deriveLocalisedPathnames",
+                fn: deriveLocalisedPathnames,
+                ext: "ts",
+                index: true,
+            },
+            { name: "isLocale", fn: isLocale, ext: "ts", index: true },
+            { name: "locales", fn: locales, ext: "ts", index: true },
+            {
+                name: "pathnameToRouteId",
+                fn: pathnameToRouteId,
+                ext: "ts",
+                index: true,
+            },
+            { name: "routes", fn: routes, ext: "ts" },
+            { name: "routesSlim", fn: routesSlim, ext: "ts" },
+            { name: "routesSpa", fn: routesSpa, ext: "ts" },
+            { name: "tFns", fn: tFns, ext: "ts" },
+            {
+                name: "tInterpolateParams",
+                fn: tInterpolateParams,
+                ext: "ts",
+            },
+            { name: "to", fn: to, ext: "ts", index: true },
+            { name: "toFns", fn: toFns, ext: "ts", index: true },
+            { name: "toFormat", fn: toFormat, ext: "ts", index: true },
+            { name: "toSpa", fn: toSpa, ext: "ts", index: true },
+            { name: "tPluralise", fn: tPluralise, ext: "ts" },
+            { name: "types", fn: types, ext: "ts", index: true },
+        ],
+    };
+};
+
+var DynamicNamespaces = () => `
+"use client";
+
+import _DynamicNamespaces from "next-translate/DynamicNamespaces";
+
+export const DynamicNamespaces = _DynamicNamespaces;
+
+export default DynamicNamespaces;
+`;
+
+var T = () => `
+"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 TransText = () => `
+"use client";
+
+import _TransText from "next-translate/TransText";
+
+export const TransText = _TransText;
+
+export default TransText;
+`;
+
+var getT = () => `
+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 nextTranslateI18n = ({ config }) => `
+/**
+ * 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: [${config.locales.map((l) => `"${l}"`).join(", ")}],
+    defaultLocale: "${config.defaultLocale}",
+    logBuild: false,
+    // logger: () => void 0,
+    loadLocaleFrom: (locale, namespace) => import(\`./translations/\${locale}/\${namespace}.json\`).then((m) => m.default),
+    ...config,
+  };
+}
+`;
+
+var useT = () => `
+"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;
+`;
+
+const adapter$1 = () => {
+    return {
+        dependsOn: ["next"],
+        needsTranslationsFiles: true,
+        files: [
+            {
+                name: "DynamicNamespaces",
+                fn: DynamicNamespaces,
+                ext: "tsx",
+                index: true,
+            },
+            { name: "getT", fn: getT, ext: "ts", index: true },
+            { name: "nextTranslateI18n", fn: nextTranslateI18n, ext: "js" },
+            { name: "T", fn: T, ext: "tsx", index: true },
+            { name: "TransText", fn: TransText, ext: "tsx", index: true },
+            { name: "useT", fn: useT, ext: "ts", index: true },
+        ],
+    };
+};
+
+function transformPathname(rawPathnameOrTemplate, wildcard) {
+    return ("/" +
+        rawPathnameOrTemplate
+            .split("/")
+            .filter(Boolean)
+            .map((part) => {
+            if (part.startsWith("[[...")) {
+                return `:${encodeURIComponent(part.slice(5, -2))}`;
+            }
+            if (part.startsWith("[[")) {
+                return `:${encodeURIComponent(part.slice(2, -2))}`;
+            }
+            if (part.startsWith("[")) {
+                return `:${encodeURIComponent(part.slice(1, -1))}`;
+            }
+            return `${encodeURIComponent(part)}`;
+        })
+            .join("/") +
+        (wildcard ? "/:wildcard*" : ""));
+}
+
+function generatePathRedirect(arg) {
+    const { localeSource, localeDestination, template, pathname, permanent } = arg;
+    const sourcePrefix = localeSource ? `${localeSource}/` : "";
+    const source = formatRoutePathname.formatRoutePathname(sourcePrefix + template);
+    const destinationPrefix = localeDestination ? `${localeDestination}/` : "";
+    const destination = formatRoutePathname.formatRoutePathname(destinationPrefix + pathname);
+    if (source === destination)
+        return;
+    const redirect = {
+        source,
+        destination,
+        permanent: Boolean(permanent),
+    };
+    return redirect;
+}
+let generateRedirects = (config, routes, options, localeParam = "", permanent = false) => {
+    const { defaultLocale, hideDefaultLocaleInUrl } = config;
+    const regexIdDelimiter = new RegExp(utils.escapeRegExp(options.tokens.idDelimiter), "g");
+    const redirects = [];
+    for (const routeId in routes) {
+        const route = routes[routeId];
+        const pathnamesByLocale = routes[routeId].pathnames;
+        for (const locale in pathnamesByLocale) {
+            const localisedPathname = pathnamesByLocale[locale];
+            const template = transformPathname(routeId.replace(regexIdDelimiter, "/"), route.wildcard);
+            const pathname = transformPathname(localisedPathname, route.wildcard);
+            if (route.inWildcard)
+                break;
+            const isDefaultLocale = locale === defaultLocale;
+            const isVisibleDefaultLocale = isDefaultLocale && !hideDefaultLocaleInUrl;
+            const isHiddenDefaultLocale = isDefaultLocale && hideDefaultLocaleInUrl;
+            const arg = { template, pathname, permanent };
+            if (localeParam) {
+                if (isVisibleDefaultLocale) {
+                    redirects.push(generatePathRedirect({ ...arg, localeDestination: locale }));
+                }
+                else if (isHiddenDefaultLocale) {
+                    redirects.push(generatePathRedirect({ ...arg, localeSource: locale }));
+                }
+                else if (!isDefaultLocale) {
+                    redirects.push(generatePathRedirect({
+                        ...arg,
+                        localeSource: locale,
+                        localeDestination: locale,
+                    }));
+                }
+                else {
+                    redirects.push(generatePathRedirect(arg));
+                }
+            }
+            else {
+                if (pathname !== template) {
+                    if (isVisibleDefaultLocale) {
+                        redirects.push(generatePathRedirect({ ...arg, localeDestination: locale }));
+                    }
+                    else if (!isDefaultLocale) {
+                        redirects.push(generatePathRedirect({
+                            ...arg,
+                            localeSource: locale,
+                            localeDestination: locale,
+                        }));
+                    }
+                    else {
+                        redirects.push(generatePathRedirect(arg));
+                    }
+                }
+            }
+        }
+    }
+    const cleaned = utils.arrayUniqueByProperties(redirects.filter(Boolean), ["source", "destination"])
+        .sort((a, b) => a.source.localeCompare(b.source))
+        .map((rewrite) => (localeParam ? rewrite : { ...rewrite, locale: false }));
+    return cleaned;
+};
+
+var nextRedirects = ({ config, routes, options }) => {
+    const value = JSON.stringify(generateRedirects(config, routes.byId, options.routes), null, 2);
+    return `module.exports = ${value}`;
+};
+
+function generatePathRewrite(arg) {
+    const { localeSource, localeDestination, template, pathname } = arg;
+    let sourcePrefix = "";
+    if (localeSource)
+        sourcePrefix = `/${localeSource}`;
+    const source = formatRoutePathname.formatRoutePathname(sourcePrefix + pathname);
+    let destinationPrefix = "";
+    if (localeDestination)
+        destinationPrefix = `/${localeDestination}`;
+    const destination = formatRoutePathname.formatRoutePathname(destinationPrefix + template);
+    if (source === destination)
+        return;
+    const rewrite = { source, destination };
+    return rewrite;
+}
+const generateRewriteForPathname = (config, localeParam = "", locale, template, pathname, rewrites) => {
+    const { defaultLocale, hideDefaultLocaleInUrl } = config;
+    const isDefaultLocale = locale === defaultLocale;
+    const isHiddenDefaultLocale = isDefaultLocale && hideDefaultLocaleInUrl;
+    const isHiddenLocale = isHiddenDefaultLocale;
+    const arg = { config, template, pathname };
+    if (localeParam) {
+        if (isHiddenLocale) {
+            rewrites.push(generatePathRewrite({ ...arg, localeDestination: locale }));
+        }
+        else {
+            rewrites.push(generatePathRewrite({ ...arg, localeSource: locale, localeDestination: locale }));
+        }
+    }
+    else {
+        if (pathname !== template) {
+            if (isHiddenLocale) {
+                rewrites.push(generatePathRewrite(arg));
+            }
+            else {
+                rewrites.push({
+                    ...generatePathRewrite({ ...arg, localeSource: locale }),
+                    locale: false,
+                });
+            }
+        }
+    }
+};
+let generateRewrites = (config, routes, options, localeParam = "") => {
+    const regexIdDelimiter = new RegExp(utils.escapeRegExp(options.tokens.idDelimiter), "g");
+    const rewrites = [];
+    for (const routeId in routes) {
+        const route = routes[routeId];
+        const pathnamesByLocale = routes[routeId].pathnames;
+        for (const locale in pathnamesByLocale) {
+            const localisedPathname = pathnamesByLocale[locale];
+            const routeIdAsTemplate = routeId.replace(regexIdDelimiter, "/");
+            if (route.inWildcard)
+                break;
+            generateRewriteForPathname(config, localeParam, locale, transformPathname(routeIdAsTemplate), transformPathname(localisedPathname), rewrites);
+            if (route.wildcard) {
+                generateRewriteForPathname(config, localeParam, locale, transformPathname(routeIdAsTemplate, route.wildcard), transformPathname(localisedPathname, route.wildcard), rewrites);
+            }
+        }
+    }
+    const cleaned = utils.arrayUniqueByProperties(rewrites.filter(Boolean), ["source", "destination"]).sort((a, b) => {
+        return a.source.localeCompare(b.source);
+    });
+    return cleaned;
+};
+
+var nextRewrites = ({ config, routes, options }) => {
+    const value = JSON.stringify(generateRewrites(config, routes.byId, options.routes), null, 2);
+    return `module.exports = ${value}`;
+};
+
+var useCurrentLocalisedPathnames = () => `
+"use client";
+
+import { useEffect, useState } from "react";
+import { deriveLocalisedPathnames, type LocalisedPathnames } from "./deriveLocalisedPathnames";
+import { useRouteId } from "./useRouteId";
+
+export function useCurrentLocalisedPathnames() {
+  const routeId = useRouteId();
+  const [urls, setUrls] = useState<LocalisedPathnames>({} as LocalisedPathnames);
+
+  useEffect(() => {
+    setUrls(deriveLocalisedPathnames(routeId, location));
+  }, [routeId]);
+
+  return urls;
+}
+
+export default useCurrentLocalisedPathnames;
+`;
+
+var useLocale = ({ config }) => `
+import { useRouter } from "next/router";
+import type { I18n } from "./types";
+
+export const useLocale = () => (useRouter().locale as I18n.Locale) || "${config.defaultLocale}";
+
+export default useLocale;
+`;
+
+var useRouteId = () => `
+import { useRouter } from "next/router";
+import type { I18n } from "./types";
+import { pathnameToRouteId } from "./pathnameToRouteId";
+
+export const useRouteId = () => 
+  pathnameToRouteId(useRouter().pathname) as I18n.RouteId;
+
+export default useRouteId;
+`;
+
+var useTo = () => `
+"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 useToSpa = () => `
+"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;
+`;
+
+const adapter = () => {
+    return {
+        dependsOn: ["js"],
+        files: [
+            { name: "next-redirects", fn: nextRedirects, ext: "js" },
+            { name: "next-rewrites", fn: nextRewrites, ext: "js" },
+            {
+                name: "useCurrentLocalisedPathnames",
+                fn: useCurrentLocalisedPathnames,
+                ext: "ts",
+                index: true,
+            },
+            { name: "useLocale", fn: useLocale, ext: "ts", index: true },
+            { name: "useRouteId", fn: useRouteId, ext: "ts", index: true },
+            { name: "useTo", fn: useTo, ext: "ts", index: true },
+            { name: "useToSpa", fn: useToSpa, ext: "ts", index: true },
+        ],
+    };
+};
+
+const adaptersMap = {
+    js: adapter$2,
+    next: adapter,
+    "next-translate": adapter$1,
+};
+const getIndexFile = (generatedFiles) => {
+    let output = "";
+    generatedFiles
+        .filter((generatedFile) => generatedFile.index)
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .forEach((generatedFile) => {
+        output += `export * from "./${generatedFile.name}";\n`;
+    });
+    return output;
+};
+const getAdapters = async (adapterArg, adapterName, adapters = []) => {
+    const adapterCreator = adaptersMap[adapterName];
+    const adapterToResolve = adapterCreator(adapterArg);
+    const adapter = utils.isPromise(adapterToResolve)
+        ? await adapterToResolve
+        : adapterToResolve;
+    adapters = adapters.concat(adapter);
+    if (adapter.dependsOn) {
+        await Promise.all(adapter.dependsOn.map(async (adapaterName) => {
+            adapters = adapters.concat(await getAdapters(adapterArg, adapaterName));
+        }));
+    }
+    return adapters;
+};
+const generateCodeFromAdapters = (data, options, adapters) => {
+    const { outputFiles } = options;
+    const files = adapters.reduce((allFiles, adapter) => [...allFiles, ...adapter.files], []);
+    const generatedFiles = files.map((file) => {
+        const { fn, ...rest } = file;
+        const name = outputFiles?.[rest.name] || rest.name;
+        return { ...rest, name, content: fn(data) };
+    });
+    const indexFileContent = getIndexFile(generatedFiles);
+    if (indexFileContent) {
+        generatedFiles.push({
+            name: "index",
+            ext: "ts",
+            content: getIndexFile(generatedFiles),
+        });
+    }
+    return {
+        files: generatedFiles,
+        needsTranslationsFiles: adapters.some((adapter) => adapter.needsTranslationsFiles),
+    };
+};
+let generateCode = async (data, options) => generateCodeFromAdapters(data, options, await getAdapters(data, options.adapter));
+
+let tsCompile = (cwd, output, relativePaths, tsOptions) => {
+    const rootNames = Array.from(relativePaths)
+        .filter((p) => p.endsWith(".ts") || p.endsWith(".tsx"))
+        .map((relativePath) => node_path.join(cwd, output, relativePath));
+    const compilerOptions = {
+        noEmitOnError: true,
+        noImplicitAny: true,
+        declaration: true,
+        target: ts__namespace.ScriptTarget.ESNext,
+        module: ts__namespace.ModuleKind.ESNext,
+        moduleResolution: ts__namespace.ModuleResolutionKind.Bundler,
+        resolveJsonModule: true,
+        allowJs: false,
+        esModuleInterop: true,
+        jsx: ts__namespace.JsxEmit.ReactJSX,
+        outDir: node_path.join(cwd, output),
+        skipLibCheck: true,
+        noEmitHelpers: true,
+        importHelpers: true,
+        ...(tsOptions || {}),
+    };
+    const program = ts__namespace.createProgram(rootNames, compilerOptions);
+    const emitResult = program.emit();
+    const allDiagnostics = ts__namespace
+        .getPreEmitDiagnostics(program)
+        .concat(emitResult.diagnostics);
+    allDiagnostics.forEach((diagnostic) => {
+        if (diagnostic.file) {
+            const { line, character } = ts__namespace.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+            const message = ts__namespace.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+            console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+        }
+        else {
+            console.log(ts__namespace.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+        }
+    });
+    return emitResult;
+};
+
+const writeCodeFiles = async (cwd, output, codeGenerated, files) => Promise.all(codeGenerated.files.map(async ({ name, ext, content }) => {
+    const relativePath = `${name}.${ext}`;
+    const filepath = node_path.join(cwd, output, relativePath);
+    await node.fsWrite(filepath, content);
+    files.add(relativePath);
+}));
+const writeCompiledTypescriptFiles = (cwd, output, files) => {
+    const tsFiles = Array.from(files).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+    tsCompile(cwd, output, tsFiles);
+    tsFiles.forEach((relativePath) => {
+        files.add(relativePath.replace(/\.tsx?$/, ".js"));
+        files.add(relativePath.replace(/\.tsx?$/, ".d.ts"));
+        files.delete(relativePath);
+        node_fs.rmSync(node_path.join(cwd, output, relativePath), { force: true });
+    });
+};
+const writeTranslationsFiles = async (cwd, output, { translationFiles }, folders) => Promise.all(translationFiles.map(async ({ data, locale, path }) => {
+    const relativePath = node_path.join("translations", locale);
+    await node.fsWrite(node_path.join(cwd, output, relativePath, path), JSON.stringify(data));
+    folders.add(relativePath);
+}));
+const getWriteGitgnoreArgs = (cwd, output, folders, files) => [
+    node_path.join(cwd, output, ".gitignore"),
+    Array.from(new Set([...folders, ...files]))
+        .sort()
+        .map((relativePath) => `/${relativePath}`)
+        .join(`\n`),
+];
+let writeCode = async (options, data) => {
+    const { cwd = process.cwd(), output, skipTsCompile, skipGitignore, skipTranslations, ...generateOptions } = options;
+    const code = await generateCode(data, generateOptions);
+    const files = new Set();
+    const folders = new Set();
+    await writeCodeFiles(cwd, output, code, files);
+    if (!skipTsCompile) {
+        writeCompiledTypescriptFiles(cwd, output, files);
+    }
+    if (code.needsTranslationsFiles && !skipTranslations) {
+        await writeTranslationsFiles(cwd, output, data.input, folders);
+    }
+    if (!skipGitignore) {
+        await node.fsWrite(...getWriteGitgnoreArgs(cwd, output, folders, files));
+    }
+    return;
+};
+
+const codeDataRoutesOptions = {
+    translationJsonFileName: "~.json",
+    fnsPrefix: "",
+    tokens: {
+        parentReference: "^",
+        idDelimiter: ".",
+        catchAll: {
+            start: "[...",
+            end: "]",
+        },
+        optionalCatchAll: {
+            start: "[[...",
+            end: "]]",
+        },
+    },
+};
+const getCodeDataRoutesUtils = (config, options) => {
+    const { idDelimiter, parentReference, catchAll, optionalCatchAll } = options.tokens;
+    return {
+        ...config,
+        ...options,
+        reg: {
+            trailingDelimiter: new RegExp(`${utils.escapeRegExp(idDelimiter)}+$`),
+            indexEnd: new RegExp(`${utils.escapeRegExp(idDelimiter)}index$`),
+            parentReference: new RegExp(`^/${utils.escapeRegExp(parentReference)}`),
+            catchAll: new RegExp(`${utils.escapeRegExp(catchAll.start)}(.+)${utils.escapeRegExp(catchAll.end)}$`),
+            optionalCatchAll: new RegExp(`${utils.escapeRegExp(optionalCatchAll.start)}(.+)${utils.escapeRegExp(optionalCatchAll.end)}$`),
+        },
+    };
+};
+const parseUserDefinedRouteId = (userRouteId, { reg }) => {
+    let routeId = userRouteId.replace(reg.indexEnd, "");
+    const isOptionalCatchAll = reg.optionalCatchAll.test(userRouteId);
+    const isCatchAll = reg.catchAll.test(userRouteId);
+    if (isOptionalCatchAll)
+        routeId = routeId.replace(reg.optionalCatchAll, "");
+    if (isCatchAll)
+        routeId = routeId.replace(reg.catchAll, "");
+    routeId = routeId.replace(reg.trailingDelimiter, "");
+    return {
+        routeId,
+        isCatchAll,
+        isOptionalCatchAll,
+    };
+};
+const normaliseUserDefinedRoutePathname = (routePathname) => formatRoutePathname.formatRoutePathname(routePathname
+    .replace(/\*/g, "")
+    .replace(/[[{]{1,2}(.*?)[\]}]{1,2}/g, (_search, replaceValue) => `[${replaceValue.trim()}]`));
+const extractRouteParamsFromRouteId = (routeId) => {
+    const matches = routeId.match(/\[.*?\]/g);
+    if (matches) {
+        return matches
+            .map((match) => match.slice(1, -1).trim())
+            .reduce((map, paramName) => {
+            map[paramName] = "stringOrNumber";
+            return map;
+        }, {});
+    }
+    return;
+};
+const replaceRouteParentTokens = (dataRoutes, utils, locale, id, continueWhen) => {
+    const { tokens: { parentReference, idDelimiter }, reg, } = utils;
+    const route = dataRoutes.byId[id];
+    let pathname = route.pathnames[locale];
+    if (pathname.startsWith(`/${parentReference}`)) {
+        pathname = pathname.replace(reg.parentReference, "");
+        const parentId = id.split(idDelimiter).slice(0, -1).join(idDelimiter);
+        if (!continueWhen || (continueWhen && continueWhen(route, parentId))) {
+            if (parentId) {
+                pathname =
+                    replaceRouteParentTokens(dataRoutes, utils, locale, parentId, continueWhen) + pathname;
+            }
+            else {
+                throw Error("Used a parent route token reference without a matching parent route");
+            }
+        }
+    }
+    return pathname;
+};
+const replaceRoutesPathnamesParentTokens = (dataRoutes, utils) => {
+    for (const routeId in dataRoutes.byId) {
+        for (const locale in dataRoutes.byId[routeId].pathnames) {
+            dataRoutes.byId[routeId].pathnames[locale] = replaceRouteParentTokens(dataRoutes, utils, locale, routeId);
+        }
+    }
+};
+const manageRoutesSpaPathnames = (dataRoutes, utils) => {
+    const continueWhen = (currentRoute, parentRouteId) => currentRoute.inWildcard && !dataRoutes.wildcardIds.includes(parentRouteId);
+    for (const routeId in dataRoutes.byId) {
+        const { inWildcard } = dataRoutes.byId[routeId];
+        if (inWildcard && dataRoutes.byId[routeId].pathnamesSpa) {
+            for (const locale in dataRoutes.byId[routeId].pathnamesSpa) {
+                dataRoutes.byId[routeId].pathnamesSpa[locale] =
+                    replaceRouteParentTokens(dataRoutes, utils, locale, routeId, continueWhen);
+            }
+        }
+        else {
+            delete dataRoutes.byId[routeId].pathnamesSpa;
+        }
+    }
+};
+const addRoutesSlimPathnames = (dataRoutes, utils$1) => {
+    const { defaultLocale, locales } = utils$1;
+    for (const routeId in dataRoutes.byId) {
+        const pathnamesPerLocale = dataRoutes.byId[routeId].pathnames;
+        const defaultLocalePathname = pathnamesPerLocale[defaultLocale];
+        const pathnamesSlim = {};
+        for (const locale in pathnamesPerLocale) {
+            const url = pathnamesPerLocale[locale];
+            if (url !== defaultLocalePathname) {
+                pathnamesSlim[locale] = url;
+            }
+        }
+        if (Object.keys(pathnamesSlim).length === locales.length - 1) ;
+        else if (Object.keys(pathnamesSlim).length >= 1) {
+            pathnamesSlim[defaultLocale] = defaultLocalePathname;
+            dataRoutes.byId[routeId].pathnamesSlim = utils.objectSortByKeysMatching(pathnamesSlim, defaultLocale);
+        }
+        else {
+            dataRoutes.byId[routeId].pathnamesSlim = defaultLocalePathname;
+        }
+    }
+};
+const addInWildcardFlags = (dataRoutes) => {
+    if (dataRoutes.wildcardIds.length) {
+        for (const routeId in dataRoutes.byId) {
+            const inWildcard = dataRoutes.wildcardIds.some((wildcardRouteId) => routeId.startsWith(wildcardRouteId) && wildcardRouteId !== routeId);
+            if (inWildcard)
+                dataRoutes.byId[routeId].inWildcard = true;
+        }
+    }
+};
+const buildDataRoutesFromJsonData = (json, locale, utils$1, data) => {
+    const routes = utils.objectFlat(json, utils$1.tokens.idDelimiter);
+    for (const _key in routes) {
+        const key = _key;
+        const routePathname = routes[key];
+        const { routeId, isCatchAll, isOptionalCatchAll } = parseUserDefinedRouteId(key, utils$1);
+        if (!data.byId[routeId]) {
+            data.byId[routeId] = data.byId[routeId] || {};
+            const params = extractRouteParamsFromRouteId(routeId);
+            data.byId[routeId].id = routeId;
+            if (params)
+                data.byId[routeId].params = params;
+            if (isCatchAll || isOptionalCatchAll) {
+                data.byId[routeId].wildcard = true;
+                data.wildcardIds.push(routeId);
+            }
+        }
+        data.byId[routeId].pathnames = data.byId[routeId].pathnames || {};
+        data.byId[routeId].pathnames[locale] = normaliseUserDefinedRoutePathname(routePathname);
+        data.byId[routeId].pathnames = utils.objectSortByKeysMatching(data.byId[routeId].pathnames, utils$1.defaultLocale);
+        data.byId[routeId].pathnamesSpa = { ...data.byId[routeId].pathnames };
+    }
+    data.byId = utils.objectSort(data.byId);
+};
+let getCodeDataRoutes = (config, options, { translationFiles }) => {
+    const dataRoutes = { byId: {}, wildcardIds: [] };
+    const utils = getCodeDataRoutesUtils(config, options);
+    for (let i = 0; i < translationFiles.length; i++) {
+        const { path, locale, data } = translationFiles[i];
+        if (path === options.translationJsonFileName) {
+            buildDataRoutesFromJsonData(data, locale, utils, dataRoutes);
+        }
+    }
+    addInWildcardFlags(dataRoutes);
+    manageRoutesSpaPathnames(dataRoutes, utils);
+    replaceRoutesPathnamesParentTokens(dataRoutes, utils);
+    addRoutesSlimPathnames(dataRoutes, utils);
+    return dataRoutes;
+};
+
+const codeDataTranslationsOptions = {
+    ignorePaths: [],
+    dynamicDelimiters: {
+        start: "{{",
+        end: "}}",
+    },
+    fnsAsDataCodes: true,
+    fnsPrefix: "",
+    createArrayIndexBasedFns: false,
+};
+const slashRegex = new RegExp(node_path.sep, "g");
+const normaliseTranslationKey = (key) => {
+    const replaced = key
+        .replace(/~/g, "$")
+        .replace(/-/g, "_")
+        .replace(slashRegex, "_")
+        .replace(/_+/g, "_")
+        .replace(/[^a-zA-Z0-9_$]/gi, "");
+    return /^[0-9]/.test(replaced) ? "$" + replaced : replaced;
+};
+const extractTranslationParamsFromPrimitive = (options, value) => {
+    if (utils.isString(value)) {
+        const { start, end } = options.dynamicDelimiters;
+        const regex = new RegExp(`${start}(.*?)${end}`, "gm");
+        const matches = value.match(regex);
+        if (matches) {
+            return matches
+                .map((match) => match.replace(start, "").replace(end, "").trim())
+                .reduce((map, paramName) => {
+                map[paramName] = "stringOrNumber";
+                return map;
+            }, {});
+        }
+    }
+    return;
+};
+const extractTranslationParamsFromValue = (options, value, params = {}) => {
+    if (utils.isPrimitive(value)) {
+        const extracted = extractTranslationParamsFromPrimitive(options, value);
+        if (extracted)
+            params = { ...params, ...extracted };
+        return params;
+    }
+    else if (utils.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const extracted = extractTranslationParamsFromPrimitive(options, value[i]);
+            if (extracted)
+                params = { ...params, ...extracted };
+        }
+    }
+    else {
+        for (const key in value) {
+            const extracted = extractTranslationParamsFromValue(options, value[key], params);
+            if (extracted)
+                params = { ...params, ...extracted };
+        }
+    }
+    return {};
+};
+const manageDataTranslationsPlurals = (options, dataTranslations) => {
+    const pluralTranslationIds = Object.keys(dataTranslations).filter(isPluralKey);
+    pluralTranslationIds.forEach((translationIdPluralised) => {
+        const id = removePluralSuffix(translationIdPluralised);
+        const pluralSuffix = getPluralSuffix(translationIdPluralised);
+        dataTranslations[id] = dataTranslations[id] || {};
+        if (dataTranslations[translationIdPluralised]) {
+            const values = dataTranslations[id].values || {};
+            utils.forin(dataTranslations[translationIdPluralised].values, (locale, value) => {
+                values[locale] = utils.isObject(values[locale]) ? values[locale] : {};
+                values[locale][pluralSuffix] = value;
+                const params = extractTranslationParamsFromValue(options, value);
+                if (params) {
+                    dataTranslations[id].params = {
+                        ...(dataTranslations[id].params || {}),
+                        ...params,
+                    };
+                }
+            });
+            if (Object.keys(values).length) {
+                dataTranslations[id].values = values;
+                dataTranslations[id].plural = true;
+            }
+            delete dataTranslations[translationIdPluralised];
+        }
+    });
+    return dataTranslations;
+};
+const addDataTranslationEntry = (options, id, locale, value, dataTranslations) => {
+    if (utils.isPrimitive(value)) {
+        dataTranslations[id] = dataTranslations[id] || {};
+        dataTranslations[id].values = dataTranslations[id].values || {};
+        dataTranslations[id].values[locale] = value;
+        dataTranslations[id].typeValue = "Primitive";
+        const params = extractTranslationParamsFromPrimitive(options, value);
+        if (params)
+            dataTranslations[id].params = params;
+    }
+    else {
+        if (options.fnsAsDataCodes) {
+            const typeValue = utils.isArray(value) ? "Array" : "Object";
+            dataTranslations[id] = dataTranslations[id] || {};
+            dataTranslations[id].values = dataTranslations[id].values || {};
+            dataTranslations[id].values[locale] = value;
+            dataTranslations[id].typeValue = typeValue;
+        }
+        if (utils.isArray(value)) {
+            if (options.createArrayIndexBasedFns) {
+                for (let i = 0; i < value.length; i++) {
+                    addDataTranslationEntry(options, id + "_" + i, locale, value[i], dataTranslations);
+                }
+            }
+        }
+        else {
+            for (const tKey in value) {
+                addDataTranslationEntry(options, id + "_" + normaliseTranslationKey(tKey), locale, value[tKey], dataTranslations);
+            }
+        }
+    }
+    return dataTranslations;
+};
+const getCodeDataTranslationsFromFile = (options, file, dataTranslations) => {
+    const { locale, path } = file;
+    const filename = node_path.join(node_path.dirname(path), node_path.basename(path, node_path.extname(path)));
+    for (const tKey in file.data) {
+        const tValue = file.data[tKey];
+        const id = normaliseTranslationKey(filename + (tKey ? "_" + tKey : ""));
+        addDataTranslationEntry(options, id, locale, tValue, dataTranslations);
+    }
+    return dataTranslations;
+};
+let getCodeDataTranslations = (_config, options, { translationFiles }) => {
+    const { ignorePaths } = options;
+    let dataTranslations = {};
+    for (let i = 0; i < translationFiles.length; i++) {
+        if (!ignorePaths ||
+            (ignorePaths &&
+                ignorePaths.every((glob) => !minimatch.minimatch(translationFiles[i].path, glob)))) {
+            getCodeDataTranslationsFromFile(options, translationFiles[i], dataTranslations);
+        }
+    }
+    dataTranslations = manageDataTranslationsPlurals(options, dataTranslations);
+    dataTranslations = utils.objectSort(dataTranslations);
+    return dataTranslations;
+};
+
+const codeDataOptions = {
+    routes: codeDataRoutesOptions,
+    translations: codeDataTranslationsOptions,
+};
+let getCodeData = (config, options, input) => {
+    const optionsSafe = utils.objectMergeWithDefaults(codeDataOptions, options);
+    optionsSafe.translations.ignorePaths.push(optionsSafe.routes.translationJsonFileName);
+    input = {
+        ...input,
+        localesFolders: input.localesFolders.sort((a, b) => config.defaultLocale ? -1 : a.localeCompare(b)),
+    };
+    return {
+        config,
+        options: optionsSafe,
+        input,
+        routes: getCodeDataRoutes(config, optionsSafe.routes, input),
+        translations: getCodeDataTranslations(config, optionsSafe.translations, input),
+    };
+};
+
+const configDefaults = {
+    locales: ["en"],
+    defaultLocale: "en",
+    hideDefaultLocaleInUrl: true,
+};
+let getConfig = (dataInput, options = {}) => {
+    options.locales = options.locales || dataInput.localesFolders;
+    options.defaultLocale = options.defaultLocale || options.locales?.[0];
+    options.hideDefaultLocaleInUrl = !!options.hideDefaultLocaleInUrl;
+    const merged = utils.objectMergeWithDefaults(configDefaults, options);
+    merged.locales = merged.locales.sort((a, b) => merged.defaultLocale ? -1 : a.localeCompare(b));
+    return merged;
+};
+
+const getWriteInputArgs = (options, data) => {
+    const { cwd = process.cwd(), output, pretty } = options;
+    return [
+        node_path.join(cwd, output),
+        pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data),
+    ];
+};
+let writeInput = async (options, data) => {
+    await node.fsWrite(...getWriteInputArgs(options, data));
+};
+
+const getLocalesFolders = (options) => {
+    const { cwd, ignore } = options;
+    const folders = glob.glob
+        .sync("*", {
+        cwd,
+        withFileTypes: true,
+        ignore: [...ignore, "node_modules/**"],
+    })
+        .filter((folder) => folder.isDirectory())
+        .map((path) => path.relative());
+    return folders.sort((a, b) => a.localeCompare(b));
+};
+let getInputDataLocal = async (options) => {
+    const { cwd = process.cwd(), ignore = [], source } = options;
+    const path = node_path.join(cwd, source);
+    const localesFolders = getLocalesFolders({ cwd: path, ignore });
+    const translationFiles = [];
+    await Promise.all(localesFolders.map(async (locale) => {
+        const jsonFiles = await glob.glob("**/*.json", {
+            cwd: node_path.join(path, locale),
+            ignore: options.ignore,
+        });
+        await Promise.all(jsonFiles.map(async (relativePath) => {
+            const fullPath = node_path.join(path, locale, relativePath);
+            const rawContent = await promises.readFile(fullPath, "utf8");
+            if (rawContent) {
+                translationFiles.push({
+                    path: relativePath,
+                    data: JSON.parse(rawContent),
+                    locale: locale,
+                });
+            }
+        }));
+    }));
+    return {
+        localesFolders,
+        translationFiles,
+    };
+};
+
+const GITHUB_RAW_URL = "https://raw.githubusercontent.com";
+let getInputDataRemote = async (options) => new Promise((resolve, reject) => {
+    const { ignore = [], source } = options;
+    const isGithubUrl = source.startsWith(GITHUB_RAW_URL);
+    let result = "";
+    const req = node_https.request(source, isGithubUrl
+        ? {}
+        : {
+            headers: {
+                Accept: "application/json",
+            },
+        }, (res) => {
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+            result += chunk;
+        });
+        res.on("end", () => {
+            try {
+                const dataInput = (isGithubUrl ? JSON.parse(result) : result);
+                resolve({
+                    ...dataInput,
+                    localesFolders: ignore.length
+                        ? dataInput.localesFolders.filter((folder) => ignore.every((glob) => !minimatch.minimatch(folder, glob)))
+                        : dataInput.localesFolders,
+                    translationFiles: ignore.length
+                        ? dataInput.translationFiles.filter((file) => ignore.every((glob) => !minimatch.minimatch(file.path, glob)))
+                        : dataInput.translationFiles,
+                });
+            }
+            catch (e) {
+                throw Error(`Failed to parse JSON from ${source}`);
+            }
+        });
+    });
+    req.on("error", (e) => {
+        console.error(e);
+        reject("");
+    });
+    req.end();
+});
+
+let getInputData = async (options) => {
+    const { source } = options;
+    if (utils$1.isAbsoluteUrl(source)) {
+        return await getInputDataRemote(options);
+    }
+    return await getInputDataLocal(options);
+};
+
+const getWords = (value, options = {}) => {
+    let out = "";
+    if (value && typeof value === "string") {
+        out += " " + value.trim();
+    }
+    else if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            out += getWords(value[i], options);
+        }
+    }
+    else if (typeof value === "object") {
+        for (const _key in value) {
+            const key = _key;
+            const single = value[key];
+            out += getWords(single, options);
+        }
+    }
+    return out;
+};
+const getSummaryDataEntry = (sourceUrl, file) => {
+    const { locale, path } = file;
+    const url = `${sourceUrl}/${locale}/${path}`;
+    const words = getWords(file.data);
+    const wordsCount = words.split(" ").filter(Boolean).length;
+    const characters = words.split(" ").filter(Boolean).join("").length;
+    return {
+        characters,
+        locale: locale,
+        path,
+        url,
+        words: wordsCount,
+    };
+};
+const summaryDataOptions = {};
+let getSummaryData = (config, options, { translationFiles }) => {
+    const { defaultLocale } = config;
+    let dataSummary = {};
+    for (let i = 0; i < translationFiles.length; i++) {
+        const file = translationFiles[i];
+        const { locale } = file;
+        const entry = getSummaryDataEntry(options.sourceUrl, file);
+        dataSummary[locale] = dataSummary[locale] || {};
+        dataSummary[locale].files = dataSummary[locale].files || [];
+        dataSummary[locale].files.push(entry);
+    }
+    dataSummary = utils.objectSortByKeysMatching(dataSummary, defaultLocale);
+    utils.forin(dataSummary, (locale, dataPerLocale) => {
+        dataSummary[locale].characters = utils.arraySum(dataPerLocale.files.map((f) => f.characters));
+        dataSummary[locale].files = dataSummary[locale].files.sort((a, b) => a.path.localeCompare(b.path));
+        dataSummary[locale].words = utils.arraySum(dataPerLocale.files.map((f) => f.words));
+        dataSummary[locale] = utils.objectSort(dataSummary[locale]);
+    });
+    return dataSummary;
+};
+
+const getSummaryDataByPath = (data) => {
+    let out = {};
+    utils.forin(data, (locale, dataPerLocale) => {
+        const { files } = dataPerLocale;
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            const { path } = file;
+            out[path] = out[path] || {};
+            out[path][locale] = file;
+        }
+    });
+    out = utils.objectSort(out);
+    return out;
+};
+const generateSummaryMarkdownByPath = (data) => {
+    const dataByPath = getSummaryDataByPath(data);
+    let output = "";
+    let body = "";
+    const locales = [];
+    const styleBorder = `style="border-right:1px solid grey"`;
+    utils.forin(dataByPath, (path, dataPerPath) => {
+        body += `<tr>`;
+        body += `<td ${styleBorder}>${path}</td>`;
+        utils.forin(dataPerPath, (locale, file) => {
+            const { characters, words, url } = file;
+            if (!locales.includes(locale))
+                locales.push(locale);
+            body += `<td><a href="${url}">${locale}</a></td>`;
+            body += `<td>${words}</td>`;
+            body += `<td ${styleBorder}>${characters}</td>`;
+        });
+        body += `</tr>`;
+    });
+    output += `<table><thead><tr>`;
+    output += `<th ${styleBorder}>file path</th>`;
+    output += locales
+        .map(() => `<th>lang</th><th>words</th><th ${styleBorder}>chars</th>`)
+        .join("");
+    output += `</tr></thead><tbody>${body}</tbody></table>\n`;
+    return output;
+};
+const generateSummaryMarkdownByLocale = (data, options) => {
+    let output = "";
+    let body = "";
+    utils.forin(data, (locale, dataPerLocale) => {
+        const { files, characters, words } = dataPerLocale;
+        const url = `${options.sourceUrl}/${locale}`;
+        body += `<tr>`;
+        body += `<th><a href="${url}">${locale}</a></th>`;
+        body += `<td>${files.length}</td>`;
+        body += `<td>${words}</td>`;
+        body += `<td>${characters}</td>`;
+        body += `</tr>`;
+    });
+    output += `<table><thead><tr>`;
+    output += `<th>locale</th><th>files</th><th>words</th><th>chars</th>`;
+    output += `</tr></thead><tbody>${body}</tbody></table>\n`;
+    return output;
+};
+const generateSummaryMarkdown = (data, options) => {
+    let output = "# Summary\n";
+    output += "\n### By locale\n\n";
+    output += generateSummaryMarkdownByLocale(data, options);
+    output += "\n### By file path\n\n";
+    output += generateSummaryMarkdownByPath(data);
+    return output;
+};
+let generateSummary = (data, options) => {
+    const markdown = generateSummaryMarkdown(data, utils.objectMergeWithDefaults(summaryDataOptions, options));
+    return markdown;
+};
+
+const getWriteSummaryJsonArgs = (options, data, cwd, outputJson) => [
+    node_path.join(cwd, outputJson),
+    options.pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data),
+];
+const getWriteSummaryMdArgs = (options, data, cwd, outputMarkdown) => [node_path.join(cwd, outputMarkdown), generateSummary(data, options)];
+let writeSummary = async (options, data) => {
+    const { cwd = process.cwd(), outputJson, outputMarkdown, ...rest } = options;
+    if (outputJson) {
+        await node.fsWrite(...getWriteSummaryJsonArgs(options, data, cwd, outputJson));
+    }
+    if (outputMarkdown) {
+        await node.fsWrite(...getWriteSummaryMdArgs(rest, data, cwd, outputMarkdown));
+    }
+    return data;
+};
+
+let i18nCompiler = async (options) => {
+    const { input: optsInput, code: optsCode, summary: optsSummary, ...configOptions } = options;
+    const writables = [];
+    const input = await getInputData(optsInput);
+    const config = getConfig(input, configOptions);
+    const code = getCodeData(config, optsCode, input);
+    if (optsInput?.write) {
+        writables.push(writeInput(optsInput.write, input));
+    }
+    if (optsCode?.write) {
+        writables.push(writeCode({ ...optsCode, ...optsCode.write }, code));
+    }
+    if (optsSummary?.write) {
+        writables.push(writeSummary({ ...optsSummary, ...optsSummary.write }, getSummaryData(config, optsSummary, input)));
+    }
+    await Promise.all(writables);
+    return { config, input, code };
+};
+
+exports.generateRedirects = generateRedirects;
+exports.generateRewrites = generateRewrites;
+exports.i18nCompiler = i18nCompiler;