@koine/i18n 2.0.0-beta.82 → 2.0.0-beta.83

package/api.cjs.js

@@ -70,7 +70,8 @@ export const defaultLocale: I18n.Locale = "${e.defaultLocale}";
 export default defaultLocale;
 `);
 
-var m$5 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var m$5 = (()=>/* {}: I18nCompiler.AdapterArg, */ `
 import { locales } from "./locales";
 import { to } from "./to";
 import type { I18n } from "./types";
@@ -149,7 +150,8 @@ export const deriveLocalisedPathnames = (routeId: I18n.RouteId, locationLike: Lo
 export default deriveLocalisedPathnames;
 `);
 
-var n$6 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var n$6 = (()=>/* {}: I18nCompiler.AdapterArg */ `
 import { locales } from "./locales";
 import type { I18n } from "./types";
 
@@ -224,7 +226,12 @@ export default routesSpa;
 `;
 });
 
-let dataParamsToTsInterfaceBody = (e)=>Object.keys(e).reduce((r, t)=>{
+/**
+ * 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":
@@ -239,6 +246,38 @@ let dataParamsToTsInterfaceBody = (e)=>Object.keys(e).reduce((r, t)=>{
         return r.push(`${t}: ${s};`), r;
     }, []).join(" ");
 
+// /**
+//  * 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$4 = (t)=>utils.isString(t) || utils.isNumber(t) ? `"${t}"` : utils.isBoolean(t) ? `${t}` : utils.isArray(t) ? JSON.stringify(t) : `(${JSON.stringify(t)})`, s$6 = (e, r)=>utils.areEqual(e, r), p$2 = (t, e)=>{
     let { defaultLocale: r } = t, l = "";
     for(let t in e){
@@ -263,11 +302,22 @@ import { tPluralise } from "./tPluralise";
         });
         let $ = [
             m ? `params: { ${dataParamsToTsInterfaceBody(m)} }` : "",
+            // for ergonomy always allow the user to pass the locale
             "locale?: I18n.Locale"
         ].filter(Boolean).join(", ");
+        // const formatArgParams = params ? ", params" : "";
         l += `export let ${u} = (${$}) => `;
         let c = "";
-        utils.isPrimitive(s) ? c += i$4(s) : c += p$2(t, s), f && (c = `tPluralise(${c}, params.count)`), l += (c = m ? `tInterpolateParams(${c}, params);` : `${c};`) + `\n`;
+        utils.isPrimitive(s) ? c += i$4(s) : c += p$2(t, s), f && (c = `tPluralise(${c}, params.count)`), // TODO: t interpolation and pluralisation
+        // if (isString(values)) {
+        //   output += `toFormat(${formatArgLocale}, "${values}"${formatArgParams});`;
+        // } else {
+        //   output += `toFormat(${formatArgLocale}, ${getFunctionBodyWithLocales(
+        //     data,
+        //     values,
+        //   )}${formatArgParams});`;
+        // }
+        l += (c = m ? `tInterpolateParams(${c}, params);` : `${c};`) + `\n`;
     }
     return l;
 });
@@ -291,7 +341,8 @@ export default tInterpolateParams;
 `;
 });
 
-var l$3 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var l$3 = (()=>/* {}: I18nCompiler.AdapterArg */ `
 /* eslint-disable prefer-const */
 let pluralRules = new Intl.PluralRules();
 
@@ -460,7 +511,9 @@ export default toSpa;
 `;
 });
 
-let s$5 = [
+/**
+ * @see https://github.com/aralroca/next-translate?tab=readme-ov-file#5-plurals
+ */ let s$5 = [
     "zero",
     "one",
     "two",
@@ -468,13 +521,24 @@ let s$5 = [
     "many",
     "other"
 ], i$3 = "other";
-let isPluralSuffix = (e)=>s$5.includes(e) || utils.isNumericLiteral(e);
-let removePluralSuffix = (e)=>{
+/**
+ * Is the given string a valid plural suffix?
+ */ let isPluralSuffix = (e)=>s$5.includes(e) || utils.isNumericLiteral(e);
+/**
+ * Remove plural suffix from string
+ */ let removePluralSuffix = (e)=>{
     let [l] = utils.splitReverse(e, "_");
     return l ? e.replace(`_${l}`, "") : e;
 };
-let getPluralSuffix = (e)=>utils.splitReverse(e, "_")[0];
-let isPluralKey = (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);
 };
@@ -485,7 +549,11 @@ let a$3 = (e)=>{
         l[r] = l[r] || [], l[r].push(e);
     }), l;
 };
-let transformKeysForPlurals = (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$3)) {
         let r = l.filter(isPluralKey);
         if (r.length) {
@@ -493,7 +561,9 @@ let transformKeysForPlurals = (l)=>{
                 ...l
             ];
             return utils.forin(a$3(r), (e, r)=>{
-                l.includes(e) || t.push(e), r.forEach((e)=>{
+                // 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;
@@ -501,11 +571,24 @@ let transformKeysForPlurals = (l)=>{
     }
     return l;
 };
-let hasRequiredPluralSuffix = (e)=>isPluralKey(e) && getPluralSuffix(e) === i$3;
-let hasPlurals = (e)=>Object.keys(e).some(hasRequiredPluralSuffix) || Object.keys(e).includes(i$3);
-let hasOnlyPluralKeys = (e)=>!!hasPlurals(e) && 0 === pickNonPluralKeys(e).length;
-let pickNonPluralKeys = (e)=>Object.keys(e).filter((e)=>!isPluralSuffix(e));
-let pickNonPluralValue = (e)=>hasPlurals(e) ? utils.objectPick(e, pickNonPluralKeys(e)) : e;
+/**
+ * Check if the given key has the required plural suffix
+ */ let hasRequiredPluralSuffix = (e)=>isPluralKey(e) && getPluralSuffix(e) === i$3;
+/**
+ * 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$3);
+/**
+ * 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$1 = (e, a)=>!utils.isArray(a) && utils.isObject(a) && hasPlurals(a) ? hasOnlyPluralKeys(a) ? `"${e}": string;` : `"${e}": ${h$2(pickNonPluralValue(a))}` : `"${e}": ${h$2(a)}`, h$2 = (e)=>{
     let o = "", i = "";
@@ -518,13 +601,16 @@ let c$1 = (e, a)=>!utils.isArray(a) && utils.isObject(a) && hasPlurals(a) ? hasO
             o += "{";
             let t = transformKeysForPlurals(Object.keys(e));
             for(let a = 0; a < t.length; a++){
-                let s = t[a], n = e[s] || "";
+                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$1(s, n);
             }
             o += "};";
         }
     } else o += "";
-    return (o = o.replace(/;\[\];/g, "[];")).replace(/;+/g, ";");
+    return(// adjust syntax
+    (o = o.replace(/;\[\];/g, "[];")).replace(/;+/g, ";"));
 }, d$3 = (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++){
@@ -546,7 +632,9 @@ let c$1 = (e, a)=>!utils.isArray(a) && utils.isObject(a) && hasPlurals(a) ? hasO
     }, {}), f$1 = (e, t, a)=>{
     let s = m$4(t), n = [];
     for(let o in s){
-        let i = s[o].map((e)=>e.split(o)[1].slice(1)), r = t.byId[o].pathnames[e.defaultLocale], l = [];
+        let i = 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)), r = t.byId[o].pathnames[e.defaultLocale], l = [];
         for(let s = 0; s < i.length; s++){
             let n = i[s], p = `${o}${a.routes.tokens.idDelimiter}${n}`, c = t.byId[p].pathnames[e.defaultLocale].split(r)[1];
             l.push(`"${n}": "${c}";`);
@@ -562,8 +650,11 @@ let c$1 = (e, a)=>!utils.isArray(a) && utils.isObject(a) && hasPlurals(a) ? hasO
     }
     return a;
 };
+// TODO: probably move the  Translate types into the adapter-next-translate
+// unless we will use the same api for other adapters
 var L = (({ config: e, input: t, routes: a, options: s })=>{
-    let n = y$1(a, (e, { params: t })=>!t), o = y$1(a, (e, { params: t })=>!!t), { idDelimiter: i } = s.routes.tokens;
+    let n = y$1(a, (e, { params: t })=>!t), o = y$1(a, (e, { params: t })=>!!t), // const routeIdSpa = buildRoutesUnion(routes, (_, { inWildcard }) => inWildcard);
+    { idDelimiter: i } = s.routes.tokens;
     return `
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -938,7 +1029,8 @@ var t$2 = (()=>({
         ]
     }));
 
