i18next-cli 1.34.0 → 1.35.0

package/dist/cjs/extractor/parsers/call-expression-handler.js

@@ -1 +1,942 @@
-"use strict";var e=require("./ast-utils.js");const t=e=>e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&");exports.CallExpressionHandler=class{pluginContext;config;logger;expressionResolver;objectKeys=new Set;getCurrentFile;getCurrentCode;lastSearchIndex=0;constructor(e,t,n,r,s,i){this.config=e,this.pluginContext=t,this.logger=n,this.expressionResolver=r,this.getCurrentFile=s,this.getCurrentCode=i}resetSearchIndex(){this.lastSearchIndex=0}getLocationFromNode(e){const t=this.getCurrentCode();let n;if("CallExpression"===e.type&&e.arguments.length>0){const t=e.arguments[0].expression;"StringLiteral"===t.type?n=t.raw??`'${t.value}'`:"TemplateLiteral"===t.type?n="`":"ArrowFunctionExpression"===t.type&&(n="=>")}if(!n)return;const r=t.indexOf(n,this.lastSearchIndex);if(-1===r)return;this.lastSearchIndex=r+n.length;const s=t.substring(0,r).split("\n");return{line:s.length,column:s[s.length-1].length}}handleCallExpression(n,r){const s=this.getFunctionName(n.callee);if(!s)return;const i=r(s),o=this.config.extract.functions||["t","*.t"];let l=void 0!==i;if(!l)for(const e of o)if(e.startsWith("*.")){if(s.endsWith(e.substring(1))){l=!0;break}}else if(e===s){l=!0;break}if(!l||0===n.arguments.length)return;const{keysToProcess:a,isSelectorAPI:c}=this.handleCallExpressionArgument(n,0);if(0===a.length)return;let u=!1;const f=this.config.extract.pluralSeparator??"_";for(let e=0;e<a.length;e++)a[e].endsWith(`${f}ordinal`)&&(u=!0,a[e]=a[e].slice(0,-8));let p,y;if(n.arguments.length>1){const t=n.arguments[1].expression;"ObjectExpression"===t.type?y=t:"StringLiteral"===t.type?p=t.value:"TemplateLiteral"===t.type&&e.isSimpleTemplateLiteral(t)&&(p=t.quasis[0].cooked)}if(n.arguments.length>2){const e=n.arguments[2].expression;"ObjectExpression"===e.type&&(y=e)}const g=y?e.getObjectPropValue(y,"defaultValue"):void 0,h="string"==typeof g?g:p,d=e=>{if(!e||!Array.isArray(e.properties))return!1;for(const t of e.properties)if(t&&"KeyValueProperty"===t.type&&t.key){const e="Identifier"===t.key.type&&t.key.value||"StringLiteral"===t.key.type&&t.key.value;if("string"==typeof e&&e.startsWith("defaultValue"))return!0}return!1},x="string"==typeof h||d(y),$=d(y),k=Boolean($||"string"==typeof h&&!(e=>{if("string"!=typeof e)return!1;const n=this.config.extract.interpolationPrefix??"{{",r=this.config.extract.interpolationSuffix??"}}";return new RegExp(`${t(n)}\\s*count\\s*${t(r)}`).test(e)})(h));for(let t=0;t<a.length;t++){const r=a[t];let s,o=a[t];if(y){const t=e.getObjectPropValue(y,"ns");"string"==typeof t&&(s=t)}const l=this.config.extract.nsSeparator??":";if(!s&&l&&o.includes(l)){const e=o.split(l);if(s=e.shift(),o=e.join(l),!o||""===o.trim()){this.logger.warn(`Skipping key that became empty after namespace removal: '${s}${l}'`);continue}}!s&&i?.defaultNs&&(s=i.defaultNs),s||(s=this.config.extract.defaultNS);let f=o;if(i?.keyPrefix){const e=this.config.extract.keySeparator??".";if(f=!1!==e?i.keyPrefix.endsWith(e)?`${i.keyPrefix}${o}`:`${i.keyPrefix}${e}${o}`:`${i.keyPrefix}${o}`,!1!==e){if(f.split(e).some(e=>""===e.trim())){this.logger.warn(`Skipping key with empty segments: '${f}' (keyPrefix: '${i.keyPrefix}', key: '${o}')`);continue}}}const p=t===a.length-1?"string"==typeof h?h:l&&r.includes(l||":")?r:o:o;if(y){const t=e.getObjectPropValueExpression(y,"context"),n=[];if("StringLiteral"===t?.type||"NumericLiteral"===t?.type||"BooleanLiteral"===t?.type){const e=`${t.value}`,r=this.config.extract.contextSeparator??"_";""!==e&&n.push({key:`${f}${r}${e}`,ns:s,defaultValue:p,explicitDefault:x})}else if(t){const e=this.expressionResolver.resolvePossibleContextStringValues(t),r=this.config.extract.contextSeparator??"_";e.length>0&&e.forEach(e=>{n.push({key:`${f}${r}${e}`,ns:s,defaultValue:p,explicitDefault:x})}),n.push({key:f,ns:s,defaultValue:p,explicitDefault:x,keyAcceptingContext:f})}const r=e=>{if(e){if("KeyValueProperty"===e.type&&e.key){if("Identifier"===e.key.type)return e.key.value;if("StringLiteral"===e.key.type)return e.key.value}return"KeyValueProperty"===e.type&&e.value&&"Identifier"===e.value.type?e.key&&"Identifier"===e.key.type?e.key.value:void 0:"ShorthandProperty"!==e.type&&"Identifier"!==e.type||!e.value?e.key&&"string"==typeof e.key?e.key:void 0:e.value}},i=(()=>{if(!y||!Array.isArray(y.properties))return!1;for(const e of y.properties){if("count"===r(e))return!0}return!1})(),o=(()=>{if(!y||!Array.isArray(y.properties))return!1;for(const e of y.properties){if("ordinal"===r(e))return!("KeyValueProperty"!==e.type||!e.value||"BooleanLiteral"!==e.value.type)&&Boolean(e.value.value)}return!1})();if(i||u){try{const e=u?"ordinal":"cardinal",t=this.config.extract?.primaryLanguage||(Array.isArray(this.config.locales)?this.config.locales[0]:void 0)||"en";let r=!1;try{const n=new Intl.PluralRules(t,{type:e}).resolvedOptions().pluralCategories;1===n.length&&"other"===n[0]&&(r=!0)}catch{}if(!r){const t=new Set;for(const n of this.config.locales)try{new Intl.PluralRules(n,{type:e}).resolvedOptions().pluralCategories.forEach(e=>t.add(e))}catch{new Intl.PluralRules("en",{type:e}).resolvedOptions().pluralCategories.forEach(e=>t.add(e))}const n=Array.from(t).sort();1===n.length&&"other"===n[0]&&(r=!0)}if(r){if(n.length>0)for(const e of n)this.pluginContext.addKey({key:e.key,ns:e.ns,defaultValue:e.defaultValue,hasCount:!0,isOrdinal:u});else this.pluginContext.addKey({key:f,ns:s,defaultValue:p,hasCount:!0,isOrdinal:u});continue}}catch(e){}this.config.extract.disablePlurals?n.length>0?n.forEach(this.pluginContext.addKey):this.pluginContext.addKey({key:f,ns:s,defaultValue:p,explicitDefault:x}):this.handlePluralKeys(f,s,y,o||u,h,k);continue}if(n.length>0){n.forEach(this.pluginContext.addKey);continue}!0===e.getObjectPropValue(y,"returnObjects")&&this.objectKeys.add(f)}c&&this.objectKeys.add(f);{const e=this.getLocationFromNode(n);this.pluginContext.addKey({key:f,ns:s,defaultValue:p,explicitDefault:x,locations:e?[{file:this.getCurrentFile(),line:e.line,column:e.column}]:void 0}),this.extractNestedKeys(f,s)}"string"==typeof h&&this.extractNestedKeys(h,s)}}extractNestedKeys(e,n){if(!e||"string"!=typeof e)return;const r=this.config.extract.nestingPrefix??"$t(",s=this.config.extract.nestingSuffix??")",i=t(r),o=t(s),l=new RegExp(`${i}((?:[^()"']+|"[^"]*"|'[^']*'|\\((?:[^()]|"[^"]*"|'[^']*')*\\))*?)${o}`,"g");let a;for(;null!==(a=l.exec(e));)a[1]&&this.processNestedContent(a[1],void 0)}processNestedContent(e,n){let r=e,s="";const i=this.config.extract.nestingOptionsSeparator??",";if(e.indexOf(i)<0)r=e.trim();else{const n=new RegExp(`${t(i)}[ ]*{`),o=e.split(n);if(o.length>1)r=o[0].trim(),s=`{${o.slice(1).join(i+" {")}`;else{const t=e.indexOf(i);r=e.substring(0,t).trim(),s=e.substring(t+1).trim()}}if((r.startsWith("'")&&r.endsWith("'")||r.startsWith('"')&&r.endsWith('"'))&&(r=r.slice(1,-1)),!r)return;let o;const l=this.config.extract.nsSeparator??":";if(l&&r.includes(l)){const e=r.split(l);if(o=e.shift(),r=e.join(l),!r||""===r.trim())return}else o=this.config.extract.defaultNS;let a,c=!1;if(s){/['"]?count['"]?\s*:/.test(s)&&(c=!0);const e=/['"]?context['"]?\s*:\s*(['"])(.*?)\1/.exec(s);e&&(a=e[2])}c||void 0!==a?this.generateNestedPluralKeys(r,o,c,a):this.pluginContext.addKey({key:r,ns:o})}generateNestedPluralKeys(e,t,n,r){try{const s="cardinal";if(!n&&void 0!==r)return this.pluginContext.addKey({key:e,ns:t}),void this.pluginContext.addKey({key:`${e}_${r}`,ns:t});const i=new Set,o=this.config.locales||["en"];for(const e of o)try{const t=new Intl.PluralRules(e,{type:s});t.resolvedOptions().pluralCategories.forEach(e=>i.add(e))}catch(e){const t=new Intl.PluralRules("en",{type:s});t.resolvedOptions().pluralCategories.forEach(e=>i.add(e))}const l=Array.from(i).sort(),a=this.config.extract.pluralSeparator??"_",c=this.config.extract.contextSeparator??"_",u=this.config.extract?.primaryLanguage||(Array.isArray(this.config.locales)?this.config.locales[0]:void 0)||"en";let f=!1;try{const e=new Intl.PluralRules(u,{type:s}).resolvedOptions().pluralCategories;1===e.length&&"other"===e[0]&&(f=!0)}catch{f=!1}const p=f||1===l.length&&"other"===l[0],y=[];if(void 0!==r?y.push({key:e,context:r}):y.push({key:e}),p){for(const{key:e,context:n}of y){const r=n?`${e}${c}${n}`:e;this.pluginContext.addKey({key:r,ns:t,hasCount:!0})}return}for(const{key:e,context:n}of y)for(const r of l){let s;s=n?`${e}${c}${n}${a}${r}`:`${e}${a}${r}`,this.pluginContext.addKey({key:s,ns:t,hasCount:!0})}}catch(n){this.pluginContext.addKey({key:e,ns:t})}}handleCallExpressionArgument(e,t){const n=e.arguments[t].expression,r=[];let s=!1;if("ArrowFunctionExpression"===n.type){const e=this.extractKeyFromSelector(n);e&&(r.push(e),s=!0)}else if("ArrayExpression"===n.type)for(const e of n.elements)e?.expression&&r.push(...this.expressionResolver.resolvePossibleKeyStringValues(e.expression));else r.push(...this.expressionResolver.resolvePossibleKeyStringValues(n));return{keysToProcess:r.filter(e=>!!e),isSelectorAPI:s}}extractKeyFromSelector(e){let t=e.body;if("BlockStatement"===t.type){const e=t.stmts.find(e=>"ReturnStatement"===e.type);if("ReturnStatement"!==e?.type||!e.argument)return null;t=e.argument}let n=t;const r=[];for(;"MemberExpression"===n.type;){const e=n.property;if("Identifier"===e.type)r.unshift(e.value);else{if("Computed"!==e.type||"StringLiteral"!==e.expression.type)return null;r.unshift(e.expression.value)}n=n.object}if(r.length>0){const e=this.config.extract.keySeparator,t="string"==typeof e?e:".";return r.join(t)}return null}handlePluralKeys(t,n,r,s,i,o){try{const l=s?"ordinal":"cardinal",a=new Set;for(const e of this.config.locales)try{const t=new Intl.PluralRules(e,{type:l});t.resolvedOptions().pluralCategories.forEach(e=>a.add(e))}catch(e){const t=new Intl.PluralRules("en",{type:l});t.resolvedOptions().pluralCategories.forEach(e=>a.add(e))}const c=Array.from(a).sort(),u=this.config.extract.pluralSeparator??"_",f=e.getObjectPropValue(r,"defaultValue"),p=e.getObjectPropValue(r,`defaultValue${u}other`),y=e.getObjectPropValue(r,`defaultValue${u}ordinal${u}other`),g=e.getObjectPropValueExpression(r,"context"),h=[];if(g){const e=this.expressionResolver.resolvePossibleContextStringValues(g);if(e.length>0)if("StringLiteral"===g.type)for(const n of e)n.length>0&&h.push({key:t,context:n});else{for(const n of e)n.length>0&&h.push({key:t,context:n});!1!==this.config.extract?.generateBasePluralForms&&h.push({key:t})}else h.push({key:t})}else h.push({key:t});const d=this.config.extract?.primaryLanguage||(Array.isArray(this.config.locales)?this.config.locales[0]:void 0)||"en";let x=!1;try{const e=new Intl.PluralRules(d,{type:l}).resolvedOptions().pluralCategories;1===e.length&&"other"===e[0]&&(x=!0)}catch{x=!1}if(x||1===c.length&&"other"===c[0]){for(const{key:t,context:l}of h){const a=e.getObjectPropValue(r,`defaultValue${u}other`);let c;c="string"==typeof a?a:"string"==typeof f?f:"string"==typeof i?i:l?`${t}_${l}`:t;const p=this.config.extract.contextSeparator??"_",y=l?`${t}${p}${l}`:t;this.pluginContext.addKey({key:y,ns:n,defaultValue:c,hasCount:!0,isOrdinal:s,explicitDefault:Boolean(o||"string"==typeof a)})}return}for(const{key:l,context:a}of h)for(const g of c){const c=s?`defaultValue${u}ordinal${u}${g}`:`defaultValue${u}${g}`,h=e.getObjectPropValue(r,c);let d,x;if(d="string"==typeof h?h:"one"===g&&"string"==typeof f?f:"one"===g&&"string"==typeof i?i:s&&"string"==typeof y?y:s||"string"!=typeof p?"string"==typeof f?f:"string"==typeof i?i:l:p,a){const e=this.config.extract.contextSeparator??"_";x=s?`${l}${e}${a}${u}ordinal${u}${g}`:`${l}${e}${a}${u}${g}`}else x=s?`${l}${u}ordinal${u}${g}`:`${l}${u}${g}`;this.pluginContext.addKey({key:x,ns:n,defaultValue:d,hasCount:!0,isOrdinal:s,explicitDefault:Boolean(o||"string"==typeof h||"string"==typeof p),keyAcceptingContext:void 0!==a?t:void 0})}}catch(s){this.logger.warn(`Could not determine plural rules for language "${this.config.extract?.primaryLanguage}". Falling back to simple key extraction.`);const o=i||e.getObjectPropValue(r,"defaultValue");this.pluginContext.addKey({key:t,ns:n,defaultValue:"string"==typeof o?o:t})}}getFunctionName(e){if("Identifier"===e.type)return e.value;if("MemberExpression"===e.type){const t=[];let n=e;for(;"MemberExpression"===n.type;){if("Identifier"!==n.property.type)return null;t.unshift(n.property.value),n=n.object}if("ThisExpression"===n.type)t.unshift("this");else{if("Identifier"!==n.type)return null;t.unshift(n.value)}return t.join(".")}return null}};
+'use strict';
+
+var astUtils = require('./ast-utils.js');
+
+// Helper to escape regex characters
+const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+class CallExpressionHandler {
+    pluginContext;
+    config;
+    logger;
+    expressionResolver;
+    objectKeys = new Set();
+    getCurrentFile;
+    getCurrentCode;
+    lastSearchIndex = 0;
+    constructor(config, pluginContext, logger, expressionResolver, getCurrentFile, getCurrentCode) {
+        this.config = config;
+        this.pluginContext = pluginContext;
+        this.logger = logger;
+        this.expressionResolver = expressionResolver;
+        this.getCurrentFile = getCurrentFile;
+        this.getCurrentCode = getCurrentCode;
+    }
+    /**
+     * Reset the search index when starting to process a new file.
+     * This should be called before processing each file.
+     */
+    resetSearchIndex() {
+        this.lastSearchIndex = 0;
+    }
+    /**
+     * Helper method to calculate line and column from a position in the code.
+     * Uses string searching instead of SWC span offsets to avoid accumulation bugs.
+     */
+    getLocationFromNode(node) {
+        const code = this.getCurrentCode();
+        // Extract searchable text from the node
+        // For CallExpression and NewExpression, we can search for the key argument
+        let searchText;
+        if ((node.type === 'CallExpression' || node.type === 'NewExpression') && node.arguments.length > 0) {
+            const firstArg = node.arguments[0].expression;
+            if (firstArg.type === 'StringLiteral') {
+                // Search for the string literal including quotes
+                searchText = firstArg.raw ?? `'${firstArg.value}'`;
+            }
+            else if (firstArg.type === 'TemplateLiteral') {
+                // For template literals, search for the backtick
+                searchText = '`';
+            }
+            else if (firstArg.type === 'ArrowFunctionExpression') {
+                searchText = '=>';
+            }
+        }
+        if (!searchText)
+            return undefined;
+        // Search for the text starting from last known position
+        const position = code.indexOf(searchText, this.lastSearchIndex);
+        if (position === -1) {
+            // Not found - might be a parsing issue, skip location tracking
+            return undefined;
+        }
+        // Update last search position for next search
+        this.lastSearchIndex = position + searchText.length;
+        // Calculate line and column from the position
+        const upToPosition = code.substring(0, position);
+        const lines = upToPosition.split('\n');
+        return {
+            line: lines.length,
+            column: lines[lines.length - 1].length
+        };
+    }
+    /**
+     * Processes function call expressions and new expressions to extract translation keys.
+     *
+     * This is the core extraction method that handles:
+     * - Standard t() calls with string literals
+     * - NewExpression calls like new TranslatedError(...)
+     * - Selector API calls with arrow functions: `t($ => $.path.to.key)`
+     * - Namespace resolution from multiple sources
+     * - Default value extraction from various argument patterns
+     * - Pluralization and context handling
+     * - Key prefix application from scope
+     *
+     * @param node - Call expression or new expression node to process
+     * @param getScopeInfo - Function to retrieve scope information for variables
+     */
+    handleCallExpression(node, getScopeInfo) {
+        const functionName = this.getFunctionName(node.callee);
+        if (!functionName)
+            return;
+        // The scope lookup will only work for simple identifiers, which is okay for this fix.
+        const scopeInfo = getScopeInfo(functionName);
+        const configuredFunctions = this.config.extract.functions || ['t', '*.t'];
+        let isFunctionToParse = scopeInfo !== undefined; // A scoped variable (from useTranslation, etc.) is always parsed.
+        if (!isFunctionToParse) {
+            for (const pattern of configuredFunctions) {
+                if (pattern.startsWith('*.')) {
+                    // Handle wildcard suffix (e.g., '*.t' matches 'i18n.t')
+                    if (functionName.endsWith(pattern.substring(1))) {
+                        isFunctionToParse = true;
+                        break;
+                    }
+                }
+                else {
+                    // Handle exact match
+                    if (pattern === functionName) {
+                        isFunctionToParse = true;
+                        break;
+                    }
+                }
+            }
+        }
+        if (!isFunctionToParse || node.arguments.length === 0)
+            return;
+        const { keysToProcess, isSelectorAPI } = this.handleCallExpressionArgument(node, 0);
+        if (keysToProcess.length === 0)
+            return;
+        let isOrdinalByKey = false;
+        const pluralSeparator = this.config.extract.pluralSeparator ?? '_';
+        for (let i = 0; i < keysToProcess.length; i++) {
+            if (keysToProcess[i].endsWith(`${pluralSeparator}ordinal`)) {
+                isOrdinalByKey = true;
+                // Normalize the key by stripping the suffix
+                keysToProcess[i] = keysToProcess[i].slice(0, -8);
+            }
+        }
+        let defaultValue;
+        let options;
+        if (node.arguments.length > 1) {
+            const arg2 = node.arguments[1].expression;
+            if (arg2.type === 'ObjectExpression') {
+                options = arg2;
+            }
+            else if (arg2.type === 'StringLiteral') {
+                defaultValue = arg2.value;
+            }
+            else if (arg2.type === 'TemplateLiteral' && astUtils.isSimpleTemplateLiteral(arg2)) {
+                defaultValue = arg2.quasis[0].cooked;
+            }
+        }
+        if (node.arguments.length > 2) {
+            const arg3 = node.arguments[2].expression;
+            if (arg3.type === 'ObjectExpression') {
+                options = arg3;
+            }
+        }
+        const defaultValueFromOptions = options ? astUtils.getObjectPropValue(options, 'defaultValue') : undefined;
+        const finalDefaultValue = (typeof defaultValueFromOptions === 'string' ? defaultValueFromOptions : defaultValue);
+        // Helper: detect if options object contains any defaultValue* properties
+        const optionsHasDefaultProps = (opts) => {
+            if (!opts || !Array.isArray(opts.properties))
+                return false;
+            for (const p of opts.properties) {
+                if (p && p.type === 'KeyValueProperty' && p.key) {
+                    const keyName = (p.key.type === 'Identifier' && p.key.value) || (p.key.type === 'StringLiteral' && p.key.value);
+                    if (typeof keyName === 'string' && keyName.startsWith('defaultValue'))
+                        return true;
+                }
+            }
+            return false;
+        };
+        // explicit for base key when a string default was provided OR explicit plural defaults are present
+        const explicitDefaultForBase = typeof finalDefaultValue === 'string' || optionsHasDefaultProps(options);
+        // detect if options contain plural-specific defaultValue_* props
+        const explicitPluralDefaultsInOptions = optionsHasDefaultProps(options);
+        // If a base default string exists, consider it explicit for plural VARIANTS only when
+        // it does NOT contain a count interpolation like '{{count}}' — templates with count
+        // are often the runtime interpolation form and should NOT overwrite existing variant forms.
+        const containsCountPlaceholder = (s) => {
+            if (typeof s !== 'string')
+                return false;
+            const ip = this.config.extract.interpolationPrefix ?? '{{';
+            const is = this.config.extract.interpolationSuffix ?? '}}';
+            const re = new RegExp(`${escapeRegex(ip)}\\s*count\\s*${escapeRegex(is)}`);
+            return re.test(s);
+        };
+        const explicitPluralForVariants = Boolean(explicitPluralDefaultsInOptions || (typeof finalDefaultValue === 'string' && !containsCountPlaceholder(finalDefaultValue)));
+        // Loop through each key found (could be one or more) and process it
+        for (let i = 0; i < keysToProcess.length; i++) {
+            const originalKey = keysToProcess[i]; // preserve original (possibly namespaced) form
+            let key = keysToProcess[i];
+            let ns;
+            // Determine namespace (explicit ns > ns:key > scope ns > default)
+            // See https://www.i18next.com/overview/api#getfixedt
+            if (options) {
+                const nsVal = astUtils.getObjectPropValue(options, 'ns');
+                if (typeof nsVal === 'string')
+                    ns = nsVal;
+            }
+            const nsSeparator = this.config.extract.nsSeparator ?? ':';
+            if (!ns && nsSeparator && key.includes(nsSeparator)) {
+                const parts = key.split(nsSeparator);
+                ns = parts.shift();
+                key = parts.join(nsSeparator);
+                if (!key || key.trim() === '') {
+                    this.logger.warn(`Skipping key that became empty after namespace removal: '${ns}${nsSeparator}'`);
+                    continue;
+                }
+            }
+            if (!ns && scopeInfo?.defaultNs)
+                ns = scopeInfo.defaultNs;
+            if (!ns)
+                ns = this.config.extract.defaultNS;
+            let finalKey = key;
+            // Apply keyPrefix AFTER namespace extraction
+            if (scopeInfo?.keyPrefix) {
+                const keySeparator = this.config.extract.keySeparator ?? '.';
+                // Apply keyPrefix - handle case where keyPrefix already ends with separator
+                if (keySeparator !== false) {
+                    if (scopeInfo.keyPrefix.endsWith(keySeparator)) {
+                        finalKey = `${scopeInfo.keyPrefix}${key}`;
+                    }
+                    else {
+                        finalKey = `${scopeInfo.keyPrefix}${keySeparator}${key}`;
+                    }
+                }
+                else {
+                    finalKey = `${scopeInfo.keyPrefix}${key}`;
+                }
+                // Validate keyPrefix combinations that create problematic keys
+                if (keySeparator !== false) {
+                    // Check for patterns that would create empty segments in the nested key structure
+                    const segments = finalKey.split(keySeparator);
+                    const hasEmptySegment = segments.some(segment => segment.trim() === '');
+                    if (hasEmptySegment) {
+                        this.logger.warn(`Skipping key with empty segments: '${finalKey}' (keyPrefix: '${scopeInfo.keyPrefix}', key: '${key}')`);
+                        continue;
+                    }
+                }
+            }
+            const isLastKey = i === keysToProcess.length - 1;
+            // Use the original (possibly namespaced) key as the default when no explicit
+            // default was provided and the source key contained a namespace prefix.
+            const dv = isLastKey
+                ? (typeof finalDefaultValue === 'string'
+                    ? finalDefaultValue
+                    : (nsSeparator && originalKey.includes(nsSeparator || ':') ? originalKey : key))
+                : key;
+            // Handle plurals, context, and returnObjects
+            if (options) {
+                const contextPropValue = astUtils.getObjectPropValueExpression(options, 'context');
+                const keysWithContext = [];
+                // 1. Handle Context
+                if (contextPropValue?.type === 'StringLiteral' || contextPropValue?.type === 'NumericLiteral' || contextPropValue?.type === 'BooleanLiteral') {
+                    // If the context is static, we don't need to add the base key
+                    const contextValue = `${contextPropValue.value}`;
+                    const contextSeparator = this.config.extract.contextSeparator ?? '_';
+                    // Ignore context: ''
+                    if (contextValue !== '') {
+                        keysWithContext.push({ key: `${finalKey}${contextSeparator}${contextValue}`, ns, defaultValue: dv, explicitDefault: explicitDefaultForBase });
+                    }
+                }
+                else if (contextPropValue) {
+                    const contextValues = this.expressionResolver.resolvePossibleContextStringValues(contextPropValue);
+                    const contextSeparator = this.config.extract.contextSeparator ?? '_';
+                    if (contextValues.length > 0) {
+                        contextValues.forEach(context => {
+                            keysWithContext.push({ key: `${finalKey}${contextSeparator}${context}`, ns, defaultValue: dv, explicitDefault: explicitDefaultForBase });
+                        });
+                    }
+                    // For dynamic context, also add the base key as a fallback
+                    keysWithContext.push({
+                        key: finalKey,
+                        ns,
+                        defaultValue: dv,
+                        explicitDefault: explicitDefaultForBase,
+                        keyAcceptingContext: finalKey
+                    });
+                }
+                // 2. Handle Plurals
+                // Robust detection for `{ count }`, `{ count: x }`, `{ 'count': x }` etc.
+                // Support KeyValueProperty and common shorthand forms that SWC may emit.
+                const propNameFromNode = (p) => {
+                    if (!p)
+                        return undefined;
+                    // Standard key:value property
+                    if (p.type === 'KeyValueProperty' && p.key) {
+                        if (p.key.type === 'Identifier')
+                            return p.key.value;
+                        if (p.key.type === 'StringLiteral')
+                            return p.key.value;
+                    }
+                    // SWC may represent shorthand properties differently (no explicit key node).
+                    // Try common shapes: property with `value` being an Identifier (shorthand).
+                    if (p.type === 'KeyValueProperty' && p.value && p.value.type === 'Identifier') {
+                        // e.g. { count: count } - already covered above, but keep safe fallback
+                        return p.key && p.key.type === 'Identifier' ? p.key.value : undefined;
+                    }
+                    // Some AST variants use 'ShorthandProperty' or keep the Identifier directly.
+                    if ((p.type === 'ShorthandProperty' || p.type === 'Identifier') && p.value) {
+                        return p.value;
+                    }
+                    // Fallback: if node has an 'id' or 'key' string value
+                    if (p.key && typeof p.key === 'string')
+                        return p.key;
+                    return undefined;
+                };
+                const hasCount = (() => {
+                    if (!options || !Array.isArray(options.properties))
+                        return false;
+                    for (const p of options.properties) {
+                        const name = propNameFromNode(p);
+                        if (name === 'count')
+                            return true;
+                    }
+                    return false;
+                })();
+                const isOrdinalByOption = (() => {
+                    if (!options || !Array.isArray(options.properties))
+                        return false;
+                    for (const p of options.properties) {
+                        const name = propNameFromNode(p);
+                        if (name === 'ordinal') {
+                            // If it's a key:value pair with a BooleanLiteral true, respect it.
+                            if (p.type === 'KeyValueProperty' && p.value && p.value.type === 'BooleanLiteral') {
+                                return Boolean(p.value.value);
+                            }
+                            // shorthand `ordinal` without explicit true -> treat as false
+                            return false;
+                        }
+                    }
+                    return false;
+                })();
+                if (hasCount || isOrdinalByKey) {
+                    // QUICK PATH: If ALL target locales only have the "other" category,
+                    // emit base/context keys directly (avoid generating *_other). This
+                    // mirrors the special-case in handlePluralKeys but is placed here as a
+                    // defensive guard to ensure keys are always emitted.
+                    try {
+                        const typeForCheck = isOrdinalByKey ? 'ordinal' : 'cardinal';
+                        // Prefer the configured primaryLanguage as the deciding signal for
+                        // "single-other" languages (ja/zh/ko). Fall back to union of locales.
+                        const primaryLang = this.config.extract?.primaryLanguage || (Array.isArray(this.config.locales) ? this.config.locales[0] : undefined) || 'en';
+                        let isSingleOther = false;
+                        try {
+                            const primaryCategories = new Intl.PluralRules(primaryLang, { type: typeForCheck }).resolvedOptions().pluralCategories;
+                            if (primaryCategories.length === 1 && primaryCategories[0] === 'other') {
+                                isSingleOther = true;
+                            }
+                        }
+                        catch {
+                            // ignore and fall back to union-of-locales check below
+                        }
+                        if (!isSingleOther) {
+                            const allPluralCategoriesCheck = new Set();
+                            for (const locale of this.config.locales) {
+                                try {
+                                    const rules = new Intl.PluralRules(locale, { type: typeForCheck });
+                                    rules.resolvedOptions().pluralCategories.forEach(c => allPluralCategoriesCheck.add(c));
+                                }
+                                catch {
+                                    new Intl.PluralRules('en', { type: typeForCheck }).resolvedOptions().pluralCategories.forEach(c => allPluralCategoriesCheck.add(c));
+                                }
+                            }
+                            const pluralCategoriesCheck = Array.from(allPluralCategoriesCheck).sort();
+                            if (pluralCategoriesCheck.length === 1 && pluralCategoriesCheck[0] === 'other') {
+                                isSingleOther = true;
+                            }
+                        }
+                        if (isSingleOther) {
+                            // Emit only base/context keys (no _other) and skip the heavy plural path.
+                            if (keysWithContext.length > 0) {
+                                for (const k of keysWithContext) {
+                                    this.pluginContext.addKey({
+                                        key: k.key,
+                                        ns: k.ns,
+                                        defaultValue: k.defaultValue,
+                                        hasCount: true,
+                                        isOrdinal: isOrdinalByKey
+                                    });
+                                }
+                            }
+                            else {
+                                this.pluginContext.addKey({
+                                    key: finalKey,
+                                    ns,
+                                    defaultValue: dv,
+                                    hasCount: true,
+                                    isOrdinal: isOrdinalByKey
+                                });
+                            }
+                            continue;
+                        }
+                    }
+                    catch (e) {
+                        // Ignore Intl failures here and fall through to normal logic
+                    }
+                    // Check if plurals are disabled
+                    if (this.config.extract.disablePlurals) {
+                        // When plurals are disabled, treat count as a regular option (for interpolation only)
+                        // Still handle context normally
+                        if (keysWithContext.length > 0) {
+                            keysWithContext.forEach(this.pluginContext.addKey);
+                        }
+                        else {
+                            this.pluginContext.addKey({ key: finalKey, ns, defaultValue: dv, explicitDefault: explicitDefaultForBase });
+                        }
+                    }
+                    else {
+                        // Original plural handling logic when plurals are enabled
+                        // Always pass the base key to handlePluralKeys - it will handle context internally.
+                        // Pass explicitDefaultForBase so that when a call-site provided an explicit
+                        // base default (e.g. t('key', 'Default', { count })), plural variant keys
+                        // are treated as explicit and may be synced to that default.
+                        this.handlePluralKeys(finalKey, ns, options, isOrdinalByOption || isOrdinalByKey, finalDefaultValue, explicitPluralForVariants);
+                    }
+                    continue; // This key is fully handled
+                }
+                if (keysWithContext.length > 0) {
+                    keysWithContext.forEach(this.pluginContext.addKey);
+                    continue; // This key is now fully handled
+                }
+                // 3. Handle returnObjects
+                if (astUtils.getObjectPropValue(options, 'returnObjects') === true) {
+                    this.objectKeys.add(finalKey);
+                    // Fall through to add the base key itself
+                }
+            }
+            // 4. Handle selector API as implicit returnObjects
+            if (isSelectorAPI) {
+                this.objectKeys.add(finalKey);
+                // Fall through to add the base key itself
+            }
+            // 5. Default case: Add the simple key
+            {
+                // ✅ Use the helper method to find location by searching the code
+                const location = this.getLocationFromNode(node);
+                this.pluginContext.addKey({
+                    key: finalKey,
+                    ns,
+                    defaultValue: dv,
+                    explicitDefault: explicitDefaultForBase,
+                    locations: location
+                        ? [{
+                                file: this.getCurrentFile(),
+                                line: location.line,
+                                column: location.column
+                            }]
+                        : undefined
+                });
+                // Check for nested translations in the key itself
+                this.extractNestedKeys(finalKey, ns);
+            }
+            // Check for nested translations in the default value
+            if (typeof finalDefaultValue === 'string') {
+                this.extractNestedKeys(finalDefaultValue, ns);
+            }
+        }
+    }
+    /**
+     * Scans a string for nested translations like $t(key, options) and extracts them.
+     */
+    extractNestedKeys(text, ns) {
+        if (!text || typeof text !== 'string')
+            return;
+        const prefix = this.config.extract.nestingPrefix ?? '$t(';
+        const suffix = this.config.extract.nestingSuffix ?? ')';
+        const escapedPrefix = escapeRegex(prefix);
+        const escapedSuffix = escapeRegex(suffix);
+        // Regex adapted from i18next Interpolator.js
+        // Matches nested calls like $t(key) or $t(key, { options })
+        // It handles balanced parentheses to some extent and quoted strings
+        const nestingRegexp = new RegExp(`${escapedPrefix}((?:[^()"']+|"[^"]*"|'[^']*'|\\((?:[^()]|"[^"]*"|'[^']*')*\\))*?)${escapedSuffix}`, 'g');
+        let match;
+        while ((match = nestingRegexp.exec(text)) !== null) {
+            if (match[1]) {
+                // Do NOT trust the outer `ns` blindly — compute namespace from the nested key itself
+                // inside processNestedContent. Pass `undefined` so processNestedContent resolves ns
+                // deterministically (either from key "ns:key" or from defaultNS).
+                this.processNestedContent(match[1], undefined);
+            }
+        }
+    }
+    processNestedContent(content, ns) {
+        let key = content;
+        let optionsString = '';
+        const separator = this.config.extract.nestingOptionsSeparator ?? ',';
+        // Logic adapted from i18next Interpolator.js handleHasOptions
+        if (content.indexOf(separator) < 0) {
+            key = content.trim();
+        }
+        else {
+            // Split by separator, but be careful about objects
+            // i18next does: const c = key.split(new RegExp(`${sep}[ ]*{`));
+            // This assumes options start with {
+            const sepRegex = new RegExp(`${escapeRegex(separator)}[ ]*{`);
+            const parts = content.split(sepRegex);
+            if (parts.length > 1) {
+                key = parts[0].trim();
+                // Reconstruct the options part: add back the '{' that was consumed by split
+                optionsString = `{${parts.slice(1).join(separator + ' {')}`;
+            }
+            else {
+                // Fallback for simple split if no object pattern found
+                const sepIdx = content.indexOf(separator);
+                key = content.substring(0, sepIdx).trim();
+                optionsString = content.substring(sepIdx + 1).trim();
+            }
+        }
+        // Remove quotes from key if present
+        if ((key.startsWith("'") && key.endsWith("'")) || (key.startsWith('"') && key.endsWith('"'))) {
+            key = key.slice(1, -1);
+        }
+        if (!key)
+            return;
+        // Resolve namespace for the nested key:
+        // If nested key contains nsSeparator (e.g. "ns:key"), extract namespace,
+        // otherwise use configured defaultNS.
+        let nestedNs;
+        const nsSeparator = this.config.extract.nsSeparator ?? ':';
+        if (nsSeparator && key.includes(nsSeparator)) {
+            const parts = key.split(nsSeparator);
+            nestedNs = parts.shift();
+            key = parts.join(nsSeparator);
+            if (!key || key.trim() === '')
+                return;
+        }
+        else {
+            nestedNs = this.config.extract.defaultNS;
+        }
+        let hasCount = false;
+        let context;
+        if (optionsString) {
+            // Simple regex check for count and context in the options string
+            // This is an approximation since we don't have a full JSON parser here that handles JS objects perfectly
+            // but it should cover most static cases.
+            // Check for count: ...
+            if (/['"]?count['"]?\s*:/.test(optionsString)) {
+                hasCount = true;
+            }
+            // Check for context: ...
+            const contextMatch = /['"]?context['"]?\s*:\s*(['"])(.*?)\1/.exec(optionsString);
+            if (contextMatch) {
+                context = contextMatch[2];
+            }
+        }
+        if (hasCount || context !== undefined) {
+            this.generateNestedPluralKeys(key, nestedNs, hasCount, context);
+        }
+        else {
+            this.pluginContext.addKey({ key, ns: nestedNs });
+        }
+    }
+    generateNestedPluralKeys(key, ns, hasCount, context) {
+        try {
+            const type = 'cardinal';
+            // If only context, no plural
+            if (!hasCount && context !== undefined) {
+                this.pluginContext.addKey({ key, ns });
+                this.pluginContext.addKey({ key: `${key}_${context}`, ns });
+                return;
+            }
+            // If hasCount, generate plurals
+            const allPluralCategories = new Set();
+            const locales = this.config.locales || ['en'];
+            for (const locale of locales) {
+                try {
+                    const pluralRules = new Intl.PluralRules(locale, { type });
+                    const categories = pluralRules.resolvedOptions().pluralCategories;
+                    categories.forEach(cat => allPluralCategories.add(cat));
+                }
+                catch (e) {
+                    const englishRules = new Intl.PluralRules('en', { type });
+                    const categories = englishRules.resolvedOptions().pluralCategories;
+                    categories.forEach(cat => allPluralCategories.add(cat));
+                }
+            }
+            const pluralCategories = Array.from(allPluralCategories).sort();
+            const pluralSeparator = this.config.extract.pluralSeparator ?? '_';
+            const contextSeparator = this.config.extract.contextSeparator ?? '_';
+            const primaryLang = this.config.extract?.primaryLanguage || (Array.isArray(this.config.locales) ? this.config.locales[0] : undefined) || 'en';
+            let primaryIsSingleOther = false;
+            try {
+                const primaryCats = new Intl.PluralRules(primaryLang, { type }).resolvedOptions().pluralCategories;
+                if (primaryCats.length === 1 && primaryCats[0] === 'other')
+                    primaryIsSingleOther = true;
+            }
+            catch {
+                primaryIsSingleOther = false;
+            }
+            const isSingleOther = primaryIsSingleOther || (pluralCategories.length === 1 && pluralCategories[0] === 'other');
+            const keysToGenerate = [];
+            if (context !== undefined) {
+                keysToGenerate.push({ key, context });
+            }
+            else {
+                keysToGenerate.push({ key });
+            }
+            if (isSingleOther) {
+                for (const { key: baseKey, context } of keysToGenerate) {
+                    const finalKey = context ? `${baseKey}${contextSeparator}${context}` : baseKey;
+                    this.pluginContext.addKey({ key: finalKey, ns, hasCount: true });
+                }
+                return;
+            }
+            for (const { key: baseKey, context } of keysToGenerate) {
+                for (const category of pluralCategories) {
+                    let finalKey;
+                    if (context) {
+                        finalKey = `${baseKey}${contextSeparator}${context}${pluralSeparator}${category}`;
+                    }
+                    else {
+                        finalKey = `${baseKey}${pluralSeparator}${category}`;
+                    }
+                    this.pluginContext.addKey({ key: finalKey, ns, hasCount: true });
+                }
+            }
+        }
+        catch (e) {
+            this.pluginContext.addKey({ key, ns });
+        }
+    }
+    /**
+     * Processed a call expression to extract keys from the specified argument.
+     *
+     * @param node - The call expression node
+     * @param argIndex - The index of the argument to process
+     * @returns An object containing the keys to process and a flag indicating if the selector API is used
+     */
+    handleCallExpressionArgument(node, argIndex) {
+        const firstArg = node.arguments[argIndex].expression;
+        const keysToProcess = [];
+        let isSelectorAPI = false;
+        if (firstArg.type === 'ArrowFunctionExpression') {
+            const key = this.extractKeyFromSelector(firstArg);
+            if (key) {
+                keysToProcess.push(key);
+                isSelectorAPI = true;
+            }
+        }
+        else if (firstArg.type === 'ArrayExpression') {
+            for (const element of firstArg.elements) {
+                if (element?.expression) {
+                    keysToProcess.push(...this.expressionResolver.resolvePossibleKeyStringValues(element.expression));
+                }
+            }
+        }
+        else {
+            keysToProcess.push(...this.expressionResolver.resolvePossibleKeyStringValues(firstArg));
+        }
+        return {
+            keysToProcess: keysToProcess.filter((key) => !!key),
+            isSelectorAPI,
+        };
+    }
+    /**
+     * Extracts translation key from selector API arrow function.
+     *
+     * Processes selector expressions like:
+     * - `$ => $.path.to.key` → 'path.to.key'
+     * - `$ => $.app['title'].main` → 'app.title.main'
+     * - `$ => { return $.nested.key; }` → 'nested.key'
+     *
+     * Handles both dot notation and bracket notation, respecting
+     * the configured key separator or flat key structure.
+     *
+     * @param node - Arrow function expression from selector call
+     * @returns Extracted key path or null if not statically analyzable
+     */
+    extractKeyFromSelector(node) {
+        let body = node.body;
+        // Handle block bodies, e.g., $ => { return $.key; }
+        if (body.type === 'BlockStatement') {
+            const returnStmt = body.stmts.find(s => s.type === 'ReturnStatement');
+            if (returnStmt?.type === 'ReturnStatement' && returnStmt.argument) {
+                body = returnStmt.argument;
+            }
+            else {
+                return null;
+            }
+        }
+        let current = body;
+        const parts = [];
+        // Recursively walk down MemberExpressions
+        while (current.type === 'MemberExpression') {
+            const prop = current.property;
+            if (prop.type === 'Identifier') {
+                // This handles dot notation: .key
+                parts.unshift(prop.value);
+            }
+            else if (prop.type === 'Computed' && prop.expression.type === 'StringLiteral') {
+                // This handles bracket notation: ['key']
+                parts.unshift(prop.expression.value);
+            }
+            else {
+                // This is a dynamic property like [myVar] or a private name, which we cannot resolve.
+                return null;
+            }
+            current = current.object;
+        }
+        if (parts.length > 0) {
+            const keySeparator = this.config.extract.keySeparator;
+            const joiner = typeof keySeparator === 'string' ? keySeparator : '.';
+            return parts.join(joiner);
+        }
+        return null;
+    }
+    /**
+     * Generates plural form keys based on the primary language's plural rules.
+     *
+     * Uses Intl.PluralRules to determine the correct plural categories
+     * for the configured primary language and generates suffixed keys
+     * for each category (e.g., 'item_one', 'item_other').
+     *
+     * @param key - Base key name for pluralization
+     * @param ns - Namespace for the keys
+     * @param options - object expression options
+     * @param isOrdinal - isOrdinal flag
+     */
+    handlePluralKeys(key, ns, options, isOrdinal, defaultValueFromCall, explicitDefaultFromSource) {
+        try {
+            const type = isOrdinal ? 'ordinal' : 'cardinal';
+            // Generate plural forms for ALL target languages to ensure we have all necessary keys
+            const allPluralCategories = new Set();
+            for (const locale of this.config.locales) {
+                try {
+                    const pluralRules = new Intl.PluralRules(locale, { type });
+                    const categories = pluralRules.resolvedOptions().pluralCategories;
+                    categories.forEach(cat => allPluralCategories.add(cat));
+                }
+                catch (e) {
+                    // If a locale is invalid, fall back to English rules
+                    const englishRules = new Intl.PluralRules('en', { type });
+                    const categories = englishRules.resolvedOptions().pluralCategories;
+                    categories.forEach(cat => allPluralCategories.add(cat));
+                }
+            }
+            const pluralCategories = Array.from(allPluralCategories).sort();
+            const pluralSeparator = this.config.extract.pluralSeparator ?? '_';
+            // Get all possible default values once at the start
+            const defaultValue = astUtils.getObjectPropValue(options, 'defaultValue');
+            const otherDefault = astUtils.getObjectPropValue(options, `defaultValue${pluralSeparator}other`);
+            const ordinalOtherDefault = astUtils.getObjectPropValue(options, `defaultValue${pluralSeparator}ordinal${pluralSeparator}other`);
+            // Handle context - both static and dynamic
+            const contextPropValue = astUtils.getObjectPropValueExpression(options, 'context');
+            const keysToGenerate = [];
+            if (contextPropValue) {
+                // Handle dynamic context by resolving all possible values
+                const contextValues = this.expressionResolver.resolvePossibleContextStringValues(contextPropValue);
+                if (contextValues.length > 0) {
+                    // For static context (string literal), only generate context variants
+                    if (contextPropValue.type === 'StringLiteral') {
+                        // Only generate context-specific plural forms, no base forms
+                        for (const contextValue of contextValues) {
+                            if (contextValue.length > 0) {
+                                keysToGenerate.push({ key, context: contextValue });
+                            }
+                        }
+                    }
+                    else {
+                        // For dynamic context, generate context variants AND base forms
+                        for (const contextValue of contextValues) {
+                            if (contextValue.length > 0) {
+                                keysToGenerate.push({ key, context: contextValue });
+                            }
+                        }
+                        // Only generate base plural forms if generateBasePluralForms is not disabled
+                        const shouldGenerateBaseForms = this.config.extract?.generateBasePluralForms !== false;
+                        if (shouldGenerateBaseForms) {
+                            keysToGenerate.push({ key });
+                        }
+                    }
+                }
+                else {
+                    // Couldn't resolve context, fall back to base key only
+                    keysToGenerate.push({ key });
+                }
+            }
+            else {
+                // No context, always generate base plural forms
+                keysToGenerate.push({ key });
+            }
+            // If the only plural category across configured locales is "other",
+            // prefer the base key (no "_other" suffix) as it's more natural for languages
+            // with no grammatical plural forms (ja/zh/ko).
+            // Prefer the configured primaryLanguage as signal for single-"other" languages.
+            // If primaryLanguage indicates single-"other", treat as that case; otherwise
+            // fall back to earlier union-of-locales check that produced `pluralCategories`.
+            const primaryLang = this.config.extract?.primaryLanguage || (Array.isArray(this.config.locales) ? this.config.locales[0] : undefined) || 'en';
+            let primaryIsSingleOther = false;
+            try {
+                const primaryCats = new Intl.PluralRules(primaryLang, { type }).resolvedOptions().pluralCategories;
+                if (primaryCats.length === 1 && primaryCats[0] === 'other')
+                    primaryIsSingleOther = true;
+            }
+            catch {
+                primaryIsSingleOther = false;
+            }
+            if (primaryIsSingleOther || (pluralCategories.length === 1 && pluralCategories[0] === 'other')) {
+                for (const { key: baseKey, context } of keysToGenerate) {
+                    const specificOther = astUtils.getObjectPropValue(options, `defaultValue${pluralSeparator}other`);
+                    // Final default resolution:
+                    // 1) plural-specific defaultValue_other
+                    // 2) general defaultValue (from options)
+                    // 3) defaultValueFromCall (string arg)
+                    // 4) fallback to key (or context-key for context variants)
+                    let finalDefaultValue;
+                    if (typeof specificOther === 'string') {
+                        finalDefaultValue = specificOther;
+                    }
+                    else if (typeof defaultValue === 'string') {
+                        finalDefaultValue = defaultValue;
+                    }
+                    else if (typeof defaultValueFromCall === 'string') {
+                        finalDefaultValue = defaultValueFromCall;
+                    }
+                    else {
+                        finalDefaultValue = context ? `${baseKey}_${context}` : baseKey;
+                    }
+                    const ctxSep = this.config.extract.contextSeparator ?? '_';
+                    const finalKey = context ? `${baseKey}${ctxSep}${context}` : baseKey;
+                    this.pluginContext.addKey({
+                        key: finalKey,
+                        ns,
+                        defaultValue: finalDefaultValue,
+                        hasCount: true,
+                        isOrdinal,
+                        explicitDefault: Boolean(explicitDefaultFromSource || typeof specificOther === 'string')
+                    });
+                }
+                return;
+            }
+            // Generate plural forms for each key variant
+            for (const { key: baseKey, context } of keysToGenerate) {
+                for (const category of pluralCategories) {
+                    // 1. Look for the most specific default value
+                    const specificDefaultKey = isOrdinal ? `defaultValue${pluralSeparator}ordinal${pluralSeparator}${category}` : `defaultValue${pluralSeparator}${category}`;
+                    const specificDefault = astUtils.getObjectPropValue(options, specificDefaultKey);
+                    // 2. Determine the final default value using the ORIGINAL fallback chain with corrections
+                    let finalDefaultValue;
+                    if (typeof specificDefault === 'string') {
+                        // Most specific: defaultValue_one, defaultValue_ordinal_other, etc.
+                        finalDefaultValue = specificDefault;
+                    }
+                    else if (category === 'one' && typeof defaultValue === 'string') {
+                        // For "one" category, prefer the general defaultValue
+                        finalDefaultValue = defaultValue;
+                    }
+                    else if (category === 'one' && typeof defaultValueFromCall === 'string') {
+                        // For "one" category, also consider defaultValueFromCall
+                        finalDefaultValue = defaultValueFromCall;
+                    }
+                    else if (isOrdinal && typeof ordinalOtherDefault === 'string') {
+                        // For ordinals (non-one categories), fall back to ordinal_other
+                        finalDefaultValue = ordinalOtherDefault;
+                    }
+                    else if (!isOrdinal && typeof otherDefault === 'string') {
+                        // For cardinals (non-one categories), fall back to _other
+                        finalDefaultValue = otherDefault;
+                    }
+                    else if (typeof defaultValue === 'string') {
+                        // General defaultValue as fallback
+                        finalDefaultValue = defaultValue;
+                    }
+                    else if (typeof defaultValueFromCall === 'string') {
+                        // defaultValueFromCall as fallback
+                        finalDefaultValue = defaultValueFromCall;
+                    }
+                    else {
+                        // Final fallback to the base key itself
+                        finalDefaultValue = baseKey;
+                    }
+                    // 3. Construct the final plural key
+                    let finalKey;
+                    if (context) {
+                        const contextSeparator = this.config.extract.contextSeparator ?? '_';
+                        finalKey = isOrdinal
+                            ? `${baseKey}${contextSeparator}${context}${pluralSeparator}ordinal${pluralSeparator}${category}`
+                            : `${baseKey}${contextSeparator}${context}${pluralSeparator}${category}`;
+                    }
+                    else {
+                        finalKey = isOrdinal
+                            ? `${baseKey}${pluralSeparator}ordinal${pluralSeparator}${category}`
+                            : `${baseKey}${pluralSeparator}${category}`;
+                    }
+                    this.pluginContext.addKey({
+                        key: finalKey,
+                        ns,
+                        defaultValue: finalDefaultValue,
+                        hasCount: true,
+                        isOrdinal,
+                        // Only treat plural/context variant as explicit when:
+                        // - the extractor marked the source as explicitly providing plural defaults
+                        // - OR a plural-specific default was provided in the options (specificDefault/otherDefault)
+                        // Do NOT treat the presence of a general base defaultValueFromCall as making variants explicit.
+                        explicitDefault: Boolean(explicitDefaultFromSource || typeof specificDefault === 'string' || typeof otherDefault === 'string'),
+                        // If this is a context variant, track the base key (without context or plural suffixes)
+                        keyAcceptingContext: context !== undefined ? key : undefined
+                    });
+                }
+            }
+        }
+        catch (e) {
+            this.logger.warn(`Could not determine plural rules for language "${this.config.extract?.primaryLanguage}". Falling back to simple key extraction.`);
+            // Fallback to a simple key if Intl API fails
+            const defaultValue = defaultValueFromCall || astUtils.getObjectPropValue(options, 'defaultValue');
+            this.pluginContext.addKey({ key, ns, defaultValue: typeof defaultValue === 'string' ? defaultValue : key });
+        }
+    }
+    /**
+     * Serializes a callee node (Identifier or MemberExpression) into a string.
+     *
+     * Produces a dotted name for simple callees that can be used for scope lookups
+     * or configuration matching.
+     *
+     * @param callee - The CallExpression callee node to serialize
+     * @returns A dotted string name for supported callees, or null when the callee
+     *          is a computed/unsupported expression.
+     */
+    getFunctionName(callee) {
+        if (callee.type === 'Identifier') {
+            return callee.value;
+        }
+        if (callee.type === 'MemberExpression') {
+            const parts = [];
+            let current = callee;
+            while (current.type === 'MemberExpression') {
+                if (current.property.type === 'Identifier') {
+                    parts.unshift(current.property.value);
+                }
+                else {
+                    return null; // Cannot handle computed properties like i18n['t']
+                }
+                current = current.object;
+            }
+            // Handle `this` as the base of the expression (e.g., this._i18n.t)
+            if (current.type === 'ThisExpression') {
+                parts.unshift('this');
+            }
+            else if (current.type === 'Identifier') {
+                parts.unshift(current.value);
+            }
+            else {
+                return null; // Base of the expression is not a simple identifier
+            }
+            return parts.join('.');
+        }
+        return null;
+    }
+}
+
+exports.CallExpressionHandler = CallExpressionHandler;