@sdeverywhere/parse 0.1.1 → 0.1.3

package/dist/index.cjs

@@ -27,20 +27,50 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
+  canonicalFunctionId: () => canonicalFunctionId,
+  canonicalId: () => canonicalId,
+  canonicalVarId: () => canonicalVarId,
   debugPrintExpr: () => debugPrintExpr,
   parseVensimEquation: () => parseVensimEquation,
   parseVensimExpr: () => parseVensimExpr,
   parseVensimModel: () => parseVensimModel,
   parseVensimSubscriptRange: () => parseVensimSubscriptRange,
+  parseXmileDimensionDef: () => parseXmileDimensionDef,
+  parseXmileModel: () => parseXmileModel,
+  parseXmileVariableDef: () => parseXmileVariableDef,
+  preprocessVensimModel: () => preprocessVensimModel,
   prettyPrintExpr: () => prettyPrintExpr,
   printExprStats: () => printExprStats,
   reduceConditionals: () => reduceConditionals,
   reduceExpr: () => reduceExpr,
   toPrettyString: () => toPrettyString
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
+
+// src/_shared/canonical-id.js
+var reTrailingMark = new RegExp("\\s+!$", "g");
+var reWhitespace = new RegExp("(\\s|_)+", "g");
+var reSpecialChars = new RegExp(`['"\\.,\\-\\$&%\\/\\|()]`, "g");
+function canonicalId(name) {
+  return "_" + name.trim().replace(reTrailingMark, "!").replace(reWhitespace, "_").replace(reSpecialChars, "_").toLowerCase();
+}
+function canonicalVarId(name) {
+  const m = name.match(/([^[]+)(?:\[([^\]]+)\])?/);
+  if (!m) {
+    throw new Error(`Invalid variable name: ${name}`);
+  }
+  let id = canonicalId(m[1]);
+  if (m[2]) {
+    const subscripts = m[2].split(",").map((x) => canonicalId(x));
+    id += `[${subscripts.join(",")}]`;
+  }
+  return id;
+}
+function canonicalFunctionId(name) {
+  return canonicalId(name).toUpperCase();
+}
 
 // src/ast/print-expr.ts
 var import_assert_never = require("assert-never");