-var e$2 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var e$2 = (()=>/* {}: I18nCompiler.AdapterArg, */ `
 "use client";
 
 import _DynamicNamespaces from "next-translate/DynamicNamespaces";
@@ -948,7 +1040,8 @@ export const DynamicNamespaces = _DynamicNamespaces;
 export default DynamicNamespaces;
 `);
 
-var n$5 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var n$5 = (()=>/* {}: I18nCompiler.AdapterArg, */ `
 "use client";
 
 import type { TransProps } from "next-translate";
@@ -980,7 +1073,8 @@ export const T = Trans as typeof TypedT;
 export default T;
 `);
 
-var t$1 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var t$1 = (()=>/* {}: I18nCompiler.AdapterArg, */ `
 "use client";
 
 import _TransText from "next-translate/TransText";
@@ -990,7 +1084,8 @@ export const TransText = _TransText;
 export default TransText;
 `);
 
-var m$3 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var m$3 = (()=>/* {}: I18nCompiler.AdapterArg, */ `
 import _getT from "next-translate/getT";
 import type { I18n } from "./types";
 
@@ -1026,7 +1121,8 @@ module.exports = (config = { pages: {} }) => {
 }
 `);
 
-var a$2 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var a$2 = (()=>/* {}: I18nCompiler.AdapterArg, */ `
 "use client";
 
 import { useMemo } from "react";
@@ -1114,31 +1210,48 @@ var a$1 = (()=>({
         ]
     }));
 
-function transformPathname(e, t) {
+/**
+ * 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 r$3(e) {
     let { localeSource: o, localeDestination: l, template: r, pathname: i, permanent: a } = e, n = formatRoutePathname.formatRoutePathname((o ? `${o}/` : "") + r), c = formatRoutePathname.formatRoutePathname((l ? `${l}/` : "") + i);
+    // console.log(`redirect template "${source}" to pathname "${destination}"`);
     if (n !== c) return {
         source: n,
         destination: c,
         permanent: !!a
     };
 }
-let generateRedirects = (t, i, a, n = "", c = !1)=>{
+/**
+ * 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 = (t, i, a, n = "", c = !1)=>{
     let { defaultLocale: s, hideDefaultLocaleInUrl: p } = t, u = RegExp(utils.escapeRegExp(a.tokens.idDelimiter), "g"), m = [];
     for(let e in i){
         let o = i[e], t = i[e].pathnames;
         for(let i in t){
-            let a = t[i], f = transformPathname(e.replace(u, "/"), o.wildcard), d = transformPathname(a, o.wildcard);
+            let a = t[i], // prettier-ignore
+            f = transformPathname(e.replace(u, "/"), o.wildcard), d = transformPathname(a, o.wildcard);
+            // we do not redirect urls children of wildcard urls
             if (o.inWildcard) break;
             let h = i === s, D = h && !p, g = h && p, k = {
                 template: f,
                 pathname: d,
                 permanent: c
             };
-            n ? D ? m.push(r$3({
+            n ? // app router:
+            D ? m.push(r$3({
                 ...k,
                 localeDestination: i
             })) : g ? m.push(r$3({
@@ -1148,7 +1261,8 @@ let generateRedirects = (t, i, a, n = "", c = !1)=>{
                 ...k,
                 localeSource: i,
                 localeDestination: i
-            })) : d !== f && (D ? m.push(r$3({
+            })) : // pages router:
+            d !== f && (D ? m.push(r$3({
                 ...k,
                 localeDestination: i
             })) : h ? m.push(r$3(k)) : m.push(r$3({
@@ -1177,47 +1291,75 @@ function o$5(e) {
     t && (a = `/${t}`);
     let n = formatRoutePathname.formatRoutePathname(a + i), c = "";
     r && (c = `/${r}`);
+    // else if (localeParam) destinationPrefix = `/:${localeParam}`;
     let s = formatRoutePathname.formatRoutePathname(c + o);
+    // console.log(`rewrite pathname "${source}" to template "${destination}"`);
     if (n !== s) return {
         source: n,
         destination: s
     };
 }
 let i$2 = (e, t = "", l, r, i, a)=>{
-    let { defaultLocale: n, hideDefaultLocaleInUrl: c } = e, s = l === n && c, u = {
+    let { defaultLocale: n, hideDefaultLocaleInUrl: c } = e, s = l === n && c, // TODO: maybe support other locales to be hidden in the URL other than the default?
+    u = {
         config: e,
         template: r,
         pathname: i
     };
-    t ? s ? a.push(o$5({
+    t ? // app router:
+    s ? a.push(o$5({
         ...u,
         localeDestination: l
-    })) : a.push(o$5({
+    })) : a.push(// prettier-ignore
+    o$5({
         ...u,
         localeSource: l,
         localeDestination: l
-    })) : i !== r && (s ? a.push(o$5(u)) : a.push({
+    })) : // 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
+    i !== r && (s ? a.push(o$5(u)) : a.push({
         ...o$5({
             ...u,
             localeSource: l
         }),
+        // this 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
         locale: !1
     }));
 };
-let generateRewrites = (l, o, a, n = "")=>{
+/**
+ * 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 = (l, o, a, n = "")=>{
     let c = RegExp(utils.escapeRegExp(a.tokens.idDelimiter), "g"), s = [];
     for(let e in o){
         let t = o[e], a = o[e].pathnames;
         for(let o in a){
             let u = a[o], p = e.replace(c, "/");
+            // we do not rewrite urls children of wildcard urls
             if (t.inWildcard) break;
-            i$2(l, n, o, transformPathname(p), transformPathname(u), s), t.wildcard && i$2(l, n, o, transformPathname(p, t.wildcard), transformPathname(u, t.wildcard), s);
+            // we need to rewrite both the root path...
+            i$2(l, n, o, transformPathname(p), transformPathname(u), s), t.wildcard && // and for wildcard routes the ones with the `/:segment*` portion
+            i$2(l, n, o, transformPathname(p, t.wildcard), transformPathname(u, t.wildcard), s);
         }
     }
+    // simple sort by destination:
+    // return a.destination.localeCompare(b.destination);
+    // sort by locale
+    // return a.
     return utils.arrayUniqueByProperties(s.filter(Boolean), [
         "source",
         "destination"
-    ]).sort((e, t)=>e.source.localeCompare(t.source));
+    ]).sort((e, t)=>// simple sort by source:
+        e.source.localeCompare(t.source));
 };
 
 var t = (({ config: e, routes: t, options: o })=>{
@@ -1225,7 +1367,8 @@ var t = (({ config: e, routes: t, options: o })=>{
     return `module.exports = ${l}`;
 });
 
-var n$4 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var n$4 = (()=>/* {}: I18nCompiler.AdapterArg, */ `
 "use client";
 
 import { useEffect, useState } from "react";
@@ -1255,7 +1398,8 @@ export const useLocale = () => (useRouter().locale as I18n.Locale) || "${e.defau
 export default useLocale;
 `);
 
-var r$2 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var r$2 = (()=>/* {}: I18nCompiler.AdapterArg, */ `
 import { useRouter } from "next/router";
 import type { I18n } from "./types";
 import { pathnameToRouteId } from "./pathnameToRouteId";
@@ -1266,7 +1410,8 @@ export const useRouteId = () =>
 export default useRouteId;
 `);
 
-var o$4 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var o$4 = (()=>/* {}: I18nCompiler.AdapterArg */ `
 "use client";
 
 import { to } from "./to";
@@ -1293,7 +1438,8 @@ export const useTo = () => {
 export default useTo;
 `);
 
-var m$2 = (()=>`
+// import type { I18nCompiler } from "../../compiler/types";
+var m$2 = (()=>/* {}: I18nCompiler.AdapterArg */ `
 "use client";
 
 import { toSpa } from "./toSpa";
@@ -1333,6 +1479,8 @@ var n$3 = (()=>({
             "js"
         ],
         files: [
+            // TODO: maybe remove these files, they are useful for debugging for now
+            // but probably will be useless
             {
                 name: "next-redirects",
                 fn: e$1,
@@ -1385,13 +1533,26 @@ let r$1 = {
     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 = async (t, a, n = [])=>{
+}, /**
+ * Recursively builds a list of adapters to use based on the `dependsOn` array
+ * of the choosen adapter
+ */ s$2 = async (t, a, n = [])=>{
     let o = (0, r$1[a])(t), d = utils.isPromise(o) ? await o : o;
     return n = n.concat(d), d.dependsOn && await Promise.all(d.dependsOn.map(async (e)=>{
         n = n.concat(await s$2(t, e));
     })), n;
 }, l$2 = (e, t, a)=>{
-    let { outputFiles: n } = t, r = a.reduce((e, t)=>[
+    let { outputFiles: n } = t, // 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",
+    //   });
+    // }
+    r = a.reduce((e, t)=>[
             ...e,
             ...t.files
         ], []).map((t)=>{
@@ -1402,23 +1563,39 @@ let r$1 = {
             content: a(e)
         };
     });
-    return o$3(r) && r.push({
+    return(// automatically create an index file if the adapters want it
+    o$3(r) && r.push({
         name: "index",
         ext: "ts",
         content: o$3(r)
     }), {
         files: r,
+        // it is enough that just one adapter requires this
         needsTranslationsFiles: a.some((e)=>e.needsTranslationsFiles)
-    };
+    });
 };
+// 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 generateCode = async (e, t)=>l$2(e, t, await s$2(e, t.adapter));
 
-let tsCompile = (o, i, s, r)=>{
+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,
@@ -1430,13 +1607,26 @@ let tsCompile = (o, i, s, r)=>{
         noEmitHelpers: !0,
         importHelpers: !0,
         ...r || {}
-    }, a = t__namespace.createProgram(l, n), m = a.emit();
-    return t__namespace.getPreEmitDiagnostics(a).concat(m.diagnostics).forEach((e)=>{
+    }, // 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, e.start), s = t__namespace.flattenDiagnosticMessageText(e.messageText, "\n");
+            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;
+    }), m);
 };
 
 let n$2 = async (e, r, s, i)=>Promise.all(s.files.map(async ({ name: s, ext: o, content: n })=>{
@@ -1445,7 +1635,8 @@ let n$2 = async (e, r, s, i)=>Promise.all(s.files.map(async ({ name: s, ext: o,
     })), 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")), s.delete(i), node_fs.rmSync(node_path.join(a, r, 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
         });
     });
@@ -1459,24 +1650,40 @@ let n$2 = async (e, r, s, i)=>Promise.all(s.files.map(async ({ name: s, ext: o,
             ...s
         ])).sort().map((e)=>`/${e}`).join(`\n`)
     ];
-let writeCode = async (e, t)=>{
+/**
+   * @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, ...c } = e, w = await generateCode(t, c), y = new Set(), S = new Set();
     await n$2(r, i, w, y), o || d$2(r, i, y), w.needsTranslationsFiles && !p && await m$1(r, i, t.input, S), l || await node.fsWrite(...f(r, i, S, y));
 };
 
 const codeDataRoutesOptions = {
-    translationJsonFileName: "~.json",
-    fnsPrefix: "",
+    /** @default  "~.json" */ translationJsonFileName: "~.json",
+    /**
+   * Generated `route_id()` functions prefix, prepended to the automatically
+   * generated function names.
+   *
+   * @default ""
+   */ fnsPrefix: "",
     tokens: {
-        parentReference: "^",
-        idDelimiter: ".",
-        catchAll: {
-            start: "[...",
-            end: "]"
+        /** @default  "^" */ parentReference: "^",
+        /** @default  "." */ idDelimiter: ".",
+        /**
+     * @see https://nextjs.org/docs/pages/building-your-application/routing/dynamic-routes#catch-all-segments
+     */ catchAll: {
+            /** @default  "[..." */ start: "[...",
+            /** @default  "]" */ end: "]"
         },
-        optionalCatchAll: {
-            start: "[[...",
-            end: "]]"
+        /**
+     * @see https://nextjs.org/docs/pages/building-your-application/routing/dynamic-routes#optional-catch-all-segments
+     */ optionalCatchAll: {
+            /** @default  "[[..." */ start: "[[...",
+            /** @default  "]]" */ end: "]]"
         }
     }
 };
@@ -1493,20 +1700,51 @@ let r = (t, a)=>{
             optionalCatchAll: RegExp(`${utils.escapeRegExp(d.start)}(.+)${utils.escapeRegExp(d.end)}$`)
         }
     };
-}, d$1 = (e, { reg: t })=>{
+}, /**
+ * 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
     };
-}, i$1 = (e)=>formatRoutePathname.formatRoutePathname(e.replace(/\*/g, "").replace(/[[{]{1,2}(.*?)[\]}]{1,2}/g, (e, t)=>`[${t.trim()}]`)), s$1 = (e)=>{
+}, /**
+ * 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)=>formatRoutePathname.formatRoutePathname(e.replace(/\*/g, "").replace(/[[{]{1,2}(.*?)[\]}]{1,2}/g, (e, t)=>`[${t.trim()}]`)), /**
+ * 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)=>(e[t] = "stringOrNumber", e), {});
-}, p = (e, t, a, l, n)=>{
+    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;
@@ -1514,16 +1752,50 @@ let r = (t, a)=>{
         }
     }
     return o;
-}, o$2 = (e, t)=>{
+}, /**
+ * 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);
-}, c = (e, t)=>{
+}, /**
+ * 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)e.byId[l].pathnamesSpa[n] = p(e, t, n, l, a);
-        else delete e.byId[l].pathnamesSpa;
+        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;
     }
-}, m = (e, t)=>{
+}, /**
+ * 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 = {};
@@ -1531,26 +1803,44 @@ let r = (t, a)=>{
             let t = r[e];
             t !== d && (i[e] = t);
         }
-        Object.keys(i).length === n.length - 1 || (Object.keys(i).length >= 1 ? (i[a] = d, e.byId[t].pathnamesSlim = utils.objectSortByKeysMatching(i, a)) : e.byId[t].pathnamesSlim = d);
+        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);
     }
-}, h$1 = (e)=>{
+}, /**
+ * 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], { routeId: a, isCatchAll: c, isOptionalCatchAll: m } = d$1(e, r);
+        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 || {}, p.byId[a].pathnames[n] = i$1(t), p.byId[a].pathnames = utils.objectSortByKeysMatching(p.byId[a].pathnames, r.defaultLocale), p.byId[a].pathnamesSpa = {
+        p.byId[a].pathnames = p.byId[a].pathnames || {}, // prettier-ignore
+        p.byId[a].pathnames[n] = i$1(t), // 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);
 };
-let getCodeDataRoutes = (e, t, { translationFiles: a })=>{
+/**
+ * Get routes data
+ */ let getCodeDataRoutes = (e, t, { translationFiles: a })=>{
     let l = {
         byId: {},
         wildcardIds: []
@@ -1559,28 +1849,79 @@ let getCodeDataRoutes = (e, t, { translationFiles: a })=>{
         let { path: r, locale: d, data: i } = a[e];
         r === t.translationJsonFileName && I(i, d, n, l);
     }
-    return h$1(l), c(l, n), o$2(l, n), m(l, 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 = {
-    ignorePaths: [],
+    /**
+   * A list of globs to run against source files, those that are matched will be
+   * ignored
+   *
+   * @see https://www.npmjs.com/package/minimatch
+   */ ignorePaths: [],
     dynamicDelimiters: {
         start: "{{",
         end: "}}"
     },
-    fnsAsDataCodes: !0,
-    fnsPrefix: "",
-    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: "",
+    /**
+   * 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
 };
-let g = RegExp(node_path.sep, "g"), v = (e)=>{
-    let t = e.replace(/~/g, "$").replace(/-/g, "_").replace(g, "_").replace(/_+/g, "_").replace(/[^a-zA-Z0-9_$]/gi, "");
+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.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)=>(e[t] = "stringOrNumber", e), {});
+        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), {});
     }
-}, y = (e, t, r = {})=>{
+}, /**
+ * 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 = {
@@ -1603,20 +1944,67 @@ let g = RegExp(node_path.sep, "g"), v = (e)=>{
         });
     }
     return {};
-}, _ = (e, t)=>(Object.keys(t).filter(isPluralKey).forEach((r)=>{
+}, // 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);
-        if (t[a] = t[a] || {}, t[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)=>{
-                s[r] = utils.isObject(s[r]) ? s[r] : {}, s[r][l] = 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), delete t[r];
+            }), 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), x = (e, t, r, a, l)=>{
+    }), 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);
@@ -1626,12 +2014,17 @@ let g = RegExp(node_path.sep, "g"), v = (e)=>{
             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;
-}, A = (l, s, i)=>{
+}, /**
+ * Get translation data recursively starting from a specific file
+ */ A = (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];
@@ -1639,10 +2032,14 @@ let g = RegExp(node_path.sep, "g"), v = (e)=>{
     }
     return i;
 };
-let getCodeDataTranslations = (e, t, { translationFiles: r })=>{
+/**
+ * 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))) && A(t, r[e], l);
-    return utils.objectSort(l = _(t, l));
+    // console.log("generateTypes: outputDir", outputDir, "outputPath", outputPath);
+    return(// sort
+    utils.objectSort(l = _(t, l)));
 };
 
 let e = {
@@ -1651,7 +2048,8 @@ let e = {
 };
 let getCodeData = (o, s, l)=>{
     let n = utils.objectMergeWithDefaults(e, s);
-    return n.translations.ignorePaths.push(n.routes.translationJsonFileName), l = {
+    return n.translations.ignorePaths.push(n.routes.translationJsonFileName), // order locales
+    l = {
         ...l,
         localesFolders: l.localesFolders.sort((t, a)=>o.defaultLocale ? -1 : t.localeCompare(a))
     }, {
@@ -1670,13 +2068,24 @@ const configDefaults = {
     defaultLocale: "en",
     hideDefaultLocaleInUrl: !0
 };
-let getConfig = (e, o = {})=>{
-    o.locales = o.locales || e.localesFolders, o.defaultLocale = o.defaultLocale || o.locales?.[0], o.hideDefaultLocaleInUrl = !!o.hideDefaultLocaleInUrl;
+/**
+ * Get basic i18n compiler config with defaults and automatic inference from
+ * input data
+ */ let getConfig = (e, o = {})=>{
+    // dynamically define locales
+    o.locales = o.locales || e.localesFolders, // ensure defaultLocale
+    o.defaultLocale = o.defaultLocale || o.locales?.[0], // ensure boolean value
+    o.hideDefaultLocaleInUrl = !!o.hideDefaultLocaleInUrl;
     let a = utils.objectMergeWithDefaults(configDefaults, o);
-    return a.locales = a.locales.sort((l, e)=>a.defaultLocale ? -1 : l.localeCompare(e)), a;
+    return(// ensure sorted locales
+    a.locales = a.locales.sort((l, e)=>a.defaultLocale ? -1 : l.localeCompare(e)), a);
 };
 
-let n$1 = (e, r)=>{
+/**
+   * @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),
@@ -1696,7 +2105,10 @@ let l$1 = (e)=>{
             ...a,
             "node_modules/**"
         ]
-    }).filter((e)=>e.isDirectory()).map((e)=>e.relative()).sort((e, t)=>e.localeCompare(t));
+    }).// 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({
@@ -1722,8 +2134,12 @@ let getInputDataLocal = async (e)=>{
     };
 };
 
-let getInputDataRemote = async (r)=>new Promise((l, o)=>{
-        let { ignore: a = [], source: s } = r, n = s.startsWith("https://raw.githubusercontent.com"), i = "", c = node_https.request(s, 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"
             }
@@ -1770,14 +2186,19 @@ let o$1 = (e, t = {})=>{
     };
 };
 const summaryDataOptions = {};
-let getSummaryData = (o, a, { translationFiles: i })=>{
+/**
+   * 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(n = utils.objectSortByKeysMatching(n, f), (t, l)=>{
-        n[t].characters = utils.arraySum(l.files.map((e)=>e.characters)), 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)), n[t] = utils.objectSort(n[t]);
+    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;
 };
 
@@ -1807,7 +2228,15 @@ let l = (e)=>{
 }, 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));
 
-let i = (t, e, o, i)=>[
+/**
+   * @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)=>[
@@ -1819,8 +2248,14 @@ let writeSummary = async (r, e)=>{
     return m && await node.fsWrite(...i(r, e, o, m)), a && await node.fsWrite(...n(p, e, o, a)), e;
 };
 
-let i18nCompiler = async (a)=>{
-    let { input: u, code: w, summary: s, ...n } = a, f = [], l = await getInputData(u), c = getConfig(l, n), h = getCodeData(c, w, l);
+/**
+ * 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
@@ -1832,7 +2267,37 @@ let i18nCompiler = async (a)=>{
         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.generateRedirects = generateRedirects;
 exports.generateRewrites = generateRewrites;