@intlayer/lsp 9.4.2 → 9.4.4

package/dist/types/callers/patterns.d.ts

@@ -3,7 +3,7 @@
  * Alternation of every caller name whose dictionary key appears as a
  * positional string argument — for building text-search patterns.
  */
-declare const getCallerNamesAlternation: () => string;
+export declare const getCallerNamesAlternation: () => string;
 /**
  * Regexes matching call sites that reference the dictionary `key` in project
  * source files. Used by "find all references" (content file → call sites).
@@ -17,14 +17,13 @@ declare const getCallerNamesAlternation: () => string;
  *
  * @param key - The dictionary key to search for.
  */
-declare const buildKeyUsagePatterns: (key: string) => RegExp[];
+export declare const buildKeyUsagePatterns: (key: string) => RegExp[];
 /**
  * Regex testing whether a file contains a caller invoked with the given
  * dictionary key — a cheap pre-filter before running field-level analysis.
  *
  * @param key - The dictionary key.
  */
-declare const buildCallerWithKeyPattern: (key: string) => RegExp;
+export declare const buildCallerWithKeyPattern: (key: string) => RegExp;
 //#endregion
-export { buildCallerWithKeyPattern, buildKeyUsagePatterns, getCallerNamesAlternation };
 //# sourceMappingURL=patterns.d.ts.map

package/dist/types/callers/patterns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"patterns.d.ts","names":[],"sources":["../../../src/callers/patterns.ts"],"mappings":";;;;;cAOa;;;;;;;;;;;;;;cAgBA,wBAAyB,gBAAc;;;;;;;cAqBvC,4BAA6B,gBAAc"}
+{"version":3,"file":"patterns.d.ts","names":[],"sources":["../../../src/callers/patterns.ts"],"mappings":";;;;;qBAOa;;;;;;;;;;;;;;qBAgBA,wBAAyB,gBAAc;;;;;;;qBAqBvC,4BAA6B,gBAAc"}

package/dist/types/dictionaryUtils.d.ts

@@ -1,11 +1,10 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/dictionaryUtils.d.ts
-declare const formatFieldValue: (value: unknown) => string;
-declare const getFieldByPath: (content: unknown, path: string[]) => unknown;
-declare const getTopLevelFields: (content: unknown) => string[];
-declare const getFieldsAtPath: (content: unknown, path: string[]) => string[];
-declare const formatDictionaryHover: (dictionaries: Dictionary[], key: string) => string;
-declare const formatFieldHover: (dictionaries: Dictionary[], dictionaryKey: string, fieldPath: string[]) => string | null;
+export declare const formatFieldValue: (value: unknown) => string;
+export declare const getFieldByPath: (content: unknown, path: string[]) => unknown;
+export declare const getTopLevelFields: (content: unknown) => string[];
+export declare const getFieldsAtPath: (content: unknown, path: string[]) => string[];
+export declare const formatDictionaryHover: (dictionaries: Dictionary[], key: string) => string;
+export declare const formatFieldHover: (dictionaries: Dictionary[], dictionaryKey: string, fieldPath: string[]) => string | null;
 //#endregion
-export { formatDictionaryHover, formatFieldHover, formatFieldValue, getFieldByPath, getFieldsAtPath, getTopLevelFields };
 //# sourceMappingURL=dictionaryUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dictionaryUtils.d.ts","names":[],"sources":["../../src/dictionaryUtils.ts"],"mappings":";;cAoDa,mBAAoB;cAoBpB,iBAAkB,kBAAkB;cAYpC,oBAAqB;cAKrB,kBAAmB,kBAAkB;cASrC,wBACX,cAAc,cACd;cAyBW,mBACX,cAAc,cACd,uBACA"}
+{"version":3,"file":"dictionaryUtils.d.ts","names":[],"sources":["../../src/dictionaryUtils.ts"],"mappings":";;qBAoDa,mBAAoB;qBAoBpB,iBAAkB,kBAAkB;qBAYpC,oBAAqB;qBAKrB,kBAAmB,kBAAkB;qBASrC,wBACX,cAAc,cACd;qBAyBW,mBACX,cAAc,cACd,uBACA"}