@@ -290,15 +320,13 @@ function fullIdForVarRef(varRef) {
 // src/ast/reduce-expr.ts
 var import_assert_never2 = require("assert-never");
 
-// src/_shared/names.js
-function canonicalName(name) {
-  return "_" + name.trim().replace(/"/g, "_").replace(/\s+!$/g, "!").replace(/\s/g, "_").replace(/,/g, "_").replace(/-/g, "_").replace(/\./g, "_").replace(/\$/g, "_").replace(/'/g, "_").replace(/&/g, "_").replace(/%/g, "_").replace(/\//g, "_").replace(/\|/g, "_").toLowerCase();
-}
-function cFunctionName(name) {
-  return canonicalName(name).toUpperCase();
-}
-
 // src/ast/ast-builders.ts
+function subRef(dimOrSubName) {
+  return {
+    subName: dimOrSubName,
+    subId: canonicalId(dimOrSubName)
+  };
+}
 function num(value, text) {
   return {
     kind: "number",
@@ -327,6 +355,13 @@ function parens(expr) {
     expr
   };
 }
+function lookupDef(points, range) {
+  return {
+    kind: "lookup-def",
+    range,
+    points
+  };
+}
 function lookupCall(varRef, arg) {
   return {
     kind: "lookup-call",
@@ -334,6 +369,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) {
@@ -673,7 +716,7 @@ var SubscriptRangeReader = class extends import_antlr4_vensim2.ModelVisitor {
     const ids = ctx.Id();
     if (ids.length === 1) {
       const dimName = ids[0].getText();
-      const dimId = canonicalName(dimName);
+      const dimId = canonicalId(dimName);
       super.visitSubscriptRange(ctx);
       return {
         dimName,
@@ -683,7 +726,7 @@ var SubscriptRangeReader = class extends import_antlr4_vensim2.ModelVisitor {
         subscriptRefs: this.subscriptNames.map((subName) => {
           return {
             subName,
-            subId: canonicalName(subName)
+            subId: canonicalId(subName)
           };
         }),
         subscriptMappings: this.subscriptMappings,
@@ -691,9 +734,9 @@ var SubscriptRangeReader = class extends import_antlr4_vensim2.ModelVisitor {
       };
     } else if (ids.length === 2) {
       const dimName = ids[0].getText();
-      const dimId = canonicalName(dimName);
+      const dimId = canonicalId(dimName);
       const familyName = ids[1].getText();
-      const familyId = canonicalName(familyName);
+      const familyId = canonicalId(familyName);
       return {
         dimName,
         dimId,
@@ -733,11 +776,11 @@ var SubscriptRangeReader = class extends import_antlr4_vensim2.ModelVisitor {
     super.visitSubscriptMapping(ctx);
     this.subscriptMappings.push({
       toDimName,
-      toDimId: canonicalName(toDimName),
+      toDimId: canonicalId(toDimName),
       subscriptRefs: this.mappedSubscriptNames.map((subName) => {
         return {
           subName,
-          subId: canonicalName(subName)
+          subId: canonicalId(subName)
         };
       })
     });
@@ -747,7 +790,7 @@ var SubscriptRangeReader = class extends import_antlr4_vensim2.ModelVisitor {
   }
   visitCall(ctx) {
     const fnName = ctx.Id().getText();
-    const fnId = cFunctionName(fnName);
+    const fnId = canonicalFunctionId(fnName);
     if (fnId === "_GET_DIRECT_SUBSCRIPT") {
       super.visitCall(ctx);
     } else {
@@ -843,7 +886,7 @@ var ExprReader = class extends import_antlr4_vensim3.ModelVisitor {
   //
   visitCall(ctx) {
     const vensimFnName = ctx.Id().getText();
-    const fnId = cFunctionName(vensimFnName);
+    const fnId = canonicalFunctionId(vensimFnName);
     this.callStack.push({ fn: fnId, args: [] });
     super.visitCall(ctx);
     const callInfo = this.callStack.pop();
@@ -866,14 +909,14 @@ var ExprReader = class extends import_antlr4_vensim3.ModelVisitor {
   }
   visitVar(ctx) {
     const vensimVarName = ctx.Id().getText().trim();
-    const varId = canonicalName(vensimVarName);
+    const varId = canonicalId(vensimVarName);
     this.subscripts = void 0;
     super.visitVar(ctx);
     const subscriptNames = this.subscripts;
     const subscriptRefs = subscriptNames?.map((name) => {
       return {
         subName: name,
-        subId: canonicalName(name)
+        subId: canonicalId(name)
       };
     });
     this.subscripts = void 0;
@@ -923,7 +966,7 @@ var ExprReader = class extends import_antlr4_vensim3.ModelVisitor {
   }
   visitLookupCall(ctx) {
     const lookupVarName = ctx.Id().getText();
-    const lookupVarId = canonicalName(lookupVarName);
+    const lookupVarId = canonicalId(lookupVarName);
     if (ctx.subscriptList()) {
       ctx.subscriptList().accept(this);
     }
@@ -931,7 +974,7 @@ var ExprReader = class extends import_antlr4_vensim3.ModelVisitor {
     const subscriptRefs = subscriptNames?.map((name) => {
       return {
         subName: name,
-        subId: canonicalName(name)
+        subId: canonicalId(name)
       };
     });
     this.subscripts = void 0;
@@ -1128,13 +1171,13 @@ var EquationReader = class extends import_antlr4_vensim4.ModelVisitor {
   }
   visitLhs(ctx) {
     const lhsVarName = ctx.Id().getText();
-    const lhsVarId = canonicalName(lhsVarName);
+    const lhsVarId = canonicalId(lhsVarName);
     super.visitLhs(ctx);
     const subscriptNames = this.subscripts;
     const subscriptRefs = subscriptNames?.map((name) => {
       return {
         subName: name,
-        subId: canonicalName(name)
+        subId: canonicalId(name)
       };
     });
     const exceptSubscriptSets = this.exceptSubscriptSets;
@@ -1142,7 +1185,7 @@ var EquationReader = class extends import_antlr4_vensim4.ModelVisitor {
       return subscriptSet.map((name) => {
         return {
           subName: name,
-          subId: canonicalName(name)
+          subId: canonicalId(name)
         };
       });
     });
@@ -1222,16 +1265,41 @@ function parseVensimEquation(input) {
 
 // src/vensim/preprocess-vensim.ts
 var import_split_string = __toESM(require("split-string"), 1);
-function preprocessVensimModel(input) {
+function preprocessVensimModel(input, options) {
+  const removalKeys = options?.removalKeys;
+  function shouldRemove(text) {
+    if (text.includes("TABBED ARRAY")) {
+      return true;
+    }
+    if (removalKeys) {
+      for (const key of removalKeys) {
+        if (text.includes(key)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  const macrosResult = removeMacros(input);
+  input = macrosResult.processed;
   const rawDefs = splitDefs(input);
   const vensimDefs = [];
+  const removedBlocks = [];
   for (const rawDef of rawDefs) {
+    if (shouldRemove(rawDef.text)) {
+      removedBlocks.push(rawDef.text.trim() + "|");
+      continue;
+    }
     const vensimDef = processDef(rawDef);
     if (vensimDef) {
       vensimDefs.push(vensimDef);
     }
   }
-  return vensimDefs;
+  return {
+    defs: vensimDefs,
+    removedMacros: macrosResult.removed,
+    removedBlocks
+  };
 }
 function splitDefs(input) {
   const defTexts = (0, import_split_string.default)(input, { separator: "|", quotes: ['"'], keep: () => true });
@@ -1273,6 +1341,9 @@ function splitDefs(input) {
 function splitLines(input) {
   return input.split(/\r\n|\n|\r/);
 }
+function splitExceptInQuoted(input, sep) {
+  return (0, import_split_string.default)(input, { separator: sep, quotes: ['"'] });
+}
 function processBackslashes(input) {
   const inputLines = splitLines(input);
   let output = "";
@@ -1318,22 +1389,27 @@ function replaceDelimitedStrings(str, open, close, newStr) {
 function reduceWhitespace(input) {
   return input.replace(/\s\s+/g, " ").trim();
 }
+var reWhitespace2 = new RegExp("(\\s|_)+", "g");
 function keyForDef(def) {
   let key = def;
   key = key.replace(/:INTERPOLATE:/g, "");
+  let kind;
   if (key.includes("=")) {
+    kind = "eqn";
     key = key.split("=")[0].trim();
   } else if (key.includes(":")) {
+    kind = "dim";
     key = key.split(":")[0].trim();
   } else {
+    kind = "decl";
   }
+  key = splitExceptInQuoted(key, "(")[0];
   key = key.replace(/"/g, "");
-  key = key.split("(")[0];
   key = key.trim();
-  key = key.replace(/\[\s*/g, "[");
-  key = key.replace(/\s*\]/g, "]");
+  key = key.replace(/(?<=\[).*?(?=\])/g, (match) => match.replace(/\s/g, ""));
+  key = key.replace(reWhitespace2, "_");
   key = key.toLowerCase();
-  return key;
+  return { key, kind };
 }
 function processDef(rawDef) {
   let input = rawDef.text;
@@ -1351,7 +1427,7 @@ function processDef(rawDef) {
 ${input}`);
   }
   const rawDefText = reduceWhitespace(parts[0]);
-  const key = keyForDef(rawDefText);
+  const { key, kind } = keyForDef(rawDefText);
   const def = `${rawDefText} ~~|`;
   const units = reduceWhitespace(parts[1]);
   const comment = reduceWhitespace(parts[2]);
@@ -1359,12 +1435,25 @@ ${input}`);
   return {
     key,
     def,
+    kind,
     line: rawDef.line,
     units,
     comment,
     ...group ? { group } : {}
   };
 }
+function removeMacros(input) {
+  const removed = [];
+  const processed = input.replace(/:MACRO:.*:END OF MACRO:/gms, (match) => {
+    removed.push(match);
+    const numBreaks = match.split(/\r\n|\n|\r/gms).length - 1;
+    return numBreaks > 0 ? "\n".repeat(numBreaks) : "";
+  });
+  return {
+    processed,
+    removed
+  };
+}
 
 // src/vensim/impl/model-reader.js
 var import_antlr4_vensim5 = require("antlr4-vensim");
@@ -1423,7 +1512,7 @@ var ModelReader = class extends import_antlr4_vensim5.ModelVisitor {
 function parseVensimModel(input, context, sort = false) {
   const dimensions = [];
   const equations = [];
-  const defs = preprocessVensimModel(input);
+  const { defs } = preprocessVensimModel(input);
   if (sort) {
     defs.sort((a, b) => {
       return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
@@ -1474,13 +1563,604 @@ Detail:
     equations
   };
 }
+
+// src/xmile/xml.ts
+var import_parse_xml = require("@rgrove/parse-xml");
+function firstElemOf(parent, tagName) {
+  return parent?.children.find((n) => {
+    if (n.type === import_parse_xml.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 === import_parse_xml.XmlNode.TYPE_TEXT;
+  });
+}
+function elemsOf(parent, tagNames) {
+  if (parent === void 0) {
+    return [];
+  }
+  const elems = [];
+  for (const n of parent.children) {
+    if (n.type === import_parse_xml.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
+var import_parse_xml2 = require("@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 = (0, import_parse_xml2.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;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  canonicalFunctionId,
+  canonicalId,
+  canonicalVarId,
   debugPrintExpr,
   parseVensimEquation,
   parseVensimExpr,
   parseVensimModel,
   parseVensimSubscriptRange,
+  parseXmileDimensionDef,
+  parseXmileModel,
+  parseXmileVariableDef,
+  preprocessVensimModel,
   prettyPrintExpr,
   printExprStats,
   reduceConditionals,