@shenghuabi/knowledge 1.0.21

package/file-parser.mjs

@@ -0,0 +1,850 @@
+// packages/file-parser/file-parser.service.ts
+import { fileTypeFromBuffer } from "file-type";
+import { inject as inject2, RootStaticInjectOptions as RootStaticInjectOptions2 } from "static-injector";
+import { path as path3 } from "@cyia/vfs2";
+
+// packages/file-parser/text-analyse.ts
+import { analyse } from "chardet";
+function resultWeight(item) {
+  let offset = 0;
+  if (item.lang === "zh") {
+    offset++;
+    if (item.name === "GB18030") {
+      offset += 2;
+    } else if (item.name === "Big5") {
+      offset++;
+    }
+  }
+  return item.confidence + offset;
+}
+function textAnalyse(buffer) {
+  return analyse(buffer).sort((a, b) => resultWeight(b) - resultWeight(a))[0].name;
+}
+
+// packages/file-parser/text-parser.ts
+function bufferDecodeToText(buffer, metadata) {
+  const type = textAnalyse(buffer);
+  const decoder2 = new TextDecoder(type, { fatal: true });
+  try {
+    return decoder2.decode(buffer);
+  } catch (error) {
+    throw new Error(`尝试使用 ${type} 编码解析失败;${metadata?.path ?? ""}`);
+  }
+}
+
+// packages/file-parser/const.ts
+import { InjectionToken } from "static-injector";
+var FileParserToken = new InjectionToken("FileParser");
+var ImageParserToken = new InjectionToken("ImageParserToken");
+var DocumentParserConfigToken = new InjectionToken("DocumentParserConfigToken");
+
+// packages/file-parser/document-file-parser.service.ts
+import { inject, Injector, RootStaticInjectOptions } from "static-injector";
+import { EPubLoader } from "@langchain/community/document_loaders/fs/epub";
+import { DocxLoader } from "@langchain/community/document_loaders/fs/docx";
+import { CSVLoader } from "@langchain/community/document_loaders/fs/csv";
+import { PDFLoader } from "@langchain/community/document_loaders/fs/pdf";
+import { PPTXLoader } from "@langchain/community/document_loaders/fs/pptx";
+import { SRTLoader } from "@langchain/community/document_loaders/fs/srt";
+import { Blob } from "node:buffer";
+import { path as path2 } from "@cyia/vfs2";
+
+// packages/file-parser/document-loader/xlsx.loader.ts
+async function xlsxLoader(buffer) {
+  const { read, utils } = await import("xlsx");
+  const workbook = read(buffer);
+  return workbook.SheetNames.map((name) => {
+    const worksheet = workbook.Sheets[name];
+    const csv = utils.sheet_to_csv(worksheet);
+    return { pageContent: csv, metadata: { title: name } };
+  });
+}
+
+// packages/file-parser/document-loader/pdf-img.loader.ts
+import { path } from "@cyia/vfs2";
+async function pdfImageLoader(buffer, filePath, injector) {
+  let canvas = await import("@napi-rs/canvas");
+  if (!globalThis.DOMMatrix) {
+    globalThis.DOMMatrix = canvas.DOMMatrix;
+  }
+  if (!globalThis.ImageData) {
+    globalThis.ImageData = canvas.ImageData;
+  }
+  if (!globalThis.Path2D) {
+    globalThis.Path2D = canvas.Path2D;
+  }
+  const { getDocument } = await import("pdfjs-dist");
+  let pdf = await getDocument(new Uint8Array(buffer)).promise;
+  let list = [];
+  let metadata = await pdf.getMetadata();
+  const fileName = path.basename(filePath, path.extname(filePath));
+  let title = metadata.info["Title"] || fileName;
+  let imageParser = injector.get(ImageParserToken);
+  let documentParserConfig = injector.get(DocumentParserConfigToken);
+  for (let i = 1; i <= pdf.numPages; i++) {
+    const page = await pdf.getPage(i);
+    const viewport = page.getViewport({
+      scale: documentParserConfig().pdfAsImage?.viewPortOptions?.scale ?? 1
+    });
+    const canvasEl = canvas.createCanvas(viewport.width, viewport.height);
+    const ctx = canvasEl.getContext("2d");
+    await page.render({
+      canvasContext: ctx,
+      viewport,
+      canvas: canvasEl
+    }).promise;
+    const image = canvasEl.toBuffer("image/png");
+    let result = await imageParser(filePath, `${fileName}-${i}`, image);
+    list.push({
+      pageContent: result.content,
+      metadata: { title },
+      parseTo: result.parseTo
+    });
+  }
+  return list;
+}
+
+// packages/file-parser/document-file-parser.service.ts
+var DocumentFileParserService = class extends RootStaticInjectOptions {
+  #documentParser = inject(DocumentParserConfigToken, { optional: true });
+  #injector = inject(Injector);
+  async parse(filePath, buffer, type) {
+    try {
+      const baseName = path2.basename(filePath, path2.extname(filePath));
+      const blob = new Blob([buffer]);
+      if (filePath.endsWith(".srt")) {
+        const instance = new SRTLoader(blob);
+        const result = await instance.load();
+        return this.#formatResult(result, baseName);
+      } else if (type?.ext === "pptx" || type?.ext === "odt" || type?.ext === "odp" || type?.ext === "ods") {
+        const instance = new PPTXLoader(blob);
+        const result = await instance.load();
+        return this.#formatResult(result, baseName);
+      } else if (type?.ext === "pdf") {
+        let result;
+        const useImage = this.#documentParser?.().pdfAsImage?.enable;
+        if (useImage) {
+          result = await pdfImageLoader(buffer, filePath, this.#injector);
+        } else {
+          const instance = new PDFLoader(blob);
+          result = await instance.load();
+        }
+        return this.#formatResult(result, baseName);
+      } else if (filePath.endsWith(".csv")) {
+        const instance = new CSVLoader(blob);
+        const result = await instance.load();
+        return this.#formatResult(result, baseName);
+      } else if (type?.ext === "docx") {
+        const instance = new DocxLoader(blob);
+        const result = await instance.load();
+        return this.#formatResult(result, baseName);
+      } else if (type?.ext === "xlsx") {
+        const result = await xlsxLoader(buffer);
+        return this.#formatResult(result, baseName);
+      } else if (type?.ext === "epub") {
+        const instance = new EPubLoader(filePath);
+        const result = await instance.load();
+        return result.filter((item) => !!item.pageContent).map((item, i) => ({
+          title: item.metadata["chapter"] || `[未命名]${i + 1}`,
+          content: item.pageContent
+        }));
+      } else {
+        return;
+      }
+    } catch (error) {
+      throw new Error(
+        `文件:[${filePath}]解析失败;类型[${JSON.stringify(type) ?? ""}]`,
+        {
+          cause: error
+        }
+      );
+    }
+  }
+  #formatResult(list, title) {
+    if (list.length === 1) {
+      return [
+        {
+          title: list[0].metadata?.["title"] ?? title,
+          content: list[0].pageContent.trim(),
+          parseTo: list[0].parseTo
+        }
+      ];
+    }
+    return list.map((item) => ({ ...item, pageContent: item.pageContent?.trim() })).filter((item) => !!item.pageContent).map((item, index) => ({
+      title: item.metadata?.["title"] ?? `${title}-${index}`,
+      content: item.pageContent,
+      parseTo: item.parseTo
+    }));
+  }
+};
+
+// packages/file-parser/file-parser.service.ts
+var FileParserService = class extends RootStaticInjectOptions2 {
+  priority = 0;
+  #parserList = inject2(FileParserToken, { optional: true })?.slice().sort((a, b) => a.priority - b.priority) ?? [
+    inject2(DocumentFileParserService)
+  ];
+  async parse(fileName, buffer) {
+    const baseName = path3.basename(fileName, path3.extname(fileName));
+    let type;
+    try {
+      type = await fileTypeFromBuffer(buffer);
+    } catch (error) {
+      throw new Error(`文件:[${fileName}]类型解析失败`, {
+        cause: error
+      });
+    }
+    for (const item of this.#parserList) {
+      const result = await item.parse(fileName, buffer, type);
+      if (result) {
+        return result;
+      }
+    }
+    return [
+      { title: baseName, content: bufferDecodeToText(new Uint8Array(buffer)) }
+    ];
+  }
+  /** 用于支持工作流读文件 */
+  parseOne(fileName, buffer) {
+    return this.parse(fileName, buffer).then((list) => {
+      return {
+        content: list?.map((item) => item.content).join("\n"),
+        parseTo: list[0].parseTo
+      };
+    });
+  }
+};
+
+// packages/file-parser/dict/dict-format/stardict-parse.service.ts
+import * as fs from "fs/promises";
+import * as zlib from "zlib";
+import * as util from "util";
+import { RootStaticInjectOptions as RootStaticInjectOptions3 } from "static-injector";
+import decompress from "decompress";
+import decompressTarbz from "@xhmikosr/decompress-tarbz2";
+import { tmpdir } from "os";
+import { v4 } from "uuid";
+import { path as path4 } from "@cyia/vfs2";
+import { decode } from "html-entities";
+var decoder = new util.TextDecoder("utf-8");
+var StardictParseService = class extends RootStaticInjectOptions3 {
+  async parse(filePathList) {
+    const filePath = filePathList;
+    let infoFileContent;
+    let indexFileBuffer;
+    let dictFileBuffer;
+    if (filePath.endsWith("tar.bz2")) {
+      const dir = path4.join(tmpdir(), v4());
+      const list2 = await decompress(filePath, dir, {
+        plugins: [decompressTarbz()]
+      });
+      for (const item of list2) {
+        if (item.path.endsWith("ifo")) {
+          infoFileContent = item.data.toString();
+        } else if (item.path.endsWith("idx")) {
+          indexFileBuffer = item.data;
+        } else if (item.path.endsWith("dict.dz")) {
+          dictFileBuffer = item.data;
+        }
+      }
+      if (!infoFileContent || !indexFileBuffer || !dictFileBuffer) {
+        throw new Error(`解压后未找到指定内容,文件夹:${dir}`);
+      }
+    } else {
+      const fileName = path4.basename(filePath).replace(/\.(ifo|tar\.bz)$/, "");
+      infoFileContent = (await fs.readFile(
+        path4.resolve(path4.dirname(filePath), `${fileName}.ifo`)
+      )).toString();
+      indexFileBuffer = await fs.readFile(
+        path4.resolve(path4.dirname(filePath), `${fileName}.idx`)
+      );
+      dictFileBuffer = await fs.readFile(
+        path4.resolve(path4.dirname(filePath), `${fileName}.dict.dz`)
+      );
+    }
+    const [info, list] = await Promise.all([
+      this.#getInfo(infoFileContent).then((obj) => {
+        obj["name"] ??= obj["bookname"];
+        return obj;
+      }),
+      this.#getIndex(indexFileBuffer)
+    ]);
+    return {
+      info,
+      dataListGenerator: () => this.#getDict(dictFileBuffer, list)
+    };
+  }
+  async #getInfo(content) {
+    const list = content.split(/\r\n|\n\r|\n|\r/).filter(Boolean).map((item) => item.split("=").filter(Boolean)).filter((list2) => list2.length === 2);
+    return list.reduce(
+      (obj, item) => {
+        obj[item[0]] = item[1];
+        return obj;
+      },
+      {}
+    );
+  }
+  async #getIndex(buffer) {
+    const indexData = [];
+    let index = 0;
+    while (index < buffer.length) {
+      const beg = index;
+      index = buffer.indexOf("\0", beg);
+      let word = buffer.toString("utf-8", beg, index);
+      if (word.includes("&#")) {
+        word = decode(word);
+      }
+      index++;
+      const offset = buffer.readUInt32BE(index);
+      index += 4;
+      const size = buffer.readUInt32BE(index);
+      index += 4;
+      indexData.push([word, offset, size]);
+    }
+    return indexData;
+  }
+  async *#getDict(buffer, indexData) {
+    const rawdata = new Uint8Array(buffer);
+    const buffer_1 = zlib.gunzipSync(rawdata);
+    const rawdata_1 = new Uint8Array(buffer_1);
+    for (const [word, offset, size] of indexData) {
+      const chunk = rawdata_1.slice(offset, offset + size);
+      const decoded = (decoder.decode(chunk) ?? "").trim();
+      if (!decoded) {
+        continue;
+      }
+      yield {
+        word,
+        content: decoded
+      };
+    }
+  }
+};
+
+// packages/file-parser/dict/dict-format/mdict-parse.service.ts
+import { Mdict } from "@cyia/mdict-reader";
+import { existsSync } from "fs";
+import { RootStaticInjectOptions as RootStaticInjectOptions4 } from "static-injector";
+import { path as path5, createNormalizeVfs } from "@cyia/vfs2";
+var MdictParseService = class extends RootStaticInjectOptions4 {
+  async parse(filePathList, options) {
+    let passCode;
+    if (options?.regCode && options.userId) {
+      passCode = options;
+    }
+    const filePath = filePathList;
+    const fileName = path5.basename(filePath, path5.extname(filePath));
+    const mdxFilePath = path5.resolve(path5.dirname(filePath), `${fileName}.mdx`);
+    const mdxInstance = await Mdict.build(mdxFilePath, passCode);
+    const mddFilePath = path5.resolve(path5.dirname(filePath), `${fileName}.mdd`);
+    const dataInfo = mdxInstance.getDictInfo().mdx;
+    return {
+      // todo 其实还可以保存更多信息
+      info: {
+        name: dataInfo.Title === "Title (No HTML code allowed)" ? fileName : dataInfo.Title,
+        fileName
+      },
+      dataListGenerator: () => this.wordListGenerator(mdxInstance),
+      afterSave: async (assetFolder) => {
+        let pendList = [];
+        let sum = 0;
+        const waitingWrite = async () => {
+          const result = (await Promise.all(pendList)).filter(Boolean);
+          if (result.length) {
+            throw new Error(
+              result.map((item) => `文件[${item.name}]写入失败,${item?.message}`).join("\n")
+            );
+          } else {
+            sum += pendList.length;
+          }
+          pendList = [];
+        };
+        if (existsSync(mddFilePath)) {
+          const vfs = createNormalizeVfs({ dir: assetFolder });
+          const mddInstance = await Mdict.build(mddFilePath, passCode);
+          const wordGenerator = mddInstance.load();
+          for await (const item of wordGenerator) {
+            pendList.push(
+              mddInstance.getMddAsset(item).then(
+                (buffer) => vfs.writeFile(path5.join(assetFolder, item.word), buffer).then(() => void 0).catch((reason) => ({
+                  name: item.word,
+                  message: reason
+                }))
+              )
+            );
+            if (pendList.length >= 20) {
+              await waitingWrite();
+            }
+          }
+          if (pendList.length) {
+            await waitingWrite();
+          }
+        }
+      }
+    };
+  }
+  async *wordListGenerator(mdxInstance) {
+    const list = mdxInstance.load();
+    for await (const item of list) {
+      const definition = (await mdxInstance.getDefinition(item) || "").trim();
+      if (!definition) {
+        continue;
+      }
+      yield {
+        content: definition,
+        word: item.word
+      };
+    }
+  }
+};
+
+// packages/file-parser/dict/dict.service.ts
+import { inject as inject3, Injector as Injector2, RootStaticInjectOptions as RootStaticInjectOptions7 } from "static-injector";
+import fs4 from "fs";
+import { path as path7 } from "@cyia/vfs2";
+
+// packages/file-parser/dict/dict-format/yaml-parse.service.ts
+import { path as path6 } from "@cyia/vfs2";
+import * as fs2 from "fs/promises";
+import { parse } from "yaml";
+import { RootStaticInjectOptions as RootStaticInjectOptions5 } from "static-injector";
+import * as v from "valibot";
+var YamlDefine = v.object({
+  list: v.array(
+    v.object({
+      word: v.string(),
+      content: v.string(),
+      extra: v.optional(v.record(v.string(), v.any()))
+    })
+  )
+});
+var YamlDictParseService = class extends RootStaticInjectOptions5 {
+  async parse(filePathList) {
+    const filePath = filePathList;
+    const ext = path6.extname(filePath);
+    const content = await fs2.readFile(filePath, { encoding: "utf-8" });
+    const data = v.parse(YamlDefine, parse(content));
+    return {
+      info: {
+        fileName: path6.basename(filePath),
+        name: path6.basename(filePath, ext)
+      },
+      dataListGenerator: async function* () {
+        for (const item of data.list) {
+          yield item;
+        }
+      }
+    };
+  }
+};
+
+// packages/file-parser/dict/dict.service.ts
+import { LRUCache } from "lru-cache";
+
+// packages/file-parser/dict/dict-format/dsl/dsl-parse.service.ts
+import fs3 from "fs";
+import chardet from "chardet";
+
+// packages/file-parser/dict/dict-format/dsl/dsl.format.ts
+var inlineStatusList = ["b", "i", "u", "c"];
+var sImageList = ["bmp", "pcx", "dcx", "jpg", "tif"];
+var sSoundList = ["wav"];
+var sVideoList = ["avi", "webm", "mp4"];
+var NodeItem = class {
+  start;
+  // attr: Record<string, any> = {};
+  type;
+};
+var InlineNode = class extends NodeItem {
+  type = "inline";
+  attr;
+  tag;
+  constructor(tag, attr) {
+    super();
+    this.attr = attr;
+    this.tag = tag;
+  }
+};
+var BlockNode = class extends NodeItem {
+  type = "block";
+  fn;
+  tag;
+  constructor(tag, fn) {
+    super();
+    this.tag = tag;
+    this.fn = fn;
+  }
+};
+var TextNode = class extends NodeItem {
+  type = "text";
+  text;
+  style = {};
+  constructor(text) {
+    super();
+    this.text = text;
+  }
+  renderedText;
+  renderText() {
+    const styleAttr = Object.entries(this.style).map((item) => `${item[0]}: ${item[1]}`).join(";");
+    const formatedText = this.text.replace(/\\\[/g, "[").replace(/\\]/g, "]");
+    if (styleAttr.trim().length) {
+      this.renderedText = `<span style="${styleAttr}">${formatedText}</span>`;
+    } else {
+      this.renderedText = `${formatedText}`;
+    }
+  }
+};
+var DslFormat = class {
+  #inlineStatus = [];
+  #blockStatus = [];
+  #textNodeList = [];
+  #input;
+  #start = 0;
+  constructor(input) {
+    this.#input = input;
+  }
+  run() {
+    if (!this.#input) {
+      return this.#input;
+    }
+    this.#scan();
+    return this.#textNodeList.map((item) => item.renderedText).join("");
+  }
+  #scan() {
+    let startResult;
+    let endResult;
+    const startRegexp = /(?<!\\)\[(?!\/)(?<tagName>m(?<leftPadding>[0-9])|[^\]\s]+)((\s+)(?<attr>[^\]]+))?]/dg;
+    const endRegexp = /(?<!\\)\[\/(?<tagName>[^\]]+)]/dg;
+    while (true) {
+      startRegexp.lastIndex = this.#start;
+      endRegexp.lastIndex = this.#start;
+      const currentText = this.#input;
+      startResult = startRegexp.exec(currentText);
+      endResult = endRegexp.exec(currentText);
+      if (startResult && (!endResult || startResult.indices[0][0] < endResult.indices[0][0])) {
+        const tagName = startResult.groups["tagName"];
+        const matchStart = startResult.indices[0][0];
+        this.#createTextNode(this.#start, matchStart);
+        this.#createStatusNode(
+          tagName.startsWith("m") ? "m" : tagName,
+          matchStart,
+          startResult.groups["leftPadding"] || startResult.groups["attr"]
+        );
+        this.#start = startResult.indices[0][1];
+      } else {
+        if (endResult) {
+          const tagName = endResult.groups["tagName"];
+          const matchStart = endResult.indices[0][0];
+          this.#createTextNode(this.#start, matchStart);
+          this.#mergeTextNode(tagName, matchStart);
+          this.#removeStatus(tagName);
+          this.#start = endResult.indices[0][1];
+        } else {
+          break;
+        }
+      }
+    }
+  }
+  /** 普通的文本节点创建 */
+  #createTextNode(start, end) {
+    if (start < end) {
+      const node = new TextNode(this.#input.slice(start, end));
+      node.start = start;
+      node.style = this.#inlineStatus.reduce(
+        (obj, item) => ({ ...obj, ...item.attr }),
+        {}
+      );
+      node.renderText();
+      this.#textNodeList.push(node);
+      return node;
+    }
+  }
+  #createStatusNode(name, start, attrStr) {
+    if (inlineStatusList.includes(name)) {
+      attrStr;
+      let attr = {};
+      switch (name) {
+        case "c":
+          if (attrStr) {
+            attr = { color: attrStr };
+          }
+          break;
+        case "b":
+          attr = { "font-weight": "bolder" };
+          break;
+        case "u":
+          attr = { "text-decoration": "#f00 wavy underline" };
+          break;
+        case "i":
+          attr = { "font-style": "italic" };
+          break;
+      }
+      const node = new InlineNode(name, attr);
+      node.start = start;
+      this.#inlineStatus.unshift(node);
+    } else {
+      const node = new BlockNode(name, (text) => {
+        switch (name) {
+          case "m": {
+            return `<div style="padding-left: ${attrStr}em;">${text}</div>`;
+          }
+          case "url": {
+            return `<a href="${text}">${text}</a>`;
+          }
+          case "ref": {
+            return `<a href="entry://${text}">${text}</a>`;
+          }
+          case "sub":
+          case "sup": {
+            {
+              return `<${name}>${text}</${name}>`;
+            }
+          }
+          case "s": {
+            if (sImageList.some((item) => text.endsWith(item))) {
+              const baseName = text.slice(0, text.lastIndexOf("."));
+              return `<picture><source srcset="${text}"><source srcset="${baseName}.webp"><source srcset="${baseName}.jpg"><img src="${text}"></picture>`;
+            } else if (sSoundList.some((item) => text.endsWith(item))) {
+              return `<figure><audio controls src="${text}"></audio></figure>`;
+            } else if (sVideoList.some((item) => text.endsWith(item))) {
+              const baseName = text.slice(0, text.lastIndexOf("."));
+              return `<video controls style="width:100%"><source src="${text}"/><source src="${baseName}.mp4"/><source src="${baseName}.webm"/></video>`;
+            }
+            return ``;
+          }
+          default: {
+            return `<span>${text}</span>`;
+          }
+        }
+      });
+      node.start = start;
+      this.#blockStatus.unshift(node);
+    }
+  }
+  #mergeTextNode(name, end) {
+    const blockStart = this.#blockStatus.find((item) => item.tag === name);
+    if (blockStart) {
+      const start = blockStart.start;
+      let tempIndex = -1;
+      for (let i = this.#textNodeList.length - 1; i > -1; i--) {
+        const textNode = this.#textNodeList[i];
+        if (textNode.start < start) {
+          break;
+        } else {
+          tempIndex = i;
+        }
+      }
+      if (tempIndex !== -1) {
+        const delNodeList = this.#textNodeList.slice(tempIndex);
+        const mergeText = blockStart.fn(
+          delNodeList.map((item) => item.renderedText).join("")
+        );
+        this.#textNodeList = this.#textNodeList.slice(0, tempIndex);
+        const node = new TextNode(mergeText);
+        node.start = start;
+        node.renderedText = node.text;
+        this.#textNodeList.push(node);
+      }
+    }
+  }
+  #removeStatus(name) {
+    if (inlineStatusList.includes(name)) {
+      const index = this.#inlineStatus.findIndex((item) => item.tag === name);
+      this.#inlineStatus.splice(index, 1);
+    } else {
+      const index = this.#blockStatus.findIndex((item) => item.tag === name);
+      this.#blockStatus.splice(index, 1);
+    }
+  }
+};
+function dslFormat(input) {
+  const item = new DslFormat(input);
+  return item.run();
+}
+
+// packages/file-parser/dict/dict-format/dsl/dsl-parse.service.ts
+import { RootStaticInjectOptions as RootStaticInjectOptions6 } from "static-injector";
+import { basename } from "path";
+var DslParseService = class extends RootStaticInjectOptions6 {
+  async parse(filePath, options) {
+    const instance = new DslParse(filePath);
+    await instance.init();
+    return {
+      info: {
+        ...instance.info,
+        name: instance.info["NAME"],
+        fileName: basename(filePath, ".dsl")
+      },
+      dataListGenerator: () => instance.generate()
+    };
+  }
+};
+var DslParse = class {
+  filePath;
+  fileContent;
+  start = 0;
+  info = {};
+  wordStart;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  async init() {
+    const buffer = await fs3.promises.readFile(this.filePath);
+    const subBuf = new Uint8Array(buffer.subarray(0, 500));
+    const a = chardet.detect(subBuf);
+    this.fileContent = buffer.toString(a ?? "UTF-16LE").trimStart();
+    while (this.readMetadata()) {
+    }
+    this.readEntry();
+  }
+  readMetadata() {
+    const regexp = /^#(NAME|INDEX_LANGUAGE|CONTENTS_LANGUAGE|SOUND_DICTIONARY|SOURCE_CODE_PAGE)\s+(.+)/dgm;
+    regexp.lastIndex = this.start;
+    const result = regexp.exec(this.fileContent.trimStart());
+    if (result) {
+      try {
+        this.info[result[1]] = JSON.parse(result[2]);
+      } catch (error) {
+        this.info[result[1]] = result[2];
+      }
+      this.start = result.indices[0][1];
+      return true;
+    }
+    return false;
+  }
+  lastWordInfo;
+  async *generate() {
+    let result;
+    while (result = this.readEntry()) {
+      yield result;
+    }
+  }
+  readEntry() {
+    const regexp = /^[^\s]+/dgm;
+    regexp.lastIndex = this.start;
+    const result = regexp.exec(this.fileContent);
+    if (result) {
+      this.start = result.indices[0][1];
+      const lastWordInfo = this.lastWordInfo;
+      this.lastWordInfo = {
+        word: result[0],
+        range: result.indices[0]
+      };
+      if (lastWordInfo) {
+        const content = this.fileContent.slice(lastWordInfo.range[1], this.lastWordInfo.range[0]).replace(/^\s+/gm, "");
+        return {
+          word: lastWordInfo.word,
+          content,
+          htmlContent: dslFormat(content)
+        };
+      }
+    } else {
+      if (this.lastWordInfo) {
+        const content = this.fileContent.slice(this.lastWordInfo.range[1]).replace(/^\s+/gm, "");
+        const result2 = {
+          word: this.lastWordInfo.word,
+          content,
+          htmlContent: dslFormat(content)
+        };
+        this.lastWordInfo = void 0;
+        return result2;
+      }
+    }
+    return void 0;
+  }
+};
+
+// packages/file-parser/dict/dict.service.ts
+var DictService = class extends RootStaticInjectOptions7 {
+  #injector = inject3(Injector2);
+  #cache = new LRUCache({
+    max: 2,
+    ttl: 12e4
+  });
+  async getDictName(input) {
+    const dict = await this.#getDictResolve(input);
+    return dict.info.name || dict.info.fileName;
+  }
+  async #getDictResolve(input) {
+    if (this.#cache.has(input.filePath)) {
+      return this.#cache.get(input.filePath);
+    }
+    const { filePath, type } = input;
+    let result;
+    if (type === "stardict") {
+      result = await this.#injector.get(StardictParseService).parse(filePath);
+    } else if (type === "mdict") {
+      result = await this.#injector.get(MdictParseService).parse(filePath, input);
+    } else if (type === "dsl") {
+      result = await this.#injector.get(DslParseService).parse(filePath);
+    } else if (type === "yaml") {
+      result = await this.#injector.get(YamlDictParseService).parse(filePath);
+    } else {
+      throw new Error(`没有找到${type}字典对应解析器`);
+    }
+    this.#cache.set(input.filePath, result);
+    return result;
+  }
+  /**
+   * 第一个需要修改为3个操作
+   */
+  // 这里顺序反了,应该调用base,让base分配
+  async importDict(name, dir, input) {
+    const baseName = path7.basename(
+      input.filePath,
+      path7.extname(input.filePath)
+    );
+    const result = await this.#getDictResolve(input);
+    name ||= result.info.name || baseName;
+    const assetFolder = path7.join(dir, "assets");
+    if (result.afterSave) {
+      await fs4.promises.mkdir(assetFolder, {
+        recursive: true
+      });
+      await result.afterSave(assetFolder);
+    }
+    return result.dataListGenerator();
+  }
+};
+
+// packages/file-parser/vl-parser/markdown.parser.ts
+import { lexer } from "marked";
+import MS from "magic-string";
+var regex = /<!--\s*(Image|Table)\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\s*-->/dg;
+async function vlMarkdownParser(content, options) {
+  let mdContent = getMdLexer(content);
+  let result = mdContent.matchAll(regex);
+  let ms = new MS(mdContent);
+  for (const item of result) {
+    let imageData = await options.imageGet("qwen3-vl", [
+      +item[2],
+      +item[3],
+      +item[4],
+      +item[5]
+    ]);
+    ms.update(
+      item.index,
+      item.index + item[0].length,
+      `![${imageData.title}](${imageData.src})`
+    );
+  }
+  return ms.toString();
+}
+function getMdLexer(content) {
+  const list = lexer(content);
+  if (list.length === 1 && list[0].type === "code" && (list[0].lang === "markdown" || !list[0].lang)) {
+    return list[0].text;
+  }
+  return content;
+}
+export {
+  DictService,
+  DocumentFileParserService,
+  DocumentParserConfigToken,
+  FileParserService,
+  FileParserToken,
+  ImageParserToken,
+  bufferDecodeToText,
+  vlMarkdownParser
+};
+//# sourceMappingURL=file-parser.mjs.map