mathsteps-experimental-fork/dist/cjs/lib/newServices/nodeServices/parseText.js

Step by step math solutions. Experimental Fork

'use strict';

Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

const config = require('../../config.js');
const clone = require('./clone.js');
const index = require('../../simplifyExpression/index.js');
const kemuSimplifyCommonServices = require('../../simplifyExpression/kemuSimplifyCommonServices.js');
const print$1 = require('../../util/print.js');

const print = print$1.printAscii;
const CACHE_TEXT_TO_TEX = {};
const CACHE_TEXT_TO_NODE = {};
const ARRAY_OF_PREPROCESS_FUNCTIONS_BEFORE_PARSE = [];
const ARRAY_OF_PREPROCESS_FUNCTIONS_AFTER_PARSE = [];
const registerPreprocessorBeforeParse = (cb) => {
  ARRAY_OF_PREPROCESS_FUNCTIONS_BEFORE_PARSE.push(cb);
};
const registerPreprocessorAfterParse = (cb) => {
  ARRAY_OF_PREPROCESS_FUNCTIONS_AFTER_PARSE.push(cb);
};
const _postProcessResultTeX = (resultTeX) => {
  return resultTeX.replace(":=", "=");
};
function printAsTeX(node) {
  return _postProcessResultTeX(print$1.printLatex(node));
}
const _convertTextToTeXInternal = (text) => {
  let rv = "";
  const tokens = text.split("=");
  let sep = "";
  tokens.forEach((token) => {
    token = token.trim();
    if (token !== "") {
      rv += sep + printAsTeX(parseText(token));
      sep = "=";
    }
  });
  return rv;
};
function convertTextToTeX(text) {
  let rv = text;
  if (text && text.trim() !== "") {
    {
      text = text.trim();
      rv = CACHE_TEXT_TO_TEX[text];
      if (rv == null) {
        rv = _convertTextToTeXInternal(text);
        CACHE_TEXT_TO_TEX[text] = rv;
      }
    }
  }
  return rv;
}
const _parseTextInternal = (text) => {
  ARRAY_OF_PREPROCESS_FUNCTIONS_BEFORE_PARSE.forEach((preprocessFct) => {
    text = preprocessFct(text);
  });
  text = text.replaceAll(/\b0[a-z]\b/gi, "0");
  let rv = config.default.parse(text);
  rv = kemuSimplifyCommonServices.kemuNormalizeConstantNodes(rv);
  ARRAY_OF_PREPROCESS_FUNCTIONS_AFTER_PARSE.forEach((preprocessFct) => {
    rv = preprocessFct(rv);
  });
  return rv;
};
function parseText(text) {
  let rv = null;
  {
    text = text.trim();
    rv = CACHE_TEXT_TO_NODE[text];
    if (rv == null) {
      rv = _parseTextInternal(text);
      CACHE_TEXT_TO_NODE[text] = rv;
    }
    rv = clone(rv);
  }
  return rv;
}
const isOkAsSymbolicExpression = (expressionAsText) => {
  let rv = false;
  if (expressionAsText && expressionAsText.search(/-\s*-/) === -1) {
    try {
      const expressionNode = parseText(`${expressionAsText}*1`);
      const steps = index.default.oldApi(expressionNode);
      rv = steps.length > 0;
    } catch (e) {
    }
  }
  return rv;
};

exports.convertTextToTeX = convertTextToTeX;
exports.isOkAsSymbolicExpression = isOkAsSymbolicExpression;
exports.parseText = parseText;
exports.print = print;
exports.printAsTeX = printAsTeX;
exports.registerPreprocessorAfterParse = registerPreprocessorAfterParse;
exports.registerPreprocessorBeforeParse = registerPreprocessorBeforeParse;