koishi-plugin-warframe 1.6.3 → 1.6.5

package/lib/index.js

@@ -693,9 +693,9 @@ var require_LocalDatastore = __commonJS({
           return _this2.Promise.resolve();
         })();
       }
-      yieldLoop(t = 0) {
+      yieldLoop(t2 = 0) {
         return new this.Promise(function(resolve2, reject) {
-          return setTimeout(resolve2, t);
+          return setTimeout(resolve2, t2);
         });
       }
       computePenalty() {
@@ -4208,6 +4208,48 @@ function HotRivenComponent(data) {
 }
 __name(HotRivenComponent, "HotRivenComponent");
 
+// src/messages.ts
+var messages = {
+  "common.fetchFailed": "内部错误，获取最新信息失败",
+  "relic.invalidName": "请提供正确的遗物名称",
+  "relic.dataLoading": "遗物数据未加载完成，请稍后再试",
+  "relic.notFound": "未找到对应遗物信息",
+  "arbitration.invalidDayRange": "天数需小于等于14且大于0",
+  "voidTrader.drifting": "虚空商人仍在未知地带漂流...",
+  "voidTrader.arriving": "距离虚空商人到达还有: {time}",
+  "riven.imageNotFound": "未检测到图片",
+  "riven.ocrNotConfigured": "未配置 OCR，请在插件设置中配置。",
+  "riven.imageFetchFailed": "获取图片失败",
+  "riven.imageParseFailed": "解析图片失败",
+  "riven.weaponNotFound": "未找到武器: {weapon}",
+  "riven.dispositionError": "裂罅倾向错误",
+  "riven.weaponTypeError": "武器类型错误",
+  "riven.statTypeError": "词条类型错误",
+  "riven.invalidParams": "请输入正确参数",
+  "riven.noWeeklyData": "没有找到符合条件的紫卡参考数据",
+  "wfm.inputItemName": "请输入物品名称",
+  "wfm.itemNotFound": "未找到物品: {input}",
+  "wfm.orderFetchFailed": "订单获取失败，请稍后重试",
+  "wfm.noOnlineSeller": "当前没有在线游戏中的卖家",
+  "wfm.rivenWeaponNotFound": "未找到紫卡武器: {input}",
+  "wfm.rivenOrderFetchFailed": "紫卡订单获取失败，请稍后重试",
+  "wfm.noOnlineRivenSeller": "当前没有在线出售的紫卡",
+  "miscs.hotRiven.noData": "暂无热门紫卡数据",
+  "miscs.hotRiven.fetchFailed": "获取热门紫卡数据失败",
+  "miscs.inDevelopment": "功能暂未开放"
+};
+function t(messageOrResult, params) {
+  if (typeof messageOrResult !== "string") {
+    return t(messageOrResult.message, messageOrResult.params);
+  }
+  let text = messages[messageOrResult];
+  for (const [key, value] of Object.entries(params ?? {})) {
+    text = text.replaceAll(`{${key}}`, String(value));
+  }
+  return text;
+}
+__name(t, "t");
+
 // src/utils/assets.ts
 var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
@@ -4311,8 +4353,8 @@ var dictToKeyDict = /* @__PURE__ */ __name((dict, predict) => {
 }, "dictToKeyDict");
 
 // src/utils/color.ts
-function lerp(start, end, t) {
-  return Math.round(start + (end - start) * t);
+function lerp(start, end, t2) {
+  return Math.round(start + (end - start) * t2);
 }
 __name(lerp, "lerp");
 function hexToRgb(hex) {
@@ -4484,11 +4526,11 @@ async function getHotRivenWeapons2() {
   try {
     const result = await globalHotRivenWeapons.get();
     if (!result || result.length === 0) {
-      return { ok: false, message: "暂无热门紫卡数据" };
+      return { ok: false, message: "miscs.hotRiven.noData" };
     }
     return { ok: true, data: result };
   } catch {
-    return { ok: false, message: "获取热门紫卡数据失败" };
+    return { ok: false, message: "miscs.hotRiven.fetchFailed" };
   }
 }
 __name(getHotRivenWeapons2, "getHotRivenWeapons");
@@ -4509,6 +4551,7 @@ var arbitrationScheduleText = loadAssetText("arbys.txt");
 var arbyRewards = loadAssetJson("arbyRewards.json");
 var Baro = loadAssetText("baro.txt");
 var BaroParsed = loadAssetJson("baroParsed.json");
+var warframeAlias = loadAssetJson("warframeAlias.json");
 
 // src/data/wf/arbitrationSchedule.ts
 var arbitrationSchedule = arbitrationScheduleText.split("\n").map((line) => line.split(",")).filter((arr) => arr.length === 2).map((arr) => {
@@ -5176,8 +5219,48 @@ var globalRivenAttribute = createAsyncCache(
 );
 
 // src/data/wfm/globalRivenItem.ts
-var globalRivenItemData = createAsyncCache(async () => {
-  const rivenData = await wfmClient.rivens.getItems();
+function normalizeWordPrefixName(input) {
+  return fullWidthToHalfWidth(input).toLowerCase().replace(/[·'()+【】[\]{}，。！？；：_]/g, " ").replace(/[-/\\]/g, " ").replace(/\s+/g, " ").trim();
+}
+__name(normalizeWordPrefixName, "normalizeWordPrefixName");
+function splitWordPrefixTokens(input) {
+  const normalized = normalizeWordPrefixName(input);
+  if (!normalized) {
+    return [];
+  }
+  return normalized.split(" ").filter(Boolean);
+}
+__name(splitWordPrefixTokens, "splitWordPrefixTokens");
+function buildGlobalRivenItemWordPrefixCandidates(globalRivenItemList) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of globalRivenItemList) {
+    const names = [
+      item.i18n?.en?.name,
+      item.i18n?.["zh-hans"]?.name
+    ].filter((name2) => typeof name2 === "string" && name2.length > 0);
+    for (const name2 of names) {
+      const normalizedName = normalizeWordPrefixName(name2);
+      if (!normalizedName || seen.has(`${item.slug}:${normalizedName}`)) {
+        continue;
+      }
+      const tokens = splitWordPrefixTokens(normalizedName);
+      if (tokens.length === 0) {
+        continue;
+      }
+      seen.add(`${item.slug}:${normalizedName}`);
+      candidates.push({
+        item,
+        normalizedName,
+        tokens
+      });
+    }
+  }
+  return candidates;
+}
+__name(buildGlobalRivenItemWordPrefixCandidates, "buildGlobalRivenItemWordPrefixCandidates");
+async function globalRivenItemFactory(rivenData) {
+  rivenData ??= await wfmClient.rivens.getItems();
   if (!rivenData) {
     throw new Error("Failed to fetch riven items from Warframe Market API.");
   }
@@ -5198,11 +5281,17 @@ var globalRivenItemData = createAsyncCache(async () => {
     }
     return result;
   })(data);
+  const globalRivenItemWordPrefixCandidates = buildGlobalRivenItemWordPrefixCandidates(data);
   return {
     globalRivenItemList,
     globalRivenItemDict,
-    globalRivenItemNameToSlugDict
+    globalRivenItemNameToSlugDict,
+    globalRivenItemWordPrefixCandidates
   };
+}
+__name(globalRivenItemFactory, "globalRivenItemFactory");
+var globalRivenItemData = createAsyncCache(async () => {
+  return globalRivenItemFactory();
 }, -1);
 
 // src/infrastructure/ocr-api.ts
@@ -5242,7 +5331,7 @@ async function getTextFromTencentOCR(image, secret) {
   const { TextDetections } = await client.GeneralAccurateOCR({
     ImageBase64: image
   });
-  const result = TextDetections?.map((t) => t.DetectedText).filter(
+  const result = TextDetections?.map((t2) => t2.DetectedText).filter(
     Boolean
   );
   return result;
@@ -5266,14 +5355,14 @@ __name(extractTextFromImage, "extractTextFromImage");
 // src/services/wf-service.ts
 async function getRelic(input) {
   if (!input) {
-    return { ok: false, message: "请提供正确的遗物名称" };
+    return { ok: false, message: "relic.invalidName" };
   }
   input = normalizeName(input);
   if (!input) {
-    return { ok: false, message: "请提供正确的遗物名称" };
+    return { ok: false, message: "relic.invalidName" };
   }
   if (!relics) {
-    return { ok: false, message: "遗物数据未加载完成，请稍后再试" };
+    return { ok: false, message: "relic.dataLoading" };
   }
   const tierListForMatch = [
     "古纪",
@@ -5288,10 +5377,10 @@ async function getRelic(input) {
     "Axi",
     "Requiem",
     "Vanguard"
-  ].map((t) => normalizeName(t));
-  const tier = tierListForMatch.find((t) => input.startsWith(t));
+  ].map((t2) => normalizeName(t2));
+  const tier = tierListForMatch.find((t2) => input.startsWith(t2));
   if (!tier) {
-    return { ok: false, message: "请提供正确的遗物名称" };
+    return { ok: false, message: "relic.invalidName" };
   }
   const category = input.replace(new RegExp(`^${tier}`), "").replace(/遗物$|relic$/, "");
   const zhTierMap = {
@@ -5304,12 +5393,12 @@ async function getRelic(input) {
   };
   const enTier = zhTierMap[tier] ?? tier;
   const key = normalizeName(enTier + category);
-  return relics[key] ? { ok: true, data: relics[key] } : { ok: false, message: "未找到对应遗物信息" };
+  return relics[key] ? { ok: true, data: relics[key] } : { ok: false, message: "relic.notFound" };
 }
 __name(getRelic, "getRelic");
 function getArbitrations(day = 3) {
   if (day > 14 || day <= 0) {
-    return { ok: false, message: "天数需小于等于14且大于0" };
+    return { ok: false, message: "arbitration.invalidDayRange" };
   }
   const currentHourTimeStamp = Math.floor(
     (/* @__PURE__ */ new Date()).setUTCMinutes(0, 0, 0) / 1e3
@@ -5348,7 +5437,7 @@ __name(getArbitrations, "getArbitrations");
 async function getWeekly() {
   const { raw: worldState } = await globalWorldState.get();
   if (!worldState) {
-    return { ok: false, message: "内部错误，获取最新信息失败" };
+    return { ok: false, message: "common.fetchFailed" };
   }
   const archon = {
     name: import_warframe_public_export_plus6.dict_zh[`/Lotus/Language/Narmer/${removeSpace(worldState.archonHunt.boss)}`],
@@ -5485,45 +5574,44 @@ function getCircuitWeek() {
 __name(getCircuitWeek, "getCircuitWeek");
 async function getFissures() {
   const { fissures } = await globalWorldState.get();
-  return fissures ? { ok: true, data: fissures } : { ok: false, message: "内部错误，获取最新信息失败" };
+  return fissures ? { ok: true, data: fissures } : { ok: false, message: "common.fetchFailed" };
 }
 __name(getFissures, "getFissures");
 async function getSteelPathFissures() {
   const { spFissures } = await globalWorldState.get();
-  return spFissures ? { ok: true, data: spFissures } : { ok: false, message: "内部错误，获取最新信息失败" };
+  return spFissures ? { ok: true, data: spFissures } : { ok: false, message: "common.fetchFailed" };
 }
 __name(getSteelPathFissures, "getSteelPathFissures");
 async function getRailjackFissures() {
   const { rjFissures } = await globalWorldState.get();
-  return rjFissures ? { ok: true, data: rjFissures } : { ok: false, message: "内部错误，获取最新信息失败" };
+  return rjFissures ? { ok: true, data: rjFissures } : { ok: false, message: "common.fetchFailed" };
 }
 __name(getRailjackFissures, "getRailjackFissures");
 async function getAnalyzedRiven(secret, url) {
   const img = await fetchAsyncImage(url);
   if (!img) {
-    return { ok: false, message: "获取图片失败" };
+    return { ok: false, message: "riven.imageFetchFailed" };
   }
   const extractResult = await extractTextFromImage(img, secret);
   if (!extractResult) {
-    return { ok: false, message: "解析图片失败" };
+    return { ok: false, message: "riven.imageParseFailed" };
   }
   const parseResult = await parseOCRResult(extractResult);
   if (!parseResult || parseResult.attributes.length < 2 || parseResult.attributes.length > 4) {
-    return { ok: false, message: "解析图片失败" };
+    return { ok: false, message: "riven.imageParseFailed" };
   }
-  const analyzed = analyzeRivenStat(parseResult);
-  return typeof analyzed === "string" ? { ok: false, message: analyzed } : { ok: true, data: analyzed };
+  return analyzeRivenStat(parseResult);
 }
 __name(getAnalyzedRiven, "getAnalyzedRiven");
 async function getVoidTrader() {
   const { raw: worldState } = await globalWorldState.get();
   if (worldState.voidTraders.length === 0) {
-    return { ok: false, message: "虚空商人仍在未知地带漂流..." };
+    return { ok: false, message: "voidTrader.drifting" };
   }
   const trader = worldState.voidTraders[0];
   if (trader && trader.activation && trader.activation.getTime() > Date.now()) {
     const diff2 = trader.activation.getTime() - Date.now();
-    return { ok: false, message: `距离虚空商人到达还有: ${msToHumanReadable(diff2)}` };
+    return { ok: false, message: "voidTrader.arriving", params: { time: msToHumanReadable(diff2) } };
   }
   const diff = trader.expiry.getTime() - Date.now();
   const items = trader.inventory.map(getVoidTraderItem);
@@ -5566,7 +5654,7 @@ async function getWeeklyRivens(minPrice) {
 __name(getWeeklyRivens, "getWeeklyRivens");
 async function getStaticRivenStats(weaponType, statType, disposition) {
   if (disposition > 1.55 || disposition < 0.5) {
-    return { ok: false, message: "裂罅倾向错误" };
+    return { ok: false, message: "riven.dispositionError" };
   }
   const weaponTypes = [
     "步枪",
@@ -5584,7 +5672,7 @@ async function getStaticRivenStats(weaponType, statType, disposition) {
     (v) => normalizeName(v).startsWith(normalizeName(weaponType))
   );
   if (!matchedWeaponType) {
-    return { ok: false, message: "武器类型错误" };
+    return { ok: false, message: "riven.weaponTypeError" };
   }
   const weaponTypeKeys = {
     步枪: "Rifle",
@@ -5596,7 +5684,7 @@ async function getStaticRivenStats(weaponType, statType, disposition) {
   const weaponTypeKey = weaponTypeKeys[matchedWeaponType] ?? matchedWeaponType;
   const statTypes = ["2", "3", "21", "31"];
   if (!statTypes.includes(statType)) {
-    return { ok: false, message: "词条类型错误" };
+    return { ok: false, message: "riven.statTypeError" };
   }
   const rivenAttrValues2 = rivenAttrValueDict[weaponTypeKey];
   const factor = rivenStatFixFactor[statType];
@@ -5671,20 +5759,20 @@ async function parseOCRResult(ocrResult) {
     if (standard.includes(input) || input.includes(standard) || standard.split("/").some((x) => !!x && input.includes(x))) {
       return 1;
     }
-    const t = tokenSimilarity(standard, input);
+    const t2 = tokenSimilarity(standard, input);
     const s = normalSimilarity(standard, input);
-    return Math.max(t, s);
+    return Math.max(t2, s);
   }
   __name(similarity, "similarity");
   const texts = list;
   const attributes = [];
   const statLines = [];
-  for (const t of texts) {
-    if (!t || !/^[x+-]|^\d/.test(t)) {
+  for (const t2 of texts) {
+    if (!t2 || !/^[x+-]|^\d/.test(t2)) {
       continue;
     }
-    const prefix = /^[x+-]/.test(t) ? t[0] : "";
-    const attrNamePart = removeSpace(t ?? "").replace(/^[^\u4E00-\u9FA5]+/u, "");
+    const prefix = /^[x+-]/.test(t2) ? t2[0] : "";
+    const attrNamePart = removeSpace(t2 ?? "").replace(/^[^\u4E00-\u9FA5]+/u, "");
     const attr = globalRivenAttributeList.find((a) => {
       if (!a)
         return false;
@@ -5699,24 +5787,24 @@ async function parseOCRResult(ocrResult) {
     if (!attr) {
       continue;
     }
-    statLines.push(t);
+    statLines.push(t2);
     const value = (/* @__PURE__ */ __name((function extractStatValue(text) {
-      const t2 = text.replace(/\s+/g, "");
-      const multMatch = t2.match(/x(\d+(?:\.\d+)?)/i);
+      const t3 = text.replace(/\s+/g, "");
+      const multMatch = t3.match(/x(\d+(?:\.\d+)?)/i);
       if (multMatch) {
         return {
           value: Number.parseFloat(multMatch[1]),
           type: "multiply"
         };
       }
-      const percentMatch = t2.match(/([+-]?\d+(?:\.\d+)?)%/);
+      const percentMatch = t3.match(/([+-]?\d+(?:\.\d+)?)%/);
       if (percentMatch) {
         return {
           value: Number.parseFloat(percentMatch[1]),
           type: "percent"
         };
       }
-      const numMatch = t2.match(/([+-]?\d+(?:\.\d+)?)/);
+      const numMatch = t3.match(/([+-]?\d+(?:\.\d+)?)/);
       if (numMatch) {
         return {
           value: Number.parseFloat(numMatch[1]),
@@ -5724,7 +5812,7 @@ async function parseOCRResult(ocrResult) {
         };
       }
       return void 0;
-    }), "extractStatValue"))(t);
+    }), "extractStatValue"))(t2);
     if (!value) {
       return void 0;
     }
@@ -5770,7 +5858,7 @@ async function parseOCRResult(ocrResult) {
     }
     __name(removeRivenSuffix, "removeRivenSuffix");
     return merged ? removeRivenSuffix(merged) : null;
-  }), "extractWeaponName"))(texts.filter((t) => !statLines.includes(t)));
+  }), "extractWeaponName"))(texts.filter((t2) => !statLines.includes(t2)));
   if (!weaponName || !attributes.length) {
     return void 0;
   }
@@ -5783,7 +5871,11 @@ __name(parseOCRResult, "parseOCRResult");
 function analyzeRivenStat(parseResult) {
   const weaponRiven = getWeaponRivenDisposition(parseResult.name);
   if (!weaponRiven) {
-    return `未找到武器: ${parseResult.name}`;
+    return {
+      ok: false,
+      message: "riven.weaponNotFound",
+      params: { weapon: parseResult.name }
+    };
   }
   const disposition = weaponRiven.calc.disposition;
   const weaponType = weaponRiven.calc.riventype;
@@ -5837,15 +5929,18 @@ function analyzeRivenStat(parseResult) {
     }
   }
   return {
-    name: weaponRiven.name.zh,
-    disposition,
-    buffs,
-    curses
+    ok: true,
+    data: {
+      name: weaponRiven.name.zh,
+      disposition,
+      buffs,
+      curses
+    }
   };
 }
 __name(analyzeRivenStat, "analyzeRivenStat");
 
-// src/services/wfm-service.ts
+// src/services/wfm-service/index.ts
 var import_warframe_public_export_plus7 = require("warframe-public-export-plus");
 
 // src/data/wfm/globalDucatnator.ts
@@ -5858,6 +5953,46 @@ var globalDucatnatorIDDict = createAsyncCache(async () => {
 }, 36e5);
 
 // src/data/wfm/globalItem.ts
+function normalizeWordPrefixName2(input) {
+  return fullWidthToHalfWidth(input).toLowerCase().replace(/[·'()+【】[\]{}，。！？；：_]/g, " ").replace(/[-/\\]/g, " ").replace(/\s+/g, " ").trim();
+}
+__name(normalizeWordPrefixName2, "normalizeWordPrefixName");
+function splitWordPrefixTokens2(input) {
+  const normalized = normalizeWordPrefixName2(input);
+  if (!normalized) {
+    return [];
+  }
+  return normalized.split(" ").filter(Boolean);
+}
+__name(splitWordPrefixTokens2, "splitWordPrefixTokens");
+function buildGlobalItemWordPrefixCandidates(globalItemList) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of globalItemList) {
+    const names = [
+      item.i18n?.en?.name,
+      item.i18n?.["zh-hans"]?.name
+    ].filter((name2) => typeof name2 === "string" && name2.length > 0);
+    for (const name2 of names) {
+      const normalizedName = normalizeWordPrefixName2(name2.toLowerCase());
+      if (!normalizedName || seen.has(`${item.slug}:${normalizedName}`)) {
+        continue;
+      }
+      const tokens = splitWordPrefixTokens2(normalizedName);
+      if (tokens.length === 0) {
+        continue;
+      }
+      seen.add(`${item.slug}:${normalizedName}`);
+      candidates.push({
+        item,
+        normalizedName,
+        tokens
+      });
+    }
+  }
+  return candidates;
+}
+__name(buildGlobalItemWordPrefixCandidates, "buildGlobalItemWordPrefixCandidates");
 async function globalItemDataFactory(response) {
   response ??= await wfmClient.items.getList();
   if (!response) {
@@ -5865,7 +6000,8 @@ async function globalItemDataFactory(response) {
       globalItemList: [],
       globalItemDict: {},
       globalItemNameToSlugDict: {},
-      globalItemGameRefDict: {}
+      globalItemGameRefDict: {},
+      globalItemWordPrefixCandidates: []
     };
   }
   const data = response;
@@ -5887,111 +6023,409 @@ async function globalItemDataFactory(response) {
     return result;
   })(globalItemList);
   const globalItemGameRefDict = listToDict(data, (i) => [i.gameRef]);
+  const globalItemWordPrefixCandidates = buildGlobalItemWordPrefixCandidates(
+    globalItemList
+  );
   return {
     globalItemList,
     globalItemDict,
     globalItemNameToSlugDict,
-    globalItemGameRefDict
+    globalItemGameRefDict,
+    globalItemWordPrefixCandidates
   };
 }
 __name(globalItemDataFactory, "globalItemDataFactory");
 var globalItemData = createAsyncCache(globalItemDataFactory, -1);
 
-// src/services/wfm-service.ts
-var warframeAlias = {
-  "Volt": ["电", "电男", "伏特"],
-  "Trinity": ["奶妈", "奶"],
-  "Rhino": ["犀牛", "牛"],
-  "Mag": ["磁妹", "磁力"],
-  "Loki": ["洛基"],
-  "Excalibur": ["咖喱棒", "圣剑", "咖喱"],
-  "Ember": ["火鸡"],
-  "Ash": ["灰烬", "灰烬之刃"],
-  "Nyx": ["脑溢血"],
-  "Frost": ["冰男", "冰雪寒霜", "冰队", "冰"],
-  "Saryn": ["毒妈", "毒"],
-  "Banshee": ["女妖", "女高音"],
-  "Vauban": ["工程"],
-  "Nova": ["诺娃", "加速", "加速娃"],
-  "Nekros": ["摸尸", "摸"],
-  "Valkyr": ["瓦尔基里", "瓦喵", "瓦"],
-  "Oberon": ["奶爸", "龙王", "奥伯龙"],
-  "Zephyr": ["鸟姐", "鸟"],
-  "Hydroid": ["水男"],
-  "Mirage": ["小丑", "丑"],
-  "Limbo": ["小明", "李明博", "明"],
-  "Mesa": ["女枪"],
-  "Chroma": ["龙甲", "龙"],
-  "Equinox": ["阴阳", "双子"],
-  "Atlas": ["土石魔像", "土"],
-  "Wukong": ["猴子", "齐天大圣", "悟空", "猴"],
-  "Ivara": ["弓妹", "弓"],
-  "Nezha": ["哪吒", "三太子"],
-  "Inaros": ["沙"],
-  "Titania": ["蝶妹"],
-  "Nidus": ["蛆甲", "蛆"],
-  "Octavia": ["DJ", "音乐"],
-  "Harrow": ["主教"],
-  "Gara": ["玻璃"],
-  "Khora": ["猫"],
-  "Revenant": ["夜灵"],
-  "Garuda": ["血妈", "血"],
-  "Baruuk": ["武僧"],
-  "Hildryn": ["母牛"],
-  "Wisp": ["花"],
-  "Gauss": ["高斯"],
-  "Grendel": ["肥宅"],
-  "Protea": ["茶", "茶妹"],
-  "Xaku": ["骨"],
-  "Lavos": ["炼金", "药水", "药水哥", "蛇"],
-  "Sevagoth": ["鬼", "鲨鱼"],
-  "Yareli": ["水妹"],
-  "Caliban": ["卡利班"],
-  "Gyre": ["电妹"],
-  "Styanax": ["斯巴达"],
-  "Voruna": ["狼", "狼妹"],
-  "Citrine": ["水晶", "宝石"],
-  "Kullervo": ["刀哥"],
-  "Dagath": ["马", "赛马娘", "马娘"],
-  "Qorvex": ["暖气片"],
-  "Dante": ["但丁"],
-  "Jade": ["翡翠", "天使"],
-  "Koumei": [],
-  "Cyte-09": ["Cyte09", "老九", "9", "九"],
-  "Temple": ["吉他"],
-  "Nokko": ["蘑菇"]
-};
-var warframeAliasDict = ((aliasObject) => {
-  const transformedObject = {};
-  for (const [key, aliases] of Object.entries(aliasObject)) {
-    transformedObject[key] = key;
-    for (const alias of aliases) {
-      if (typeof alias === "string" && alias.length > 0) {
-        transformedObject[alias] = key;
-        const warframeNameWithSuffix = `${alias}甲`;
-        transformedObject[warframeNameWithSuffix] = key;
-      }
-    }
-  }
-  return transformedObject;
-})(warframeAlias);
-var setSuffix = "一套";
-var bpSuffix = "蓝图";
-var primeSuffix = "prime";
-var warframePartSuffix = ["系统", "头部神经光元", "机体"];
-var weaponPartSuffix = [
-  "枪管",
-  "枪托",
-  "枪机",
-  "弓弦",
-  "上弓臂",
-  "下弓臂",
-  "刀刃",
-  "握柄",
-  "拳套",
-  "圆盘",
-  "连接器"
-];
+// src/services/wfm-service/wfm-service.item-matcher.ts
+var wfmItemMatcher = (() => {
+  const setSuffix = "一套";
+  const bpSuffix = "蓝图";
+  const primeSuffix = "prime";
+  const warframePartSuffix = ["系统", "头部神经光元", "机体"];
+  const weaponPartSuffix = [
+    "枪管",
+    "枪托",
+    "枪机",
+    "弓弦",
+    "上弓臂",
+    "下弓臂",
+    "刀刃",
+    "握柄",
+    "拳套",
+    "圆盘",
+    "连接器"
+  ];
+  const warframeAliasDict = ((aliasObject) => {
+    const transformedObject = {};
+    for (const [key, aliases] of Object.entries(aliasObject)) {
+      const normalizedKey = normalizeName(key);
+      transformedObject[normalizedKey] = normalizedKey;
+      for (const alias of aliases) {
+        if (typeof alias !== "string" || alias.length === 0) {
+          continue;
+        }
+        const normalizedAlias = normalizeName(alias);
+        transformedObject[normalizedAlias] = normalizedKey;
+        const warframeNameWithSuffix = normalizeName(`${alias}甲`);
+        transformedObject[warframeNameWithSuffix] = normalizedKey;
+      }
+    }
+    return transformedObject;
+  })(warframeAlias);
+  function removeNameSuffix2(input) {
+    let hasBPSuffix = false;
+    if (input.endsWith(bpSuffix)) {
+      input = input.replace(new RegExp(`${bpSuffix}$`), "");
+      hasBPSuffix = true;
+    }
+    if (input.endsWith(setSuffix)) {
+      input = input.replace(new RegExp(`${setSuffix}$`), "");
+    }
+    if (input.endsWith(bpSuffix)) {
+      input = input.replace(new RegExp(`${bpSuffix}$`), "");
+      hasBPSuffix = true;
+    }
+    const suffix = warframePartSuffix.find((value) => input.endsWith(value)) ?? weaponPartSuffix.find((value) => input.endsWith(value)) ?? (input.endsWith("头") ? "头部神经光元" : void 0) ?? (hasBPSuffix ? bpSuffix : void 0) ?? "";
+    if (suffix) {
+      input = input.endsWith("头") ? input.replace(/头$/, "") : input;
+      const pure = input.replace(new RegExp(`${suffix}$`), "");
+      return {
+        pure,
+        suffix
+      };
+    } else {
+      return {
+        pure: input,
+        suffix
+      };
+    }
+  }
+  __name(removeNameSuffix2, "removeNameSuffix");
+  function shortHandProcess3(input, lookup) {
+    const { pure: inputNoSuffix, suffix } = removeNameSuffix2(input);
+    if (inputNoSuffix === input) {
+      const fixSet = input + setSuffix;
+      const fixSetRes = lookup.globalItemNameToSlugDict[fixSet];
+      if (fixSetRes)
+        return lookup.globalItemDict[fixSetRes];
+      const fixPrime = input.endsWith(primeSuffix) ? input : input.endsWith("p") ? input.slice(0, input.length - 1) + primeSuffix : input + primeSuffix;
+      const fixPrimeRes = lookup.globalItemNameToSlugDict[fixPrime];
+      if (fixPrimeRes)
+        return lookup.globalItemDict[fixPrimeRes];
+      const fixPrimeSet = fixPrime + setSuffix;
+      const fixPrimeSetRes = lookup.globalItemNameToSlugDict[fixPrimeSet];
+      if (fixPrimeSetRes)
+        return lookup.globalItemDict[fixPrimeSetRes];
+      const fixBP = input + bpSuffix;
+      const fixBPRes = lookup.globalItemNameToSlugDict[fixBP];
+      if (fixBPRes)
+        return lookup.globalItemDict[fixBPRes];
+      const fixPrimeBP = fixPrime + bpSuffix;
+      const fixPrimeBPRes = lookup.globalItemNameToSlugDict[fixPrimeBP];
+      if (fixPrimeBPRes)
+        return lookup.globalItemDict[fixPrimeBPRes];
+    } else {
+      const fixBP = inputNoSuffix + suffix + bpSuffix;
+      const fixBPRes = lookup.globalItemNameToSlugDict[fixBP];
+      if (fixBPRes)
+        return lookup.globalItemDict[fixBPRes];
+      const fixPrime = inputNoSuffix.endsWith(primeSuffix) ? inputNoSuffix : inputNoSuffix.endsWith("p") ? inputNoSuffix.slice(0, inputNoSuffix.length - 1) + primeSuffix : inputNoSuffix + primeSuffix;
+      const fixPrimeRes = lookup.globalItemNameToSlugDict[fixPrime + suffix];
+      if (fixPrimeRes)
+        return lookup.globalItemDict[fixPrimeRes];
+      const fixPrimeBP = fixPrime + suffix + bpSuffix;
+      const fixPrimeBPRes = lookup.globalItemNameToSlugDict[fixPrimeBP];
+      if (fixPrimeBPRes)
+        return lookup.globalItemDict[fixPrimeBPRes];
+    }
+  }
+  __name(shortHandProcess3, "shortHandProcess");
+  function matchBySlugDict3(input, lookup) {
+    const slug = lookup.globalItemNameToSlugDict[input];
+    return slug ? lookup.globalItemDict[slug] : void 0;
+  }
+  __name(matchBySlugDict3, "matchBySlugDict");
+  function matchByShortHand2(input, lookup) {
+    return shortHandProcess3(input, lookup);
+  }
+  __name(matchByShortHand2, "matchByShortHand");
+  function transformByWarframeAlias2(input) {
+    const { pure: inputNoSuffix, suffix } = removeNameSuffix2(input);
+    const aliasHasEndP = inputNoSuffix.endsWith(primeSuffix) ? inputNoSuffix.replace(new RegExp(`${primeSuffix}$`), "") : inputNoSuffix;
+    const mappedAliasHasEndP = warframeAliasDict[aliasHasEndP];
+    if (mappedAliasHasEndP) {
+      return normalizeName(mappedAliasHasEndP) + suffix;
+    }
+    if (inputNoSuffix.endsWith("p")) {
+      const aliasNoEndP = inputNoSuffix.replace(/p$/, "");
+      const mappedAliasNoEndP = warframeAliasDict[aliasNoEndP];
+      if (mappedAliasNoEndP) {
+        return normalizeName(mappedAliasNoEndP) + suffix;
+      }
+    }
+    return void 0;
+  }
+  __name(transformByWarframeAlias2, "transformByWarframeAlias");
+  function buildSuffixVariantCandidates2(input) {
+    const candidates = /* @__PURE__ */ new Set();
+    const { pure, suffix } = removeNameSuffix2(input);
+    candidates.add(input);
+    candidates.add(input + bpSuffix);
+    candidates.add(`${input}blueprint`);
+    candidates.add(input + setSuffix);
+    candidates.add(`${input}set`);
+    if (suffix) {
+      const base = pure + suffix;
+      candidates.add(base);
+      candidates.add(base + bpSuffix);
+      candidates.add(`${base}blueprint`);
+      candidates.add(base + setSuffix);
+      candidates.add(`${base}set`);
+    }
+    return [...candidates];
+  }
+  __name(buildSuffixVariantCandidates2, "buildSuffixVariantCandidates");
+  function matchBySuffixVariantLookup2(input, lookup) {
+    for (const candidate of buildSuffixVariantCandidates2(input)) {
+      const slug = lookup.globalItemNameToSlugDict[candidate];
+      if (slug)
+        return lookup.globalItemDict[slug];
+    }
+    return void 0;
+  }
+  __name(matchBySuffixVariantLookup2, "matchBySuffixVariantLookup");
+  function normalizeWordPrefixName5(input) {
+    return fullWidthToHalfWidth(input).toLowerCase().replace(/[·'()+【】[\]{}，。！？；：_]/g, " ").replace(/[-/\\]/g, " ").replace(/\s+/g, " ").trim();
+  }
+  __name(normalizeWordPrefixName5, "normalizeWordPrefixName");
+  function splitWordPrefixTokens5(input) {
+    const normalized = normalizeWordPrefixName5(input);
+    if (!normalized) {
+      return [];
+    }
+    return normalized.split(" ").filter(Boolean);
+  }
+  __name(splitWordPrefixTokens5, "splitWordPrefixTokens");
+  function compareWordPrefixCandidates2(left, right, inputTokens) {
+    const leftExtraTokenCount = left.tokens.length - inputTokens.length;
+    const rightExtraTokenCount = right.tokens.length - inputTokens.length;
+    if (leftExtraTokenCount !== rightExtraTokenCount) {
+      return leftExtraTokenCount - rightExtraTokenCount;
+    }
+    const leftRemainderKey = inputTokens.map((token, index) => left.tokens[index].slice(token.length)).join("\0");
+    const rightRemainderKey = inputTokens.map((token, index) => right.tokens[index].slice(token.length)).join("\0");
+    if (leftRemainderKey !== rightRemainderKey) {
+      return leftRemainderKey.localeCompare(rightRemainderKey);
+    }
+    return left.normalizedName.localeCompare(right.normalizedName);
+  }
+  __name(compareWordPrefixCandidates2, "compareWordPrefixCandidates");
+  function matchByWordPrefixSequence3(input, lookup) {
+    const inputTokens = splitWordPrefixTokens5(input);
+    if (inputTokens.length < 2) {
+      return void 0;
+    }
+    const matchedCandidates = lookup.globalItemWordPrefixCandidates.filter((candidate) => {
+      if (candidate.tokens.length < inputTokens.length) {
+        return false;
+      }
+      return inputTokens.every(
+        (token, index) => candidate.tokens[index].startsWith(token)
+      );
+    }).sort((left, right) => compareWordPrefixCandidates2(left, right, inputTokens));
+    return matchedCandidates[0]?.item;
+  }
+  __name(matchByWordPrefixSequence3, "matchByWordPrefixSequence");
+  async function stringToWFMItem2(input) {
+    const { globalItemDict, globalItemNameToSlugDict, globalItemWordPrefixCandidates } = await globalItemData.get();
+    const normalizedInput = normalizeName(input);
+    const lookup = {
+      globalItemDict,
+      globalItemNameToSlugDict,
+      globalItemWordPrefixCandidates
+    };
+    const slugMatchedItem = matchBySlugDict3(normalizedInput, lookup);
+    if (slugMatchedItem)
+      return slugMatchedItem;
+    const shortHandMatchedItem = matchByShortHand2(normalizedInput, lookup);
+    if (shortHandMatchedItem)
+      return shortHandMatchedItem;
+    const aliasInput = transformByWarframeAlias2(normalizedInput);
+    if (aliasInput) {
+      const aliasShortHandMatchedItem = matchByShortHand2(aliasInput, lookup);
+      if (aliasShortHandMatchedItem)
+        return aliasShortHandMatchedItem;
+    }
+    const suffixMatchedItem = matchBySuffixVariantLookup2(normalizedInput, lookup);
+    if (suffixMatchedItem)
+      return suffixMatchedItem;
+    if (aliasInput) {
+      const aliasSuffixMatchedItem = matchBySuffixVariantLookup2(aliasInput, lookup);
+      if (aliasSuffixMatchedItem)
+        return aliasSuffixMatchedItem;
+    }
+    const wordPrefixMatchedItem = matchByWordPrefixSequence3(input, lookup);
+    if (wordPrefixMatchedItem)
+      return wordPrefixMatchedItem;
+    return void 0;
+  }
+  __name(stringToWFMItem2, "stringToWFMItem");
+  return {
+    buildSuffixVariantCandidates: buildSuffixVariantCandidates2,
+    matchByShortHand: matchByShortHand2,
+    matchBySlugDict: matchBySlugDict3,
+    matchBySuffixVariantLookup: matchBySuffixVariantLookup2,
+    matchByWordPrefixSequence: matchByWordPrefixSequence3,
+    removeNameSuffix: removeNameSuffix2,
+    splitWordPrefixTokens: splitWordPrefixTokens5,
+    shortHandProcess: shortHandProcess3,
+    stringToWFMItem: stringToWFMItem2,
+    transformByWarframeAlias: transformByWarframeAlias2,
+    normalizeWordPrefixName: normalizeWordPrefixName5
+  };
+})();
+var buildSuffixVariantCandidates = wfmItemMatcher.buildSuffixVariantCandidates;
+var matchByShortHand = wfmItemMatcher.matchByShortHand;
+var matchBySlugDict = wfmItemMatcher.matchBySlugDict;
+var matchBySuffixVariantLookup = wfmItemMatcher.matchBySuffixVariantLookup;
+var matchByWordPrefixSequence = wfmItemMatcher.matchByWordPrefixSequence;
+var normalizeWordPrefixName3 = wfmItemMatcher.normalizeWordPrefixName;
+var removeNameSuffix = wfmItemMatcher.removeNameSuffix;
+var splitWordPrefixTokens3 = wfmItemMatcher.splitWordPrefixTokens;
+var shortHandProcess = wfmItemMatcher.shortHandProcess;
+var stringToWFMItem = wfmItemMatcher.stringToWFMItem;
+var transformByWarframeAlias = wfmItemMatcher.transformByWarframeAlias;
+
+// src/services/wfm-service/wfm-service.riven-item-matcher.ts
+function normalizeWordPrefixName4(input) {
+  return fullWidthToHalfWidth(input).toLowerCase().replace(/[·'()+【】[\]{}，。！？；：_]/g, " ").replace(/[-/\\]/g, " ").replace(/\s+/g, " ").trim();
+}
+__name(normalizeWordPrefixName4, "normalizeWordPrefixName");
+function splitWordPrefixTokens4(input) {
+  const normalized = normalizeWordPrefixName4(input);
+  if (!normalized) {
+    return [];
+  }
+  return normalized.split(" ").filter(Boolean);
+}
+__name(splitWordPrefixTokens4, "splitWordPrefixTokens");
+function buildRivenItemLookupData(globalRivenItemList) {
+  const globalRivenItemDict = {};
+  const globalRivenItemNameToSlugDict = {};
+  const globalRivenItemWordPrefixCandidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of globalRivenItemList) {
+    globalRivenItemDict[item.slug] = item;
+    const names = [
+      item.i18n?.["zh-hans"]?.name,
+      item.i18n?.en?.name
+    ].filter((name2) => typeof name2 === "string" && name2.length > 0);
+    for (const name2 of names) {
+      const normalizedName = normalizeName(name2);
+      if (normalizedName && !globalRivenItemNameToSlugDict[normalizedName]) {
+        globalRivenItemNameToSlugDict[normalizedName] = item.slug;
+      }
+      const normalizedWordPrefixName = normalizeWordPrefixName4(name2);
+      if (!normalizedWordPrefixName || seen.has(`${item.slug}:${normalizedWordPrefixName}`)) {
+        continue;
+      }
+      const tokens = splitWordPrefixTokens4(normalizedWordPrefixName);
+      if (tokens.length === 0) {
+        continue;
+      }
+      seen.add(`${item.slug}:${normalizedWordPrefixName}`);
+      globalRivenItemWordPrefixCandidates.push({
+        item,
+        normalizedName: normalizedWordPrefixName,
+        tokens
+      });
+    }
+  }
+  return {
+    globalRivenItemDict,
+    globalRivenItemNameToSlugDict,
+    globalRivenItemWordPrefixCandidates
+  };
+}
+__name(buildRivenItemLookupData, "buildRivenItemLookupData");
+function matchBySlugDict2(input, lookup) {
+  const slug = lookup.globalRivenItemNameToSlugDict[input];
+  return slug ? lookup.globalRivenItemDict[slug] : void 0;
+}
+__name(matchBySlugDict2, "matchBySlugDict");
+function shortHandProcess2(input, lookup) {
+  const primeSuffix = "prime";
+  const fixPrime = input.endsWith(primeSuffix) ? input : input.endsWith("p") ? input.slice(0, input.length - 1) + primeSuffix : input + primeSuffix;
+  const fixPrimeRes = lookup.globalRivenItemNameToSlugDict[fixPrime];
+  if (fixPrimeRes)
+    return lookup.globalRivenItemDict[fixPrimeRes];
+  const fixPrimeSpace = `${input} ${primeSuffix}`;
+  const fixPrimeSpaceRes = lookup.globalRivenItemNameToSlugDict[fixPrimeSpace];
+  if (fixPrimeSpaceRes)
+    return lookup.globalRivenItemDict[fixPrimeSpaceRes];
+  return void 0;
+}
+__name(shortHandProcess2, "shortHandProcess");
+function compareWordPrefixCandidates(left, right, inputTokens) {
+  const leftExtraTokenCount = left.tokens.length - inputTokens.length;
+  const rightExtraTokenCount = right.tokens.length - inputTokens.length;
+  if (leftExtraTokenCount !== rightExtraTokenCount) {
+    return leftExtraTokenCount - rightExtraTokenCount;
+  }
+  const leftRemainderKey = inputTokens.map((token, index) => left.tokens[index].slice(token.length)).join("\0");
+  const rightRemainderKey = inputTokens.map((token, index) => right.tokens[index].slice(token.length)).join("\0");
+  if (leftRemainderKey !== rightRemainderKey) {
+    return leftRemainderKey.localeCompare(rightRemainderKey);
+  }
+  return left.normalizedName.localeCompare(right.normalizedName);
+}
+__name(compareWordPrefixCandidates, "compareWordPrefixCandidates");
+function matchByWordPrefixSequence2(input, lookup) {
+  const inputTokens = splitWordPrefixTokens4(input);
+  if (inputTokens.length < 2) {
+    return void 0;
+  }
+  const matchedCandidates = lookup.globalRivenItemWordPrefixCandidates.filter((candidate) => {
+    if (candidate.tokens.length < inputTokens.length) {
+      return false;
+    }
+    return inputTokens.every(
+      (token, index) => candidate.tokens[index].startsWith(token)
+    );
+  }).sort((left, right) => compareWordPrefixCandidates(left, right, inputTokens));
+  return matchedCandidates[0]?.item;
+}
+__name(matchByWordPrefixSequence2, "matchByWordPrefixSequence");
+function findFromLookup(input, lookup) {
+  const normalizedInput = normalizeName(input);
+  if (!normalizedInput) {
+    return void 0;
+  }
+  const slugMatchedItem = matchBySlugDict2(normalizedInput, lookup);
+  if (slugMatchedItem) {
+    return slugMatchedItem;
+  }
+  const shortHandMatchedItem = shortHandProcess2(normalizedInput, lookup);
+  if (shortHandMatchedItem) {
+    return shortHandMatchedItem;
+  }
+  const wordPrefixMatchedItem = matchByWordPrefixSequence2(input, lookup);
+  if (wordPrefixMatchedItem) {
+    return wordPrefixMatchedItem;
+  }
+  return void 0;
+}
+__name(findFromLookup, "findFromLookup");
+async function findRivenItemByName(input, globalRivenItemList) {
+  if (globalRivenItemList) {
+    return findFromLookup(input, buildRivenItemLookupData(globalRivenItemList));
+  }
+  return globalRivenItemData.get().then((lookup) => findFromLookup(input, lookup));
+}
+__name(findRivenItemByName, "findRivenItemByName");
+
+// src/services/wfm-service/index.ts
 async function updateCache() {
   const updateTasks = [
     { name: "globalItemData", fn: globalItemData.update() },
@@ -6012,32 +6446,32 @@ async function updateCache() {
 }
 __name(updateCache, "updateCache");
 async function getItemOrders(input) {
+  input = input.trim();
   if (!input) {
-    return { ok: false, message: "请输入物品名称" };
+    return { ok: false, message: "wfm.inputItemName" };
   }
-  input = normalizeName(input);
-  const isFullLevel = /^满级|满级$/.test(input);
+  const isFullLevel = /^满级|满级$/.test(normalizeName(input));
   if (isFullLevel) {
     if (input.startsWith("满级")) {
-      input = input.slice(2, input.length);
+      input = input.slice(2, input.length).trimStart();
     } else if (input.endsWith("满级")) {
-      input = input.slice(0, input.length - 2);
+      input = input.slice(0, input.length - 2).trimEnd();
     }
   }
   const targetItem = await stringToWFMItem(input);
   if (!targetItem) {
-    return { ok: false, message: `未找到物品: ${input}` };
+    return { ok: false, message: "wfm.itemNotFound", params: { input } };
   }
   const itemId = targetItem.slug;
   const data = await wfmClient.items.getOrders(itemId);
   if (!data) {
-    return { ok: false, message: "订单获取失败，请稍后重试" };
+    return { ok: false, message: "wfm.orderFetchFailed" };
   }
   const result = data.filter(
     (order) => order.user.status === "ingame" && order.visible && order.type === "sell" && (!isFullLevel || order.rank === targetItem.maxRank)
   ).sort((a, b) => toTimeStamp(b.updatedAt) - toTimeStamp(a.updatedAt)).sort((a, b) => a.platinum - b.platinum).slice(0, 5);
   if (result.length === 0) {
-    return { ok: false, message: "当前没有在线游戏中的卖家" };
+    return { ok: false, message: "wfm.noOnlineSeller" };
   }
   return {
     ok: true,
@@ -6046,26 +6480,21 @@ async function getItemOrders(input) {
 }
 __name(getItemOrders, "getItemOrders");
 async function getRivenOrders(input) {
-  const { globalRivenItemList } = await globalRivenItemData.get();
   const { globalRivenAttributeDict } = await globalRivenAttribute.get();
-  const targetItem = globalRivenItemList.find(
-    (item) => compareRivenItemName(input, item.i18n?.["zh-hans"]?.name ?? "")
-  ) ?? globalRivenItemList.find(
-    (item) => compareRivenItemName(input, item.i18n?.en?.name ?? "")
-  );
+  const targetItem = await findRivenItemByName(input);
   if (!targetItem) {
-    return { ok: false, message: `未找到紫卡武器: ${input}` };
+    return { ok: false, message: "wfm.rivenWeaponNotFound", params: { input } };
   }
   const itemId = targetItem.slug;
   const data = await wfmClient.rivens.getOrders(itemId);
   if (!data) {
-    return { ok: false, message: "紫卡订单获取失败，请稍后重试" };
+    return { ok: false, message: "wfm.rivenOrderFetchFailed" };
   }
   const top5 = data.filter(
     (order) => order.owner.status === "ingame" && order.visible && !order.private && !order.closed && order.is_direct_sell
   ).sort((a, b) => toTimeStamp(b.updated) - toTimeStamp(a.updated)).sort((a, b) => a.starting_price - b.starting_price).slice(0, 5);
   if (top5.length === 0) {
-    return { ok: false, message: "当前没有在线出售的紫卡" };
+    return { ok: false, message: "wfm.noOnlineRivenSeller" };
   }
   const orders = top5.map((e) => {
     const transformed = e.item.attributes.map(
@@ -6168,179 +6597,20 @@ var primedModHistory = createAsyncCache(async () => {
   }
   return result;
 }, 432e5);
-async function stringToWFMItem(input) {
-  const { globalItemList, globalItemDict, globalItemNameToSlugDict } = await globalItemData.get();
-  input = normalizeName(input);
-  const slug = globalItemNameToSlugDict[input];
-  if (slug)
-    return globalItemDict[slug];
-  const normalShortHandRes = await shortHandProcess(input);
-  if (normalShortHandRes)
-    return normalShortHandRes;
-  const { pure: inputNoSuffix, suffix } = removeNameSuffix(input);
-  const aliasHasEndP = inputNoSuffix.endsWith(primeSuffix) ? inputNoSuffix.replace(new RegExp(`${primeSuffix}$`), "") : inputNoSuffix;
-  const mappedAliasHasEndP = warframeAliasDict[aliasHasEndP];
-  if (mappedAliasHasEndP) {
-    const aliasHasEndPRes = await shortHandProcess(
-      normalizeName(mappedAliasHasEndP) + primeSuffix + suffix
-    );
-    if (aliasHasEndPRes)
-      return aliasHasEndPRes;
-  }
-  if (inputNoSuffix.endsWith("p")) {
-    const aliasNoEndP = inputNoSuffix.replace(/p$/, "");
-    const mappedAliasNoEndP = warframeAliasDict[aliasNoEndP];
-    if (mappedAliasNoEndP) {
-      const aliasNoEndPRes = await shortHandProcess(
-        normalizeName(mappedAliasNoEndP) + primeSuffix + suffix
-      );
-      if (aliasNoEndPRes)
-        return aliasNoEndPRes;
-    }
-  }
-  const compareCNOrderName = /* @__PURE__ */ __name((input2, standard) => {
-    if (!input2 || !standard || typeof input2 !== "string" || typeof standard !== "string") {
-      return false;
-    }
-    const normalizedInput = normalizeName(input2);
-    const normalizedStandard = normalizeName(standard);
-    if (!normalizedInput || !normalizedStandard)
-      return false;
-    const normalizedStandardNoSet = normalizedStandard.replace(/一套/g, "");
-    const normalizedStandardNoSetSimplifiedPrime = normalizedStandardNoSet.replace(/prime/g, "p");
-    const normalizedStandardNoBlueprint = normalizedStandard.replace(
-      /蓝图/g,
-      ""
-    );
-    const normalizedStandardNoBlueprintSimplifiedPrime = normalizedStandardNoBlueprint.replace(/prime/g, "p");
-    const normalizedStandardNoNeu = normalizedStandardNoBlueprintSimplifiedPrime.replace(
-      /头部神经光元/g,
-      "头"
-    );
-    return normalizedInput === normalizedStandard || normalizedInput === normalizedStandardNoSet || normalizedInput === normalizedStandardNoSetSimplifiedPrime || normalizedInput === normalizedStandardNoBlueprintSimplifiedPrime || normalizedInput === normalizedStandardNoNeu;
-  }, "compareCNOrderName");
-  const compareENOrderName = /* @__PURE__ */ __name((input2, standard) => {
-    if (!input2 || !standard || typeof input2 !== "string" || typeof standard !== "string") {
-      return false;
-    }
-    const endWithSet = standard.toLowerCase().endsWith(" set");
-    const standardNoSet = endWithSet ? standard.slice(0, -4) : standard;
-    const endWithBlueprint = standard.toLocaleLowerCase().endsWith("blueprint");
-    const standardNoBlueprint = endWithBlueprint ? standard.slice(0, -10) : standard;
-    const standardSimplifiedPrime = standardNoSet.replace(/ Prime/g, "p");
-    const standardNoBlueprintSimplifiedPrime = standardNoBlueprint.replace(
-      / Prime/g,
-      "p"
-    );
-    const normalizedInput = normalizeName(input2);
-    const normalizedStandard = normalizeName(standard);
-    if (!normalizedInput || !normalizedStandard)
-      return false;
-    const normalizedStandardNoSet = normalizeName(standardNoSet);
-    const normalizedStandardSimplifiedPrime = normalizeName(
-      standardSimplifiedPrime
-    );
-    const normalizedStandardNoBlueprint = normalizeName(
-      standardNoBlueprintSimplifiedPrime
-    );
-    return normalizedInput === normalizedStandard || normalizedInput === normalizedStandardNoSet || normalizedInput === normalizedStandardSimplifiedPrime || normalizedInput === normalizedStandardNoBlueprint;
-  }, "compareENOrderName");
-  return globalItemList.find(
-    (item) => compareCNOrderName(input, item.i18n?.["zh-hans"]?.name ?? "")
-  ) ?? globalItemList.find(
-    (item) => compareENOrderName(input, item.i18n?.en?.name ?? "")
-  );
-}
-__name(stringToWFMItem, "stringToWFMItem");
-function removeNameSuffix(input) {
-  let hasBPSuffix = false;
-  if (input.endsWith(bpSuffix)) {
-    input = input.replace(new RegExp(`${bpSuffix}$`), "");
-    hasBPSuffix = true;
-  }
-  if (input.endsWith(setSuffix)) {
-    input = input.replace(new RegExp(`${setSuffix}$`), "");
-  }
-  if (input.endsWith(bpSuffix)) {
-    input = input.replace(new RegExp(`${bpSuffix}$`), "");
-    hasBPSuffix = true;
-  }
-  const suffix = warframePartSuffix.find((value) => input.endsWith(value)) ?? weaponPartSuffix.find((value) => input.endsWith(value)) ?? (input.endsWith("头") ? "头部神经光元" : void 0) ?? (hasBPSuffix ? bpSuffix : void 0) ?? "";
-  if (suffix) {
-    input = input.endsWith("头") ? input.replace(/头$/, "") : input;
-    const pure = input.replace(new RegExp(`${suffix}$`), "");
-    return {
-      pure,
-      suffix
-    };
-  } else {
-    return {
-      pure: input,
-      suffix
-    };
-  }
-}
-__name(removeNameSuffix, "removeNameSuffix");
-async function shortHandProcess(input) {
-  const { globalItemDict, globalItemNameToSlugDict } = await globalItemData.get();
-  const { pure: inputNoSuffix, suffix } = removeNameSuffix(input);
-  if (inputNoSuffix === input) {
-    const fixSet = input + setSuffix;
-    const fixSetRes = globalItemNameToSlugDict[fixSet];
-    if (fixSetRes)
-      return globalItemDict[fixSetRes];
-    const fixPrime = input.endsWith(primeSuffix) ? input : input.endsWith("p") ? input.slice(0, input.length - 1) + primeSuffix : input + primeSuffix;
-    const fixPrimeRes = globalItemNameToSlugDict[fixPrime];
-    if (fixPrimeRes)
-      return globalItemDict[fixPrimeRes];
-    const fixPrimeSet = fixPrime + setSuffix;
-    const fixPrimeSetRes = globalItemNameToSlugDict[fixPrimeSet];
-    if (fixPrimeSetRes)
-      return globalItemDict[fixPrimeSetRes];
-    const fixBP = input + bpSuffix;
-    const fixBPRes = globalItemNameToSlugDict[fixBP];
-    if (fixBPRes)
-      return globalItemDict[fixBPRes];
-    const fixPrimeBP = fixPrime + bpSuffix;
-    const fixPrimeBPRes = globalItemNameToSlugDict[fixPrimeBP];
-    if (fixPrimeBPRes)
-      return globalItemDict[fixPrimeBPRes];
-  } else {
-    const fixBP = inputNoSuffix + suffix + bpSuffix;
-    const fixBPRes = globalItemNameToSlugDict[fixBP];
-    if (fixBPRes)
-      return globalItemDict[fixBPRes];
-    const fixPrime = inputNoSuffix.endsWith(primeSuffix) ? inputNoSuffix : inputNoSuffix.endsWith("p") ? inputNoSuffix.slice(0, inputNoSuffix.length - 1) + primeSuffix : inputNoSuffix + primeSuffix;
-    const fixPrimeRes = globalItemNameToSlugDict[fixPrime + suffix];
-    if (fixPrimeRes)
-      return globalItemDict[fixPrimeRes];
-    const fixPrimeBP = fixPrime + suffix + bpSuffix;
-    const fixPrimeBPRes = globalItemNameToSlugDict[fixPrimeBP];
-    if (fixPrimeBPRes)
-      return globalItemDict[fixPrimeBPRes];
-  }
-}
-__name(shortHandProcess, "shortHandProcess");
-function compareRivenItemName(input, standard) {
-  if (!input || !standard || typeof input !== "string" || typeof standard !== "string") {
-    return false;
-  }
-  const normalizedInput = normalizeName(input);
-  const normalizedStandard = normalizeName(standard);
-  if (!normalizedInput || !normalizedStandard)
-    return false;
-  return normalizedInput === normalizedStandard;
-}
-__name(compareRivenItemName, "compareRivenItemName");
 
 // src/commands/miscs.ts
+function inDevelopment() {
+  return t("miscs.inDevelopment");
+}
+__name(inDevelopment, "inDevelopment");
 function createMiscsCommands(deps) {
   const { render } = deps;
   return {
+    inDevelopment,
     hotRivenCommand: /* @__PURE__ */ __name(async () => {
       const result = await getHotRivenWeapons2();
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       return render(
         HotRivenComponent(result.data)
@@ -7947,7 +8217,7 @@ function createWfCommands(deps) {
     arbitrationCommand: /* @__PURE__ */ __name(async (_action, input) => {
       const result = getArbitrations(input);
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       return render(ArbitrationComponent(result.data));
     }, "arbitrationCommand"),
@@ -7965,69 +8235,69 @@ function createWfCommands(deps) {
     voidtraderCommand: /* @__PURE__ */ __name(async (_action) => {
       const result = await getVoidTrader();
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       return render(VoidTraderComponent(result.data));
     }, "voidtraderCommand"),
     fissureCommand: /* @__PURE__ */ __name(async (_action) => {
       const result = await getFissures();
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       return render(FissureComponent(result.data, "fissure"));
     }, "fissureCommand"),
     steelPathFissureCommand: /* @__PURE__ */ __name(async (_action) => {
       const result = await getSteelPathFissures();
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       return render(FissureComponent(result.data, "sp-fissure"));
     }, "steelPathFissureCommand"),
     railjackFissureCommand: /* @__PURE__ */ __name(async (_action) => {
       const result = await getRailjackFissures();
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       return render(FissureComponent(result.data, "rj-fissure"));
     }, "railjackFissureCommand"),
     relicCommand: /* @__PURE__ */ __name(async (_action, input) => {
       const result = await getRelic(input);
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       const relic = await applyRelicData(result.data);
       return render(RelicComponent(relic));
     }, "relicCommand"),
     rivenCommand: /* @__PURE__ */ __name(async (_action, input) => {
       if (!input?.src) {
-        return "未检测到图片";
+        return t("riven.imageNotFound");
       }
       if (!config.ocrAPISecret?.id || !config.ocrAPISecret?.key) {
-        return "未配置 OCR，请在插件设置中配置。";
+        return t("riven.ocrNotConfigured");
       }
       const result = await getAnalyzedRiven(
         config.ocrAPISecret,
         input.src
       );
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       return render(RivenComponent(result.data));
     }, "rivenCommand"),
     rivenStatCommand: /* @__PURE__ */ __name(async (_action, weaponType, statType, disposition) => {
       if (!weaponType || !statType || !disposition) {
-        return "请输入正确参数";
+        return t("riven.invalidParams");
       }
       const result = await getStaticRivenStats(weaponType, statType, disposition);
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       return render(RivenStatComponent(result.data));
     }, "rivenStatCommand"),
     weeklyCommand: /* @__PURE__ */ __name(async (_action) => {
       const result = await getWeekly();
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       return render(
         WeeklyComponent(
@@ -8041,7 +8311,7 @@ function createWfCommands(deps) {
       const threshold = minPrice && minPrice > 0 ? minPrice : 100;
       const result = await getWeeklyRivens(threshold);
       if (result.length === 0) {
-        return "没有找到符合条件的紫卡参考数据";
+        return t("riven.noWeeklyData");
       }
       return render(WeeklyRivenComponent(result.slice(0, 20), threshold));
     }, "weeklyRivenCommand"),
@@ -8561,14 +8831,14 @@ function createWfmCommands(deps) {
     wmCommand: /* @__PURE__ */ __name(async (_action, input) => {
       const result = await getItemOrders(input);
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       return render(ItemOrderComponent(result.data.item, result.data.orders));
     }, "wmCommand"),
     wmrCommand: /* @__PURE__ */ __name(async (_action, input) => {
       const result = await getRivenOrders(input);
       if (!result.ok) {
-        return result.message;
+        return t(result);
       }
       return render(RivenOrderComponent(result.data.item, result.data.orders));
     }, "wmrCommand"),
@@ -8679,17 +8949,13 @@ function setupCommands(ctx, deps) {
     "武器类型: 步枪, 手枪, 霰弹枪, 近战, Archwing枪械\n词条类型: 2, 3, 21, 31"
   ).example("riven-stat 步枪 31 0.7").alias("rivenstat").alias("紫卡数值").action(wf.rivenStatCommand);
   ctx.command("void-trader", "虚空商人").alias("voidtrader").alias("虚空商人").alias("奸商").action(wf.voidtraderCommand);
-  ctx.command("lich-c", "c系玄骸武器", { hidden: true }).alias("lichc").action(inDevelopment);
-  ctx.command("lich-i", "i系玄骸武器", { hidden: true }).alias("lichi").action(inDevelopment);
+  ctx.command("lich-c", "c系玄骸武器", { hidden: true }).alias("lichc").action(miscs.inDevelopment);
+  ctx.command("lich-i", "i系玄骸武器", { hidden: true }).alias("lichi").action(miscs.inDevelopment);
   ctx.command("riven-weekly [minPrice:number]", "每周高价值紫卡参考 (未洗中位价)").alias("weeklyriven").alias("周紫卡").alias("周卡").action(wf.weeklyRivenCommand);
   ctx.command("riven-hot", "热门紫卡").alias("hotriven").action(miscs.hotRivenCommand);
   ctx.command("pmod-history", "Primed MOD 历史").alias("pmodhistory").alias("pmod").alias("P卡").alias("p卡").alias("P卡历史").alias("p卡历史").action(wfm.pmodhistoryCommand);
 }
 __name(setupCommands, "setupCommands");
-function inDevelopment() {
-  return "功能暂未开放";
-}
-__name(inDevelopment, "inDevelopment");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,