package/dist/types/findFieldInFile.d.ts

@@ -1,7 +1,7 @@
 import { Range } from "vscode-languageserver/node";
 //#region src/findFieldInFile.d.ts
-declare const escapeRegularExpression: (content: string) => string;
-declare const offsetToRange: (text: string, start: number, end: number) => Range;
+export declare const escapeRegularExpression: (content: string) => string;
+export declare const offsetToRange: (text: string, start: number, end: number) => Range;
 /**
  * Within a single file's text, find all positions where `fieldPath` (or legacy
  * `fieldName`) is consumed from the dictionary `escapedKey` — through any
@@ -21,7 +21,6 @@ declare const offsetToRange: (text: string, start: number, end: number) => Range
  * the function derives the single-element path from `escapedField`, preserving
  * backward compatibility.
  */
-declare const findFieldRangesInFile: (text: string, escapedKey: string, _fieldName: string, escapedField: string, fieldPath?: string[]) => Range[];
+export declare const findFieldRangesInFile: (text: string, escapedKey: string, _fieldName: string, escapedField: string, fieldPath?: string[]) => Range[];
 //#endregion
-export { escapeRegularExpression, findFieldRangesInFile, offsetToRange };
 //# sourceMappingURL=findFieldInFile.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"findFieldInFile.d.ts","names":[],"sources":["../../src/findFieldInFile.ts"],"mappings":";;cAGa,0BAA2B;cAG3B,gBACX,cACA,eACA,gBACC;;;;;;;;;;;;;;;;;;;;cAiCU,wBACX,cACA,oBACA,oBACA,sBACA,yBACC"}
+{"version":3,"file":"findFieldInFile.d.ts","names":[],"sources":["../../src/findFieldInFile.ts"],"mappings":";;qBAGa,0BAA2B;qBAG3B,gBACX,cACA,eACA,gBACC;;;;;;;;;;;;;;;;;;;;qBAiCU,wBACX,cACA,oBACA,oBACA,sBACA,yBACC"}

package/dist/types/findKeyAtOffset.d.ts

@@ -15,7 +15,6 @@
  * Self callers (`formatMessage`, lingui `t`/`_`) are message *usages*, not
  * namespace declarations — they are resolved by `findMessageUsageAtOffset`.
  */
-declare const findKeyAtOffset: (text: string, offset: number) => string | null;
+export declare const findKeyAtOffset: (text: string, offset: number) => string | null;
 //#endregion
-export { findKeyAtOffset };
 //# sourceMappingURL=findKeyAtOffset.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"findKeyAtOffset.d.ts","names":[],"sources":["../../src/findKeyAtOffset.ts"],"mappings":";;;;;;;;;;;;;;;;;cAkBa,kBACX,cACA"}
