@sciexpr/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,579 @@
+"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, {
+  ExpressionClassifier: () => ExpressionClassifier,
+  ExpressionKind: () => ExpressionKind,
+  SymbolType: () => SymbolType,
+  ValidationErrorCode: () => ValidationErrorCode,
+  cloneNode: () => cloneNode,
+  collectNodes: () => collectNodes,
+  countNodes: () => countNodes,
+  createAccent: () => createAccent,
+  createChemBond: () => createChemBond,
+  createChemElement: () => createChemElement,
+  createChemGroup: () => createChemGroup,
+  createChemReaction: () => createChemReaction,
+  createColor: () => createColor,
+  createDelimiter: () => createDelimiter,
+  createFraction: () => createFraction,
+  createGroup: () => createGroup,
+  createLargeOp: () => createLargeOp,
+  createMatrix: () => createMatrix,
+  createRadical: () => createRadical,
+  createRoot: () => createRoot,
+  createScript: () => createScript,
+  createSpace: () => createSpace,
+  createSymbol: () => createSymbol,
+  createText: () => createText,
+  deserializeAST: () => deserializeAST,
+  findNode: () => findNode,
+  flattenNode: () => flattenNode,
+  generateNodeId: () => generateNodeId,
+  getNodeChildren: () => getNodeChildren,
+  isNodeType: () => isNodeType,
+  resetNodeIdCounter: () => resetNodeIdCounter,
+  safeDeserializeAST: () => safeDeserializeAST,
+  serializeAST: () => serializeAST,
+  serializeASTCompact: () => serializeASTCompact,
+  serializeASTPretty: () => serializeASTPretty,
+  traverseAST: () => traverseAST
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/ast.ts
+var ExpressionKind = /* @__PURE__ */ ((ExpressionKind2) => {
+  ExpressionKind2["Math"] = "math";
+  ExpressionKind2["Molecule"] = "molecule";
+  ExpressionKind2["ChemicalEquation"] = "chemical-equation";
+  ExpressionKind2["Matrix"] = "matrix";
+  ExpressionKind2["Text"] = "text";
+  ExpressionKind2["Mixed"] = "mixed";
+  return ExpressionKind2;
+})(ExpressionKind || {});
+var SymbolType = /* @__PURE__ */ ((SymbolType2) => {
+  SymbolType2["Greek"] = "greek";
+  SymbolType2["Operator"] = "operator";
+  SymbolType2["Relation"] = "relation";
+  SymbolType2["Arrow"] = "arrow";
+  SymbolType2["Accent"] = "accent";
+  SymbolType2["Ordinary"] = "ordinary";
+  SymbolType2["Variable"] = "variable";
+  SymbolType2["Number"] = "number";
+  return SymbolType2;
+})(SymbolType || {});
+
+// src/types/validator.ts
+var ValidationErrorCode = /* @__PURE__ */ ((ValidationErrorCode2) => {
+  ValidationErrorCode2["UNEXPECTED_NODE"] = "UNEXPECTED_NODE";
+  ValidationErrorCode2["EMPTY_EXPRESSION"] = "EMPTY_EXPRESSION";
+  ValidationErrorCode2["UNBALANCED_BRACE"] = "UNBALANCED_BRACE";
+  ValidationErrorCode2["UNBALANCED_BRACKET"] = "UNBALANCED_BRACKET";
+  ValidationErrorCode2["INVALID_SCRIPT"] = "INVALID_SCRIPT";
+  ValidationErrorCode2["DIVISION_BY_ZERO"] = "DIVISION_BY_ZERO";
+  ValidationErrorCode2["MATRIX_DIMENSION_MISMATCH"] = "MATRIX_DIMENSION_MISMATCH";
+  ValidationErrorCode2["NEGATIVE_RADICAL"] = "NEGATIVE_RADICAL";
+  ValidationErrorCode2["INVALID_ELEMENT_SYMBOL"] = "INVALID_ELEMENT_SYMBOL";
+  ValidationErrorCode2["INVALID_CHEMICAL_FORMULA"] = "INVALID_CHEMICAL_FORMULA";
+  ValidationErrorCode2["CHARGE_IMBALANCE"] = "CHARGE_IMBALANCE";
+  ValidationErrorCode2["ELEMENT_IMBALANCE"] = "ELEMENT_IMBALANCE";
+  ValidationErrorCode2["INVALID_BOND"] = "INVALID_BOND";
+  return ValidationErrorCode2;
+})(ValidationErrorCode || {});
+
+// src/node-factory.ts
+var _nodeIdCounter = 0;
+function generateNodeId() {
+  return `n${++_nodeIdCounter}`;
+}
+function resetNodeIdCounter() {
+  _nodeIdCounter = 0;
+}
+function createRoot(type, children, metadata) {
+  return {
+    kind: "root",
+    id: generateNodeId(),
+    type,
+    children,
+    metadata
+  };
+}
+function createSymbol(value, symbolType) {
+  return {
+    kind: "symbol",
+    id: generateNodeId(),
+    value,
+    symbolType
+  };
+}
+function createFraction(numerator, denominator) {
+  return {
+    kind: "frac",
+    id: generateNodeId(),
+    numerator,
+    denominator
+  };
+}
+function createScript(base, options) {
+  return {
+    kind: "script",
+    id: generateNodeId(),
+    base,
+    ...options
+  };
+}
+function createRadical(radicand, index) {
+  return {
+    kind: "radical",
+    id: generateNodeId(),
+    radicand,
+    index
+  };
+}
+function createDelimiter(left, right, body) {
+  return {
+    kind: "delimiter",
+    id: generateNodeId(),
+    left,
+    right,
+    body
+  };
+}
+function createMatrix(rows, options) {
+  return {
+    kind: "matrix",
+    id: generateNodeId(),
+    rows,
+    ...options
+  };
+}
+function createText(content) {
+  return {
+    kind: "text",
+    id: generateNodeId(),
+    content
+  };
+}
+function createSpace(width) {
+  return {
+    kind: "space",
+    id: generateNodeId(),
+    width
+  };
+}
+function createAccent(accentType, base) {
+  return {
+    kind: "accent",
+    id: generateNodeId(),
+    accentType,
+    base
+  };
+}
+function createLargeOp(opType, body, options) {
+  return {
+    kind: "largeop",
+    id: generateNodeId(),
+    opType,
+    body,
+    ...options
+  };
+}
+function createColor(color, body) {
+  return {
+    kind: "color",
+    id: generateNodeId(),
+    color,
+    body
+  };
+}
+function createGroup(children) {
+  return {
+    kind: "group",
+    id: generateNodeId(),
+    children
+  };
+}
+function createChemElement(symbol, options) {
+  return {
+    kind: "chem-element",
+    id: generateNodeId(),
+    symbol,
+    ...options
+  };
+}
+function createChemBond(bondType, left, right) {
+  return {
+    kind: "chem-bond",
+    id: generateNodeId(),
+    bondType,
+    left,
+    right
+  };
+}
+function createChemReaction(reactants, products, arrowType, conditions) {
+  return {
+    kind: "chem-reaction",
+    id: generateNodeId(),
+    reactants,
+    products,
+    arrowType,
+    conditions
+  };
+}
+function createChemGroup(atoms, name) {
+  return {
+    kind: "chem-group",
+    id: generateNodeId(),
+    name,
+    atoms
+  };
+}
+function cloneNode(node) {
+  const cloned = JSON.parse(JSON.stringify(node));
+  cloned.id = generateNodeId();
+  return cloned;
+}
+function isNodeType(node, kind) {
+  return node.kind === kind;
+}
+function flattenNode(node) {
+  const result = [node];
+  const children = getNodeChildren(node);
+  for (const child of children) {
+    result.push(...flattenNode(child));
+  }
+  return result;
+}
+function getNodeChildren(node) {
+  const n = node;
+  switch (n.kind) {
+    case "root":
+    case "group":
+      return n.children;
+    case "frac":
+      return [n.numerator, n.denominator];
+    case "script":
+      return [n.base, n.sub, n.super].filter(Boolean);
+    case "radical":
+      return [n.radicand, n.index].filter(Boolean);
+    case "delimiter":
+      return [n.body];
+    case "matrix":
+      return n.rows.flat();
+    case "color":
+      return [n.body];
+    case "accent":
+      return [n.base];
+    case "largeop":
+      return [n.body, n.lower, n.upper].filter(Boolean);
+    case "chem-bond":
+      return [n.left, n.right];
+    case "chem-reaction":
+      return [...n.reactants, ...n.products, n.conditions].filter(Boolean);
+    case "chem-group":
+      return n.atoms;
+    case "symbol":
+    case "text":
+    case "space":
+    case "chem-element":
+      return [];
+    default:
+      return [];
+  }
+}
+
+// src/ast-utils.ts
+function traverseAST(node, visitor, options = {}) {
+  const { order = "pre" } = options;
+  let result;
+  if (order === "pre") {
+    result = visitNode(node, visitor);
+  }
+  const children = getChildren(node);
+  for (const child of children) {
+    traverseAST(child, visitor, options);
+  }
+  if (order === "post") {
+    result = visitNode(node, visitor);
+  }
+  return result;
+}
+function visitNode(node, visitor) {
+  let result;
+  const n = node;
+  switch (n.kind) {
+    case "root":
+      result = visitor.visitRoot?.(n);
+      break;
+    case "symbol":
+      result = visitor.visitSymbol?.(n);
+      break;
+    case "frac":
+      result = visitor.visitFraction?.(n);
+      break;
+    case "script":
+      result = visitor.visitScript?.(n);
+      break;
+    case "radical":
+      result = visitor.visitRadical?.(n);
+      break;
+    case "delimiter":
+      result = visitor.visitDelimiter?.(n);
+      break;
+    case "matrix":
+      result = visitor.visitMatrix?.(n);
+      break;
+    case "text":
+      result = visitor.visitText?.(n);
+      break;
+    case "space":
+      result = visitor.visitSpace?.(n);
+      break;
+    case "accent":
+      result = visitor.visitAccent?.(n);
+      break;
+    case "largeop":
+      result = visitor.visitLargeOp?.(n);
+      break;
+    case "color":
+      result = visitor.visitColor?.(n);
+      break;
+    case "group":
+      result = visitor.visitGroup?.(n);
+      break;
+    case "chem-element":
+      result = visitor.visitChemElement?.(n);
+      break;
+    case "chem-bond":
+      result = visitor.visitChemBond?.(n);
+      break;
+    case "chem-reaction":
+      result = visitor.visitChemReaction?.(n);
+      break;
+    case "chem-group":
+      result = visitor.visitChemGroup?.(n);
+      break;
+    default:
+      result = visitor.visitDefault?.(n);
+      break;
+  }
+  if (result === void 0 && visitor.visitDefault) {
+    result = visitor.visitDefault(node);
+  }
+  return result;
+}
+function getChildren(node) {
+  const n = node;
+  switch (n.kind) {
+    case "root":
+    case "group":
+      return n.children;
+    case "frac":
+      return [n.numerator, n.denominator];
+    case "script": {
+      const children = [n.base];
+      if (n.sub) children.push(n.sub);
+      if (n.super) children.push(n.super);
+      return children;
+    }
+    case "radical": {
+      const children = [n.radicand];
+      if (n.index) children.push(n.index);
+      return children;
+    }
+    case "delimiter":
+      return [n.body];
+    case "matrix":
+      return n.rows.flat();
+    case "color":
+      return [n.body];
+    case "accent":
+      return [n.base];
+    case "largeop": {
+      const children = [];
+      if (n.body) children.push(n.body);
+      if (n.lower) children.push(n.lower);
+      if (n.upper) children.push(n.upper);
+      return children;
+    }
+    case "chem-bond":
+      return [n.left, n.right];
+    case "chem-reaction": {
+      const children = [...n.reactants, ...n.products];
+      if (n.conditions) children.push(n.conditions);
+      return children;
+    }
+    case "chem-group":
+      return n.atoms;
+    case "symbol":
+    case "text":
+    case "space":
+    case "chem-element":
+      return [];
+    default:
+      return [];
+  }
+}
+function collectNodes(root, predicate) {
+  const results = [];
+  traverseAST(root, {
+    visitDefault(node) {
+      if (predicate(node)) {
+        results.push(node);
+      }
+    }
+  });
+  return results;
+}
+function findNode(root, predicate) {
+  return collectNodes(root, predicate)[0];
+}
+function countNodes(root) {
+  let count = 0;
+  traverseAST(root, {
+    visitDefault() {
+      count++;
+    }
+  });
+  return count;
+}
+
+// src/serializer.ts
+function serializeAST(root) {
+  return JSON.stringify(root);
+}
+function deserializeAST(json) {
+  const parsed = JSON.parse(json);
+  if (!parsed || parsed.kind !== "root") {
+    throw new Error('Invalid AST JSON: root node must have kind "root"');
+  }
+  return parsed;
+}
+function safeDeserializeAST(json) {
+  try {
+    return deserializeAST(json);
+  } catch {
+    return null;
+  }
+}
+function serializeASTCompact(root) {
+  return JSON.stringify(root, (key, value) => {
+    if (key === "id" && typeof value === "string" && value.startsWith("n")) {
+      return void 0;
+    }
+    if (key === "source" && value === void 0) {
+      return void 0;
+    }
+    return value;
+  });
+}
+function serializeASTPretty(root) {
+  return JSON.stringify(root, null, 2);
+}
+
+// src/classifier.ts
+var ExpressionClassifier = class {
+  /**
+   * 分类表达式
+   */
+  classify(root) {
+    if (root.type !== "mixed" /* Mixed */) {
+      return root.type;
+    }
+    const hasChemistryNodes = this.hasChemistryNodes(root);
+    const hasMathNodes = this.hasMathNodes(root);
+    if (hasChemistryNodes && !hasMathNodes) {
+      const hasReaction = collectNodes(root, (n) => n.kind === "chem-reaction").length > 0;
+      return hasReaction ? "chemical-equation" /* ChemicalEquation */ : "molecule" /* Molecule */;
+    }
+    if (hasMathNodes && hasChemistryNodes) {
+      return "mixed" /* Mixed */;
+    }
+    if (hasMathNodes) {
+      const hasMatrix = collectNodes(root, (n) => n.kind === "matrix").length > 0;
+      return hasMatrix ? "matrix" /* Matrix */ : "math" /* Math */;
+    }
+    return "text" /* Text */;
+  }
+  /**
+   * 检测是否包含化学相关节点
+   */
+  hasChemistryNodes(root) {
+    return collectNodes(
+      root,
+      (n) => ["chem-element", "chem-bond", "chem-reaction", "chem-group"].includes(n.kind)
+    ).length > 0;
+  }
+  /**
+   * 检测是否包含数学相关节点
+   */
+  hasMathNodes(root) {
+    return collectNodes(
+      root,
+      (n) => ["frac", "script", "radical", "delimiter", "matrix", "accent", "largeop"].includes(n.kind)
+    ).length > 0;
+  }
+  /**
+   * 检测是否为 display 模式（块级公式）
+   */
+  isDisplayMode(root) {
+    return root.metadata?.displayMode ?? false;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExpressionClassifier,
+  ExpressionKind,
+  SymbolType,
+  ValidationErrorCode,
+  cloneNode,
+  collectNodes,
+  countNodes,
+  createAccent,
+  createChemBond,
+  createChemElement,
+  createChemGroup,
+  createChemReaction,
+  createColor,
+  createDelimiter,
+  createFraction,
+  createGroup,
+  createLargeOp,
+  createMatrix,
+  createRadical,
+  createRoot,
+  createScript,
+  createSpace,
+  createSymbol,
+  createText,
+  deserializeAST,
+  findNode,
+  flattenNode,
+  generateNodeId,
+  getNodeChildren,
+  isNodeType,
+  resetNodeIdCounter,
+  safeDeserializeAST,
+  serializeAST,
+  serializeASTCompact,
+  serializeASTPretty,
+  traverseAST
+});