@sciexpr/parser 0.1.0

package/dist/index.cjs

@@ -0,0 +1,562 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChemicalParser: () => ChemicalParser,
+  LatexParser: () => LatexParser,
+  LatexTokenizer: () => LatexTokenizer,
+  ParserRegistry: () => ParserRegistry,
+  TokenType: () => TokenType
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2["Command"] = "command";
+  TokenType2["OpenBrace"] = "openBrace";
+  TokenType2["CloseBrace"] = "closeBrace";
+  TokenType2["OpenBracket"] = "openBracket";
+  TokenType2["CloseBracket"] = "closeBracket";
+  TokenType2["OpenParen"] = "openParen";
+  TokenType2["CloseParen"] = "closeParen";
+  TokenType2["Superscript"] = "superscript";
+  TokenType2["Subscript"] = "subscript";
+  TokenType2["Whitespace"] = "whitespace";
+  TokenType2["Text"] = "text";
+  TokenType2["Number"] = "number";
+  TokenType2["Ampersand"] = "ampersand";
+  TokenType2["Newline"] = "newline";
+  TokenType2["Dollar"] = "dollar";
+  TokenType2["DoubleDollar"] = "doubleDollar";
+  TokenType2["EOF"] = "eof";
+  return TokenType2;
+})(TokenType || {});
+
+// src/tokenizer.ts
+var LatexTokenizer = class {
+  input;
+  pos = 0;
+  constructor(input) {
+    this.input = input;
+  }
+  /** 获取所有 token */
+  tokenize() {
+    const tokens = [];
+    while (this.pos < this.input.length) {
+      const token = this.nextToken();
+      if (token) tokens.push(token);
+    }
+    tokens.push({
+      type: "eof" /* EOF */,
+      value: "",
+      position: this.pos,
+      length: 0
+    });
+    return tokens;
+  }
+  /** 获取下一个 token */
+  nextToken() {
+    const ch = this.input[this.pos];
+    if (ch === void 0) return null;
+    const start = this.pos;
+    if (ch === " " || ch === "	") {
+      this.pos++;
+      while (this.pos < this.input.length && (this.input[this.pos] === " " || this.input[this.pos] === "	")) {
+        this.pos++;
+      }
+      return { type: "whitespace" /* Whitespace */, value: this.input.slice(start, this.pos), position: start, length: this.pos - start };
+    }
+    if (ch === "$" && this.input[this.pos + 1] === "$") {
+      this.pos += 2;
+      return { type: "doubleDollar" /* DoubleDollar */, value: "$$", position: start, length: 2 };
+    }
+    if (ch === "$") {
+      this.pos++;
+      return { type: "dollar" /* Dollar */, value: "$", position: start, length: 1 };
+    }
+    if (ch === "\\") {
+      this.pos++;
+      if (this.pos < this.input.length && /[a-zA-Z]/.test(this.input[this.pos])) {
+        while (this.pos < this.input.length && /[a-zA-Z*]/.test(this.input[this.pos])) {
+          this.pos++;
+        }
+        return { type: "command" /* Command */, value: this.input.slice(start, this.pos), position: start, length: this.pos - start };
+      }
+      this.pos++;
+      return { type: "command" /* Command */, value: this.input.slice(start, this.pos), position: start, length: this.pos - start };
+    }
+    if (ch === "{") {
+      this.pos++;
+      return { type: "openBrace" /* OpenBrace */, value: "{", position: start, length: 1 };
+    }
+    if (ch === "}") {
+      this.pos++;
+      return { type: "closeBrace" /* CloseBrace */, value: "}", position: start, length: 1 };
+    }
+    if (ch === "[") {
+      this.pos++;
+      return { type: "openBracket" /* OpenBracket */, value: "[", position: start, length: 1 };
+    }
+    if (ch === "]") {
+      this.pos++;
+      return { type: "closeBracket" /* CloseBracket */, value: "]", position: start, length: 1 };
+    }
+    if (ch === "(") {
+      this.pos++;
+      return { type: "openParen" /* OpenParen */, value: "(", position: start, length: 1 };
+    }
+    if (ch === ")") {
+      this.pos++;
+      return { type: "closeParen" /* CloseParen */, value: ")", position: start, length: 1 };
+    }
+    if (ch === "^") {
+      this.pos++;
+      return { type: "superscript" /* Superscript */, value: "^", position: start, length: 1 };
+    }
+    if (ch === "_") {
+      this.pos++;
+      return { type: "subscript" /* Subscript */, value: "_", position: start, length: 1 };
+    }
+    if (ch === "&") {
+      this.pos++;
+      return { type: "ampersand" /* Ampersand */, value: "&", position: start, length: 1 };
+    }
+    if (ch === "\\" && this.input[this.pos + 1] === "\\") {
+    }
+    if (/[0-9]/.test(ch)) {
+      this.pos++;
+      while (this.pos < this.input.length && /[0-9.]/.test(this.input[this.pos])) {
+        this.pos++;
+      }
+      return { type: "number" /* Number */, value: this.input.slice(start, this.pos), position: start, length: this.pos - start };
+    }
+    this.pos++;
+    while (this.pos < this.input.length && /[a-zA-Z0-9]/.test(this.input[this.pos])) {
+      this.pos++;
+    }
+    return { type: "text" /* Text */, value: this.input.slice(start, this.pos), position: start, length: this.pos - start };
+  }
+};
+
+// src/latex-parser.ts
+var import_core = require("@sciexpr/core");
+var import_core2 = require("@sciexpr/core");
+var LatexParser = class {
+  id = "latex";
+  formats = ["latex", "tex"];
+  tokens = [];
+  pos = 0;
+  displayMode = false;
+  canParse(input) {
+    return /\\[a-zA-Z]+/.test(input) || /[\^_]/.test(input) || /[{}]/.test(input);
+  }
+  parse(input, options) {
+    this.displayMode = options?.displayMode ?? false;
+    const tokenizer = new LatexTokenizer(input);
+    this.tokens = tokenizer.tokenize();
+    this.pos = 0;
+    const children = this.parseExpressions();
+    return (0, import_core2.createRoot)(import_core.ExpressionKind.Math, children, {
+      displayMode: this.displayMode,
+      originalSource: input
+    });
+  }
+  // ==========================================================================
+  // Parse Expressions
+  // ==========================================================================
+  parseExpressions() {
+    const exprs = [];
+    while (!this.isEOF()) {
+      const expr = this.parseExpression();
+      if (expr) exprs.push(expr);
+    }
+    return exprs;
+  }
+  parseExpression() {
+    const token = this.peek();
+    if (!token) return null;
+    let expr = null;
+    switch (token.type) {
+      case "command" /* Command */:
+        expr = this.parseCommand();
+        break;
+      case "openBrace" /* OpenBrace */:
+        expr = this.parseGroup();
+        break;
+      case "closeBrace" /* CloseBrace */:
+        this.advance();
+        return null;
+      case "superscript" /* Superscript */:
+      case "subscript" /* Subscript */: {
+        this.advance();
+        const next = this.parseExpression();
+        if (next) {
+          expr = (0, import_core2.createScript)((0, import_core2.createText)(""), {
+            super: token.type === "superscript" /* Superscript */ ? next : void 0,
+            sub: token.type === "subscript" /* Subscript */ ? next : void 0
+          });
+        }
+        break;
+      }
+      case "text" /* Text */:
+        this.advance();
+        expr = (0, import_core2.createSymbol)(token.value, this.classifySymbol(token.value));
+        break;
+      case "number" /* Number */:
+        this.advance();
+        expr = (0, import_core2.createSymbol)(token.value, import_core.SymbolType.Number);
+        break;
+      case "whitespace" /* Whitespace */:
+        this.advance();
+        return null;
+      // Skip whitespace
+      case "openParen" /* OpenParen */:
+        this.advance();
+        const body = this.parseExpressions();
+        this.skipType("closeParen" /* CloseParen */);
+        expr = (0, import_core2.createDelimiter)("(", ")", body.length === 1 ? body[0] : (0, import_core2.createGroup)(body));
+        break;
+      case "openBracket" /* OpenBracket */:
+        this.advance();
+        const bracketBody = this.parseExpressions();
+        this.skipType("closeBracket" /* CloseBracket */);
+        expr = (0, import_core2.createDelimiter)("[", "]", bracketBody.length === 1 ? bracketBody[0] : (0, import_core2.createGroup)(bracketBody));
+        break;
+      case "eof" /* EOF */:
+        return null;
+      default:
+        this.advance();
+        expr = (0, import_core2.createText)(token.value);
+        break;
+    }
+    if (expr) {
+      expr = this.handleScripts(expr);
+    }
+    return expr;
+  }
+  // ==========================================================================
+  // Script Handling (shared)
+  // ==========================================================================
+  /** 处理上/下标：检查 ^ 和 _ 后附加到 base 节点 */
+  handleScripts(base) {
+    let result = base;
+    while (this.peek()?.type === "subscript" /* Subscript */ || this.peek()?.type === "superscript" /* Superscript */) {
+      const scriptType = this.advance().type;
+      const scriptContent = this.parseScriptContent();
+      if (scriptType === "subscript" /* Subscript */) {
+        result = (0, import_core2.createScript)(result, { sub: scriptContent });
+      } else {
+        result = (0, import_core2.createScript)(result, { super: scriptContent });
+      }
+    }
+    return result;
+  }
+  // ==========================================================================
+  // Parse Commands
+  // ==========================================================================
+  parseCommand() {
+    const token = this.advance();
+    const command = token.value;
+    if (command === "\\frac") {
+      const num = this.parseBraceGroup();
+      const den = this.parseBraceGroup();
+      return this.handleScripts((0, import_core2.createFraction)(num, den));
+    }
+    if (command === "\\sqrt") {
+      let index;
+      if (this.peek()?.type === "openBracket" /* OpenBracket */) {
+        this.advance();
+        index = this.parseSingleExpression();
+        this.skipType("closeBracket" /* CloseBracket */);
+      }
+      const radicand = this.parseBraceGroup();
+      return this.handleScripts((0, import_core2.createRadical)(radicand, index));
+    }
+    const greekLower = {
+      "\\alpha": "\u03B1",
+      "\\beta": "\u03B2",
+      "\\gamma": "\u03B3",
+      "\\delta": "\u03B4",
+      "\\epsilon": "\u03B5",
+      "\\zeta": "\u03B6",
+      "\\eta": "\u03B7",
+      "\\theta": "\u03B8",
+      "\\iota": "\u03B9",
+      "\\kappa": "\u03BA",
+      "\\lambda": "\u03BB",
+      "\\mu": "\u03BC",
+      "\\pi": "\u03C0",
+      "\\sigma": "\u03C3",
+      "\\tau": "\u03C4",
+      "\\phi": "\u03C6",
+      "\\omega": "\u03C9",
+      "\\xi": "\u03BE",
+      "\\rho": "\u03C1",
+      "\\psi": "\u03C8"
+    };
+    if (command in greekLower) {
+      return this.handleScripts((0, import_core2.createSymbol)(command, import_core.SymbolType.Greek));
+    }
+    if (command === "\\text") {
+      const content = this.parseBraceGroup();
+      if (content.kind === "group") {
+        const group = content;
+        const textContent = group.children.map((c) => {
+          if (c.kind === "symbol") return c.value;
+          return "";
+        }).join("");
+        return this.handleScripts((0, import_core2.createText)(textContent));
+      }
+      return this.handleScripts(content);
+    }
+    const specialSymbols = ["\\infty", "\\partial", "\\nabla", "\\forall", "\\exists", "\\emptyset", "\\neg"];
+    if (specialSymbols.includes(command)) {
+      return this.handleScripts((0, import_core2.createSymbol)(command, import_core.SymbolType.Operator));
+    }
+    return this.handleScripts((0, import_core2.createSymbol)(command, import_core.SymbolType.Ordinary));
+  }
+  // ==========================================================================
+  // Helpers
+  // ==========================================================================
+  /** 解析 {} 包裹的分组 */
+  parseBraceGroup() {
+    if (this.peek()?.type === "openBrace" /* OpenBrace */) {
+      return this.parseGroup();
+    }
+    return this.parseSingleExpression();
+  }
+  /** 解析 { expressions } 分组 */
+  parseGroup() {
+    this.skipType("openBrace" /* OpenBrace */);
+    const children = this.parseExpressions();
+    this.skipType("closeBrace" /* CloseBrace */);
+    return (0, import_core2.createGroup)(children);
+  }
+  /** 解析单个表达式（用于上/下标参数） */
+  parseSingleExpression() {
+    const children = this.parseExpressions();
+    return children.length === 1 ? children[0] : (0, import_core2.createGroup)(children);
+  }
+  /** 解析上/下标内容 */
+  parseScriptContent() {
+    if (this.peek()?.type === "openBrace" /* OpenBrace */) {
+      return this.parseGroup();
+    }
+    const expr = this.parseExpression();
+    return expr ?? (0, import_core2.createText)("");
+  }
+  // ==========================================================================
+  // Token Stream Helpers
+  // ==========================================================================
+  peek() {
+    return this.tokens[this.pos];
+  }
+  advance() {
+    const token = this.tokens[this.pos];
+    this.pos++;
+    return token;
+  }
+  skipType(type) {
+    if (this.peek()?.type === type) {
+      this.advance();
+    }
+  }
+  isEOF() {
+    return this.pos >= this.tokens.length || this.peek()?.type === "eof" /* EOF */;
+  }
+  /** 根据文本内容判断符号类型 */
+  classifySymbol(text) {
+    if (/^[a-zA-Z]$/.test(text)) return import_core.SymbolType.Variable;
+    if (/^[0-9.]+$/.test(text)) return import_core.SymbolType.Number;
+    if (/^[+\-*/=<>|]$/.test(text)) return import_core.SymbolType.Operator;
+    return import_core.SymbolType.Ordinary;
+  }
+};
+
+// src/chem-parser.ts
+var import_core3 = require("@sciexpr/core");
+var import_core4 = require("@sciexpr/core");
+var ChemicalParser = class {
+  id = "chemical";
+  formats = ["chemical", "chem"];
+  canParse(input) {
+    return /^[A-Z][a-z]?\d*/.test(input) || /[A-Z][a-z]?[A-Z]/.test(input);
+  }
+  parse(input, _options) {
+    const elements = this.parseFormula(input);
+    return (0, import_core4.createRoot)(import_core3.ExpressionKind.Molecule, elements, {
+      originalSource: input
+    });
+  }
+  /**
+   * 解析化学式，如 "H2SO4" → [H, 2, S, O, 4]
+   */
+  parseFormula(formula) {
+    const nodes = [];
+    let i = 0;
+    while (i < formula.length) {
+      const ch = formula[i];
+      if (/[A-Z]/.test(ch)) {
+        let symbol = ch;
+        i++;
+        while (i < formula.length && /[a-z]/.test(formula[i])) {
+          symbol += formula[i];
+          i++;
+        }
+        let count;
+        if (i < formula.length && /[0-9]/.test(formula[i])) {
+          let numStr = "";
+          while (i < formula.length && /[0-9]/.test(formula[i])) {
+            numStr += formula[i];
+            i++;
+          }
+          count = parseInt(numStr, 10);
+        }
+        nodes.push((0, import_core4.createChemElement)(symbol, count ? { count } : void 0));
+        continue;
+      }
+      if (ch === "(") {
+        i++;
+        const groupStart = i;
+        let depth = 1;
+        while (i < formula.length && depth > 0) {
+          if (formula[i] === "(") depth++;
+          else if (formula[i] === ")") depth--;
+          i++;
+        }
+        const groupContent = formula.slice(groupStart, i - 1);
+        const groupAtoms = this.parseFormula(groupContent);
+        let groupCount;
+        if (i < formula.length && /[0-9]/.test(formula[i])) {
+          let numStr = "";
+          while (i < formula.length && /[0-9]/.test(formula[i])) {
+            numStr += formula[i];
+            i++;
+          }
+          groupCount = parseInt(numStr, 10);
+          if (groupCount && groupCount > 1) {
+            for (const atom of groupAtoms) {
+              atom.count = (atom.count ?? 1) * groupCount;
+            }
+          }
+        }
+        nodes.push((0, import_core4.createChemGroup)(groupAtoms));
+        continue;
+      }
+      if (ch === "^") {
+        i++;
+        let chargeStr = "";
+        while (i < formula.length && /[0-9+\-]/.test(formula[i])) {
+          chargeStr += formula[i];
+          i++;
+        }
+        const lastNode = nodes[nodes.length - 1];
+        if (lastNode && lastNode.kind === "chem-element") {
+          const chargeMatch = chargeStr.match(/^(\d*)([+\-])$/);
+          if (chargeMatch) {
+            const el = lastNode;
+            el.charge = parseInt(chargeMatch[1] || "1", 10);
+            el.chargeSign = chargeMatch[2];
+          }
+        }
+        continue;
+      }
+      if (ch === "=" || ch === "-" || ch === "<") {
+        i++;
+        continue;
+      }
+      if (ch === " " || ch === "+" || ch === ",") {
+        i++;
+        continue;
+      }
+      nodes.push((0, import_core4.createSymbol)(ch, import_core4.SymbolType.Ordinary));
+      i++;
+    }
+    return nodes;
+  }
+};
+
+// src/registry.ts
+var ParserRegistry = class {
+  parsers = /* @__PURE__ */ new Map();
+  defaultParsers;
+  constructor() {
+    const latex = new LatexParser();
+    const chemical = new ChemicalParser();
+    this.defaultParsers = [latex, chemical];
+    this.register(latex);
+    this.register(chemical);
+  }
+  /** 注册自定义解析器 */
+  register(parser) {
+    this.parsers.set(parser.id, parser);
+  }
+  /** 移除解析器 */
+  unregister(id) {
+    return this.parsers.delete(id);
+  }
+  /** 根据 ID 获取解析器 */
+  get(id) {
+    return this.parsers.get(id);
+  }
+  /**
+   * 自动检测并选择合适的解析器
+   */
+  find(input) {
+    for (const parser of this.parsers.values()) {
+      if (parser.canParse(input)) {
+        return parser;
+      }
+    }
+    return null;
+  }
+  /**
+   * 解析输入
+   * @param input 输入文本
+   * @param options 解析选项
+   * @returns 解析后的 AST
+   */
+  parse(input, options) {
+    if (options?.hint && options.hint !== "auto") {
+      const parser2 = this.parsers.get(options.hint);
+      if (parser2) {
+        return parser2.parse(input, options);
+      }
+    }
+    const parser = this.find(input);
+    if (parser) {
+      return parser.parse(input, options);
+    }
+    return this.defaultParsers[0].parse(input, options);
+  }
+  /** 列出所有已注册的解析器 ID */
+  list() {
+    return Array.from(this.parsers.keys());
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChemicalParser,
+  LatexParser,
+  LatexTokenizer,
+  ParserRegistry,
+  TokenType
+});