i18next-cli 1.49.0 → 1.49.1

package/dist/cjs/cli.js

@@ -31,7 +31,7 @@ const program = new commander.Command();
 program
     .name('i18next-cli')
     .description('A unified, high-performance i18next CLI.')
-    .version('1.49.0'); // This string is replaced with the actual version at build time by rollup
+    .version('1.49.1'); // This string is replaced with the actual version at build time by rollup
 // new: global config override option
 program.option('-c, --config <path>', 'Path to i18next-cli config file (overrides detection)');
 program

package/dist/cjs/extractor/core/ast-visitors.js

@@ -301,6 +301,18 @@ class ASTVisitors {
         }
         this.hooks.onAfterVisitNode?.(node);
         // --- END VISIT LOGIC ---
+        // Detect array iteration calls (.map / .forEach / .flatMap etc.) on a known
+        // as-const array so the callback parameter is bound to the array values while
+        // the callback body is walked.  We inject the binding BEFORE generic recursion
+        // and remove it AFTER, so the whole subtree sees the correct value.
+        let arrayCallbackCleanup;
+        if (node.type === 'CallExpression') {
+            const info = this.tryGetArrayIterationCallbackInfo(node);
+            if (info) {
+                this.expressionResolver.setTemporaryVariable(info.paramName, info.values);
+                arrayCallbackCleanup = () => this.expressionResolver.deleteTemporaryVariable(info.paramName);
+            }
+        }
         // --- RECURSION ---
         // Recurse into the children of the current node
         for (const key in node) {
@@ -308,49 +320,112 @@ class ASTVisitors {
                 continue;
             const child = node[key];
             if (Array.isArray(child)) {
-                // Pre-scan array children to register VariableDeclarator-based scopes
-                // (e.g., `const { t } = useTranslation(...)`) before walking the rest
-                // of the items. This ensures that functions/arrow-functions defined
-                // earlier in the same block that reference t will resolve to the
-                // correct scope even if the `useTranslation` declarator appears later.
+                // Pre-scan array children in THREE passes:
+                //   Pass 1 — variables WITH init (arrays, objects, strings, fns) + enums
+                //   Pass 2 — type aliases + functions (may depend on pass-1 arrays)
+                //   Pass 3 — `declare const x: Type` (no init; depends on pass-2 type aliases)
+                // This ordering ensures e.g.:
+                //   const OPTS = ['a','b'] as const          → pass 1
+                //   type T = (typeof OPTS)[number]            → pass 2 (resolves OPTS)
+                //   declare const v: T                        → pass 3 (resolves T)
+                // ── Pass 1: variables with init ──────────────────────────────────────
                 for (const item of child) {
                     if (!item || typeof item !== 'object')
                         continue;
-                    // Direct declarator present in arrays (rare)
-                    if (item.type === 'VariableDeclarator') {
+                    // Direct declarator (rare)
+                    if (item.type === 'VariableDeclarator' && item.init) {
                         this.scopeManager.handleVariableDeclarator(item);
                         this.expressionResolver.captureVariableDeclarator(item);
                         continue;
                     }
-                    // enum declarations can appear as ExportDeclaration.declaration earlier; be permissive
-                    if (item && item.id && Array.isArray(item.members)) {
+                    // enum declarations
+                    if (item.id && Array.isArray(item.members)) {
                         this.expressionResolver.captureEnumDeclaration(item);
-                        // continue to allow further traversal
                     }
-                    // pre-scan type alias declarations and function declarations
+                    // Bare VariableDeclaration — only declarators that have an init
+                    if (item.type === 'VariableDeclaration' && Array.isArray(item.declarations)) {
+                        for (const decl of item.declarations) {
+                            if (decl?.type === 'VariableDeclarator' && decl.init) {
+                                this.scopeManager.handleVariableDeclarator(decl);
+                                this.expressionResolver.captureVariableDeclarator(decl);
+                            }
+                        }
+                    }
+                    // ExportDeclaration wrapping VariableDeclaration — only inited declarators
+                    if ((item.type === 'ExportDeclaration' || item.type === 'ExportNamedDeclaration') && item.declaration) {
+                        const inner = item.declaration;
+                        if (inner.type === 'VariableDeclaration' && Array.isArray(inner.declarations)) {
+                            for (const vd of inner.declarations) {
+                                if (vd?.type === 'VariableDeclarator' && vd.init) {
+                                    this.scopeManager.handleVariableDeclarator(vd);
+                                    this.expressionResolver.captureVariableDeclarator(vd);
+                                }
+                            }
+                        }
+                    }
+                }
+                // ── Pass 2: type aliases + functions ─────────────────────────────────
+                for (const item of child) {
+                    if (!item || typeof item !== 'object')
+                        continue;
                     if (item.type === 'TsTypeAliasDeclaration' || item.type === 'TSTypeAliasDeclaration' || item.type === 'TsTypeAliasDecl') {
                         this.expressionResolver.captureTypeAliasDeclaration(item);
                     }
                     if (item.type === 'FunctionDeclaration' || item.type === 'FnDecl') {
                         this.expressionResolver.captureFunctionDeclaration(item);
                     }
-                    // Also handle ExportDeclaration wrapping either of the above
                     if ((item.type === 'ExportDeclaration' || item.type === 'ExportNamedDeclaration') && item.declaration) {
-                        const decl = item.declaration;
-                        if (decl.type === 'TsTypeAliasDeclaration' || decl.type === 'TSTypeAliasDeclaration' || decl.type === 'TsTypeAliasDecl') {
-                            this.expressionResolver.captureTypeAliasDeclaration(decl);
+                        const inner = item.declaration;
+                        if (inner.type === 'TsTypeAliasDeclaration' || inner.type === 'TSTypeAliasDeclaration' || inner.type === 'TsTypeAliasDecl') {
+                            this.expressionResolver.captureTypeAliasDeclaration(inner);
                         }
-                        if (decl.type === 'FunctionDeclaration' || decl.type === 'FnDecl') {
-                            this.expressionResolver.captureFunctionDeclaration(decl);
+                        if (inner.type === 'FunctionDeclaration' || inner.type === 'FnDecl') {
+                            this.expressionResolver.captureFunctionDeclaration(inner);
                         }
                     }
-                    // Common case: VariableDeclaration which contains .declarations (VariableDeclarator[])
+                }
+                // ── Pass 3: `declare const x: Type` — no init, depends on type aliases ─
+                // Also re-processes ArrayPattern destructuring (e.g. useState<T>) whose
+                // type argument resolution failed in Pass 1 because typeAliasTable was empty.
+                for (const item of child) {
+                    if (!item || typeof item !== 'object')
+                        continue;
+                    // Direct declarator with no init
+                    if (item.type === 'VariableDeclarator' && !item.init) {
+                        this.scopeManager.handleVariableDeclarator(item);
+                        this.expressionResolver.captureVariableDeclarator(item);
+                        continue;
+                    }
+                    // ArrayPattern destructuring with init — re-run now that type aliases are populated
+                    if (item.type === 'VariableDeclarator' && item.init && item.id?.type === 'ArrayPattern') {
+                        this.expressionResolver.captureVariableDeclarator(item);
+                        continue;
+                    }
+                    // VariableDeclaration — process no-init declarators and re-process ArrayPattern ones
                     if (item.type === 'VariableDeclaration' && Array.isArray(item.declarations)) {
                         for (const decl of item.declarations) {
-                            if (decl && typeof decl === 'object' && decl.type === 'VariableDeclarator') {
+                            if (!decl.init) {
                                 this.scopeManager.handleVariableDeclarator(decl);
                                 this.expressionResolver.captureVariableDeclarator(decl);
                             }
+                            else if (decl.id?.type === 'ArrayPattern') {
+                                this.expressionResolver.captureVariableDeclarator(decl);
+                            }
+                        }
+                    }
+                    // ExportDeclaration wrapping — same logic
+                    if ((item.type === 'ExportDeclaration' || item.type === 'ExportNamedDeclaration') && item.declaration) {
+                        const inner = item.declaration;
+                        if (inner.type === 'VariableDeclaration' && Array.isArray(inner.declarations)) {
+                            for (const vd of inner.declarations) {
+                                if (!vd.init) {
+                                    this.scopeManager.handleVariableDeclarator(vd);
+                                    this.expressionResolver.captureVariableDeclarator(vd);
+                                }
+                                else if (vd.id?.type === 'ArrayPattern') {
+                                    this.expressionResolver.captureVariableDeclarator(vd);
+                                }
+                            }
                         }
                     }
                 }
@@ -370,11 +445,60 @@ class ASTVisitors {
             }
         }
         // --- END RECURSION ---
+        // Remove temporary callback param binding if one was injected for this node
+        arrayCallbackCleanup?.();
         // LEAVE SCOPE for functions
         if (isNewScope) {
             this.scopeManager.exitScope();
         }
     }
+    /**
+     * If `node` is a call like `ARRAY.map(param => ...)` where ARRAY is a known
+     * string-array constant, returns the callback's first parameter name and the
+     * array values so the caller can inject a temporary variable binding.
+     */
+    tryGetArrayIterationCallbackInfo(node) {
+        try {
+            const callee = node.callee;
+            if (callee?.type !== 'MemberExpression')
+                return undefined;
+            const prop = callee.property;
+            if (prop?.type !== 'Identifier')
+                return undefined;
+            if (!['map', 'forEach', 'flatMap', 'filter', 'find', 'some', 'every'].includes(prop.value))
+                return undefined;
+            // The object must be an identifier whose value is a known string array
+            const obj = callee.object;
+            if (obj?.type !== 'Identifier')
+                return undefined;
+            const values = this.expressionResolver.getVariableValues(obj.value);
+            if (!values || values.length === 0)
+                return undefined;
+            // First argument must be a callback with at least one parameter
+            const callbackArg = node.arguments?.[0]?.expression;
+            if (!callbackArg)
+                return undefined;
+            // Normalise param across SWC shapes: ArrowFunctionExpression / FunctionExpression
+            const params = callbackArg.params ?? callbackArg.parameters ?? [];
+            const firstParam = params[0];
+            if (!firstParam)
+                return undefined;
+            // SWC wraps params in `Param { pat: Identifier }` or exposes them directly
+            const ident = firstParam.type === 'Identifier'
+                ? firstParam
+                : firstParam.type === 'Param' && firstParam.pat?.type === 'Identifier'
+                    ? firstParam.pat
+                    : firstParam.type === 'AssignmentPattern' && firstParam.left?.type === 'Identifier'
+                        ? firstParam.left
+                        : null;
+            if (!ident)
+                return undefined;
+            return { paramName: ident.value, values };
+        }
+        catch {
+            return undefined;
+        }
+    }
     /**
      * Retrieves variable information from the scope chain.
      * Searches from innermost to outermost scope.

package/dist/cjs/extractor/parsers/expression-resolver.js

@@ -12,6 +12,15 @@ class ExpressionResolver {
     // Per-file table for type aliases: Maps typeName -> string[]
     // e.g. `type ChangeType = 'all' | 'next' | 'this'` -> { ChangeType: ['all', 'next', 'this'] }
     typeAliasTable = new Map();
+    // Shared (cross-file) table for string-array constants (e.g. `as const` arrays).
+    // Persists across resetFileSymbols() so exported arrays are visible to importers.
+    sharedVariableTable = new Map();
+    // Shared (cross-file) table for type aliases — populated alongside typeAliasTable.
+    // Persists across resetFileSymbols() so exported type aliases are visible to importers.
+    sharedTypeAliasTable = new Map();
+    // Temporary per-scope variable overrides, used to inject .map() / .forEach()
+    // callback parameters while the callback body is being walked.
+    temporaryVariables = new Map();
     constructor(hooks) {
         this.hooks = hooks;
     }
@@ -21,6 +30,7 @@ class ExpressionResolver {
     resetFileSymbols() {
         this.variableTable.clear();
         this.typeAliasTable.clear();
+        this.temporaryVariables.clear();
     }
     /**
      * Capture a VariableDeclarator node to record simple statically analyzable
@@ -36,6 +46,41 @@ class ExpressionResolver {
         try {
             if (!node || !node.id)
                 return;
+            // ── ArrayPattern id: `const [x, y] = fn<T>(...)` ────────────────────────
+            // Handles `const [state] = useState<'a'|'b'>('a')` or similar generic calls
+            // where the type argument is a finite string-literal union.
+            if (node.id.type === 'ArrayPattern' && node.init) {
+                const init = node.init;
+                // Unwrap await / as-expressions
+                let callExpr = init;
+                while (callExpr?.type === 'AwaitExpression')
+                    callExpr = callExpr.argument;
+                while (callExpr?.type === 'TsConstAssertion' ||
+                    callExpr?.type === 'TsAsExpression' ||
+                    callExpr?.type === 'TsSatisfiesExpression')
+                    callExpr = callExpr.expression;
+                if (callExpr?.type === 'CallExpression') {
+                    const typeArgs = callExpr.typeArguments?.params ??
+                        callExpr.typeParameters?.params ??
+                        [];
+                    if (typeArgs.length > 0) {
+                        const vals = this.resolvePossibleStringValuesFromType(typeArgs[0]);
+                        if (vals.length > 0) {
+                            // Bind each array-pattern element: first element is the state variable
+                            for (const el of node.id.elements) {
+                                if (!el)
+                                    continue;
+                                const ident = el.type === 'Identifier' ? el : (el.type === 'AssignmentPattern' && el.left?.type === 'Identifier' ? el.left : null);
+                                if (ident) {
+                                    this.variableTable.set(ident.value, vals);
+                                }
+                                break; // only bind the first element (the state value, not the setter)
+                            }
+                        }
+                    }
+                }
+                return;
+            }
             // only handle simple identifier bindings like `const x = ...`
             if (node.id.type !== 'Identifier')
                 return;
@@ -86,6 +131,24 @@ class ExpressionResolver {
                     return;
                 }
             }
+            // ArrayExpression -> list of string values
+            // Handles `const OPTS = ['a', 'b', 'c'] as const`
+            if (unwrappedInit.type === 'ArrayExpression' && Array.isArray(unwrappedInit.elements)) {
+                const vals = [];
+                for (const elem of unwrappedInit.elements) {
+                    if (!elem || !elem.expression)
+                        continue;
+                    const resolved = this.resolvePossibleStringValuesFromExpression(elem.expression);
+                    if (resolved.length === 1)
+                        vals.push(resolved[0]);
+                }
+                if (vals.length > 0) {
+                    this.variableTable.set(name, vals);
+                    // Also share so importing files can see this array
+                    this.sharedVariableTable.set(name, vals);
+                    return;
+                }
+            }
             // For other initializers, try to resolve to one-or-more strings
             const vals = this.resolvePossibleStringValuesFromExpression(init);
             if (vals.length > 0) {
@@ -129,6 +192,8 @@ class ExpressionResolver {
             const vals = this.resolvePossibleStringValuesFromType(tsType);
             if (vals.length > 0) {
                 this.typeAliasTable.set(name, vals);
+                // Also share so importing files can resolve this alias by name
+                this.sharedTypeAliasTable.set(name, vals);
             }
         }
         catch {
@@ -180,6 +245,33 @@ class ExpressionResolver {
             return raw.typeAnnotation;
         return raw;
     }
+    /**
+     * Temporarily bind a variable name to a set of string values.
+     * Used by ast-visitors to inject .map()/.forEach() callback parameters.
+     * Call deleteTemporaryVariable() after walking the callback body.
+     */
+    setTemporaryVariable(name, values) {
+        this.temporaryVariables.set(name, values);
+    }
+    /**
+     * Remove a previously-injected temporary variable binding.
+     */
+    deleteTemporaryVariable(name) {
+        this.temporaryVariables.delete(name);
+    }
+    /**
+     * Return the array values stored for a variable name, checking all tables.
+     * Returns undefined if the name is not a known string array.
+     */
+    getVariableValues(name) {
+        const tmp = this.temporaryVariables.get(name);
+        if (tmp)
+            return tmp;
+        const v = this.variableTable.get(name);
+        if (Array.isArray(v))
+            return v;
+        return this.sharedVariableTable.get(name);
+    }
     /**
      * Capture a TypeScript enum declaration so members can be resolved later.
      * Accepts SWC node shapes like `TsEnumDeclaration` / `TSEnumDeclaration`.
@@ -421,9 +513,18 @@ class ExpressionResolver {
         }
         // Identifier resolution via captured per-file variable table only
         if (expression.type === 'Identifier') {
+            // Check temporary (callback param) overrides first
+            const tmp = this.temporaryVariables.get(expression.value);
+            if (tmp)
+                return tmp;
             const v = this.variableTable.get(expression.value);
-            if (!v)
+            if (!v) {
+                // Fall back to shared cross-file array table
+                const sv = this.sharedVariableTable.get(expression.value);
+                if (sv)
+                    return sv;
                 return [];
+            }
             if (Array.isArray(v))
                 return v;
             // object map - cannot be used directly as key, so return empty
@@ -433,6 +534,11 @@ class ExpressionResolver {
         return [];
     }
     resolvePossibleStringValuesFromType(type, returnEmptyStrings = false) {
+        // Unwrap TsParenthesizedType — SWC explicitly emits these for grouped types like
+        // `(typeof X)[number]` where `(typeof X)` becomes TsParenthesizedType { typeAnnotation: TsTypeQuery }
+        if (type.type === 'TsParenthesizedType') {
+            return this.resolvePossibleStringValuesFromType(type.typeAnnotation, returnEmptyStrings);
+        }
         if (type.type === 'TsUnionType') {
             return type.types.flatMap((t) => this.resolvePossibleStringValuesFromType(t, returnEmptyStrings));
         }
@@ -456,11 +562,38 @@ class ExpressionResolver {
                 ? type.typeName.value
                 : undefined;
             if (typeName) {
-                const aliasVals = this.typeAliasTable.get(typeName);
+                const aliasVals = this.typeAliasTable.get(typeName) ?? this.sharedTypeAliasTable.get(typeName);
                 if (aliasVals && aliasVals.length > 0)
                     return aliasVals;
             }
         }
+        // `(typeof ACCESS_OPTIONS)[number]` — resolve through the shared array variable table.
+        // SWC emits: TsIndexedAccessType {
+        //   objectType: TsParenthesizedType { typeAnnotation: TsTypeQuery { exprName: Identifier } }
+        //   indexType: TsKeywordType
+        // }
+        // The parens around `typeof X` produce a TsParenthesizedType wrapper that we must unwrap.
+        if (type.type === 'TsIndexedAccessType') {
+            try {
+                let objType = type.objectType;
+                // Unwrap TsParenthesizedType wrapper (SWC preserves explicit parens in type positions)
+                while (objType?.type === 'TsParenthesizedType') {
+                    objType = objType.typeAnnotation;
+                }
+                if (objType?.type === 'TsTypeQuery' || objType?.type === 'TSTypeQuery') {
+                    // SWC: TsTypeQuery.exprName is TsEntityName (Identifier | TsQualifiedName)
+                    const exprName = objType.exprName ?? objType.expr ?? objType.entityName;
+                    // access .value (Identifier) or fall back to .name for alternate SWC builds
+                    const varName = exprName?.value ?? exprName?.name;
+                    if (varName) {
+                        const vals = this.getVariableValues(varName);
+                        if (vals && vals.length > 0)
+                            return vals;
+                    }
+                }
+            }
+            catch { }
+        }
         // We can't statically determine the value of other expressions (e.g., variables, function calls)
         return [];
     }

package/dist/esm/cli.js

@@ -29,7 +29,7 @@ const program = new Command();
 program
     .name('i18next-cli')
     .description('A unified, high-performance i18next CLI.')
-    .version('1.49.0'); // This string is replaced with the actual version at build time by rollup
+    .version('1.49.1'); // This string is replaced with the actual version at build time by rollup
 // new: global config override option
 program.option('-c, --config <path>', 'Path to i18next-cli config file (overrides detection)');
 program

package/dist/esm/extractor/core/ast-visitors.js

@@ -299,6 +299,18 @@ class ASTVisitors {
         }
         this.hooks.onAfterVisitNode?.(node);
         // --- END VISIT LOGIC ---
+        // Detect array iteration calls (.map / .forEach / .flatMap etc.) on a known
+        // as-const array so the callback parameter is bound to the array values while
+        // the callback body is walked.  We inject the binding BEFORE generic recursion
+        // and remove it AFTER, so the whole subtree sees the correct value.
+        let arrayCallbackCleanup;
+        if (node.type === 'CallExpression') {
+            const info = this.tryGetArrayIterationCallbackInfo(node);
+            if (info) {
+                this.expressionResolver.setTemporaryVariable(info.paramName, info.values);
+                arrayCallbackCleanup = () => this.expressionResolver.deleteTemporaryVariable(info.paramName);
+            }
+        }
         // --- RECURSION ---
         // Recurse into the children of the current node
         for (const key in node) {
@@ -306,49 +318,112 @@ class ASTVisitors {
                 continue;
             const child = node[key];
             if (Array.isArray(child)) {
-                // Pre-scan array children to register VariableDeclarator-based scopes
-                // (e.g., `const { t } = useTranslation(...)`) before walking the rest
-                // of the items. This ensures that functions/arrow-functions defined
-                // earlier in the same block that reference t will resolve to the
-                // correct scope even if the `useTranslation` declarator appears later.
+                // Pre-scan array children in THREE passes:
+                //   Pass 1 — variables WITH init (arrays, objects, strings, fns) + enums
+                //   Pass 2 — type aliases + functions (may depend on pass-1 arrays)
+                //   Pass 3 — `declare const x: Type` (no init; depends on pass-2 type aliases)
+                // This ordering ensures e.g.:
+                //   const OPTS = ['a','b'] as const          → pass 1
+                //   type T = (typeof OPTS)[number]            → pass 2 (resolves OPTS)
+                //   declare const v: T                        → pass 3 (resolves T)
+                // ── Pass 1: variables with init ──────────────────────────────────────
                 for (const item of child) {
                     if (!item || typeof item !== 'object')
                         continue;
-                    // Direct declarator present in arrays (rare)
-                    if (item.type === 'VariableDeclarator') {
+                    // Direct declarator (rare)
+                    if (item.type === 'VariableDeclarator' && item.init) {
                         this.scopeManager.handleVariableDeclarator(item);
                         this.expressionResolver.captureVariableDeclarator(item);
                         continue;
                     }
-                    // enum declarations can appear as ExportDeclaration.declaration earlier; be permissive
-                    if (item && item.id && Array.isArray(item.members)) {
+                    // enum declarations
+                    if (item.id && Array.isArray(item.members)) {
                         this.expressionResolver.captureEnumDeclaration(item);
-                        // continue to allow further traversal
                     }
-                    // pre-scan type alias declarations and function declarations
+                    // Bare VariableDeclaration — only declarators that have an init
+                    if (item.type === 'VariableDeclaration' && Array.isArray(item.declarations)) {
+                        for (const decl of item.declarations) {
+                            if (decl?.type === 'VariableDeclarator' && decl.init) {
+                                this.scopeManager.handleVariableDeclarator(decl);
+                                this.expressionResolver.captureVariableDeclarator(decl);
+                            }
+                        }
+                    }
+                    // ExportDeclaration wrapping VariableDeclaration — only inited declarators
+                    if ((item.type === 'ExportDeclaration' || item.type === 'ExportNamedDeclaration') && item.declaration) {
+                        const inner = item.declaration;
+                        if (inner.type === 'VariableDeclaration' && Array.isArray(inner.declarations)) {
+                            for (const vd of inner.declarations) {
+                                if (vd?.type === 'VariableDeclarator' && vd.init) {
+                                    this.scopeManager.handleVariableDeclarator(vd);
+                                    this.expressionResolver.captureVariableDeclarator(vd);
+                                }
+                            }
+                        }
+                    }
+                }
+                // ── Pass 2: type aliases + functions ─────────────────────────────────
+                for (const item of child) {
+                    if (!item || typeof item !== 'object')
+                        continue;
                     if (item.type === 'TsTypeAliasDeclaration' || item.type === 'TSTypeAliasDeclaration' || item.type === 'TsTypeAliasDecl') {
                         this.expressionResolver.captureTypeAliasDeclaration(item);
                     }
                     if (item.type === 'FunctionDeclaration' || item.type === 'FnDecl') {
                         this.expressionResolver.captureFunctionDeclaration(item);
                     }
-                    // Also handle ExportDeclaration wrapping either of the above
                     if ((item.type === 'ExportDeclaration' || item.type === 'ExportNamedDeclaration') && item.declaration) {
-                        const decl = item.declaration;
-                        if (decl.type === 'TsTypeAliasDeclaration' || decl.type === 'TSTypeAliasDeclaration' || decl.type === 'TsTypeAliasDecl') {
-                            this.expressionResolver.captureTypeAliasDeclaration(decl);
+                        const inner = item.declaration;
+                        if (inner.type === 'TsTypeAliasDeclaration' || inner.type === 'TSTypeAliasDeclaration' || inner.type === 'TsTypeAliasDecl') {
+                            this.expressionResolver.captureTypeAliasDeclaration(inner);
                         }
-                        if (decl.type === 'FunctionDeclaration' || decl.type === 'FnDecl') {
-                            this.expressionResolver.captureFunctionDeclaration(decl);
+                        if (inner.type === 'FunctionDeclaration' || inner.type === 'FnDecl') {
+                            this.expressionResolver.captureFunctionDeclaration(inner);
                         }
                     }
-                    // Common case: VariableDeclaration which contains .declarations (VariableDeclarator[])
+                }
+                // ── Pass 3: `declare const x: Type` — no init, depends on type aliases ─
+                // Also re-processes ArrayPattern destructuring (e.g. useState<T>) whose
+                // type argument resolution failed in Pass 1 because typeAliasTable was empty.
+                for (const item of child) {
+                    if (!item || typeof item !== 'object')
+                        continue;
+                    // Direct declarator with no init
+                    if (item.type === 'VariableDeclarator' && !item.init) {
+                        this.scopeManager.handleVariableDeclarator(item);
+                        this.expressionResolver.captureVariableDeclarator(item);
+                        continue;
+                    }
+                    // ArrayPattern destructuring with init — re-run now that type aliases are populated
+                    if (item.type === 'VariableDeclarator' && item.init && item.id?.type === 'ArrayPattern') {
+                        this.expressionResolver.captureVariableDeclarator(item);
+                        continue;
+                    }
+                    // VariableDeclaration — process no-init declarators and re-process ArrayPattern ones
                     if (item.type === 'VariableDeclaration' && Array.isArray(item.declarations)) {
                         for (const decl of item.declarations) {
-                            if (decl && typeof decl === 'object' && decl.type === 'VariableDeclarator') {
+                            if (!decl.init) {
                                 this.scopeManager.handleVariableDeclarator(decl);
                                 this.expressionResolver.captureVariableDeclarator(decl);
                             }
+                            else if (decl.id?.type === 'ArrayPattern') {
+                                this.expressionResolver.captureVariableDeclarator(decl);
+                            }
+                        }
+                    }
+                    // ExportDeclaration wrapping — same logic
+                    if ((item.type === 'ExportDeclaration' || item.type === 'ExportNamedDeclaration') && item.declaration) {
+                        const inner = item.declaration;
+                        if (inner.type === 'VariableDeclaration' && Array.isArray(inner.declarations)) {
+                            for (const vd of inner.declarations) {
+                                if (!vd.init) {
+                                    this.scopeManager.handleVariableDeclarator(vd);
+                                    this.expressionResolver.captureVariableDeclarator(vd);
+                                }
+                                else if (vd.id?.type === 'ArrayPattern') {
+                                    this.expressionResolver.captureVariableDeclarator(vd);
+                                }
+                            }
                         }
                     }
                 }
@@ -368,11 +443,60 @@ class ASTVisitors {
             }
         }
         // --- END RECURSION ---
+        // Remove temporary callback param binding if one was injected for this node
+        arrayCallbackCleanup?.();
         // LEAVE SCOPE for functions
         if (isNewScope) {
             this.scopeManager.exitScope();
         }
     }
+    /**
+     * If `node` is a call like `ARRAY.map(param => ...)` where ARRAY is a known
+     * string-array constant, returns the callback's first parameter name and the
+     * array values so the caller can inject a temporary variable binding.
+     */
+    tryGetArrayIterationCallbackInfo(node) {
+        try {
+            const callee = node.callee;
+            if (callee?.type !== 'MemberExpression')
+                return undefined;
+            const prop = callee.property;
+            if (prop?.type !== 'Identifier')
+                return undefined;
+            if (!['map', 'forEach', 'flatMap', 'filter', 'find', 'some', 'every'].includes(prop.value))
+                return undefined;
+            // The object must be an identifier whose value is a known string array
+            const obj = callee.object;
+            if (obj?.type !== 'Identifier')
+                return undefined;
+            const values = this.expressionResolver.getVariableValues(obj.value);
+            if (!values || values.length === 0)
+                return undefined;
+            // First argument must be a callback with at least one parameter
+            const callbackArg = node.arguments?.[0]?.expression;
+            if (!callbackArg)
+                return undefined;
+            // Normalise param across SWC shapes: ArrowFunctionExpression / FunctionExpression
+            const params = callbackArg.params ?? callbackArg.parameters ?? [];
+            const firstParam = params[0];
+            if (!firstParam)
+                return undefined;
+            // SWC wraps params in `Param { pat: Identifier }` or exposes them directly
+            const ident = firstParam.type === 'Identifier'
+                ? firstParam
+                : firstParam.type === 'Param' && firstParam.pat?.type === 'Identifier'
+                    ? firstParam.pat
+                    : firstParam.type === 'AssignmentPattern' && firstParam.left?.type === 'Identifier'
+                        ? firstParam.left
+                        : null;
+            if (!ident)
+                return undefined;
+            return { paramName: ident.value, values };
+        }
+        catch {
+            return undefined;
+        }
+    }
     /**
      * Retrieves variable information from the scope chain.
      * Searches from innermost to outermost scope.

package/dist/esm/extractor/parsers/expression-resolver.js

@@ -10,6 +10,15 @@ class ExpressionResolver {
     // Per-file table for type aliases: Maps typeName -> string[]
     // e.g. `type ChangeType = 'all' | 'next' | 'this'` -> { ChangeType: ['all', 'next', 'this'] }
     typeAliasTable = new Map();
+    // Shared (cross-file) table for string-array constants (e.g. `as const` arrays).
+    // Persists across resetFileSymbols() so exported arrays are visible to importers.
+    sharedVariableTable = new Map();
+    // Shared (cross-file) table for type aliases — populated alongside typeAliasTable.
+    // Persists across resetFileSymbols() so exported type aliases are visible to importers.
+    sharedTypeAliasTable = new Map();
+    // Temporary per-scope variable overrides, used to inject .map() / .forEach()
+    // callback parameters while the callback body is being walked.
+    temporaryVariables = new Map();
     constructor(hooks) {
         this.hooks = hooks;
     }
@@ -19,6 +28,7 @@ class ExpressionResolver {
     resetFileSymbols() {
         this.variableTable.clear();
         this.typeAliasTable.clear();
+        this.temporaryVariables.clear();
     }
     /**
      * Capture a VariableDeclarator node to record simple statically analyzable
@@ -34,6 +44,41 @@ class ExpressionResolver {
         try {
             if (!node || !node.id)
                 return;
+            // ── ArrayPattern id: `const [x, y] = fn<T>(...)` ────────────────────────
+            // Handles `const [state] = useState<'a'|'b'>('a')` or similar generic calls
+            // where the type argument is a finite string-literal union.
+            if (node.id.type === 'ArrayPattern' && node.init) {
+                const init = node.init;
+                // Unwrap await / as-expressions
+                let callExpr = init;
+                while (callExpr?.type === 'AwaitExpression')
+                    callExpr = callExpr.argument;
+                while (callExpr?.type === 'TsConstAssertion' ||
+                    callExpr?.type === 'TsAsExpression' ||
+                    callExpr?.type === 'TsSatisfiesExpression')
+                    callExpr = callExpr.expression;
+                if (callExpr?.type === 'CallExpression') {
+                    const typeArgs = callExpr.typeArguments?.params ??
+                        callExpr.typeParameters?.params ??
+                        [];
+                    if (typeArgs.length > 0) {
+                        const vals = this.resolvePossibleStringValuesFromType(typeArgs[0]);
+                        if (vals.length > 0) {
+                            // Bind each array-pattern element: first element is the state variable
+                            for (const el of node.id.elements) {
+                                if (!el)
+                                    continue;
+                                const ident = el.type === 'Identifier' ? el : (el.type === 'AssignmentPattern' && el.left?.type === 'Identifier' ? el.left : null);
+                                if (ident) {
+                                    this.variableTable.set(ident.value, vals);
+                                }
+                                break; // only bind the first element (the state value, not the setter)
+                            }
+                        }
+                    }
+                }
+                return;
+            }
             // only handle simple identifier bindings like `const x = ...`
             if (node.id.type !== 'Identifier')
                 return;
@@ -84,6 +129,24 @@ class ExpressionResolver {
                     return;
                 }
             }
+            // ArrayExpression -> list of string values
+            // Handles `const OPTS = ['a', 'b', 'c'] as const`
+            if (unwrappedInit.type === 'ArrayExpression' && Array.isArray(unwrappedInit.elements)) {
+                const vals = [];
+                for (const elem of unwrappedInit.elements) {
+                    if (!elem || !elem.expression)
+                        continue;
+                    const resolved = this.resolvePossibleStringValuesFromExpression(elem.expression);
+                    if (resolved.length === 1)
+                        vals.push(resolved[0]);
+                }
+                if (vals.length > 0) {
+                    this.variableTable.set(name, vals);
+                    // Also share so importing files can see this array
+                    this.sharedVariableTable.set(name, vals);
+                    return;
+                }
+            }
             // For other initializers, try to resolve to one-or-more strings
             const vals = this.resolvePossibleStringValuesFromExpression(init);
             if (vals.length > 0) {
@@ -127,6 +190,8 @@ class ExpressionResolver {
             const vals = this.resolvePossibleStringValuesFromType(tsType);
             if (vals.length > 0) {
                 this.typeAliasTable.set(name, vals);
+                // Also share so importing files can resolve this alias by name
+                this.sharedTypeAliasTable.set(name, vals);
             }
         }
         catch {
@@ -178,6 +243,33 @@ class ExpressionResolver {
             return raw.typeAnnotation;
         return raw;
     }
+    /**
+     * Temporarily bind a variable name to a set of string values.
+     * Used by ast-visitors to inject .map()/.forEach() callback parameters.
+     * Call deleteTemporaryVariable() after walking the callback body.
+     */
+    setTemporaryVariable(name, values) {
+        this.temporaryVariables.set(name, values);
+    }
+    /**
+     * Remove a previously-injected temporary variable binding.
+     */
+    deleteTemporaryVariable(name) {
+        this.temporaryVariables.delete(name);
+    }
+    /**
+     * Return the array values stored for a variable name, checking all tables.
+     * Returns undefined if the name is not a known string array.
+     */
+    getVariableValues(name) {
+        const tmp = this.temporaryVariables.get(name);
+        if (tmp)
+            return tmp;
+        const v = this.variableTable.get(name);
+        if (Array.isArray(v))
+            return v;
+        return this.sharedVariableTable.get(name);
+    }
     /**
      * Capture a TypeScript enum declaration so members can be resolved later.
      * Accepts SWC node shapes like `TsEnumDeclaration` / `TSEnumDeclaration`.
@@ -419,9 +511,18 @@ class ExpressionResolver {
         }
         // Identifier resolution via captured per-file variable table only
         if (expression.type === 'Identifier') {
+            // Check temporary (callback param) overrides first
+            const tmp = this.temporaryVariables.get(expression.value);
+            if (tmp)
+                return tmp;
             const v = this.variableTable.get(expression.value);
-            if (!v)
+            if (!v) {
+                // Fall back to shared cross-file array table
+                const sv = this.sharedVariableTable.get(expression.value);
+                if (sv)
+                    return sv;
                 return [];
+            }
             if (Array.isArray(v))
                 return v;
             // object map - cannot be used directly as key, so return empty
@@ -431,6 +532,11 @@ class ExpressionResolver {
         return [];
     }
     resolvePossibleStringValuesFromType(type, returnEmptyStrings = false) {
+        // Unwrap TsParenthesizedType — SWC explicitly emits these for grouped types like
+        // `(typeof X)[number]` where `(typeof X)` becomes TsParenthesizedType { typeAnnotation: TsTypeQuery }
+        if (type.type === 'TsParenthesizedType') {
+            return this.resolvePossibleStringValuesFromType(type.typeAnnotation, returnEmptyStrings);
+        }
         if (type.type === 'TsUnionType') {
             return type.types.flatMap((t) => this.resolvePossibleStringValuesFromType(t, returnEmptyStrings));
         }
@@ -454,11 +560,38 @@ class ExpressionResolver {
                 ? type.typeName.value
                 : undefined;
             if (typeName) {
-                const aliasVals = this.typeAliasTable.get(typeName);
+                const aliasVals = this.typeAliasTable.get(typeName) ?? this.sharedTypeAliasTable.get(typeName);
                 if (aliasVals && aliasVals.length > 0)
                     return aliasVals;
             }
         }
+        // `(typeof ACCESS_OPTIONS)[number]` — resolve through the shared array variable table.
+        // SWC emits: TsIndexedAccessType {
+        //   objectType: TsParenthesizedType { typeAnnotation: TsTypeQuery { exprName: Identifier } }
+        //   indexType: TsKeywordType
+        // }
+        // The parens around `typeof X` produce a TsParenthesizedType wrapper that we must unwrap.
+        if (type.type === 'TsIndexedAccessType') {
+            try {
+                let objType = type.objectType;
+                // Unwrap TsParenthesizedType wrapper (SWC preserves explicit parens in type positions)
+                while (objType?.type === 'TsParenthesizedType') {
+                    objType = objType.typeAnnotation;
+                }
+                if (objType?.type === 'TsTypeQuery' || objType?.type === 'TSTypeQuery') {
+                    // SWC: TsTypeQuery.exprName is TsEntityName (Identifier | TsQualifiedName)
+                    const exprName = objType.exprName ?? objType.expr ?? objType.entityName;
+                    // access .value (Identifier) or fall back to .name for alternate SWC builds
+                    const varName = exprName?.value ?? exprName?.name;
+                    if (varName) {
+                        const vals = this.getVariableValues(varName);
+                        if (vals && vals.length > 0)
+                            return vals;
+                    }
+                }
+            }
+            catch { }
+        }
         // We can't statically determine the value of other expressions (e.g., variables, function calls)
         return [];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18next-cli",
-  "version": "1.49.0",
+  "version": "1.49.1",
   "description": "A unified, high-performance i18next CLI.",
   "type": "module",
   "bin": {

package/types/extractor/core/ast-visitors.d.ts

@@ -65,6 +65,12 @@ export declare class ASTVisitors {
      * @private
      */
     private walk;
+    /**
+     * If `node` is a call like `ARRAY.map(param => ...)` where ARRAY is a known
+     * string-array constant, returns the callback's first parameter name and the
+     * array values so the caller can inject a temporary variable binding.
+     */
+    private tryGetArrayIterationCallbackInfo;
     /**
      * Retrieves variable information from the scope chain.
      * Searches from innermost to outermost scope.

package/types/extractor/core/ast-visitors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ast-visitors.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/ast-visitors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAQ,MAAM,WAAW,CAAA;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC1G,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAInE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAe;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,KAAK,CAAiB;IAE9B,IAAW,UAAU,gBAEpB;IAED,SAAgB,YAAY,EAAE,YAAY,CAAA;IAC1C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoB;IACvD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAuB;IAC7D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;IACvC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,WAAW,CAAa;IAEhC;;;;;;OAMG;gBAED,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,eAAe,EACvB,kBAAkB,CAAC,EAAE,kBAAkB;IAiCzC;;;;;OAKG;IACI,KAAK,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAUjC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,IAAI;IAgRZ;;;;;;;;OAQG;IACI,eAAe,CAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAI5D;;OAEG;IACI,cAAc,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAKxD;;;;;;OAMG;IACI,cAAc,IAAK,MAAM;IAIhC;;OAEG;IACI,cAAc,IAAK,MAAM;CAGjC"}
+{"version":3,"file":"ast-visitors.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/ast-visitors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAQ,MAAM,WAAW,CAAA;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC1G,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAInE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAe;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,KAAK,CAAiB;IAE9B,IAAW,UAAU,gBAEpB;IAED,SAAgB,YAAY,EAAE,YAAY,CAAA;IAC1C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoB;IACvD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAuB;IAC7D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;IACvC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,WAAW,CAAa;IAEhC;;;;;;OAMG;gBAED,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,eAAe,EACvB,kBAAkB,CAAC,EAAE,kBAAkB;IAiCzC;;;;;OAKG;IACI,KAAK,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAUjC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,IAAI;IAgWZ;;;;OAIG;IACH,OAAO,CAAC,gCAAgC;IAwCxC;;;;;;;;OAQG;IACI,eAAe,CAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAI5D;;OAEG;IACI,cAAc,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAKxD;;;;;;OAMG;IACI,cAAc,IAAK,MAAM;IAIhC;;OAEG;IACI,cAAc,IAAK,MAAM;CAGjC"}

package/types/extractor/parsers/expression-resolver.d.ts

@@ -5,6 +5,9 @@ export declare class ExpressionResolver {
     private variableTable;
     private sharedEnumTable;
     private typeAliasTable;
+    private sharedVariableTable;
+    private sharedTypeAliasTable;
+    private temporaryVariables;
     constructor(hooks: ASTVisitorHooks);
     /**
      * Clear per-file captured variables. Enums / shared maps are kept.
@@ -46,6 +49,21 @@ export declare class ExpressionResolver {
      * SWC may wrap it in a `TsTypeAnnotation` node — this unwraps it.
      */
     private extractTypeAnnotation;
+    /**
+     * Temporarily bind a variable name to a set of string values.
+     * Used by ast-visitors to inject .map()/.forEach() callback parameters.
+     * Call deleteTemporaryVariable() after walking the callback body.
+     */
+    setTemporaryVariable(name: string, values: string[]): void;
+    /**
+     * Remove a previously-injected temporary variable binding.
+     */
+    deleteTemporaryVariable(name: string): void;
+    /**
+     * Return the array values stored for a variable name, checking all tables.
+     * Returns undefined if the name is not a known string array.
+     */
+    getVariableValues(name: string): string[] | undefined;
     /**
      * Capture a TypeScript enum declaration so members can be resolved later.
      * Accepts SWC node shapes like `TsEnumDeclaration` / `TSEnumDeclaration`.

package/types/extractor/parsers/expression-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expression-resolver.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/expression-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAkD,MAAM,WAAW,CAAA;AAC3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,KAAK,CAAiB;IAK9B,OAAO,CAAC,aAAa,CAA4D;IAGjF,OAAO,CAAC,eAAe,CAAiD;IAIxE,OAAO,CAAC,cAAc,CAAmC;gBAE5C,KAAK,EAAE,eAAe;IAInC;;OAEG;IACI,gBAAgB,IAAK,IAAI;IAKhC;;;;;;;;;OASG;IACH,yBAAyB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAiF3C;;;;;;;OAOG;IACH,2BAA2B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAgB7C;;;;;;;;;OASG;IACH,0BAA0B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAoB5C;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;;;OAKG;IACH,sBAAsB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAwBxC;;;;;;;OAOG;IACH,kCAAkC,CAAE,UAAU,EAAE,UAAU,GAAG,MAAM,EAAE;IAKrE;;;;;;;OAOG;IACH,8BAA8B,CAAE,UAAU,EAAE,UAAU,GAAG,MAAM,EAAE;IAKjE;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,yCAAyC;IAwLjD,OAAO,CAAC,mCAAmC;IAsC3C;;;;;;OAMG;IACH,OAAO,CAAC,6CAA6C;IAyBrD;;;;;;OAMG;IACH,OAAO,CAAC,kDAAkD;CAwB3D"}
+{"version":3,"file":"expression-resolver.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/expression-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAkD,MAAM,WAAW,CAAA;AAC3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,KAAK,CAAiB;IAK9B,OAAO,CAAC,aAAa,CAA4D;IAGjF,OAAO,CAAC,eAAe,CAAiD;IAIxE,OAAO,CAAC,cAAc,CAAmC;IAIzD,OAAO,CAAC,mBAAmB,CAAmC;IAI9D,OAAO,CAAC,oBAAoB,CAAmC;IAI/D,OAAO,CAAC,kBAAkB,CAAmC;gBAEhD,KAAK,EAAE,eAAe;IAInC;;OAEG;IACI,gBAAgB,IAAK,IAAI;IAMhC;;;;;;;;;OASG;IACH,yBAAyB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAwI3C;;;;;;;OAOG;IACH,2BAA2B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAkB7C;;;;;;;;;OASG;IACH,0BAA0B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAoB5C;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;;OAIG;IACI,oBAAoB,CAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAIlE;;OAEG;IACI,uBAAuB,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAInD;;;OAGG;IACI,iBAAiB,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAQ7D;;;;;OAKG;IACH,sBAAsB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAwBxC;;;;;;;OAOG;IACH,kCAAkC,CAAE,UAAU,EAAE,UAAU,GAAG,MAAM,EAAE;IAKrE;;;;;;;OAOG;IACH,8BAA8B,CAAE,UAAU,EAAE,UAAU,GAAG,MAAM,EAAE;IAKjE;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,yCAAyC;IAgMjD,OAAO,CAAC,mCAAmC;IAsE3C;;;;;;OAMG;IACH,OAAO,CAAC,6CAA6C;IAyBrD;;;;;;OAMG;IACH,OAAO,CAAC,kDAAkD;CAwB3D"}