+{"version":3,"file":"findKeyAtOffset.d.ts","names":[],"sources":["../../src/findKeyAtOffset.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAkBa,kBACX,cACA"}

package/dist/types/findKeyInContentFile.d.ts

@@ -7,7 +7,7 @@
  * - JSON values:   "key": "foo"                          (JSON/JSON5/JSONC)
  * - Bare values:   key: foo-bar                          (YAML / Markdown frontmatter)
  */
-declare const findKeyInContentFile: (text: string, offset: number) => string | null;
+export declare const findKeyInContentFile: (text: string, offset: number) => string | null;
 /**
  * If `offset` falls on a content field property key inside an intlayer content
  * file, return the dictionary key, the leaf field name, and the full field path.
@@ -22,12 +22,11 @@ declare const findKeyInContentFile: (text: string, offset: number) => string | n
  * When `fileExtension` is omitted the function falls back to Oxc, then to
  * JSON/YAML heuristics based on text shape.
  */
-declare const findContentFieldAtOffset: (text: string, offset: number, fileExtension?: string) => FieldResult | null;
+export declare const findContentFieldAtOffset: (text: string, offset: number, fileExtension?: string) => FieldResult | null;
 type FieldResult = {
   dictionaryKey: string;
   fieldName: string;
   fieldPath: string[];
 };
 //#endregion
-export { findContentFieldAtOffset, findKeyInContentFile };
 //# sourceMappingURL=findKeyInContentFile.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"findKeyInContentFile.d.ts","names":[],"sources":["../../src/findKeyInContentFile.ts"],"mappings":";;;;;;;;;cAea,uBACX,cACA;;;;;;;;;;;;;;;cA4BW,2BACX,cACA,gBACA,2BACC;KA4LE;EACH;EACA;EACA"}
+{"version":3,"file":"findKeyInContentFile.d.ts","names":[],"sources":["../../src/findKeyInContentFile.ts"],"mappings":";;;;;;;;;qBAea,uBACX,cACA;;;;;;;;;;;;;;;qBA4BW,2BACX,cACA,gBACA,2BACC;KA4LE;EACH;EACA;EACA"}

package/dist/types/findTCallAtOffset.d.ts

@@ -15,10 +15,9 @@
  *   const t = await getFixedT('en', 'ns');          t('field')
  *   const { t } = useI18n({ namespace: 'ns' });     t('field')
  */
-declare const findTCallAtOffset: (text: string, offset: number) => {
+export declare const findTCallAtOffset: (text: string, offset: number) => {
   dictionaryKey: string;
   fieldName: string;
 } | null;
 //#endregion
-export { findTCallAtOffset };
 //# sourceMappingURL=findTCallAtOffset.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"findTCallAtOffset.d.ts","names":[],"sources":["../../src/findTCallAtOffset.ts"],"mappings":";;;;;;;;;;;;;;;;;cAkBa,oBACX,cACA;EACG;EAAuB"}
+{"version":3,"file":"findTCallAtOffset.d.ts","names":[],"sources":["../../src/findTCallAtOffset.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAkBa,oBACX,cACA;EACG;EAAuB"}

package/dist/types/findUsageFieldAtOffset.d.ts

@@ -14,10 +14,9 @@
  * Thin compatibility wrapper over `findMessageUsageAtOffset`.
  * Returns { dictionaryKey, fieldName } when matched, null otherwise.
  */
-declare const findUsageFieldAtOffset: (text: string, offset: number) => {
+export declare const findUsageFieldAtOffset: (text: string, offset: number) => {
   dictionaryKey: string;
   fieldName: string;
 } | null;
 //#endregion
-export { findUsageFieldAtOffset };
 //# sourceMappingURL=findUsageFieldAtOffset.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"findUsageFieldAtOffset.d.ts","names":[],"sources":["../../src/findUsageFieldAtOffset.ts"],"mappings":";;;;;;;;;;;;;;;;cAiBa,yBACX,cACA;EACG;EAAuB"}
+{"version":3,"file":"findUsageFieldAtOffset.d.ts","names":[],"sources":["../../src/findUsageFieldAtOffset.ts"],"mappings":";;;;;;;;;;;;;;;;qBAiBa,yBACX,cACA;EACG;EAAuB"}

package/dist/types/oxcUtils.d.ts

@@ -1,53 +1,52 @@
 //#region src/oxcUtils.d.ts
-type OxcNode = Record<string, unknown>;
+export type OxcNode = Record<string, unknown>;
 /**
  * Parse `text` into an Oxc program AST.
  * Returns null when the parse completely fails (e.g. unsupported syntax).
  * Oxc is generally resilient to partial/in-progress edits and still returns a
  * usable AST alongside error diagnostics, so this is rare.
  */
-declare const parseText: (text: string) => OxcNode | null;
+export declare const parseText: (text: string) => OxcNode | null;
 /**
  * Depth-first walk of an Oxc AST. Visitor is called for every node that has
  * a `type` property; returning `true` prunes that subtree.
  */
-declare const walkAst: (node: unknown, visitor: (node: OxcNode) => boolean | void) => void;
+export declare const walkAst: (node: unknown, visitor: (node: OxcNode) => boolean | void) => void;
 /**
  * Build a child → parent reference map for upward traversal.
  * Only AST-node-valued properties are followed; primitives are ignored.
  */
-declare const buildParentMap: (root: OxcNode) => Map<OxcNode, OxcNode>;
+export declare const buildParentMap: (root: OxcNode) => Map<OxcNode, OxcNode>;
 /** Byte offset of the node's start. */
-declare const nodeStart: (node: OxcNode) => number;
+export declare const nodeStart: (node: OxcNode) => number;
 /** Byte offset of the node's end. */
-declare const nodeEnd: (node: OxcNode) => number;
+export declare const nodeEnd: (node: OxcNode) => number;
 /** Returns `true` when `offset` falls inside the node's span (inclusive). */
-declare const nodeContainsOffset: (node: OxcNode, offset: number) => boolean;
+export declare const nodeContainsOffset: (node: OxcNode, offset: number) => boolean;
 /**
  * Returns `true` for nodes that carry a static string value:
  * Literal / StringLiteral, and no-substitution TemplateLiteral.
  */
-declare const isStringLiteralNode: (node: OxcNode) => boolean;
+export declare const isStringLiteralNode: (node: OxcNode) => boolean;
 /**
  * Extract the static string value from a literal node, or null when the node
  * is not a static string.
  */
-declare const getStaticStringValue: (node: OxcNode | undefined) => string | null;
+export declare const getStaticStringValue: (node: OxcNode | undefined) => string | null;
 /** Extract the string value from the Nth argument of a call expression. */
-declare const getStringArgAt: (callNode: OxcNode, index: number) => string | null;
+export declare const getStringArgAt: (callNode: OxcNode, index: number) => string | null;
 /** Extract the string value from the first argument of a call expression. */
-declare const getFirstStringArg: (callExpressionNode: OxcNode) => string | null;
+export declare const getFirstStringArg: (callExpressionNode: OxcNode) => string | null;
 /**
  * Find the property node named `propertyName` inside an ObjectExpression.
  */
-declare const getObjectPropertyNode: (objectExpression: OxcNode | undefined, propertyName: string) => OxcNode | null;
+export declare const getObjectPropertyNode: (objectExpression: OxcNode | undefined, propertyName: string) => OxcNode | null;
 /**
  * Read a static string property from an ObjectExpression argument,
  * e.g. the `namespace` of `useI18n({ namespace: 'about' })`.
  */
-declare const getObjectPropertyString: (objectExpression: OxcNode | undefined, propertyName: string) => string | null;
+export declare const getObjectPropertyString: (objectExpression: OxcNode | undefined, propertyName: string) => string | null;
 /** Get the identifier or string name of an object-property key node. */
-declare const getPropertyKeyName: (keyNode: OxcNode | undefined) => string | null;
+export declare const getPropertyKeyName: (keyNode: OxcNode | undefined) => string | null;
 //#endregion
-export { OxcNode, buildParentMap, getFirstStringArg, getObjectPropertyNode, getObjectPropertyString, getPropertyKeyName, getStaticStringValue, getStringArgAt, isStringLiteralNode, nodeContainsOffset, nodeEnd, nodeStart, parseText, walkAst };
 //# sourceMappingURL=oxcUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"oxcUtils.d.ts","names":[],"sources":["../../src/oxcUtils.ts"],"mappings":";KAEY,UAAU;;;;;;;cAQT,YAAa,iBAAe;;;;;cAc5B,UACX,eAEA,UAAU,MAAM;;;;;cAyBL,iBAAkB,MAAM,YAAU,IAAI,SAAS;;cA4B/C,YAAa,MAAM;;cAMnB,UAAW,MAAM;;cAMjB,qBAAsB,MAAM,SAAS;;;;;cAOrC,sBAAuB,MAAM;;;;;cAkB7B,uBACX,MAAM;;cA8BK,iBACX,UAAU,SACV;;cAUW,oBAAqB,oBAAoB;;;;cAMzC,wBACX,kBAAkB,qBAClB,yBACC;;;;;cA4BU,0BACX,kBAAkB,qBAClB;;cAUW,qBACX,SAAS"}
+{"version":3,"file":"oxcUtils.d.ts","names":[],"sources":["../../src/oxcUtils.ts"],"mappings":";YAEY,UAAU;;;;;;;qBAQT,YAAa,iBAAe;;;;;qBAc5B,UACX,eAEA,UAAU,MAAM;;;;;qBAyBL,iBAAkB,MAAM,YAAU,IAAI,SAAS;;qBA4B/C,YAAa,MAAM;;qBAMnB,UAAW,MAAM;;qBAMjB,qBAAsB,MAAM,SAAS;;;;;qBAOrC,sBAAuB,MAAM;;;;;qBAkB7B,uBACX,MAAM;;qBA8BK,iBACX,UAAU,SACV;;qBAUW,oBAAqB,oBAAoB;;;;qBAMzC,wBACX,kBAAkB,qBAClB,yBACC;;;;;qBA4BU,0BACX,kBAAkB,qBAClB;;qBAUW,qBACX,SAAS"}

package/dist/types/protocol.d.ts

@@ -15,12 +15,11 @@
  * report every key as undeclared, so it stays silent and asks the client to
  * run the build instead.
  */
-declare const DICTIONARIES_NOT_BUILT_NOTIFICATION = "intlayer/dictionariesNotBuilt";
+export declare const DICTIONARIES_NOT_BUILT_NOTIFICATION = "intlayer/dictionariesNotBuilt";
 /** Payload of {@link DICTIONARIES_NOT_BUILT_NOTIFICATION}. */
-type DictionariesNotBuiltParams = {
+export type DictionariesNotBuiltParams = {
   /** Root directory of the project whose dictionaries are missing. */
   baseDir: string;
 };
 //#endregion
-export { DICTIONARIES_NOT_BUILT_NOTIFICATION, DictionariesNotBuiltParams };
 //# sourceMappingURL=protocol.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","names":[],"sources":["../../src/protocol.ts"],"mappings":";;;;;;;;;;;;;;;;;cAiBa;;KAID;;EAEV"}
+{"version":3,"file":"protocol.d.ts","names":[],"sources":["../../src/protocol.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAiBa;;YAID;;EAEV"}

package/dist/types/usageAnalyzer.d.ts

@@ -1,12 +1,12 @@
 import { OxcNode } from "./oxcUtils.js";
 //#region src/usageAnalyzer.d.ts
 /** How a message usage appears in source code. */
-type MessageUsageKind = "call" | "member" | "destructure" | "jsx" | "tagged-template" | "namespace";
+export type MessageUsageKind = "call" | "member" | "destructure" | "jsx" | "tagged-template" | "namespace";
 /**
  * One resolved translation usage inside a source file: which dictionary and
  * field it reads, and the text span it occupies.
  */
-type MessageUsage = {
+export type MessageUsage = {
   /** The intlayer dictionary key the usage reads from. */
   dictionaryKey: string;
   /**
@@ -53,7 +53,7 @@ type MessageUsage = {
  * @param text - Full source text (a script: TS/TSX or an extracted SFC block).
  * @returns Usages ordered by start offset.
  */
-declare const collectMessageUsages: (text: string) => MessageUsage[];
+export declare const collectMessageUsages: (text: string) => MessageUsage[];
 /**
  * Resolve the dictionary key declared by a single call-expression node when
  * it matches any registered non-self caller (`useIntlayer("key")`,
@@ -62,13 +62,13 @@ declare const collectMessageUsages: (text: string) => MessageUsage[];
  *
  * @param callNode - A candidate CallExpression node.
  */
-declare const matchCallNamespace: (callNode: OxcNode) => string | null;
+export declare const matchCallNamespace: (callNode: OxcNode) => string | null;
 /**
  * A call site declaring which dictionary a caller reads
  * (`useIntlayer("home")`, `useI18n({ namespace: 'home' })`), with the spans
  * needed to anchor diagnostics and cursor checks.
  */
-type NamespaceReference = {
+export type NamespaceReference = {
   dictionaryKey: string;
   callerName: string;
   library: string;
@@ -92,13 +92,13 @@ type NamespaceReference = {
  *
  * @param text - Full source text.
  */
-declare const collectNamespaceReferences: (text: string) => NamespaceReference[];
+export declare const collectNamespaceReferences: (text: string) => NamespaceReference[];
 /**
  * A source variable bound to a dictionary by a caller declaration:
  * dictionary content (or a field subtree of it) for `content` callers, or a
  * translation function for `return-value` / `destructured-t` callers.
  */
-type CallerVariableBinding = {
+export type CallerVariableBinding = {
   /** Local variable name. */
   variableName: string;
   /** The dictionary the variable reads from. */
@@ -121,7 +121,7 @@ type CallerVariableBinding = {
  *
  * @param text - Full source text (a script: TS/TSX or an extracted SFC block).
  */
-declare const collectCallerBindings: (text: string) => CallerVariableBinding[];
+export declare const collectCallerBindings: (text: string) => CallerVariableBinding[];
 /**
  * Find the most specific translation usage at `offset`.
  *
@@ -135,7 +135,6 @@ declare const collectCallerBindings: (text: string) => CallerVariableBinding[];
  * @param text - Full source text.
  * @param offset - Cursor offset in `text`.
  */
-declare const findMessageUsageAtOffset: (text: string, offset: number) => MessageUsage | null;
+export declare const findMessageUsageAtOffset: (text: string, offset: number) => MessageUsage | null;
 //#endregion
-export { CallerVariableBinding, MessageUsage, MessageUsageKind, NamespaceReference, collectCallerBindings, collectMessageUsages, collectNamespaceReferences, findMessageUsageAtOffset, matchCallNamespace };
 //# sourceMappingURL=usageAnalyzer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"usageAnalyzer.d.ts","names":[],"sources":["../../src/usageAnalyzer.ts"],"mappings":";;;KAwBY;;;;;KAkBA;;EAEV;;;;;EAKA;;;;;;EAMA;IAAe;IAAe;;;EAE9B;;EAEA;EACA,MAAM;;EAEN;;EAEA;;EAEA;;;;;;;EAOA;;;;;;;;;;;;;cAyjCW,uBAAwB,iBAAe;;;;;;;;;cAmCvC,qBAAsB,UAAU;;;;;;KAgCjC;EACV;EACA;EACA;;EAEA;EACA;;EAEA;EACA;;EAEA;EACA;;;;;;;;;;;;cAwCW,6BACX,iBACC;;;;;;KA8DS;;EAEV;;EAEA;;;;;EAKA;;EAEA;;EAEA;EACA;;;;;;;;;cAUW,wBACX,iBACC;;;;;;;;;;;;;;cAkEU,2BACX,cACA,mBACC"}
+{"version":3,"file":"usageAnalyzer.d.ts","names":[],"sources":["../../src/usageAnalyzer.ts"],"mappings":";;;YAwBY;;;;;YAkBA;;EAEV;;;;;EAKA;;;;;;EAMA;IAAe;IAAe;;;EAE9B;;EAEA;EACA,MAAM;;EAEN;;EAEA;;EAEA;;;;;;;EAOA;;;;;;;;;;;;;qBAyjCW,uBAAwB,iBAAe;;;;;;;;;qBAmCvC,qBAAsB,UAAU;;;;;;YAgCjC;EACV;EACA;EACA;;EAEA;EACA;;EAEA;EACA;;EAEA;EACA;;;;;;;;;;;;qBAwCW,6BACX,iBACC;;;;;;YA8DS;;EAEV;;EAEA;;;;;EAKA;;EAEA;;EAEA;EACA;;;;;;;;;qBAUW,wBACX,iBACC;;;;;;;;;;;;;;qBAkEU,2BACX,cACA,mBACC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/lsp",
-  "version": "9.4.2",
+  "version": "9.4.4",
   "private": false,
   "description": "Intlayer Language Server. Handle LSP to help IDE and AI agent to use Intlayer",
   "keywords": [
@@ -86,10 +86,10 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.4.2",
-    "@intlayer/engine": "9.4.2",
-    "@intlayer/types": "9.4.2",
-    "@intlayer/unmerged-dictionaries-entry": "9.4.2",
+    "@intlayer/config": "9.4.4",
+    "@intlayer/engine": "9.4.4",
+    "@intlayer/types": "9.4.4",
+    "@intlayer/unmerged-dictionaries-entry": "9.4.4",
     "oxc-parser": "0.148.0",
     "vscode-languageserver": "10.1.1",
     "vscode-languageserver-textdocument": "1.0.14"
@@ -100,9 +100,9 @@
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "engines": {
     "node": ">=14.18"