@sdeverywhere/parse 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/_shared/canonical-id.js
 var reTrailingMark = new RegExp("\\s+!$", "g");
 var reWhitespace = new RegExp("(\\s|_)+", "g");
-var reSpecialChars = new RegExp(`['"\\.,\\-\\$&%\\/\\|()]`, "g");
+var reSpecialChars = /[^\p{L}\p{N}_!]/gu;
 function canonicalId(name) {
   return "_" + name.trim().replace(reTrailingMark, "!").replace(reWhitespace, "_").replace(reSpecialChars, "_").toLowerCase();
 }
@@ -270,6 +270,12 @@ function fullIdForVarRef(varRef) {
 import { assertNever as assertNever2 } from "assert-never";
 
 // src/ast/ast-builders.ts
+function subRef(dimOrSubName) {
+  return {
+    subName: dimOrSubName,
+    subId: canonicalId(dimOrSubName)
+  };
+}
 function num(value, text) {
   return {
     kind: "number",
@@ -298,6 +304,13 @@ function parens(expr) {
     expr
   };
 }
+function lookupDef(points, range) {
+  return {
+    kind: "lookup-def",
+    range,
+    points
+  };
+}
 function lookupCall(varRef, arg) {
   return {
     kind: "lookup-call",
@@ -305,6 +318,14 @@ function lookupCall(varRef, arg) {
     arg
   };
 }
+function call(fnName, ...args) {
+  return {
+    kind: "function-call",
+    fnName,
+    fnId: canonicalFunctionId(fnName),
+    args
+  };
+}
 
 // src/ast/reduce-expr.ts
 function reduceExpr(expr, opts) {
@@ -1491,6 +1512,590 @@ Detail:
     equations
   };
 }
+
+// src/xmile/xml.ts
+import { XmlNode } from "@rgrove/parse-xml";
+function firstElemOf(parent, tagName) {
+  return parent?.children.find((n) => {
+    if (n.type === XmlNode.TYPE_ELEMENT) {
+      const e = n;
+      return e.name === tagName;
+    } else {
+      return void 0;
+    }
+  });
+}
+function firstTextOf(parent) {
+  return parent?.children.find((n) => {
+    return n.type === XmlNode.TYPE_TEXT;
+  });
+}
+function elemsOf(parent, tagNames) {
+  if (parent === void 0) {
+    return [];
+  }
+  const elems = [];
+  for (const n of parent.children) {
+    if (n.type === XmlNode.TYPE_ELEMENT) {
+      const e = n;
+      if (tagNames.includes(e.name)) {
+        elems.push(e);
+      }
+    }
+  }
+  return elems;
+}
+function xmlError(elem, msg) {
+  return `${msg}: ${JSON.stringify(elem.toJSON(), null, 2)}`;
+}
+
+// src/xmile/parse-xmile-dimension-def.ts
+function parseXmileDimensionDef(dimElem) {
+  const dimName = dimElem.attributes?.name;
+  if (dimName === void 0) {
+    throw new Error(xmlError(dimElem, "<dim> name attribute is required for dimension definition"));
+  }
+  const elemElems = elemsOf(dimElem, ["elem"]);
+  if (elemElems.length === 0) {
+    throw new Error(xmlError(dimElem, "<dim> must contain one or more <elem> elements"));
+  }
+  const subscriptRefs = [];
+  for (const elem of elemElems) {
+    const subName = elem.attributes?.name;
+    if (subName === void 0) {
+      throw new Error(xmlError(dimElem, "<elem> name attribute is required for dimension element definition"));
+    }
+    const subId = canonicalId(subName);
+    subscriptRefs.push({
+      subId,
+      subName
+    });
+  }
+  const comment = firstElemOf(dimElem, "doc")?.text || "";
+  const dimId = canonicalId(dimName);
+  return {
+    dimName,
+    dimId,
+    // TODO: For Vensim `DimA <-> DimB` aliases, the family name would be `DimB`
+    familyName: dimName,
+    familyId: dimId,
+    subscriptRefs,
+    // TODO: Does XMILE support mappings?
+    subscriptMappings: [],
+    comment
+  };
+}
+
+// src/xmile/parse-xmile-model.ts
+import { parseXml } from "@rgrove/parse-xml";
+
+// src/xmile/parse-xmile-variable-def.ts
+function parseXmileVariableDef(varElem) {
+  let varName = parseRequiredAttr(varElem, varElem, "name");
+  varName = varName.replace(/\\n/g, " ");
+  const varId = canonicalId(varName);
+  const units = firstElemOf(varElem, "units")?.text || "";
+  const comment = firstElemOf(varElem, "doc")?.text || "";
+  function exprEquation(subscriptRefs, expr) {
+    return {
+      lhs: {
+        varDef: {
+          kind: "variable-def",
+          varName,
+          varId,
+          subscriptRefs
+        }
+      },
+      rhs: {
+        kind: "expr",
+        expr
+      },
+      units,
+      comment
+    };
+  }
+  function lookupEquation(subscriptRefs, lookup) {
+    return {
+      lhs: {
+        varDef: {
+          kind: "variable-def",
+          varName,
+          varId,
+          subscriptRefs
+        }
+      },
+      rhs: {
+        kind: "lookup",
+        lookupDef: lookup
+      },
+      units,
+      comment
+    };
+  }
+  if (varElem.name === "gf") {
+    const lookup = parseGfElem(varElem, varElem);
+    return [lookupEquation(void 0, lookup)];
+  }
+  const dimensionsElem = firstElemOf(varElem, "dimensions");
+  const equationDefs = [];
+  if (dimensionsElem === void 0) {
+    const gfElem = firstElemOf(varElem, "gf");
+    if (gfElem) {
+      if (varElem.name !== "flow" && varElem.name !== "aux") {
+        throw new Error(xmlError(varElem, "<gf> is only allowed for <flow> and <aux> variables"));
+      }
+      const lookup = parseGfElem(varElem, gfElem);
+      equationDefs.push(lookupEquation(void 0, lookup));
+    } else {
+      const expr = parseEqnElem(varElem, varElem);
+      if (expr) {
+        equationDefs.push(exprEquation(void 0, expr));
+      }
+    }
+  } else {
+    const dimElems = elemsOf(dimensionsElem, ["dim"]);
+    const dimNames = [];
+    for (const dimElem of dimElems) {
+      const dimName = dimElem.attributes?.name;
+      if (dimName === void 0) {
+        throw new Error(xmlError(varElem, "<dim> name attribute is required in <dimensions> for variable definition"));
+      }
+      dimNames.push(dimName);
+    }
+    const elementElems = elemsOf(varElem, ["element"]);
+    if (elementElems.length === 0) {
+      const dimRefs = dimNames.map(subRef);
+      const expr = parseEqnElem(varElem, varElem);
+      if (expr) {
+        equationDefs.push(exprEquation(dimRefs, expr));
+      }
+    } else {
+      for (const elementElem of elementElems) {
+        const subscriptAttr = elementElem.attributes?.subscript;
+        if (subscriptAttr === void 0) {
+          throw new Error(xmlError(varElem, "<element> subscript attribute is required in variable definition"));
+        }
+        const subscriptNames = subscriptAttr.split(",").map((s) => s.trim());
+        const subRefs = [];
+        for (const subscriptName of subscriptNames) {
+          if (!isNaN(parseInt(subscriptAttr))) {
+            throw new Error(xmlError(varElem, "Numeric subscript indices are not currently supported"));
+          }
+          subRefs.push(subRef(subscriptName));
+        }
+        const expr = parseEqnElem(varElem, elementElem);
+        if (expr) {
+          equationDefs.push(exprEquation(subRefs, expr));
+        }
+      }
+    }
+  }
+  return equationDefs;
+}
+function parseEqnElem(varElem, parentElem) {
+  const varTagName = varElem.name;
+  const eqnElem = firstElemOf(parentElem, "eqn");
+  const eqnText = eqnElem ? firstTextOf(eqnElem) : void 0;
+  switch (varTagName) {
+    case "aux": {
+      if (eqnText === void 0) {
+        return void 0;
+      }
+      const initEqnElem = firstElemOf(parentElem, "init_eqn");
+      const initEqnText = initEqnElem ? firstTextOf(initEqnElem) : void 0;
+      if (initEqnText !== void 0) {
+        const eqnExpr = parseExpr(eqnText.text);
+        const initEqnExpr = parseExpr(initEqnText.text);
+        return call("ACTIVE INITIAL", eqnExpr, initEqnExpr);
+      }
+      return parseExpr(eqnText.text);
+    }
+    case "stock": {
+      if (eqnText === void 0) {
+        throw new Error(xmlError(varElem, "An <eqn> is required for a <stock> variable"));
+      }
+      const inflowElems = elemsOf(parentElem, ["inflow"]);
+      const outflowElems = elemsOf(parentElem, ["outflow"]);
+      const inflowTexts = inflowElems.map((inflowElem) => {
+        const inflowText = firstTextOf(inflowElem);
+        if (inflowText === void 0) {
+          throw new Error(xmlError(varElem, "An <inflow> must be non-empty for a <stock> variable"));
+        }
+        return inflowText.text;
+      });
+      const outflowTexts = outflowElems.map((outflowElem) => {
+        const outflowText = firstTextOf(outflowElem);
+        if (outflowText === void 0) {
+          throw new Error(xmlError(varElem, "An <outflow> must be non-empty for a <stock> variable"));
+        }
+        return outflowText.text;
+      });
+      if (firstElemOf(parentElem, "conveyor")) {
+        throw new Error(xmlError(varElem, "Currently <conveyor> is not supported for a <stock> variable"));
+      }
+      if (firstElemOf(parentElem, "queue")) {
+        throw new Error(xmlError(varElem, "Currently <queue> is not supported for a <stock> variable"));
+      }
+      const inflowParts = inflowTexts.join(" + ");
+      let outflowParts = outflowTexts.join(" - ");
+      if (outflowTexts.length > 0) {
+        if (inflowParts.length > 0) {
+          outflowParts = `- ${outflowParts}`;
+        } else {
+          outflowParts = `-${outflowParts}`;
+        }
+      }
+      const flowsExpr = parseExpr(`${inflowParts} ${outflowParts}`);
+      const initExpr = parseExpr(eqnText.text);
+      return call("INTEG", flowsExpr, initExpr);
+    }
+    case "flow":
+      if (eqnText === void 0) {
+        throw new Error(xmlError(varElem, "Currently <eqn> or <gf> is required for a <flow> variable"));
+      }
+      if (firstElemOf(parentElem, "multiplier")) {
+        throw new Error(xmlError(varElem, "Currently <multiplier> is not supported for a <flow> variable"));
+      }
+      if (firstElemOf(parentElem, "overflow")) {
+        throw new Error(xmlError(varElem, "Currently <overflow> is not supported for a <flow> variable"));
+      }
+      if (firstElemOf(parentElem, "leak")) {
+        throw new Error(xmlError(varElem, "Currently <leak> is not supported for a <flow> variable"));
+      }
+      return parseExpr(eqnText.text);
+    default:
+      throw new Error(xmlError(varElem, `Unhandled variable type '${varTagName}'`));
+  }
+}
+function parseExpr(exprText) {
+  exprText = convertConditionalExpressions(exprText);
+  exprText = exprText.replace(/\[([^\]]*)\*([^\]]*)\]/g, "[$1_SDE_WILDCARD_!$2]");
+  return parseVensimExpr(exprText);
+}
+function parseGfElem(varElem, gfElem) {
+  const typeAttr = parseOptionalAttr(gfElem, "type");
+  if (typeAttr && typeAttr !== "continuous") {
+    throw new Error(xmlError(varElem, 'Currently "continuous" is the only type supported for <gf>'));
+  }
+  const yptsElem = firstElemOf(gfElem, "ypts");
+  if (yptsElem === void 0) {
+    throw new Error(xmlError(varElem, "<ypts> must be defined for a <gf>"));
+  }
+  const ypts = parseGfPts(varElem, yptsElem);
+  if (ypts.length === 0) {
+    throw new Error(xmlError(varElem, "<ypts> must have at least one element"));
+  }
+  const xptsElem = firstElemOf(gfElem, "xpts");
+  const xscaleElem = firstElemOf(gfElem, "xscale");
+  if (xptsElem && xscaleElem) {
+    throw new Error(xmlError(varElem, "<gf> must contain <xpts> or <xscale> but not both"));
+  } else if (xptsElem === void 0 && xscaleElem === void 0) {
+    throw new Error(xmlError(varElem, "<gf> must contain either <xpts> or <xscale>"));
+  }
+  let xpts;
+  if (xptsElem) {
+    xpts = parseGfPts(varElem, xptsElem);
+    if (xpts.length === 0) {
+      throw new Error(xmlError(varElem, "<xpts> must have at least one element"));
+    }
+  } else {
+    const xMin = parseFloatAttr(varElem, xscaleElem, "min");
+    const xMax = parseFloatAttr(varElem, xscaleElem, "max");
+    if (xMin > xMax) {
+      throw new Error(xmlError(varElem, "<xscale> max attribute must be > min attribute"));
+    }
+    xpts = Array(ypts.length);
+    const xRange = xMax - xMin;
+    if (ypts.length === 1) {
+      xpts[0] = 0;
+    } else {
+      for (let i = 0; i < ypts.length; i++) {
+        const frac = i / (ypts.length - 1);
+        xpts[i] = xMin + xRange * frac;
+      }
+    }
+  }
+  if (xpts.length !== ypts.length) {
+    throw new Error(xmlError(varElem, "<xpts> and <ypts> must have the same number of elements"));
+  }
+  const points = [];
+  for (let i = 0; i < xpts.length; i++) {
+    points.push([xpts[i], ypts[i]]);
+  }
+  return lookupDef(points);
+}
+function parseGfPts(varElem, ptsElem) {
+  const ptsText = firstTextOf(ptsElem)?.text;
+  if (ptsText === void 0) {
+    return [];
+  }
+  const sep = ptsElem.attributes?.sep || ",";
+  const elems = ptsText.split(sep);
+  const nums = [];
+  for (const elem of elems) {
+    const numText = elem.trim();
+    const num2 = parseFloat(numText);
+    if (isNaN(num2)) {
+      console.log(JSON.stringify(ptsElem));
+      throw new Error(xmlError(varElem, `Invalid number value '${numText}' in <${ptsElem.name}>'`));
+    }
+    nums.push(num2);
+  }
+  return nums;
+}
+function parseRequiredAttr(varElem, elem, attrName) {
+  let s = elem.attributes && elem.attributes[attrName];
+  s = s?.trim();
+  if (s === void 0 || s.length === 0) {
+    throw new Error(xmlError(varElem, `<${elem.name}> ${attrName} attribute is required`));
+  }
+  return s;
+}
+function parseOptionalAttr(elem, attrName) {
+  const s = elem.attributes && elem.attributes[attrName];
+  return s?.trim();
+}
+function parseFloatAttr(varElem, elem, attrName) {
+  const s = parseRequiredAttr(varElem, elem, attrName);
+  const num2 = parseFloat(s);
+  if (isNaN(num2)) {
+    throw new Error(xmlError(varElem, `Invalid number value '${s}' for <${elem.name}> ${attrName} attribute'`));
+  }
+  return num2;
+}
+function convertConditionalExpressions(exprText) {
+  const normalizedText = exprText.trim().replace(/\s+/g, " ");
+  const ifMatch = normalizedText.match(/\bIF\s+(.+)$/i);
+  if (!ifMatch) {
+    return exprText;
+  }
+  const ifIndex = normalizedText.search(/\bIF\s+/i);
+  const beforeIf = normalizedText.substring(0, ifIndex);
+  const afterIf = normalizedText.substring(ifIndex + 3).trim();
+  const thenMatch = afterIf.match(/^(.+?)\s+THEN\s+(.+)$/i);
+  if (!thenMatch) {
+    return exprText;
+  }
+  const condition = thenMatch[1].trim();
+  const afterThen = thenMatch[2];
+  let elseIndex = -1;
+  let parenCount = 0;
+  let inQuotes = false;
+  let quoteChar = "";
+  for (let i = 0; i < afterThen.length; i++) {
+    const char = afterThen[i];
+    if ((char === '"' || char === "'") && (i === 0 || afterThen[i - 1] !== "\\")) {
+      if (!inQuotes) {
+        inQuotes = true;
+        quoteChar = char;
+      } else if (char === quoteChar) {
+        inQuotes = false;
+        quoteChar = "";
+      }
+      continue;
+    }
+    if (inQuotes) {
+      continue;
+    }
+    if (char === "(") {
+      parenCount++;
+    } else if (char === ")") {
+      parenCount--;
+    }
+    if (parenCount === 0 && !inQuotes) {
+      const elseMatch = afterThen.substring(i).match(/^ELSE\s+(.+)$/i);
+      if (elseMatch) {
+        elseIndex = i;
+        break;
+      }
+    }
+  }
+  if (elseIndex === -1) {
+    return exprText;
+  }
+  const trueExpr = afterThen.substring(0, elseIndex).trim();
+  let falseExpr = afterThen.substring(elseIndex + 5).trim();
+  let endIndex = -1;
+  parenCount = 0;
+  inQuotes = false;
+  quoteChar = "";
+  for (let i = 0; i < falseExpr.length; i++) {
+    const char = falseExpr[i];
+    if ((char === '"' || char === "'") && (i === 0 || falseExpr[i - 1] !== "\\")) {
+      if (!inQuotes) {
+        inQuotes = true;
+        quoteChar = char;
+      } else if (char === quoteChar) {
+        inQuotes = false;
+        quoteChar = "";
+      }
+      continue;
+    }
+    if (inQuotes) {
+      continue;
+    }
+    if (char === "(") {
+      parenCount++;
+    } else if (char === ")") {
+      if (parenCount === 0) {
+        endIndex = i;
+        break;
+      }
+      parenCount--;
+    }
+  }
+  if (endIndex !== -1) {
+    falseExpr = falseExpr.substring(0, endIndex).trim();
+  }
+  const convertedTrueExpr = convertConditionalExpressions(trueExpr);
+  const convertedFalseExpr = convertConditionalExpressions(falseExpr);
+  const convertedCondition = condition.replace(/(?<!".*?)\b AND \b(?!.*?")/gi, " :AND: ").replace(/(?<!".*?)\b OR \b(?!.*?")/gi, " :OR: ").replace(/(?<!".*?)\b\s?NOT \b(?!.*?")/gi, " :NOT: ").replace(/^\((.+)\)$/, "$1");
+  const elseStartInAfterIf = afterIf.indexOf(" ELSE ") + 6;
+  const falseExprStartInAfterIf = elseStartInAfterIf;
+  const falseExprEndInAfterIf = falseExprStartInAfterIf + falseExpr.length;
+  const conditionalEndInNormalizedText = ifIndex + 3 + falseExprEndInAfterIf;
+  const afterConditional = normalizedText.substring(conditionalEndInNormalizedText).trim();
+  return `${beforeIf}IF THEN ELSE(${convertedCondition}, ${convertedTrueExpr}, ${convertedFalseExpr})${afterConditional}`;
+}
+
+// src/xmile/parse-xmile-model.ts
+function parseXmileModel(input) {
+  let xml;
+  try {
+    xml = parseXml(input, { includeOffsets: true });
+  } catch (e) {
+    const msg = `Failed to parse XMILE model definition:
+
+${e.message}`;
+    throw new Error(msg);
+  }
+  const simulationSpec = parseSimSpecs(xml.root, input);
+  const dimensions = parseDimensionDefs(xml.root, input);
+  const equations = parseVariableDefs(xml.root, input);
+  return {
+    simulationSpec,
+    dimensions,
+    equations
+  };
+}
+function parseSimSpecs(rootElem, originalXml) {
+  const simSpecsElem = firstElemOf(rootElem, "sim_specs");
+  if (simSpecsElem === void 0) {
+    throw new Error(xmlError(rootElem, "<sim_specs> element is required for XMILE model definition"));
+  }
+  function getSimSpecValue(name, required) {
+    const elem = firstElemOf(simSpecsElem, name);
+    if (required && elem === void 0) {
+      const error = new Error(xmlError(simSpecsElem, `<${name}> element is required in XMILE sim specs`));
+      throwXmileParseError(error, originalXml, simSpecsElem, "model");
+    }
+    if (elem === void 0) {
+      return void 0;
+    }
+    const value = Number(elem.text);
+    if (!isNaN(value)) {
+      return value;
+    } else {
+      const error = new Error(xmlError(elem, `Invalid numeric value for <${name}> element: ${elem.text}`));
+      throwXmileParseError(error, originalXml, simSpecsElem, "model");
+    }
+  }
+  const startTime = getSimSpecValue("start", true);
+  const endTime = getSimSpecValue("stop", true);
+  let timeStep = getSimSpecValue("dt", false);
+  if (timeStep === void 0) {
+    timeStep = 1;
+  }
+  return {
+    startTime,
+    endTime,
+    timeStep
+  };
+}
+function parseDimensionDefs(rootElem, originalXml) {
+  const dimensionDefs = [];
+  const dimensionsElem = firstElemOf(rootElem, "dimensions");
+  if (dimensionsElem) {
+    const dimElems = elemsOf(dimensionsElem, ["dim"]);
+    for (const dimElem of dimElems) {
+      try {
+        dimensionDefs.push(parseXmileDimensionDef(dimElem));
+      } catch (e) {
+        throwXmileParseError(e, originalXml, dimElem, "dimension");
+      }
+    }
+  }
+  return dimensionDefs;
+}
+function parseVariableDefs(rootElem, originalXml) {
+  const modelElem = firstElemOf(rootElem, "model");
+  if (modelElem === void 0) {
+    return [];
+  }
+  const equations = [];
+  const variablesElem = firstElemOf(modelElem, "variables");
+  if (variablesElem) {
+    const varElems = elemsOf(variablesElem, ["aux", "stock", "flow", "gf"]);
+    for (const varElem of varElems) {
+      try {
+        const eqns = parseXmileVariableDef(varElem);
+        if (eqns) {
+          equations.push(...eqns);
+        }
+      } catch (e) {
+        throwXmileParseError(e, originalXml, varElem, "variable");
+      }
+    }
+  }
+  return equations;
+}
+function throwXmileParseError(originalError, originalXml, elem, elemKind) {
+  let linePart = "";
+  const lineNumInOriginalXml = getLineNumber(originalXml, elem.start);
+  if (lineNumInOriginalXml !== -1) {
+    const cause = originalError.cause;
+    if (cause?.code === "VensimParseError") {
+      if (cause.line) {
+        const lineNum = cause.line - 1 + lineNumInOriginalXml;
+        linePart += ` at line ${lineNum}`;
+        if (cause.column) {
+          linePart += `, col ${cause.column}`;
+        }
+      }
+    } else {
+      linePart += ` at line ${lineNumInOriginalXml}`;
+    }
+  }
+  const elemString = extractXmlLines(originalXml, elem.start, elem.end);
+  const msg = `Failed to parse XMILE ${elemKind} definition${linePart}:
+${elemString}
+
+Detail:
+  ${originalError.message}`;
+  throw new Error(msg);
+}
+function getLineNumber(xmlString, byteOffset) {
+  if (byteOffset === -1 || byteOffset >= xmlString.length) {
+    return -1;
+  }
+  const substring = xmlString.substring(0, byteOffset);
+  return substring.split("\n").length;
+}
+function extractXmlLines(originalXml, startOffset, endOffset) {
+  if (startOffset === -1 || endOffset === -1 || startOffset >= originalXml.length || endOffset > originalXml.length) {
+    return "[Unable to extract XML lines - invalid offsets]";
+  }
+  let lineStart = startOffset;
+  while (lineStart > 0 && originalXml[lineStart - 1] !== "\n") {
+    lineStart--;
+  }
+  let lineEnd = endOffset;
+  while (lineEnd < originalXml.length && originalXml[lineEnd] !== "\n") {
+    lineEnd++;
+  }
+  const relevantXml = originalXml.substring(lineStart, lineEnd);
+  return relevantXml;
+}
 export {
   canonicalFunctionId,
   canonicalId,
@@ -1500,6 +2105,9 @@ export {
   parseVensimExpr,
   parseVensimModel,
   parseVensimSubscriptRange,
+  parseXmileDimensionDef,
+  parseXmileModel,
+  parseXmileVariableDef,
   preprocessVensimModel,
   prettyPrintExpr,
   printExprStats,