wuchale 0.17.5 → 0.18.0

package/dist/adapter-utils/index.d.ts

@@ -1,8 +1,8 @@
 export { MixedVisitor } from './mixed-visitor.js';
+import type { HeuristicResultChecked } from '../adapters.js';
 export declare const varNames: {
     rt: string;
     hmrUpdate: string;
-    rtWrap: string;
 };
 export declare function runtimeVars(wrapFunc: (expr: string) => string, base?: string): {
     rtTrans: string;
@@ -17,12 +17,11 @@ export declare function runtimeVars(wrapFunc: (expr: string) => string, base?: s
 };
 export type RuntimeVars = ReturnType<typeof runtimeVars>;
 export declare function nonWhitespaceText(msgStr: string): [number, string, number];
-export declare function getDependencies(): Promise<Set<string>>;
 export declare function loaderPathResolver(importMetaUrl: string, baseDir: string, ext: string): (name: string) => string;
 export declare const commentPrefix = "@wc-";
 export type CommentDirectives = {
     ignoreFile?: boolean;
-    forceInclude?: boolean;
+    forceType?: HeuristicResultChecked;
     context?: string;
 };
 export declare function processCommentDirectives(data: string, current: CommentDirectives): CommentDirectives;

package/dist/adapter-utils/index.js

@@ -1,18 +1,16 @@
-import { readFile } from "node:fs/promises";
 export { MixedVisitor } from './mixed-visitor.js';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 export const varNames = {
     rt: '_w_runtime_',
     hmrUpdate: '_w_hmrUpdate_',
-    rtWrap: '_w_to_rt_',
 };
 export function runtimeVars(wrapFunc, base = varNames.rt) {
     return {
         rtTrans: `${wrapFunc(base)}.t`,
         rtTPlural: `${wrapFunc(base)}.tp`,
         rtPlural: `${wrapFunc(base)}._.p`,
-        rtLocale: `${wrapFunc(base)}._.l`,
+        rtLocale: `${wrapFunc(base)}.l`,
         rtCtx: `${wrapFunc(base)}.cx`,
         rtTransCtx: `${wrapFunc(base)}.tx`,
         rtTransTag: `${wrapFunc(base)}.tt`,
@@ -27,19 +25,6 @@ export function nonWhitespaceText(msgStr) {
     const endWh = trimmedS.length - trimmed.length;
     return [startWh, trimmed, endWh];
 }
-export async function getDependencies() {
-    let json = { devDependencies: {}, dependencies: {} };
-    try {
-        const pkgJson = await readFile('package.json');
-        json = JSON.parse(pkgJson.toString());
-    }
-    catch (err) {
-        if (err.code !== 'ENOENT') {
-            throw err;
-        }
-    }
-    return new Set(Object.keys({ ...json.devDependencies, ...json.dependencies }));
-}
 export function loaderPathResolver(importMetaUrl, baseDir, ext) {
     const dir = dirname(fileURLToPath(importMetaUrl));
     return (name) => resolve(dir, `${baseDir}/${name}.${ext}`);
@@ -49,15 +34,19 @@ const commentDirectives = {
     ignore: `${commentPrefix}ignore`,
     ignoreFile: `${commentPrefix}ignore-file`,
     include: `${commentPrefix}include`,
+    url: `${commentPrefix}url`,
     context: `${commentPrefix}context:`,
 };
 export function processCommentDirectives(data, current) {
     const directives = { ...current };
     if (data === commentDirectives.ignore) {
-        directives.forceInclude = false;
+        directives.forceType = false;
     }
     if (data === commentDirectives.include) {
-        directives.forceInclude = true;
+        directives.forceType = 'message';
+    }
+    if (data === commentDirectives.url) {
+        directives.forceType = 'url';
     }
     if (data === commentDirectives.ignoreFile) {
         directives.ignoreFile = true;

package/dist/adapter-utils/mixed-visitor.d.ts

@@ -1,5 +1,5 @@
 import type MagicString from "magic-string";
-import { IndexTracker, Message, type HeuristicDetails, type HeuristicDetailsBase, type HeuristicFunc } from "../adapters.js";
+import { IndexTracker, Message, type HeuristicDetails, type HeuristicDetailsBase, type HeuristicFunc, type MessageType } from "../adapters.js";
 import { type RuntimeVars, type CommentDirectives } from "./index.js";
 type NestedRanges = [number, number, boolean][];
 type InitProps<NodeT> = {
@@ -37,7 +37,7 @@ export interface MixedVisitor<NodeT> extends InitProps<NodeT> {
 }
 export declare class MixedVisitor<NodeT> {
     constructor(props: InitProps<NodeT>);
-    separatelyVisitChildren: (props: VisitProps<NodeT>) => [boolean, boolean, boolean, Message[]];
+    separatelyVisitChildren: (props: VisitProps<NodeT>) => [boolean, boolean, boolean, MessageType, Message[]];
     visit: (props: VisitProps<NodeT>) => Message[];
 }
 export {};

package/dist/adapter-utils/mixed-visitor.js

@@ -17,7 +17,7 @@ export class MixedVisitor {
                     continue;
                 }
                 hasTextChild = true;
-                heurStr += strContent + ' ';
+                heurStr += strContent;
             }
             else if (this.isComment(child)) {
                 if (this.getCommentData(child).trim().startsWith(commentPrefix)) {
@@ -26,7 +26,7 @@ export class MixedVisitor {
             }
             else if (!this.leaveInPlace(child)) {
                 hasNonTextChild = true;
-                heurStr += `# `;
+                heurStr += `#`;
             }
         }
         heurStr = heurStr.trimEnd();
@@ -35,11 +35,12 @@ export class MixedVisitor {
             element: props.element,
             attribute: props.attribute,
         }), null);
-        const passHeuristic = this.checkHeuristic(msg);
-        let hasCompoundText = hasTextChild && hasNonTextChild;
-        const visitAsOne = passHeuristic && !hasCommentDirectives;
-        if (props.inCompoundText || hasCompoundText && visitAsOne) {
-            return [false, hasTextChild, hasCompoundText, []];
+        const heurMsgType = this.checkHeuristic(msg);
+        if (heurMsgType) {
+            let hasCompoundText = hasTextChild && hasNonTextChild;
+            if (props.inCompoundText || hasCompoundText && !hasCommentDirectives) {
+                return [false, hasTextChild, hasCompoundText, heurMsgType, []];
+            }
         }
         // can't be extracted as one; visit each separately if markup
         const msgs = [];
@@ -48,13 +49,13 @@ export class MixedVisitor {
                 msgs.push(...this.visitFunc(child, props.inCompoundText));
             }
         }
-        return [true, false, false, msgs];
+        return [true, false, false, heurMsgType || 'message', msgs];
     };
     visit = (props) => {
         if (props.children.length === 0) {
             return [];
         }
-        const [visitedSeparately, hasTextChild, hasCompoundText, separateTxts] = this.separatelyVisitChildren(props);
+        const [visitedSeparately, hasTextChild, hasCompoundText, heurMsgType, separateTxts] = this.separatelyVisitChildren(props);
         if (visitedSeparately) {
             return separateTxts;
         }
@@ -143,6 +144,7 @@ export class MixedVisitor {
             return msgs;
         }
         const msgInfo = new Message(msgStr, this.fullHeuristicDetails({ scope: props.scope }), props.commentDirectives.context);
+        msgInfo.type = heurMsgType;
         msgInfo.comments = comments;
         if (hasTextChild || hasTextDescendants) {
             msgs.push(msgInfo);

package/dist/adapter-vanilla/index.d.ts

@@ -1,6 +1,11 @@
-import type { AdapterArgs, Adapter, CodePattern } from "../adapters.js";
+import type { AdapterArgs, Adapter, CodePattern, LoaderChoice } from "../adapters.js";
 import { Transformer } from "./transformer.js";
 export { Transformer };
 export { parseScript, scriptParseOptions, scriptParseOptionsWithComments } from './transformer.js';
 export declare const pluralPattern: CodePattern;
-export declare const adapter: (args?: AdapterArgs) => Adapter;
+type LoadersAvailable = 'bundle' | 'server' | 'vite';
+export declare function getDefaultLoaderPath(loader: LoaderChoice<LoadersAvailable>, bundle: boolean): string | {
+    client: string;
+    server: string;
+};
+export declare const adapter: (args?: AdapterArgs<LoadersAvailable>) => Adapter;

package/dist/adapter-vanilla/index.js

@@ -2,7 +2,7 @@
 import { defaultGenerateLoadID, defaultHeuristicFuncOnly } from '../adapters.js';
 import { deepMergeObjects } from "../config.js";
 import { Transformer } from "./transformer.js";
-import { getDependencies, loaderPathResolver } from '../adapter-utils/index.js';
+import { loaderPathResolver } from '../adapter-utils/index.js';
 export { Transformer };
 export { parseScript, scriptParseOptions, scriptParseOptionsWithComments } from './transformer.js';
 export const pluralPattern = {
@@ -11,53 +11,44 @@ export const pluralPattern = {
 };
 const defaultArgs = {
     files: { include: 'src/**/*.{js,ts}', ignore: '**/*.d.ts' },
-    catalog: './src/locales/{locale}',
+    localesDir: './src/locales',
     patterns: [pluralPattern],
     heuristic: defaultHeuristicFuncOnly,
     granularLoad: false,
     bundleLoad: false,
     generateLoadID: defaultGenerateLoadID,
-    writeFiles: {},
+    loader: 'vite',
     runtime: {
         useReactive: ({ nested }) => ({
             init: nested ? null : false,
             use: nested ? null : false,
         }),
         plain: {
-            importName: 'default',
             wrapInit: expr => expr,
             wrapUse: expr => expr,
         }
     }
 };
 const resolveLoaderPath = loaderPathResolver(import.meta.url, '../../src/adapter-vanilla/loaders', 'js');
+export function getDefaultLoaderPath(loader, bundle) {
+    if (bundle) {
+        return resolveLoaderPath('bundle');
+    }
+    if (loader === 'vite') {
+        return {
+            client: resolveLoaderPath('vite'),
+            server: resolveLoaderPath('vite.ssr'),
+        };
+    }
+    return resolveLoaderPath(loader);
+}
 export const adapter = (args = defaultArgs) => {
-    const { heuristic, patterns, runtime, ...rest } = deepMergeObjects(args, defaultArgs);
+    const { heuristic, patterns, runtime, loader, ...rest } = deepMergeObjects(args, defaultArgs);
     return {
-        transform: ({ content, filename, index, expr }) => new Transformer(content, filename, index, heuristic, patterns, expr, runtime).transform(),
+        transform: ({ content, filename, index, expr, matchUrl }) => new Transformer(content, filename, index, heuristic, patterns, expr, runtime, matchUrl).transform(),
         loaderExts: ['.js', '.ts'],
-        defaultLoaders: async () => {
-            if (rest.bundleLoad) {
-                return ['bundle'];
-            }
-            const deps = await getDependencies();
-            const available = ['server'];
-            if (deps.has('vite')) {
-                available.unshift('vite');
-            }
-            return available;
-        },
-        defaultLoaderPath: (loader) => {
-            if (loader === 'vite') {
-                return {
-                    client: resolveLoaderPath('vite'),
-                    server: resolveLoaderPath('vite.ssr'),
-                };
-            }
-            return resolveLoaderPath(loader);
-        },
+        defaultLoaderPath: getDefaultLoaderPath(loader, rest.bundleLoad),
         runtime,
         ...rest,
-        docsUrl: 'https://wuchale.dev/adapters/vanilla'
     };
 };

package/dist/adapter-vanilla/transformer.d.ts

@@ -1,7 +1,7 @@
 import MagicString from "magic-string";
 import type * as Estree from "acorn";
 import { Message } from '../adapters.js';
-import type { HeuristicDetailsBase, HeuristicFunc, IndexTracker, ScriptDeclType, TransformOutput, HeuristicDetails, RuntimeConf, CatalogExpr, CodePattern } from "../adapters.js";
+import type { HeuristicDetailsBase, HeuristicFunc, IndexTracker, ScriptDeclType, TransformOutput, HeuristicDetails, RuntimeConf, CatalogExpr, CodePattern, UrlMatcher, HeuristicResultChecked, MessageType } from "../adapters.js";
 import { type RuntimeVars, type CommentDirectives } from "../adapter-utils/index.js";
 export declare const scriptParseOptions: Estree.Options;
 export declare function scriptParseOptionsWithComments(): [Estree.Options, Estree.Comment[][]];
@@ -15,6 +15,7 @@ export declare class Transformer {
     filename: string;
     mstr: MagicString;
     patterns: CodePattern[];
+    matchUrl: UrlMatcher;
     initRuntime: InitRuntimeFunc;
     currentRtVar: string;
     vars: () => RuntimeVars;
@@ -25,16 +26,15 @@ export declare class Transformer {
     currentFuncDef: string | null;
     currentCall: string;
     currentTopLevelCall: string;
+    /** .start of the first statements in their respective parents, to put the runtime init before */
+    realBodyStarts: Set<number>;
     /** for subclasses. right now for svelte, if in <script module> */
     additionalState: object;
-    constructor(content: string, filename: string, index: IndexTracker, heuristic: HeuristicFunc, patterns: CodePattern[], catalogExpr: CatalogExpr, rtConf: RuntimeConf, rtBaseVars?: string[]);
+    constructor(content: string, filename: string, index: IndexTracker, heuristic: HeuristicFunc, patterns: CodePattern[], catalogExpr: CatalogExpr, rtConf: RuntimeConf, matchUrl: (url: string) => string, rtBaseVars?: string[]);
     fullHeuristicDetails: (detailsBase: HeuristicDetailsBase) => HeuristicDetails;
-    checkHeuristicBool: (msg: Message) => boolean;
-    checkHeuristic: (msgStr: string, detailsBase: HeuristicDetailsBase) => [boolean, Message];
-    visitLiteral: (node: Estree.Literal & {
-        start: number;
-        end: number;
-    }) => Message[];
+    getHeuristicMessageType: (msg: Message) => HeuristicResultChecked;
+    checkHeuristic: (msgStr: string, detailsBase: HeuristicDetailsBase) => [HeuristicResultChecked, Message];
+    visitLiteral: (node: Estree.Literal, heuristicDetailsBase?: HeuristicDetailsBase) => Message[];
     visitArrayExpression: (node: Estree.ArrayExpression) => Message[];
     visitSequenceExpression: (node: Estree.SequenceExpression) => Message[];
     visitObjectExpression: (node: Estree.ObjectExpression) => Message[];
@@ -65,6 +65,7 @@ export declare class Transformer {
     visitVariableDeclaration: (node: Estree.VariableDeclaration) => Message[];
     visitExportNamedDeclaration: (node: Estree.ExportNamedDeclaration) => Message[];
     visitExportDefaultDeclaration: (node: Estree.ExportNamedDeclaration) => Message[];
+    visitStatementsNSaveRealBodyStart: (nodes: (Estree.Statement | Estree.ModuleDeclaration)[]) => Message[];
     getRealBodyStart: (nodes: (Estree.Statement | Estree.ModuleDeclaration)[]) => number | undefined;
     visitFunctionBody: (node: Estree.BlockStatement | Estree.Expression, name: string | null, end?: number) => Message[];
     visitFunctionDeclaration: (node: Estree.FunctionDeclaration) => Message[];
@@ -74,11 +75,12 @@ export declare class Transformer {
     visitReturnStatement: (node: Estree.ReturnStatement) => Message[];
     visitIfStatement: (node: Estree.IfStatement) => Message[];
     visitClassDeclaration: (node: Estree.ClassDeclaration) => Message[];
-    checkHeuristicTemplateLiteral: (node: Estree.TemplateLiteral) => boolean;
-    visitTemplateLiteralQuasis: (node: Estree.TemplateLiteral) => [number, Message[]];
-    visitTemplateLiteral: (node: Estree.TemplateLiteral, ignoreHeuristic?: boolean) => Message[];
+    checkHeuristicTemplateLiteral: (node: Estree.TemplateLiteral, heurDetails?: HeuristicDetailsBase) => HeuristicResultChecked;
+    visitTemplateLiteralQuasis: (node: Estree.TemplateLiteral, msgTyp: MessageType) => [number, Message[]];
+    visitTemplateLiteral: (node: Estree.TemplateLiteral, heurDetails?: HeuristicDetailsBase | boolean) => Message[];
     visitTaggedTemplateExpression: (node: Estree.TaggedTemplateExpression) => Message[];
     visitProgram: (node: Estree.Program) => Message[];
+    visitWithCommentDirectives: (node: Estree.AnyNode, func: Function) => any;
     visit: (node: Estree.AnyNode) => Message[];
     finalize: (msgs: Message[], hmrHeaderIndex: number, additionalHeader?: string) => TransformOutput;
     transform: () => TransformOutput;

package/dist/adapter-vanilla/transformer.js

@@ -48,6 +48,7 @@ export class Transformer {
     filename;
     mstr;
     patterns;
+    matchUrl;
     initRuntime;
     currentRtVar;
     vars;
@@ -59,14 +60,17 @@ export class Transformer {
     currentFuncDef = null;
     currentCall;
     currentTopLevelCall;
+    /** .start of the first statements in their respective parents, to put the runtime init before */
+    realBodyStarts = new Set();
     /** for subclasses. right now for svelte, if in <script module> */
     additionalState = {};
-    constructor(content, filename, index, heuristic, patterns, catalogExpr, rtConf, rtBaseVars = [varNames.rt]) {
+    constructor(content, filename, index, heuristic, patterns, catalogExpr, rtConf, matchUrl, rtBaseVars = [varNames.rt]) {
         this.index = index;
         this.heuristic = heuristic;
         this.patterns = patterns;
         this.content = content;
         this.filename = filename;
+        this.matchUrl = matchUrl;
         const topLevelUseReactive = rtConf.useReactive({
             funcName: null,
             nested: false,
@@ -99,8 +103,7 @@ export class Transformer {
             }
             const wrapInit = useReactive.init ? rtConf.reactive.wrapInit : rtConf.plain.wrapInit;
             const expr = useReactive.init ? catalogExpr.reactive : catalogExpr.plain;
-            const runtimeExpr = `${varNames.rtWrap}(${expr})`;
-            return `\nconst ${this.currentRtVar} = ${wrapInit(runtimeExpr)}\n`;
+            return `\nconst ${this.currentRtVar} = ${wrapInit(expr)}\n`;
         };
     }
     fullHeuristicDetails = (detailsBase) => {
@@ -117,17 +120,20 @@ export class Transformer {
         }
         return details;
     };
-    checkHeuristicBool = (msg) => {
+    getHeuristicMessageType = (msg) => {
         const msgStr = msg.msgStr.join('\n');
         if (!msgStr) {
             // nothing to ask
             return false;
         }
-        let extract = this.commentDirectives.forceInclude;
-        if (extract == null) {
-            extract = this.heuristic(msg) ?? defaultHeuristicFuncOnly(msg) ?? true;
+        if (this.commentDirectives.forceType === false) {
+            return false;
+        }
+        const heuRes = this.heuristic(msg) ?? defaultHeuristicFuncOnly(msg) ?? 'message';
+        if (this.commentDirectives.forceType == null && heuRes === 'url' && this.matchUrl(msgStr) == null) {
+            return false;
         }
-        return extract;
+        return this.commentDirectives.forceType || heuRes;
     };
     checkHeuristic = (msgStr, detailsBase) => {
         if (!msgStr) {
@@ -135,14 +141,18 @@ export class Transformer {
             return [false, null];
         }
         const msg = new Message(msgStr, this.fullHeuristicDetails(detailsBase), this.commentDirectives.context);
-        return [this.checkHeuristicBool(msg), msg];
+        const heuRes = this.getHeuristicMessageType(msg);
+        if (heuRes) {
+            msg.type = heuRes;
+        }
+        return [heuRes, msg];
     };
-    visitLiteral = (node) => {
+    visitLiteral = (node, heuristicDetailsBase) => {
         if (typeof node.value !== 'string') {
             return [];
         }
         const { start, end } = node;
-        const [pass, msgInfo] = this.checkHeuristic(node.value, { scope: 'script' });
+        const [pass, msgInfo] = this.checkHeuristic(node.value, heuristicDetailsBase ?? { scope: 'script' });
         if (!pass) {
             return [];
         }
@@ -189,29 +199,53 @@ export class Transformer {
         if (!pattern) {
             return this.defaultVisitCallExpression(node);
         }
+        let iLastNonOther = pattern.args.length - 1; // after this no change will be made
+        for (; iLastNonOther >= 0; iLastNonOther--) {
+            if (pattern.args[iLastNonOther] !== 'other') {
+                break;
+            }
+        }
         const msgs = [];
+        const updates = [];
+        const appends = [];
         let lastArgEnd;
         for (const [i, arg] of pattern.args.entries()) {
             const argVal = node.arguments[i];
             let argInsertIndex;
             if (argVal == null) {
+                argInsertIndex = lastArgEnd ?? node.callee.end + 1;
                 if (lastArgEnd == null) {
-                    return this.defaultVisitCallExpression(node);
+                    lastArgEnd = argInsertIndex;
                 }
-                argInsertIndex = lastArgEnd;
             }
             else {
                 lastArgEnd = argVal.end;
             }
+            const comma = i > 0 ? ', ' : '';
             if (arg === 'other') {
+                if (argVal == null && i < iLastNonOther) {
+                    appends.push([argInsertIndex, `${comma}undefined`]);
+                }
+                continue;
+            }
+            if (arg === 'locale') {
+                if (argVal) {
+                    if (argVal.type !== 'Literal' || typeof argVal.value !== 'string') {
+                        continue;
+                    }
+                    updates.push([argVal.start, argVal.end, this.vars().rtLocale]);
+                }
+                else {
+                    appends.push([argInsertIndex, `${comma}${this.vars().rtLocale}`]);
+                }
                 continue;
             }
             if (arg === 'pluralFunc') {
                 if (argVal) {
-                    this.mstr.update(argVal.start, argVal.end, this.vars().rtPlural);
+                    updates.push([argVal.start, argVal.end, this.vars().rtPlural]);
                 }
                 else {
-                    this.mstr.appendRight(argInsertIndex, `, ${this.vars().rtPlural}`);
+                    appends.push([argInsertIndex, `${comma}${this.vars().rtPlural}`]);
                 }
                 continue;
             }
@@ -224,7 +258,7 @@ export class Transformer {
                     return this.defaultVisitCallExpression(node);
                 }
                 const msgInfo = new Message(argVal.value, this.fullHeuristicDetails({ scope: 'script' }), this.commentDirectives.context);
-                this.mstr.update(argVal.start, argVal.end, `${this.vars().rtTrans}(${this.index.get(msgInfo.toKey())})`);
+                updates.push([argVal.start, argVal.end, `${this.vars().rtTrans}(${this.index.get(msgInfo.toKey())})`]);
                 msgs.push(msgInfo);
                 continue;
             }
@@ -247,7 +281,13 @@ export class Transformer {
             msgInfo.plural = true;
             const index = this.index.get(msgInfo.toKey());
             msgs.push(msgInfo);
-            this.mstr.update(argVal.start, argVal.end, `${this.vars().rtTPlural}(${index})`);
+            updates.push([argVal.start, argVal.end, `${this.vars().rtTPlural}(${index})`]);
+        }
+        for (const [start, end, by] of updates) {
+            this.mstr.update(start, end, by);
+        }
+        for (const [index, insert] of appends) {
+            this.mstr.appendRight(index, insert);
         }
         return msgs;
     };
@@ -348,14 +388,40 @@ export class Transformer {
     visitVariableDeclaration = (node) => node.declarations.map(this.visitVariableDeclarator).flat();
     visitExportNamedDeclaration = (node) => node.declaration ? this.visit(node.declaration) : [];
     visitExportDefaultDeclaration = this.visitExportNamedDeclaration;
+    visitStatementsNSaveRealBodyStart = (nodes) => {
+        const msgs = [];
+        let bodyStart = null;
+        for (const bod of nodes) {
+            let currentContent;
+            if (bodyStart == null) {
+                currentContent = this.mstr.toString();
+            }
+            const msgsBod = this.visit(bod);
+            if (bodyStart == null && this.mstr.toString() !== currentContent) {
+                bodyStart = bod.start;
+            }
+            if (msgsBod.length) {
+                msgs.push(...msgsBod);
+            }
+        }
+        if (bodyStart) {
+            this.realBodyStarts.add(bodyStart);
+        }
+        return msgs;
+    };
     getRealBodyStart = (nodes) => {
+        let nonLiteralStart = null;
         for (const node of nodes) {
-            if (node.type === 'ExpressionStatement' && node.expression.type === 'Literal') {
-                continue;
+            if (this.realBodyStarts.has(node.start)) {
+                return node.start;
+            }
+            if (nonLiteralStart == null
+                && node.type !== 'ImportDeclaration'
+                && (node.type !== 'ExpressionStatement' || node.expression.type !== 'Literal')) {
+                nonLiteralStart = node.start;
             }
-            return node.start;
         }
-        return nodes[0]?.start;
+        return nonLiteralStart ?? nodes[0]?.start;
     };
     visitFunctionBody = (node, name, end) => {
         const prevFuncDef = this.currentFuncDef;
@@ -400,7 +466,7 @@ export class Transformer {
     };
     visitArrowFunctionExpression = (node) => this.visitFunctionBody(node.body, '', node.end);
     visitFunctionExpression = (node) => this.visitFunctionBody(node.body, '');
-    visitBlockStatement = (node) => node.body.map(this.visit).flat();
+    visitBlockStatement = (node) => this.visitStatementsNSaveRealBodyStart(node.body);
     visitReturnStatement = (node) => node.argument ? this.visit(node.argument) : [];
     visitIfStatement = (node) => {
         const msgs = this.visit(node.test);
@@ -430,7 +496,7 @@ export class Transformer {
         this.declaring = prevDecl; // restore
         return msgs;
     };
-    checkHeuristicTemplateLiteral = (node) => {
+    checkHeuristicTemplateLiteral = (node, heurDetails) => {
         let heurTxt = '';
         for (const quasi of node.quasis) {
             heurTxt += quasi.value.cooked ?? '';
@@ -439,10 +505,10 @@ export class Transformer {
             }
         }
         heurTxt = heurTxt.trim();
-        const [pass] = this.checkHeuristic(heurTxt, { scope: 'script' });
+        const [pass] = this.checkHeuristic(heurTxt, heurDetails ?? { scope: 'script' });
         return pass;
     };
-    visitTemplateLiteralQuasis = (node) => {
+    visitTemplateLiteralQuasis = (node, msgTyp) => {
         const msgs = [];
         let msgStr = node.quasis[0].value?.cooked ?? '';
         const comments = [];
@@ -460,18 +526,22 @@ export class Transformer {
             this.mstr.update(end, end + 2, ', ');
         }
         const msgInfo = new Message(msgStr, this.fullHeuristicDetails({ scope: 'script' }), this.commentDirectives.context);
+        msgInfo.type = msgTyp;
         msgInfo.comments = comments;
         const index = this.index.get(msgInfo.toKey());
         msgs.push(msgInfo);
         return [index, msgs];
     };
-    visitTemplateLiteral = (node, ignoreHeuristic = false) => {
-        if (!ignoreHeuristic) {
-            if (!this.checkHeuristicTemplateLiteral(node)) {
+    visitTemplateLiteral = (node, heurDetails = false) => {
+        let msgTyp = 'message';
+        if (heurDetails !== true) {
+            const heuRes = this.checkHeuristicTemplateLiteral(node, typeof heurDetails === 'boolean' ? undefined : heurDetails);
+            if (!heuRes) {
                 return node.expressions.map(this.visit).flat();
             }
+            msgTyp = heuRes;
         }
-        const [index, msgs] = this.visitTemplateLiteralQuasis(node);
+        const [index, msgs] = this.visitTemplateLiteralQuasis(node, msgTyp);
         const { start: start0, end: end0 } = node.quasis[0];
         let begin = `${this.vars().rtTrans}(${index}`;
         let end = ')';
@@ -491,8 +561,9 @@ export class Transformer {
         const prevCall = this.currentCall;
         this.currentCall = this.getCalleeName(node.tag);
         let msgs = [];
-        if (this.checkHeuristicTemplateLiteral(node.quasi)) {
-            const [index, msgsNew] = this.visitTemplateLiteralQuasis(node.quasi);
+        const heuRes = this.checkHeuristicTemplateLiteral(node.quasi);
+        if (heuRes) {
+            const [index, msgsNew] = this.visitTemplateLiteralQuasis(node.quasi, heuRes);
             msgs = msgsNew;
             this.mstr.appendRight(node.tag.start, `${this.vars().rtTransTag}(`);
             const { start, end, expressions } = node.quasi;
@@ -509,17 +580,14 @@ export class Transformer {
         return msgs;
     };
     visitProgram = (node) => {
-        const msgs = [];
         this.insideProgram = true;
-        for (const child of node.body) {
-            msgs.push(...this.visit(child));
-        }
+        const msgs = this.visitStatementsNSaveRealBodyStart(node.body);
         this.insideProgram = false;
         return msgs;
     };
-    visit = (node) => {
-        // for estree
+    visitWithCommentDirectives = (node, func) => {
         const commentDirectives = { ...this.commentDirectives };
+        // for estree
         const comments = this.comments[node.start];
         // @ts-expect-error
         for (const comment of node.leadingComments ?? comments ?? []) {
@@ -528,18 +596,23 @@ export class Transformer {
         if (this.commentDirectives.ignoreFile) {
             return [];
         }
+        const res = func();
+        this.commentDirectives = commentDirectives; // restore
+        return res;
+    };
+    visit = (node) => this.visitWithCommentDirectives(node, () => {
+        if (this.commentDirectives.forceType === false) {
+            return [];
+        }
         let msgs = [];
-        if (this.commentDirectives.forceInclude !== false) {
-            const methodName = `visit${node.type}`;
-            if (methodName in this) {
-                msgs = this[methodName](node);
-                // } else {
-                //     console.log(node)
-            }
+        const methodName = `visit${node.type}`;
+        if (methodName in this) {
+            msgs = this[methodName](node);
+            // } else {
+            //     console.log(node)
         }
-        this.commentDirectives = commentDirectives; // restore
         return msgs;
-    };
+    });
     finalize = (msgs, hmrHeaderIndex, additionalHeader = '') => ({
         msgs,
         output: header => {