eslint-plugin-intlayer 9.4.2 → 9.4.4

package/dist/types/index.d.ts

@@ -24,7 +24,7 @@ import { ESLint, Linter } from "eslint";
  * already makes all three compile errors, and `@intlayer/lsp` reports the first
  * as an editor diagnostic — a third report would only add noise.
  */
-declare const rules: {
+export declare const rules: {
   'no-raw-text': IntlayerRule<[NoRawTextOptions?], "rawText" | "rawAttribute" | "rawStringLiteral">;
   'static-dictionary-key': IntlayerRule<[], "dynamicKey" | "dynamicTemplateKey" | "dynamicJsxKey">;
   'no-dynamic-field-access': IntlayerRule<[], "dynamicField" | "dynamicMessageId">;
@@ -32,13 +32,13 @@ declare const rules: {
   'no-unused-content': IntlayerRule<[NoUnusedContentOptions?], "unusedDictionary" | "unusedField" | "duplicateDictionary">;
 };
 /** Rule names this plugin exposes. */
-type IntlayerRuleName = keyof typeof rules;
+export type IntlayerRuleName = keyof typeof rules;
 declare const meta: {
   name: string;
   version: string;
 };
 /** The flat configs this plugin ships. */
-type IntlayerConfigName = 'recommended' | 'strict' | 'contract-only';
+export type IntlayerConfigName = 'recommended' | 'strict' | 'contract-only';
 /**
  * Flat configs, for `eslint.config.js`:
  *
@@ -64,9 +64,9 @@ type IntlayerConfigName = 'recommended' | 'strict' | 'contract-only';
  * output for its duplicate report — spreading a preset should never quietly
  * turn that on.
  */
-declare const configs: Record<IntlayerConfigName, Linter.Config[]>;
+export declare const configs: Record<IntlayerConfigName, Linter.Config[]>;
 /** The plugin object, as consumed by `eslint.config.js`. */
-type IntlayerPlugin = ESLint.Plugin & Iterable<Linter.Config> & {
+export type IntlayerPlugin = ESLint.Plugin & Iterable<Linter.Config> & {
   meta: {
     name: string;
     version: string;
@@ -76,5 +76,5 @@ type IntlayerPlugin = ESLint.Plugin & Iterable<Linter.Config> & {
 };
 declare const intlayerPlugin: IntlayerPlugin;
 //#endregion
-export { GENERATED_OUTPUT_GLOBS, IntlayerConfigName, IntlayerPlugin, IntlayerRuleName, type NoRawTextOptions, type NoUnusedContentOptions, PLUGIN_NAMESPACE, PLUGIN_PACKAGE_NAME, RECOMMENDED_RULES, configs, intlayerPlugin as default, getReactVersion, getRecommendedRules, meta, rules };
+export { GENERATED_OUTPUT_GLOBS, type NoRawTextOptions, type NoUnusedContentOptions, PLUGIN_NAMESPACE, PLUGIN_PACKAGE_NAME, RECOMMENDED_RULES, intlayerPlugin as default, getReactVersion, getRecommendedRules, meta };
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cA+Ba;+BAAA;;;;;;;KASD,gCAAgC;cAEtC;EAAQ;EAAc;;;KAQhB;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DC,SAAS,OAAO,oBAAoB,OAAO;;KA2B5C,iBAAiB,OAAO,SAClC,SAAS,OAAO;EACd;IAAQ;IAAc;;EACtB,cAAc;EACd,SAAS,OAAO,oBAAoB,OAAO;;cAGzC,gBAAgB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;qBA+Ba;+BAAA;;;;;;;YASD,gCAAgC;cAEtC;EAAQ;EAAc;;;YAQhB;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4DC,SAAS,OAAO,oBAAoB,OAAO;;YA2B5C,iBAAiB,OAAO,SAClC,SAAS,OAAO;EACd;IAAQ;IAAc;;EACtB,cAAc;EACd,SAAS,OAAO,oBAAoB,OAAO;;cAGzC,gBAAgB"}

package/dist/types/node_modules/.bun/@types_estree@1.0.9/node_modules/@types/estree/index.d.ts

@@ -16,7 +16,7 @@
 // This makes the definitions file here somewhat more difficult to maintain,
 // but it has the notable advantage of making ESTree much easier to use as
 // an end user.
-interface BaseNodeWithoutComments {
+export interface BaseNodeWithoutComments {
   // Every leaf interface that extends BaseNode must specify a type property.
   // The type property should be a string literal. For example, Identifier
   // has: `type: "Identifier"`
@@ -24,11 +24,11 @@ interface BaseNodeWithoutComments {
   loc?: SourceLocation | null | undefined;
   range?: [number, number] | undefined;
 }
-interface BaseNode extends BaseNodeWithoutComments {
+export interface BaseNode extends BaseNodeWithoutComments {
   leadingComments?: Comment[] | undefined;
   trailingComments?: Comment[] | undefined;
 }
-interface NodeMap {
+export interface NodeMap {
   AssignmentProperty: AssignmentProperty;
   CatchClause: CatchClause;
   Class: Class;
@@ -52,34 +52,34 @@ interface NodeMap {
   TemplateElement: TemplateElement;
   VariableDeclarator: VariableDeclarator;
 }
-type Node = NodeMap[keyof NodeMap];
-interface Comment extends BaseNodeWithoutComments {
+export type Node = NodeMap[keyof NodeMap];
+export interface Comment extends BaseNodeWithoutComments {
   type: "Line" | "Block";
   value: string;
 }
-interface SourceLocation {
+export interface SourceLocation {
   source?: string | null | undefined;
   start: Position;
   end: Position;
 }
-interface Position {
+export interface Position {
   /** >= 1 */
   line: number;
   /** >= 0 */
   column: number;
 }
-interface Program extends BaseNode {
+export interface Program extends BaseNode {
   type: "Program";
   sourceType: "script" | "module";
   body: Array<Directive | Statement | ModuleDeclaration>;
   comments?: Comment[] | undefined;
 }
-interface Directive extends BaseNode {
+export interface Directive extends BaseNode {
   type: "ExpressionStatement";
   expression: Literal;
   directive: string;
 }
-interface BaseFunction extends BaseNode {
+export interface BaseFunction extends BaseNode {
   params: Pattern[];
   generator?: boolean | undefined;
   async?: boolean | undefined;
@@ -88,117 +88,117 @@ interface BaseFunction extends BaseNode {
   // FunctionExpressions have only BlockStatement bodies.
   body: BlockStatement | Expression;
 }
-type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
-type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
-interface BaseStatement extends BaseNode {}
-interface EmptyStatement extends BaseStatement {
+export type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+export type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+export interface BaseStatement extends BaseNode {}
+export interface EmptyStatement extends BaseStatement {
   type: "EmptyStatement";
 }
-interface BlockStatement extends BaseStatement {
+export interface BlockStatement extends BaseStatement {
   type: "BlockStatement";
   body: Statement[];
   innerComments?: Comment[] | undefined;
 }
-interface StaticBlock extends Omit<BlockStatement, "type"> {
+export interface StaticBlock extends Omit<BlockStatement, "type"> {
   type: "StaticBlock";
 }
-interface ExpressionStatement extends BaseStatement {
+export interface ExpressionStatement extends BaseStatement {
   type: "ExpressionStatement";
   expression: Expression;
 }
-interface IfStatement extends BaseStatement {
+export interface IfStatement extends BaseStatement {
   type: "IfStatement";
   test: Expression;
   consequent: Statement;
   alternate?: Statement | null | undefined;
 }
-interface LabeledStatement extends BaseStatement {
+export interface LabeledStatement extends BaseStatement {
   type: "LabeledStatement";
   label: Identifier;
   body: Statement;
 }
-interface BreakStatement extends BaseStatement {
+export interface BreakStatement extends BaseStatement {
   type: "BreakStatement";
   label?: Identifier | null | undefined;
 }
-interface ContinueStatement extends BaseStatement {
+export interface ContinueStatement extends BaseStatement {
   type: "ContinueStatement";
   label?: Identifier | null | undefined;
 }
-interface WithStatement extends BaseStatement {
+export interface WithStatement extends BaseStatement {
   type: "WithStatement";
   object: Expression;
   body: Statement;
 }
-interface SwitchStatement extends BaseStatement {
+export interface SwitchStatement extends BaseStatement {
   type: "SwitchStatement";
   discriminant: Expression;
   cases: SwitchCase[];
 }
-interface ReturnStatement extends BaseStatement {
+export interface ReturnStatement extends BaseStatement {
   type: "ReturnStatement";
   argument?: Expression | null | undefined;
 }
-interface ThrowStatement extends BaseStatement {
+export interface ThrowStatement extends BaseStatement {
   type: "ThrowStatement";
   argument: Expression;
 }
-interface TryStatement extends BaseStatement {
+export interface TryStatement extends BaseStatement {
   type: "TryStatement";
   block: BlockStatement;
   handler?: CatchClause | null | undefined;
   finalizer?: BlockStatement | null | undefined;
 }
-interface WhileStatement extends BaseStatement {
+export interface WhileStatement extends BaseStatement {
   type: "WhileStatement";
   test: Expression;
   body: Statement;
 }
-interface DoWhileStatement extends BaseStatement {
+export interface DoWhileStatement extends BaseStatement {
   type: "DoWhileStatement";
   body: Statement;
   test: Expression;
 }
-interface ForStatement extends BaseStatement {
+export interface ForStatement extends BaseStatement {
   type: "ForStatement";
   init?: VariableDeclaration | Expression | null | undefined;
   test?: Expression | null | undefined;
   update?: Expression | null | undefined;
   body: Statement;
 }
-interface BaseForXStatement extends BaseStatement {
+export interface BaseForXStatement extends BaseStatement {
   left: VariableDeclaration | Pattern;
   right: Expression;
   body: Statement;
 }
-interface ForInStatement extends BaseForXStatement {
+export interface ForInStatement extends BaseForXStatement {
   type: "ForInStatement";
 }
-interface DebuggerStatement extends BaseStatement {
+export interface DebuggerStatement extends BaseStatement {
   type: "DebuggerStatement";
 }
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-interface BaseDeclaration extends BaseStatement {}
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+export interface BaseDeclaration extends BaseStatement {}
+export interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
   type: "FunctionDeclaration";
   /** It is null when a function declaration is a part of the `export default function` statement */
   id: Identifier | null;
   body: BlockStatement;
 }
-interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+export interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
   id: Identifier;
 }
-interface VariableDeclaration extends BaseDeclaration {
+export interface VariableDeclaration extends BaseDeclaration {
   type: "VariableDeclaration";
   declarations: VariableDeclarator[];
   kind: "var" | "let" | "const" | "using" | "await using";
 }
-interface VariableDeclarator extends BaseNode {
+export interface VariableDeclarator extends BaseNode {
   type: "VariableDeclarator";
   id: Pattern;
   init?: Expression | null | undefined;
 }
-interface ExpressionMap {
+export interface ExpressionMap {
   ArrayExpression: ArrayExpression;
   ArrowFunctionExpression: ArrowFunctionExpression;
   AssignmentExpression: AssignmentExpression;
@@ -225,29 +225,29 @@ interface ExpressionMap {
   UpdateExpression: UpdateExpression;
   YieldExpression: YieldExpression;
 }
-type Expression = ExpressionMap[keyof ExpressionMap];
-interface BaseExpression extends BaseNode {}
-type ChainElement = SimpleCallExpression | MemberExpression;
-interface ChainExpression extends BaseExpression {
+export type Expression = ExpressionMap[keyof ExpressionMap];
+export interface BaseExpression extends BaseNode {}
+export type ChainElement = SimpleCallExpression | MemberExpression;
+export interface ChainExpression extends BaseExpression {
   type: "ChainExpression";
   expression: ChainElement;
 }
-interface ThisExpression extends BaseExpression {
+export interface ThisExpression extends BaseExpression {
   type: "ThisExpression";
 }
-interface ArrayExpression extends BaseExpression {
+export interface ArrayExpression extends BaseExpression {
   type: "ArrayExpression";
   elements: Array<Expression | SpreadElement | null>;
 }
-interface ObjectExpression extends BaseExpression {
+export interface ObjectExpression extends BaseExpression {
   type: "ObjectExpression";
   properties: Array<Property | SpreadElement>;
 }
-interface PrivateIdentifier extends BaseNode {
+export interface PrivateIdentifier extends BaseNode {
   type: "PrivateIdentifier";
   name: string;
 }
-interface Property extends BaseNode {
+export interface Property extends BaseNode {
   type: "Property";
   key: Expression;
   value: Expression | Pattern; // Could be an AssignmentProperty
@@ -256,100 +256,100 @@ interface Property extends BaseNode {
   shorthand: boolean;
   computed: boolean;
 }
-interface PropertyDefinition extends BaseNode {
+export interface PropertyDefinition extends BaseNode {
   type: "PropertyDefinition";
   key: Expression | PrivateIdentifier;
   value?: Expression | null | undefined;
   computed: boolean;
   static: boolean;
 }
-interface FunctionExpression extends BaseFunction, BaseExpression {
+export interface FunctionExpression extends BaseFunction, BaseExpression {
   id?: Identifier | null | undefined;
   type: "FunctionExpression";
   body: BlockStatement;
 }
-interface SequenceExpression extends BaseExpression {
+export interface SequenceExpression extends BaseExpression {
   type: "SequenceExpression";
   expressions: Expression[];
 }
-interface UnaryExpression extends BaseExpression {
+export interface UnaryExpression extends BaseExpression {
   type: "UnaryExpression";
   operator: UnaryOperator;
   prefix: true;
   argument: Expression;
 }
-interface BinaryExpression extends BaseExpression {
+export interface BinaryExpression extends BaseExpression {
   type: "BinaryExpression";
   operator: BinaryOperator;
   left: Expression | PrivateIdentifier;
   right: Expression;
 }
-interface AssignmentExpression extends BaseExpression {
+export interface AssignmentExpression extends BaseExpression {
   type: "AssignmentExpression";
   operator: AssignmentOperator;
   left: Pattern | MemberExpression;
   right: Expression;
 }
-interface UpdateExpression extends BaseExpression {
+export interface UpdateExpression extends BaseExpression {
   type: "UpdateExpression";
   operator: UpdateOperator;
   argument: Expression;
   prefix: boolean;
 }
-interface LogicalExpression extends BaseExpression {
+export interface LogicalExpression extends BaseExpression {
   type: "LogicalExpression";
   operator: LogicalOperator;
   left: Expression;
   right: Expression;
 }
-interface ConditionalExpression extends BaseExpression {
+export interface ConditionalExpression extends BaseExpression {
   type: "ConditionalExpression";
   test: Expression;
   alternate: Expression;
   consequent: Expression;
 }
-interface BaseCallExpression extends BaseExpression {
+export interface BaseCallExpression extends BaseExpression {
   callee: Expression | Super;
   arguments: Array<Expression | SpreadElement>;
 }
-type CallExpression = SimpleCallExpression | NewExpression;
-interface SimpleCallExpression extends BaseCallExpression {
+export type CallExpression = SimpleCallExpression | NewExpression;
+export interface SimpleCallExpression extends BaseCallExpression {
   type: "CallExpression";
   optional: boolean;
 }
-interface NewExpression extends BaseCallExpression {
+export interface NewExpression extends BaseCallExpression {
   type: "NewExpression";
 }
-interface MemberExpression extends BaseExpression, BasePattern {
+export interface MemberExpression extends BaseExpression, BasePattern {
   type: "MemberExpression";
   object: Expression | Super;
   property: Expression | PrivateIdentifier;
   computed: boolean;
   optional: boolean;
 }
-type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
-interface BasePattern extends BaseNode {}
-interface SwitchCase extends BaseNode {
+export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+export interface BasePattern extends BaseNode {}
+export interface SwitchCase extends BaseNode {
   type: "SwitchCase";
   test?: Expression | null | undefined;
   consequent: Statement[];
 }
-interface CatchClause extends BaseNode {
+export interface CatchClause extends BaseNode {
   type: "CatchClause";
   param: Pattern | null;
   body: BlockStatement;
 }
-interface Identifier extends BaseNode, BaseExpression, BasePattern {
+export interface Identifier extends BaseNode, BaseExpression, BasePattern {
   type: "Identifier";
   name: string;
 }
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-interface SimpleLiteral extends BaseNode, BaseExpression {
+export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+export interface SimpleLiteral extends BaseNode, BaseExpression {
   type: "Literal";
   value: string | boolean | number | null;
   raw?: string | undefined;
 }
-interface RegExpLiteral extends BaseNode, BaseExpression {
+export interface RegExpLiteral extends BaseNode, BaseExpression {
   type: "Literal";
   value?: RegExp | null | undefined;
   regex: {
@@ -358,49 +358,49 @@ interface RegExpLiteral extends BaseNode, BaseExpression {
   };
   raw?: string | undefined;
 }
-interface BigIntLiteral extends BaseNode, BaseExpression {
+export interface BigIntLiteral extends BaseNode, BaseExpression {
   type: "Literal";
   value?: bigint | null | undefined;
   bigint: string;
   raw?: string | undefined;
 }
-type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
-type LogicalOperator = "||" | "&&" | "??";
-type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
-type UpdateOperator = "++" | "--";
-interface ForOfStatement extends BaseForXStatement {
+export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+export type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+export type LogicalOperator = "||" | "&&" | "??";
+export type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+export type UpdateOperator = "++" | "--";
+export interface ForOfStatement extends BaseForXStatement {
   type: "ForOfStatement";
   await: boolean;
 }
-interface Super extends BaseNode {
+export interface Super extends BaseNode {
   type: "Super";
 }
-interface SpreadElement extends BaseNode {
+export interface SpreadElement extends BaseNode {
   type: "SpreadElement";
   argument: Expression;
 }
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
   type: "ArrowFunctionExpression";
   expression: boolean;
   body: BlockStatement | Expression;
 }
-interface YieldExpression extends BaseExpression {
+export interface YieldExpression extends BaseExpression {
   type: "YieldExpression";
   argument?: Expression | null | undefined;
   delegate: boolean;
 }
-interface TemplateLiteral extends BaseExpression {
+export interface TemplateLiteral extends BaseExpression {
   type: "TemplateLiteral";
   quasis: TemplateElement[];
   expressions: Expression[];
 }
-interface TaggedTemplateExpression extends BaseExpression {
+export interface TaggedTemplateExpression extends BaseExpression {
   type: "TaggedTemplateExpression";
   tag: Expression;
   quasi: TemplateLiteral;
 }
-interface TemplateElement extends BaseNode {
+export interface TemplateElement extends BaseNode {
   type: "TemplateElement";
   tail: boolean;
   value: {
@@ -409,38 +409,38 @@ interface TemplateElement extends BaseNode {
     raw: string;
   };
 }
-interface AssignmentProperty extends Property {
+export interface AssignmentProperty extends Property {
   value: Pattern;
   kind: "init";
   method: boolean; // false
 }
-interface ObjectPattern extends BasePattern {
+export interface ObjectPattern extends BasePattern {
   type: "ObjectPattern";
   properties: Array<AssignmentProperty | RestElement>;
 }
-interface ArrayPattern extends BasePattern {
+export interface ArrayPattern extends BasePattern {
   type: "ArrayPattern";
   elements: Array<Pattern | null>;
 }
-interface RestElement extends BasePattern {
+export interface RestElement extends BasePattern {
   type: "RestElement";
   argument: Pattern;
 }
-interface AssignmentPattern extends BasePattern {
+export interface AssignmentPattern extends BasePattern {
   type: "AssignmentPattern";
   left: Pattern;
   right: Expression;
 }
-type Class = ClassDeclaration | ClassExpression;
-interface BaseClass extends BaseNode {
+export type Class = ClassDeclaration | ClassExpression;
+export interface BaseClass extends BaseNode {
   superClass?: Expression | null | undefined;
   body: ClassBody;
 }
-interface ClassBody extends BaseNode {
+export interface ClassBody extends BaseNode {
   type: "ClassBody";
   body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
 }
-interface MethodDefinition extends BaseNode {
+export interface MethodDefinition extends BaseNode {
   type: "MethodDefinition";
   key: Expression | PrivateIdentifier;
   value: FunctionExpression;
@@ -448,81 +448,80 @@ interface MethodDefinition extends BaseNode {
   computed: boolean;
   static: boolean;
 }
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+export interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
   type: "ClassDeclaration";
   /** It is null when a class declaration is a part of the `export default class` statement */
   id: Identifier | null;
 }
-interface ClassDeclaration extends MaybeNamedClassDeclaration {
+export interface ClassDeclaration extends MaybeNamedClassDeclaration {
   id: Identifier;
 }
-interface ClassExpression extends BaseClass, BaseExpression {
+export interface ClassExpression extends BaseClass, BaseExpression {
   type: "ClassExpression";
   id?: Identifier | null | undefined;
 }
-interface MetaProperty extends BaseExpression {
+export interface MetaProperty extends BaseExpression {
   type: "MetaProperty";
   meta: Identifier;
   property: Identifier;
 }
-type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
-interface BaseModuleDeclaration extends BaseNode {}
-type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
-interface BaseModuleSpecifier extends BaseNode {
+export type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
+export interface BaseModuleDeclaration extends BaseNode {}
+export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+export interface BaseModuleSpecifier extends BaseNode {
   local: Identifier;
 }
-interface ImportDeclaration extends BaseModuleDeclaration {
+export interface ImportDeclaration extends BaseModuleDeclaration {
   type: "ImportDeclaration";
   specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
   attributes: ImportAttribute[];
   source: Literal;
 }
-interface ImportSpecifier extends BaseModuleSpecifier {
+export interface ImportSpecifier extends BaseModuleSpecifier {
   type: "ImportSpecifier";
   imported: Identifier | Literal;
 }
-interface ImportAttribute extends BaseNode {
+export interface ImportAttribute extends BaseNode {
   type: "ImportAttribute";
   key: Identifier | Literal;
   value: Literal;
 }
-interface ImportExpression extends BaseExpression {
+export interface ImportExpression extends BaseExpression {
   type: "ImportExpression";
   source: Expression;
   options?: Expression | null | undefined;
 }
-interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
   type: "ImportDefaultSpecifier";
 }
-interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
   type: "ImportNamespaceSpecifier";
 }
-interface ExportNamedDeclaration extends BaseModuleDeclaration {
+export interface ExportNamedDeclaration extends BaseModuleDeclaration {
   type: "ExportNamedDeclaration";
   declaration?: Declaration | null | undefined;
   specifiers: ExportSpecifier[];
   attributes: ImportAttribute[];
   source?: Literal | null | undefined;
 }
-interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+export interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
   type: "ExportSpecifier";
   local: Identifier | Literal;
   exported: Identifier | Literal;
 }
-interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
   type: "ExportDefaultDeclaration";
   declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
 }
-interface ExportAllDeclaration extends BaseModuleDeclaration {
+export interface ExportAllDeclaration extends BaseModuleDeclaration {
   type: "ExportAllDeclaration";
   exported: Identifier | Literal | null;
   attributes: ImportAttribute[];
   source: Literal;
 }
-interface AwaitExpression extends BaseExpression {
+export interface AwaitExpression extends BaseExpression {
   type: "AwaitExpression";
   argument: Expression;
 }
 //#endregion
-export { ArrayExpression, ArrayPattern, ArrowFunctionExpression, AssignmentExpression, AssignmentOperator, AssignmentPattern, AssignmentProperty, AwaitExpression, BaseCallExpression, BaseClass, BaseDeclaration, BaseExpression, BaseForXStatement, BaseFunction, BaseModuleDeclaration, BaseModuleSpecifier, BaseNode, BaseNodeWithoutComments, BasePattern, BaseStatement, BigIntLiteral, BinaryExpression, BinaryOperator, BlockStatement, BreakStatement, CallExpression, CatchClause, ChainElement, ChainExpression, Class, ClassBody, ClassDeclaration, ClassExpression, Comment, ConditionalExpression, ContinueStatement, DebuggerStatement, Declaration, Directive, DoWhileStatement, EmptyStatement, ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, ExportSpecifier, Expression, ExpressionMap, ExpressionStatement, ForInStatement, ForOfStatement, ForStatement, Function, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, ImportAttribute, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportSpecifier, LabeledStatement, Literal, LogicalExpression, LogicalOperator, MaybeNamedClassDeclaration, MaybeNamedFunctionDeclaration, MemberExpression, MetaProperty, MethodDefinition, ModuleDeclaration, ModuleSpecifier, NewExpression, Node, NodeMap, ObjectExpression, ObjectPattern, Pattern, Position, PrivateIdentifier, Program, Property, PropertyDefinition, RegExpLiteral, RestElement, ReturnStatement, SequenceExpression, SimpleCallExpression, SimpleLiteral, SourceLocation, SpreadElement, Statement, StaticBlock, Super, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, UnaryExpression, UnaryOperator, UpdateExpression, UpdateOperator, VariableDeclaration, VariableDeclarator, WhileStatement, WithStatement, YieldExpression };
 //# sourceMappingURL=index.d.ts.map

package/dist/types/node_modules/.bun/@types_estree@1.0.9/node_modules/@types/estree/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../../../../../../../node_modules/.bun/@types+estree@1.0.9/node_modules/@types/estree/index.d.ts"],"x_google_ignoreList":[0],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../../../../../../../node_modules/.bun/@types+estree@1.0.9/node_modules/@types/estree/index.d.ts"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/types/preset.d.ts

@@ -2,9 +2,9 @@ import { IntlayerRuleName } from "./index.js";
 import { Linter } from "eslint";
 //#region src/preset.d.ts
 /** npm package name of this plugin. */
-declare const PLUGIN_PACKAGE_NAME = "eslint-plugin-intlayer";
+export declare const PLUGIN_PACKAGE_NAME = "eslint-plugin-intlayer";
 /** Prefix the rules are registered under, e.g. `intlayer/no-raw-text`. */
-declare const PLUGIN_NAMESPACE = "intlayer";
+export declare const PLUGIN_NAMESPACE = "intlayer";
 /**
  * Intlayer's generated output, which every preset ignores.
  *
@@ -15,7 +15,7 @@ declare const PLUGIN_NAMESPACE = "intlayer";
  * directory (`content.watchExclude`, the build globs), so the lint preset
  * matches.
  */
-declare const GENERATED_OUTPUT_GLOBS: string[];
+export declare const GENERATED_OUTPUT_GLOBS: string[];
 /**
  * Rules enabled by the `recommended` preset, keyed by unprefixed rule name.
  *
@@ -31,7 +31,7 @@ declare const GENERATED_OUTPUT_GLOBS: string[];
  * opt-in through the `strict` preset. `no-unused-content` is absent from every
  * preset — it scans the project from disk, which no preset should impose.
  */
-declare const RECOMMENDED_RULES: Partial<Record<IntlayerRuleName, Linter.RuleEntry>>;
+export declare const RECOMMENDED_RULES: Partial<Record<IntlayerRuleName, Linter.RuleEntry>>;
 /**
  * The `recommended` preset with every rule name prefixed by the plugin
  * namespace — the shape both ESLint flat config and `.oxlintrc.json` expect.
@@ -39,7 +39,6 @@ declare const RECOMMENDED_RULES: Partial<Record<IntlayerRuleName, Linter.RuleEnt
  * `intlayer init` uses this to write the preset into `.oxlintrc.json`, since
  * oxlint resolves a plugin's rules but not its configs.
  */
-declare const getRecommendedRules: () => Record<string, Linter.RuleEntry>;
+export declare const getRecommendedRules: () => Record<string, Linter.RuleEntry>;
 //#endregion
-export { GENERATED_OUTPUT_GLOBS, PLUGIN_NAMESPACE, PLUGIN_PACKAGE_NAME, RECOMMENDED_RULES, getRecommendedRules };
 //# sourceMappingURL=preset.d.ts.map

package/dist/types/preset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preset.d.ts","names":[],"sources":["../../src/preset.ts"],"mappings":";;;;cAIa;;cAGA;;;;;;;;;;;cAYA;;;;;;;;;;;;;;;;cAiBA,mBAAmB,QAC9B,OAAO,kBAAkB,OAAO;;;;;;;;cAcrB,2BAA0B,eAAe,OAAO"}
+{"version":3,"file":"preset.d.ts","names":[],"sources":["../../src/preset.ts"],"mappings":";;;;qBAIa;;qBAGA;;;;;;;;;;;qBAYA;;;;;;;;;;;;;;;;qBAiBA,mBAAmB,QAC9B,OAAO,kBAAkB,OAAO;;;;;;;;qBAcrB,2BAA0B,eAAe,OAAO"}

package/dist/types/rules/enforceAdapterImport.d.ts

@@ -1,6 +1,5 @@
 import { IntlayerRule } from "../utils/createRule.js";
 //#region src/rules/enforceAdapterImport.d.ts
-declare const enforceAdapterImport: IntlayerRule<[], "useAdapterImport">;
+export declare const enforceAdapterImport: IntlayerRule<[], "useAdapterImport">;
 //#endregion
-export { enforceAdapterImport };
 //# sourceMappingURL=enforceAdapterImport.d.ts.map

package/dist/types/rules/enforceAdapterImport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enforceAdapterImport.d.ts","names":[],"sources":["../../../src/rules/enforceAdapterImport.ts"],"mappings":";;cA8Da,sBAAA"}
+{"version":3,"file":"enforceAdapterImport.d.ts","names":[],"sources":["../../../src/rules/enforceAdapterImport.ts"],"mappings":";;qBA8Da,sBAAA"}

package/dist/types/rules/noDynamicFieldAccess.d.ts

@@ -1,7 +1,6 @@
 import { IntlayerRule } from "../utils/createRule.js";
 //#region src/rules/noDynamicFieldAccess.d.ts
 type MessageIds = 'dynamicField' | 'dynamicMessageId';
-declare const noDynamicFieldAccess: IntlayerRule<[], MessageIds>;
+export declare const noDynamicFieldAccess: IntlayerRule<[], MessageIds>;
 //#endregion
-export { noDynamicFieldAccess };
 //# sourceMappingURL=noDynamicFieldAccess.d.ts.map

package/dist/types/rules/noDynamicFieldAccess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noDynamicFieldAccess.d.ts","names":[],"sources":["../../../src/rules/noDynamicFieldAccess.ts"],"mappings":";;KAcK;cAiFQ,sBAAoB,iBAAA"}
+{"version":3,"file":"noDynamicFieldAccess.d.ts","names":[],"sources":["../../../src/rules/noDynamicFieldAccess.ts"],"mappings":";;KAcK;qBAiFQ,sBAAoB,iBAAA"}

package/dist/types/rules/noRawText.d.ts

@@ -1,6 +1,6 @@
 import { IntlayerRule } from "../utils/createRule.js";
 //#region src/rules/noRawText.d.ts
-type NoRawTextOptions = {
+export type NoRawTextOptions = {
   /**
    * JSX attributes whose string value is user-facing copy.
    * Defaults to the compiler's own list, so the linter flags exactly what
@@ -19,7 +19,6 @@ type NoRawTextOptions = {
   includeStringLiterals?: boolean;
 };
 type MessageIds = 'rawText' | 'rawAttribute' | 'rawStringLiteral';
-declare const noRawText: IntlayerRule<[NoRawTextOptions?], MessageIds>;
+export declare const noRawText: IntlayerRule<[NoRawTextOptions?], MessageIds>;
 //#endregion
-export { NoRawTextOptions, noRawText };
 //# sourceMappingURL=noRawText.d.ts.map

package/dist/types/rules/noRawText.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noRawText.d.ts","names":[],"sources":["../../../src/rules/noRawText.ts"],"mappings":";;KAwBY;;;;;;EAMV;;EAEA;;EAEA;;;;;;EAMA;;KAGG;cAsEQ,WAAS,cAAA,oBAAA"}
+{"version":3,"file":"noRawText.d.ts","names":[],"sources":["../../../src/rules/noRawText.ts"],"mappings":";;YAwBY;;;;;;EAMV;;EAEA;;EAEA;;;;;;EAMA;;KAGG;qBAsEQ,WAAS,cAAA,oBAAA"}

package/dist/types/rules/noUnusedContent.d.ts

@@ -1,6 +1,6 @@
 import { IntlayerRule } from "../utils/createRule.js";
 //#region src/rules/noUnusedContent.d.ts
-type NoUnusedContentOptions = {
+export type NoUnusedContentOptions = {
   /** Report a dictionary whose key is never referenced anywhere. Default: `true`. */
   reportUnusedDictionaries?: boolean;
   /** Report a content field that is never read anywhere. Default: `true`. */
@@ -27,7 +27,6 @@ type NoUnusedContentOptions = {
   cacheTtl?: number;
 };
 type MessageIds = 'unusedDictionary' | 'unusedField' | 'duplicateDictionary';
-declare const noUnusedContent: IntlayerRule<[NoUnusedContentOptions?], MessageIds>;
+export declare const noUnusedContent: IntlayerRule<[NoUnusedContentOptions?], MessageIds>;
 //#endregion
-export { NoUnusedContentOptions, noUnusedContent };
 //# sourceMappingURL=noUnusedContent.d.ts.map

package/dist/types/rules/noUnusedContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noUnusedContent.d.ts","names":[],"sources":["../../../src/rules/noUnusedContent.ts"],"mappings":";;KAmBY;;EAEV;;EAEA;;;;;;EAMA;;EAEA;;;;;;EAMA;;;;;;EAMA;;KAGG;cAsDQ,iBAAe,cAAA,0BAAA"}
+{"version":3,"file":"noUnusedContent.d.ts","names":[],"sources":["../../../src/rules/noUnusedContent.ts"],"mappings":";;YAmBY;;EAEV;;EAEA;;;;;;EAMA;;EAEA;;;;;;EAMA;;;;;;EAMA;;KAGG;qBAsDQ,iBAAe,cAAA,0BAAA"}

package/dist/types/rules/staticDictionaryKey.d.ts

@@ -1,7 +1,6 @@
 import { IntlayerRule } from "../utils/createRule.js";
 //#region src/rules/staticDictionaryKey.d.ts
 type MessageIds = 'dynamicKey' | 'dynamicTemplateKey' | 'dynamicJsxKey';
-declare const staticDictionaryKey: IntlayerRule<[], MessageIds>;
+export declare const staticDictionaryKey: IntlayerRule<[], MessageIds>;
 //#endregion
-export { staticDictionaryKey };
 //# sourceMappingURL=staticDictionaryKey.d.ts.map

package/dist/types/rules/staticDictionaryKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staticDictionaryKey.d.ts","names":[],"sources":["../../../src/rules/staticDictionaryKey.ts"],"mappings":";;KAkBK;cAsBQ,qBAAmB,iBAAA"}
+{"version":3,"file":"staticDictionaryKey.d.ts","names":[],"sources":["../../../src/rules/staticDictionaryKey.ts"],"mappings":";;KAkBK;qBAsBQ,qBAAmB,iBAAA"}

package/dist/types/utils/ast.d.ts

@@ -11,27 +11,27 @@ import { Node } from "../node_modules/.bun/@types_estree@1.0.9/node_modules/@typ
  * bridge, none of which agree on a type package.
  */
 /** Any AST node, whatever the parser. Narrowed through the guards below. */
-type AstNode = {
+export type AstNode = {
   type: string;
   [key: string]: unknown;
 };
 /** An AST node as ESLint hands it to a visitor — always linked to its parent. */
-type AstNodeWithParent = AstNode & {
+export type AstNodeWithParent = AstNode & {
   parent?: AstNodeWithParent;
 };
 /** `<div>Some text</div>` — the raw text between two JSX tags. */
-type JsxTextNode = AstNode & {
+export type JsxTextNode = AstNode & {
   type: 'JSXText';
   value: string;
 };
 /** `title="Some text"` on a JSX element. */
-type JsxAttributeNode = AstNode & {
+export type JsxAttributeNode = AstNode & {
   type: 'JSXAttribute';
   name: AstNode;
   value: AstNode | null;
 };
 /** The opening tag of a JSX element, holding its name and attributes. */
-type JsxOpeningElementNode = AstNode & {
+export type JsxOpeningElementNode = AstNode & {
   type: 'JSXOpeningElement';
   name: AstNode;
   attributes: AstNode[];
@@ -42,7 +42,7 @@ type JsxOpeningElementNode = AstNode & {
  *
  * @param node - Expression to unwrap; `null`/`undefined` passes straight through.
  */
-declare const unwrapExpression: <T extends AstNode>(node: T | null | undefined) => T | null;
+export declare const unwrapExpression: <T extends AstNode>(node: T | null | undefined) => T | null;
 /**
  * Read the compile-time string value of an expression, or `null` when the value
  * can only be known at runtime.
@@ -53,7 +53,7 @@ declare const unwrapExpression: <T extends AstNode>(node: T | null | undefined)
  *
  * @param node - Expression to evaluate.
  */
-declare const getStaticStringValue: (node: AstNode | null | undefined) => string | null;
+export declare const getStaticStringValue: (node: AstNode | null | undefined) => string | null;
 /**
  * Name of the function being called, plus whether it was reached as a method.
  *
@@ -62,7 +62,7 @@ declare const getStaticStringValue: (node: AstNode | null | undefined) => string
  *
  * @param callee - The `callee` of a CallExpression.
  */
-declare const getCalleeName: (callee: AstNode | null | undefined) => {
+export declare const getCalleeName: (callee: AstNode | null | undefined) => {
   name: string;
   isMethod: boolean;
 } | null;
@@ -76,30 +76,29 @@ declare const getCalleeName: (callee: AstNode | null | undefined) => {
  * @param node - The argument expected to be an object expression.
  * @param propertyName - Property to look up.
  */
-declare const getObjectPropertyValueNode: (node: AstNode | null | undefined, propertyName: string) => AstNode | null;
+export declare const getObjectPropertyValueNode: (node: AstNode | null | undefined, propertyName: string) => AstNode | null;
 /**
  * Name of a JSX attribute, or `null` for spread attributes and namespaced
  * names the plugin does not target.
  *
  * @param attribute - A member of a JSX opening element's `attributes`.
  */
-declare const getJsxAttributeName: (attribute: AstNode | null | undefined) => string | null;
+export declare const getJsxAttributeName: (attribute: AstNode | null | undefined) => string | null;
 /**
  * Value node of a JSX attribute, unwrapping `{'…'}` expression containers so
  * `title="Text"` and `title={'Text'}` are treated alike.
  *
  * @param attribute - A JSX attribute node.
  */
-declare const getJsxAttributeValueNode: (attribute: AstNode | null | undefined) => AstNode | null;
+export declare const getJsxAttributeValueNode: (attribute: AstNode | null | undefined) => AstNode | null;
 /**
  * Tag name of the JSX element an attribute or child belongs to, e.g. `'code'`
  * for `<code>`. Member and namespaced element names are joined with `.`.
  *
  * @param openingElement - A JSXOpeningElement node.
  */
-declare const getJsxElementName: (openingElement: AstNode | null | undefined) => string | null;
+export declare const getJsxElementName: (openingElement: AstNode | null | undefined) => string | null;
 /** Narrow an ESLint visitor node to the loose {@link AstNode} shape. */
-declare const toAstNode: (node: Node | AstNode) => AstNodeWithParent;
+export declare const toAstNode: (node: Node | AstNode) => AstNodeWithParent;
 //#endregion
-export { AstNode, AstNodeWithParent, JsxAttributeNode, JsxOpeningElementNode, JsxTextNode, getCalleeName, getJsxAttributeName, getJsxAttributeValueNode, getJsxElementName, getObjectPropertyValueNode, getStaticStringValue, toAstNode, unwrapExpression };
 //# sourceMappingURL=ast.d.ts.map

package/dist/types/utils/ast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ast.d.ts","names":[],"sources":["../../../src/utils/ast.ts"],"mappings":";;;;;;;;;;;;;KAcY;EACV;GACC;;;KAIS,oBAAoB;EAC9B,SAAS;;;KAIC,cAAc;EACxB;EACA;;;KAIU,mBAAmB;EAC7B;EACA,MAAM;EACN,OAAO;;;KAIG,wBAAwB;EAClC;EACA,MAAM;EACN,YAAY;;;;;;;;cAsBD,mBAAoB,UAAU,SACzC,MAAM,yBACL;;;;;;;;;;;cAwBU,uBACX,MAAM;;;;;;;;;cAoCK,gBACX,QAAQ;EACL;EAAc;;;;;;;;;;;;cA8BN,6BACX,MAAM,4BACN,yBACC;;;;;;;cAkCU,sBACX,WAAW;;;;;;;cAeA,2BACX,WAAW,+BACV;;;;;;;cAgBU,oBACX,gBAAgB;;cAqBL,YAAa,MAAM,OAAa,YAAU"}
+{"version":3,"file":"ast.d.ts","names":[],"sources":["../../../src/utils/ast.ts"],"mappings":";;;;;;;;;;;;;YAcY;EACV;GACC;;;YAIS,oBAAoB;EAC9B,SAAS;;;YAIC,cAAc;EACxB;EACA;;;YAIU,mBAAmB;EAC7B;EACA,MAAM;EACN,OAAO;;;YAIG,wBAAwB;EAClC;EACA,MAAM;EACN,YAAY;;;;;;;;qBAsBD,mBAAoB,UAAU,SACzC,MAAM,yBACL;;;;;;;;;;;qBAwBU,uBACX,MAAM;;;;;;;;;qBAoCK,gBACX,QAAQ;EACL;EAAc;;;;;;;;;;;;qBA8BN,6BACX,MAAM,4BACN,yBACC;;;;;;;qBAkCU,sBACX,WAAW;;;;;;;qBAeA,2BACX,WAAW,+BACV;;;;;;;qBAgBU,oBACX,gBAAgB;;qBAqBL,YAAa,MAAM,OAAa,YAAU"}

package/dist/types/utils/callerMatcher.d.ts

@@ -5,7 +5,7 @@ import { CallerDescriptor, CallerValueSource } from "@intlayer/config/callers";
  * Where the dictionary key of a matched call site lives, and whether it is
  * statically knowable.
  */
-type NamespaceResolution = {
+export type NamespaceResolution = {
   /** The node holding the key, or `null` when the call omits it entirely. */
   node: AstNode | null;
   /** The compile-time key, or `null` when it can only be known at runtime. */
@@ -14,7 +14,7 @@ type NamespaceResolution = {
   source: CallerValueSource;
 };
 /** A call expression recognised as an Intlayer content read. */
-type CallerMatch = {
+export type CallerMatch = {
   descriptor: CallerDescriptor;
   /** Resolved namespace, or `null` for callers that take no namespace here. */
   namespace: NamespaceResolution | null;
@@ -27,13 +27,13 @@ type CallerMatch = {
  *
  * @param program - The Program node of the analysed file.
  */
-declare const collectImportSources: (program: AstNode) => Set<string>;
+export declare const collectImportSources: (program: AstNode) => Set<string>;
 /**
  * The registry entries that may match inside a file, given what it imports.
  *
  * @param importSources - Specifiers collected by {@link collectImportSources}.
  */
-declare const getActiveDescriptors: (importSources: ReadonlySet<string>) => CallerDescriptor[];
+export declare const getActiveDescriptors: (importSources: ReadonlySet<string>) => CallerDescriptor[];
 /**
  * Match a call expression against the shared caller registry.
  *
@@ -44,7 +44,7 @@ declare const getActiveDescriptors: (importSources: ReadonlySet<string>) => Call
  * @param callNode - A CallExpression (or TaggedTemplateExpression) node.
  * @param activeDescriptors - Result of {@link getActiveDescriptors}.
  */
-declare const matchCaller: (callNode: AstNode, activeDescriptors: CallerDescriptor[]) => CallerMatch | null;
+export declare const matchCaller: (callNode: AstNode, activeDescriptors: CallerDescriptor[]) => CallerMatch | null;
 /**
  * Match a JSX element against the registry's JSX-shaped callers,
  * e.g. `<FormattedMessage id="home.title" />` or `<Trans ns="home" …/>`.
@@ -52,7 +52,6 @@ declare const matchCaller: (callNode: AstNode, activeDescriptors: CallerDescript
  * @param elementName - Tag name of the element.
  * @param activeDescriptors - Result of {@link getActiveDescriptors}.
  */
-declare const matchJsxCaller: (elementName: string | null, activeDescriptors: CallerDescriptor[]) => CallerDescriptor | null;
+export declare const matchJsxCaller: (elementName: string | null, activeDescriptors: CallerDescriptor[]) => CallerDescriptor | null;
 //#endregion
-export { CallerMatch, NamespaceResolution, collectImportSources, getActiveDescriptors, matchCaller, matchJsxCaller };
 //# sourceMappingURL=callerMatcher.d.ts.map

package/dist/types/utils/callerMatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"callerMatcher.d.ts","names":[],"sources":["../../../src/utils/callerMatcher.ts"],"mappings":";;;;;;;KAkBY;;EAEV,MAAM;;EAEN;;EAEA,QAAQ;;;KAIE;EACV,YAAY;;EAEZ,WAAW;;;;;;;;;;cAWA,uBAAwB,SAAS,YAAU;;;;;;cA2B3C,uBACX,eAAe,wBACd;;;;;;;;;;;cAkFU,cACX,UAAU,SACV,mBAAmB,uBAClB;;;;;;;;cAuDU,iBACX,4BACA,mBAAmB,uBAClB"}
+{"version":3,"file":"callerMatcher.d.ts","names":[],"sources":["../../../src/utils/callerMatcher.ts"],"mappings":";;;;;;;YAkBY;;EAEV,MAAM;;EAEN;;EAEA,QAAQ;;;YAIE;EACV,YAAY;;EAEZ,WAAW;;;;;;;;;;qBAWA,uBAAwB,SAAS,YAAU;;;;;;qBA2B3C,uBACX,eAAe,wBACd;;;;;;;;;;;qBAkFU,cACX,UAAU,SACV,mBAAmB,uBAClB;;;;;;;;qBAuDU,iBACX,4BACA,mBAAmB,uBAClB"}

package/dist/types/utils/contentDeclaration.d.ts

@@ -9,14 +9,14 @@ import { AstNode } from "./ast.js";
  * every variant in between without caring how the object reaches the export.
  */
 /** One field declared inside a dictionary's `content`. */
-type DeclaredField = {
+export type DeclaredField = {
   /** Dotted path from the content root, e.g. `hero.title`. */
   path: string;
   /** The property key node, so a report points at the field name. */
   keyNode: AstNode;
 };
 /** A dictionary declaration found in the linted file. */
-type ContentDeclaration = {
+export type ContentDeclaration = {
   /** The static dictionary key. */
   dictionaryKey: string;
   /** The node holding the key, for reporting a fully unused dictionary. */
@@ -36,7 +36,6 @@ type ContentDeclaration = {
  *
  * @param objectExpression - Any `ObjectExpression` node from the linted file.
  */
-declare const readContentDeclaration: (objectExpression: AstNode) => ContentDeclaration | null;
+export declare const readContentDeclaration: (objectExpression: AstNode) => ContentDeclaration | null;
 //#endregion
-export { ContentDeclaration, DeclaredField, readContentDeclaration };
 //# sourceMappingURL=contentDeclaration.d.ts.map

package/dist/types/utils/contentDeclaration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contentDeclaration.d.ts","names":[],"sources":["../../../src/utils/contentDeclaration.ts"],"mappings":";;;;;;;;;;;KAaY;;EAEV;;EAEA,SAAS;;;KAIC;;EAEV;;EAEA,SAAS;;EAET,QAAQ;;;;;;EAMR;;;;;;;;cA+GW,yBACX,kBAAkB,YACjB"}
+{"version":3,"file":"contentDeclaration.d.ts","names":[],"sources":["../../../src/utils/contentDeclaration.ts"],"mappings":";;;;;;;;;;;YAaY;;EAEV;;EAEA,SAAS;;;YAIC;;EAEV;;EAEA,SAAS;;EAET,QAAQ;;;;;;EAMR;;;;;;;;qBA+GW,yBACX,kBAAkB,YACjB"}

package/dist/types/utils/createRule.d.ts

@@ -5,7 +5,7 @@ import { JSRuleDefinition } from "eslint";
  * `context.options` and `context.report({ messageId })` are checked rather than
  * inferred as `any[]` / `string`.
  */
-type IntlayerRule<Options extends readonly unknown[] = [], MessageIds extends string = string> = JSRuleDefinition<{
+export type IntlayerRule<Options extends readonly unknown[] = [], MessageIds extends string = string> = JSRuleDefinition<{
   RuleOptions: [...Options];
   MessageIds: MessageIds;
 }>;
@@ -17,7 +17,6 @@ type IntlayerRule<Options extends readonly unknown[] = [], MessageIds extends st
  * @param name - The rule name as it appears in config, e.g. `'no-raw-text'`.
  * @param rule - The rule definition.
  */
-declare const createRule: <Options extends readonly unknown[] = [], MessageIds extends string = string>(name: string, rule: IntlayerRule<Options, MessageIds>) => IntlayerRule<Options, MessageIds>;
+export declare const createRule: <Options extends readonly unknown[] = [], MessageIds extends string = string>(name: string, rule: IntlayerRule<Options, MessageIds>) => IntlayerRule<Options, MessageIds>;
 //#endregion
-export { IntlayerRule, createRule };
 //# sourceMappingURL=createRule.d.ts.map

package/dist/types/utils/createRule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createRule.d.ts","names":[],"sources":["../../../src/utils/createRule.ts"],"mappings":";;;;;;;KAUY,aACV,yCACA,sCACE;EACF,iBAAiB;EACjB,YAAY;;;;;;;;;;cAWD,aACX,yCACA,oCAEA,cACA,MAAM,aAAa,SAAS,gBAC3B,aAAa,SAAS"}
+{"version":3,"file":"createRule.d.ts","names":[],"sources":["../../../src/utils/createRule.ts"],"mappings":";;;;;;;YAUY,aACV,yCACA,sCACE;EACF,iBAAiB;EACjB,YAAY;;;;;;;;;;qBAWD,aACX,yCACA,oCAEA,cACA,MAAM,aAAa,SAAS,gBAC3B,aAAa,SAAS"}

package/dist/types/utils/projectUsage.d.ts

@@ -6,7 +6,7 @@
  * plugin keeps its single runtime dependency, and so the exact surface this
  * rule depends on stays visible in one place.
  */
-type IntlayerProjectConfig = {
+export type IntlayerProjectConfig = {
   content: {
     fileExtensions?: string[];
     codeDir?: string[];
@@ -23,7 +23,7 @@ type IntlayerProjectConfig = {
   };
 };
 /** How one dictionary key is consumed across the project. */
-type DictionaryUsage = {
+export type DictionaryUsage = {
   /**
    * Dotted content-field paths read somewhere, every parent prefix included —
    * reading `hero.title` marks `hero` used too.
@@ -38,7 +38,7 @@ type DictionaryUsage = {
   tracksEveryField: boolean;
 };
 /** The result of one project scan. */
-type ProjectUsageIndex = {
+export type ProjectUsageIndex = {
   /** Every dictionary key referenced by the project, and how. */
   byDictionaryKey: Map<string, DictionaryUsage>;
   /**
@@ -55,7 +55,7 @@ type ProjectUsageIndex = {
   isAvailable: boolean;
 };
 /** One other place a dictionary key is declared. */
-type DuplicateDeclaration = {
+export type DuplicateDeclaration = {
   /** Path as recorded in the unmerged dictionary, or `'remote'` for CMS entries. */
   filePath: string;
   /** Whether the other declaration lives in the project or in the CMS. */
@@ -67,9 +67,9 @@ type DuplicateDeclaration = {
  *
  * @param filePath - Absolute or relative path.
  */
-declare const stripModuleExtension: (filePath: string) => string;
+export declare const stripModuleExtension: (filePath: string) => string;
 /** Drop every cached configuration and usage index. Exposed for tests. */
-declare const clearProjectUsageCache: () => void;
+export declare const clearProjectUsageCache: () => void;
 /**
  * Load the Intlayer configuration for a project, or `null` when it cannot be
  * read — a project without Intlayer installed must not break the lint run.
@@ -77,14 +77,14 @@ declare const clearProjectUsageCache: () => void;
  * @param baseDir - Project root, normally ESLint's working directory.
  * @param cacheTtlMs - Lifetime of the cached configuration.
  */
-declare const getProjectConfiguration: (baseDir: string, cacheTtlMs: number) => IntlayerProjectConfig | null;
+export declare const getProjectConfiguration: (baseDir: string, cacheTtlMs: number) => IntlayerProjectConfig | null;
 /**
  * Scan the project once and aggregate every dictionary reference it contains.
  *
  * @param baseDir - Project root, normally ESLint's working directory.
  * @param cacheTtlMs - Lifetime of the cached index.
  */
-declare const getProjectUsageIndex: (baseDir: string, cacheTtlMs: number) => ProjectUsageIndex;
+export declare const getProjectUsageIndex: (baseDir: string, cacheTtlMs: number) => ProjectUsageIndex;
 /**
  * Other declarations of the same dictionary key, read from the unmerged
  * dictionaries the build writes to disk.
@@ -96,7 +96,6 @@ declare const getProjectUsageIndex: (baseDir: string, cacheTtlMs: number) => Pro
  * @param dictionaryKey - Key declared by the linted file.
  * @param currentFilePath - Absolute path of the linted file.
  */
-declare const getDuplicateDeclarations: (configuration: IntlayerProjectConfig, dictionaryKey: string, currentFilePath: string) => DuplicateDeclaration[];
+export declare const getDuplicateDeclarations: (configuration: IntlayerProjectConfig, dictionaryKey: string, currentFilePath: string) => DuplicateDeclaration[];
 //#endregion
-export { DictionaryUsage, DuplicateDeclaration, IntlayerProjectConfig, ProjectUsageIndex, clearProjectUsageCache, getDuplicateDeclarations, getProjectConfiguration, getProjectUsageIndex, stripModuleExtension };
 //# sourceMappingURL=projectUsage.d.ts.map

package/dist/types/utils/projectUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"projectUsage.d.ts","names":[],"sources":["../../../src/utils/projectUsage.ts"],"mappings":";;;;;;;;KAiGY;EACV;IAAW;IAA2B;;EACtC;IAAS;;EACT;IAAa;;EACb;IAAU;IAAiB;;;;KAMjB;;;;;EAKV,gBAAgB;;;;;;;EAOhB;;;KAIU;;EAEV,iBAAiB,YAAY;;;;;;EAM7B,qBAAqB;;;;;;EAMrB;;;KAIU;;EAEV;;EAEA;;;;;;;;cA4CW,uBAAwB;;cA+FxB;;;;;;;;cAcA,0BACX,iBACA,uBACC;;;;;;;cAqUU,uBACX,iBACA,uBACC;;;;;;;;;;;;cA6HU,2BACX,eAAe,uBACf,uBACA,4BACC"}
+{"version":3,"file":"projectUsage.d.ts","names":[],"sources":["../../../src/utils/projectUsage.ts"],"mappings":";;;;;;;;YAiGY;EACV;IAAW;IAA2B;;EACtC;IAAS;;EACT;IAAa;;EACb;IAAU;IAAiB;;;;YAMjB;;;;;EAKV,gBAAgB;;;;;;;EAOhB;;;YAIU;;EAEV,iBAAiB,YAAY;;;;;;EAM7B,qBAAqB;;;;;;EAMrB;;;YAIU;;EAEV;;EAEA;;;;;;;;qBA4CW,uBAAwB;;qBA+FxB;;;;;;;;qBAcA,0BACX,iBACA,uBACC;;;;;;;qBAqUU,uBACX,iBACA,uBACC;;;;;;;;;;;;qBA6HU,2BACX,eAAe,uBACf,uBACA,4BACC"}

package/dist/types/utils/reactVersion.d.ts

@@ -12,7 +12,6 @@
  * Next.js and React projects using `eslint-config-next` / `eslint-plugin-react` to work
  * seamlessly under both ESLint 9 and ESLint 10 without needing manual configuration hacks.
  */
-declare const getReactVersion: (dir?: string) => string;
+export declare const getReactVersion: (dir?: string) => string;
 //#endregion
-export { getReactVersion };
 //# sourceMappingURL=reactVersion.d.ts.map

package/dist/types/utils/reactVersion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reactVersion.d.ts","names":[],"sources":["../../../src/utils/reactVersion.ts"],"mappings":";;;;;;;;;;;;;;cAgBa,kBAAmB"}
+{"version":3,"file":"reactVersion.d.ts","names":[],"sources":["../../../src/utils/reactVersion.ts"],"mappings":";;;;;;;;;;;;;;qBAgBa,kBAAmB"}

package/dist/types/utils/templates.d.ts

@@ -21,7 +21,7 @@ import { AstNode, AstNodeWithParent } from "./ast.js";
  * Svelte file simply never emits a `VText`.
  */
 /** One piece of literal text found in markup. */
-type TemplateTextFinding = {
+export type TemplateTextFinding = {
   /** Node to report on. */
   node: AstNode;
   /** The literal text. */
@@ -32,9 +32,9 @@ type TemplateTextFinding = {
   elementName: string | null;
 };
 /** Callback invoked for every literal text node the visitors find. */
-type TemplateTextReporter = (finding: TemplateTextFinding) => void;
+export type TemplateTextReporter = (finding: TemplateTextFinding) => void;
 /** A visitor object as returned from a rule's `create`. */
-type TemplateVisitor = Record<string, (node: never) => void>;
+export type TemplateVisitor = Record<string, (node: never) => void>;
 /**
  * Walk up to the nearest enclosing element and return its tag name, or the
  * sentinel `false` when the text sits inside a `<script>`/`<style>` block that
@@ -42,7 +42,7 @@ type TemplateVisitor = Record<string, (node: never) => void>;
  *
  * @param node - The text or attribute node to start from.
  */
-declare const resolveEnclosingElement: (node: AstNodeWithParent | undefined) => string | null | false;
+export declare const resolveEnclosingElement: (node: AstNodeWithParent | undefined) => string | null | false;
 /**
  * Visitors covering every non-JSX template language Intlayer supports.
  *
@@ -52,7 +52,7 @@ declare const resolveEnclosingElement: (node: AstNodeWithParent | undefined) =>
  *
  * @param report - Called for each literal text node found.
  */
-declare const createTemplateVisitor: (report: TemplateTextReporter) => TemplateVisitor;
+export declare const createTemplateVisitor: (report: TemplateTextReporter) => TemplateVisitor;
 /**
  * Combine a script visitor and a template visitor into the single object the
  * active parser expects.
@@ -65,7 +65,6 @@ declare const createTemplateVisitor: (report: TemplateTextReporter) => TemplateV
  * @param scriptVisitor - Handlers for ordinary script nodes.
  * @param templateVisitor - Handlers for markup nodes.
  */
-declare const combineVisitors: (parserServices: unknown, scriptVisitor: TemplateVisitor, templateVisitor: TemplateVisitor) => TemplateVisitor;
+export declare const combineVisitors: (parserServices: unknown, scriptVisitor: TemplateVisitor, templateVisitor: TemplateVisitor) => TemplateVisitor;
 //#endregion
-export { TemplateTextFinding, TemplateTextReporter, TemplateVisitor, combineVisitors, createTemplateVisitor, resolveEnclosingElement };
 //# sourceMappingURL=templates.d.ts.map

package/dist/types/utils/templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../src/utils/templates.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;KAwBY;;EAEV,MAAM;;EAEN;;EAEA;;EAEA;;;KAIU,wBAAwB,SAAS;;KAGjC,kBAAkB,gBAAgB;;;;;;;;cAsDjC,0BACX,MAAM;;;;;;;;;;cA6CK,wBACX,QAAQ,yBACP;;;;;;;;;;;;;cAgGU,kBACX,yBACA,eAAe,iBACf,iBAAiB,oBAChB"}
+{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../src/utils/templates.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;YAwBY;;EAEV,MAAM;;EAEN;;EAEA;;EAEA;;;YAIU,wBAAwB,SAAS;;YAGjC,kBAAkB,gBAAgB;;;;;;;;qBAsDjC,0BACX,MAAM;;;;;;;;;;qBA6CK,wBACX,QAAQ,yBACP;;;;;;;;;;;;;qBAgGU,kBACX,yBACA,eAAe,iBACf,iBAAiB,oBAChB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-intlayer",
-  "version": "9.4.2",
+  "version": "9.4.4",
   "private": false,
   "description": "ESLint (and oxlint) plugin for Intlayer. Catches untranslated strings and the dynamic call shapes the Intlayer compiler cannot optimize.",
   "keywords": [
@@ -76,8 +76,8 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.4.2",
-    "@intlayer/lsp": "9.4.2",
+    "@intlayer/config": "9.4.4",
+    "@intlayer/lsp": "9.4.4",
     "fast-glob": "3.3.3"
   },
   "devDependencies": {
@@ -92,10 +92,10 @@
     "rimraf": "6.1.3",
     "svelte": "5.56.9",
     "svelte-eslint-parser": "1.8.0",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "typescript": "6.0.3",
     "typescript-eslint": "8.67.0",
-    "vitest": "4.1.11",
+    "vitest": "5.0.0",
     "vue-eslint-parser": "10.4.1"
   },
   "peerDependencies": {