@tmlmt/cooklang-parser 2.1.7 → 3.0.0-alpha.3

package/dist/index.js

@@ -63,33 +63,10 @@ var CategoryConfig = class {
   }
 };
 
-// src/classes/section.ts
-var Section = class {
-  /**
-   * Creates an instance of Section.
-   * @param name - The name of the section. Defaults to an empty string.
-   */
-  constructor(name = "") {
-    /**
-     * The name of the section. Can be an empty string for the default (first) section.
-     * @defaultValue `""`
-     */
-    __publicField(this, "name");
-    /** An array of steps and notes that make up the content of the section. */
-    __publicField(this, "content", []);
-    this.name = name;
-  }
-  /**
-   * Checks if the section is blank (has no name and no content).
-   * Used during recipe parsing
-   * @returns `true` if the section is blank, otherwise `false`.
-   */
-  isBlank() {
-    return this.name === "" && this.content.length === 0;
-  }
-};
+// src/classes/product_catalog.ts
+import TOML from "smol-toml";
 
-// node_modules/.pnpm/human-regex@2.1.5_patch_hash=6d6bd9e233f99785a7c2187fd464edc114b76d47001dbb4eb6b5d72168de7460/node_modules/human-regex/dist/human-regex.esm.js
+// node_modules/.pnpm/human-regex@2.2.0/node_modules/human-regex/dist/human-regex.esm.js
 var t = /* @__PURE__ */ new Map();
 var r = { GLOBAL: "g", NON_SENSITIVE: "i", MULTILINE: "m", DOT_ALL: "s", UNICODE: "u", STICKY: "y" };
 var e = Object.freeze({ digit: "0-9", lowercaseLetter: "a-z", uppercaseLetter: "A-Z", letter: "a-zA-Z", alphanumeric: "a-zA-Z0-9", anyCharacter: "." });
@@ -150,7 +127,7 @@ var a = class {
     return this.add(".");
   }
   newline() {
-    return this.add("(?:\\r\\n|\\r|\\n)");
+    return this.add("(\\r\\n|\\r|\\n)");
   }
   negativeLookahead(t2) {
     return this.add(`(?!${t2})`);
@@ -291,19 +268,20 @@ var i = (() => {
 var metadataRegex = d().literal("---").newline().startCaptureGroup().anyCharacter().zeroOrMore().optional().endGroup().newline().literal("---").dotAll().toRegExp();
 var scalingMetaValueRegex = (varName) => d().startAnchor().literal(varName).literal(":").anyOf("\\t ").zeroOrMore().startCaptureGroup().startCaptureGroup().notAnyOf(",\\n").oneOrMore().endGroup().startGroup().literal(",").whitespace().zeroOrMore().startCaptureGroup().anyCharacter().oneOrMore().endGroup().endGroup().optional().endGroup().endAnchor().multiline().toRegExp();
 var nonWordChar = "\\s@#~\\[\\]{(,;:!?";
-var multiwordIngredient = d().literal("@").startNamedGroup("mIngredientModifiers").anyOf("@\\-&?").zeroOrMore().endGroup().optional().startNamedGroup("mIngredientRecipeAnchor").literal("./").endGroup().optional().startNamedGroup("mIngredientName").notAnyOf(nonWordChar).oneOrMore().startGroup().whitespace().oneOrMore().notAnyOf(nonWordChar).oneOrMore().endGroup().oneOrMore().notAnyOf("\\." + nonWordChar).endGroup().positiveLookahead("\\s*(?:\\{[^\\}]*\\}|\\([^)]*\\))").startGroup().literal("{").startNamedGroup("mIngredientQuantityModifier").literal("=").exactly(1).endGroup().optional().startNamedGroup("mIngredientQuantity").notAnyOf("}%").oneOrMore().endGroup().optional().startGroup().literal("%").startNamedGroup("mIngredientUnit").notAnyOf("}").oneOrMore().lazy().endGroup().endGroup().optional().literal("}").endGroup().optional().startGroup().literal("(").startNamedGroup("mIngredientPreparation").notAnyOf(")").oneOrMore().lazy().endGroup().literal(")").endGroup().optional().toRegExp();
-var singleWordIngredient = d().literal("@").startNamedGroup("sIngredientModifiers").anyOf("@\\-&?").zeroOrMore().endGroup().optional().startNamedGroup("sIngredientRecipeAnchor").literal("./").endGroup().optional().startNamedGroup("sIngredientName").notAnyOf(nonWordChar).zeroOrMore().notAnyOf("\\." + nonWordChar).endGroup().startGroup().literal("{").startNamedGroup("sIngredientQuantityModifier").literal("=").exactly(1).endGroup().optional().startNamedGroup("sIngredientQuantity").notAnyOf("}%").oneOrMore().endGroup().optional().startGroup().literal("%").startNamedGroup("sIngredientUnit").notAnyOf("}").oneOrMore().lazy().endGroup().endGroup().optional().literal("}").endGroup().optional().startGroup().literal("(").startNamedGroup("sIngredientPreparation").notAnyOf(")").oneOrMore().lazy().endGroup().literal(")").endGroup().optional().toRegExp();
+var nonWordCharStrict = "\\s@#~\\[\\]{(,;:!?|";
+var ingredientWithAlternativeRegex = d().literal("@").startNamedGroup("ingredientModifiers").anyOf("@\\-&?").zeroOrMore().endGroup().optional().startNamedGroup("ingredientRecipeAnchor").literal("./").endGroup().optional().startGroup().startGroup().startNamedGroup("mIngredientName").notAnyOf(nonWordChar).oneOrMore().startGroup().whitespace().oneOrMore().notAnyOf(nonWordChar).oneOrMore().endGroup().oneOrMore().endGroup().positiveLookahead("\\s*(?:\\{[^\\}]*\\}|\\([^)]*\\))").endGroup().or().startNamedGroup("sIngredientName").notAnyOf(nonWordChar).zeroOrMore().notAnyOf("\\." + nonWordChar).endGroup().endGroup().startGroup().literal("{").startNamedGroup("ingredientQuantityModifier").literal("=").exactly(1).endGroup().optional().startNamedGroup("ingredientQuantity").startGroup().notAnyOf("}|%").oneOrMore().endGroup().optional().startGroup().literal("%").notAnyOf("|}").oneOrMore().lazy().endGroup().optional().startGroup().literal("|").notAnyOf("}").oneOrMore().lazy().endGroup().zeroOrMore().endGroup().literal("}").endGroup().optional().startGroup().literal("(").startNamedGroup("ingredientPreparation").notAnyOf(")").oneOrMore().lazy().endGroup().literal(")").endGroup().optional().startGroup().literal("[").startNamedGroup("ingredientNote").notAnyOf("\\]").oneOrMore().lazy().endGroup().literal("]").endGroup().optional().startNamedGroup("ingredientAlternative").startGroup().literal("|").startGroup().anyOf("@\\-&?").zeroOrMore().endGroup().optional().startGroup().literal("./").endGroup().optional().startGroup().startGroup().startGroup().notAnyOf(nonWordChar).oneOrMore().startGroup().whitespace().oneOrMore().notAnyOf(nonWordChar).oneOrMore().endGroup().oneOrMore().endGroup().positiveLookahead("\\s*(?:\\{[^\\}]*\\}|\\([^)]*\\))").endGroup().or().startGroup().notAnyOf(nonWordChar).oneOrMore().endGroup().endGroup().startGroup().literal("{").startGroup().literal("=").exactly(1).endGroup().optional().startGroup().notAnyOf("}%").oneOrMore().endGroup().optional().startGroup().literal("%").startGroup().notAnyOf("}").oneOrMore().lazy().endGroup().endGroup().optional().literal("}").endGroup().optional().startGroup().literal("(").startGroup().notAnyOf(")").oneOrMore().lazy().endGroup().literal(")").endGroup().optional().startGroup().literal("[").startGroup().notAnyOf("\\]").oneOrMore().lazy().endGroup().literal("]").endGroup().optional().endGroup().zeroOrMore().endGroup().toRegExp();
+var inlineIngredientAlternativesRegex = new RegExp("\\|" + ingredientWithAlternativeRegex.source.slice(1));
+var quantityAlternativeRegex = d().startNamedGroup("ingredientQuantityValue").notAnyOf("}|%").oneOrMore().endGroup().optional().startGroup().literal("%").startNamedGroup("ingredientUnit").notAnyOf("|}").oneOrMore().endGroup().endGroup().optional().startGroup().literal("|").startNamedGroup("ingredientAltQuantity").startGroup().notAnyOf("}").oneOrMore().endGroup().zeroOrMore().endGroup().endGroup().optional().toRegExp();
+var ingredientWithGroupKeyRegex = d().literal("@|").startNamedGroup("gIngredientGroupKey").notAnyOf(nonWordCharStrict).oneOrMore().endGroup().literal("|").startNamedGroup("gIngredientModifiers").anyOf("@\\-&?").zeroOrMore().endGroup().optional().startNamedGroup("gIngredientRecipeAnchor").literal("./").endGroup().optional().startGroup().startGroup().startNamedGroup("gmIngredientName").notAnyOf(nonWordChar).oneOrMore().startGroup().whitespace().oneOrMore().notAnyOf(nonWordChar).oneOrMore().endGroup().oneOrMore().endGroup().positiveLookahead("\\s*(?:\\{[^\\}]*\\}|\\([^)]*\\))").endGroup().or().startNamedGroup("gsIngredientName").notAnyOf(nonWordChar).zeroOrMore().notAnyOf("\\." + nonWordChar).endGroup().endGroup().startGroup().literal("{").startNamedGroup("gIngredientQuantityModifier").literal("=").exactly(1).endGroup().optional().startNamedGroup("gIngredientQuantity").startGroup().notAnyOf("}|%").oneOrMore().endGroup().optional().startGroup().literal("%").notAnyOf("|}").oneOrMore().lazy().endGroup().optional().startGroup().literal("|").notAnyOf("}").oneOrMore().lazy().endGroup().zeroOrMore().endGroup().literal("}").endGroup().optional().startGroup().literal("(").startNamedGroup("gIngredientPreparation").notAnyOf(")").oneOrMore().lazy().endGroup().literal(")").endGroup().optional().toRegExp();
 var ingredientAliasRegex = d().startAnchor().startNamedGroup("ingredientListName").notAnyOf("|").oneOrMore().endGroup().literal("|").startNamedGroup("ingredientDisplayName").notAnyOf("|").oneOrMore().endGroup().endAnchor().toRegExp();
-var multiwordCookware = d().literal("#").startNamedGroup("mCookwareModifiers").anyOf("\\-&?").zeroOrMore().endGroup().startNamedGroup("mCookwareName").notAnyOf(nonWordChar).oneOrMore().startGroup().whitespace().oneOrMore().notAnyOf(nonWordChar).oneOrMore().endGroup().oneOrMore().notAnyOf("\\." + nonWordChar).endGroup().positiveLookahead("\\s*(?:\\{[^\\}]*\\})").literal("{").startNamedGroup("mCookwareQuantity").anyCharacter().zeroOrMore().lazy().endGroup().literal("}").toRegExp();
-var singleWordCookware = d().literal("#").startNamedGroup("sCookwareModifiers").anyOf("\\-&?").zeroOrMore().endGroup().startNamedGroup("sCookwareName").notAnyOf(nonWordChar).zeroOrMore().notAnyOf("\\." + nonWordChar).endGroup().startGroup().literal("{").startNamedGroup("sCookwareQuantity").anyCharacter().zeroOrMore().lazy().endGroup().literal("}").endGroup().optional().toRegExp();
-var timer = d().literal("~").startNamedGroup("timerName").anyCharacter().zeroOrMore().lazy().endGroup().literal("{").startNamedGroup("timerQuantity").anyCharacter().oneOrMore().lazy().endGroup().startGroup().literal("%").startNamedGroup("timerUnit").anyCharacter().oneOrMore().lazy().endGroup().endGroup().optional().literal("}").toRegExp();
+var cookwareRegex = d().literal("#").startNamedGroup("cookwareModifiers").anyOf("\\-&?").zeroOrMore().endGroup().startGroup().startGroup().startNamedGroup("mCookwareName").notAnyOf(nonWordChar).oneOrMore().startGroup().whitespace().oneOrMore().notAnyOf(nonWordChar).oneOrMore().endGroup().oneOrMore().endGroup().positiveLookahead("\\s*(?:\\{[^\\}]*\\})").endGroup().or().startNamedGroup("sCookwareName").notAnyOf(nonWordChar).zeroOrMore().notAnyOf("\\." + nonWordChar).endGroup().endGroup().startGroup().literal("{").startNamedGroup("cookwareQuantity").anyCharacter().zeroOrMore().lazy().endGroup().literal("}").endGroup().optional().toRegExp();
+var timerRegex = d().literal("~").startNamedGroup("timerName").anyCharacter().zeroOrMore().lazy().endGroup().literal("{").startNamedGroup("timerQuantity").anyCharacter().oneOrMore().lazy().endGroup().startGroup().literal("%").startNamedGroup("timerUnit").anyCharacter().oneOrMore().lazy().endGroup().endGroup().optional().literal("}").toRegExp();
 var tokensRegex = new RegExp(
   [
-    multiwordIngredient,
-    singleWordIngredient,
-    multiwordCookware,
-    singleWordCookware,
-    timer
+    ingredientWithGroupKeyRegex,
+    ingredientWithAlternativeRegex,
+    cookwareRegex,
+    timerRegex
   ].map((r2) => r2.source).join("|"),
   "gu"
 );
@@ -314,8 +292,7 @@ var rangeRegex = d().startAnchor().digit().oneOrMore().startGroup().anyOf(".,/")
 var numberLikeRegex = d().startAnchor().digit().oneOrMore().startGroup().anyOf(".,/").exactly(1).digit().oneOrMore().endGroup().optional().endAnchor().toRegExp();
 var floatRegex = d().startAnchor().digit().oneOrMore().startGroup().anyOf(".").exactly(1).digit().oneOrMore().endGroup().optional().endAnchor().toRegExp();
 
-// src/units.ts
-import Big from "big.js";
+// src/units/definitions.ts
 var units = [
   // Mass (Metric)
   {
@@ -445,20 +422,19 @@ for (const unit of units) {
 function normalizeUnit(unit = "") {
   return unitMap.get(unit.toLowerCase().trim());
 }
-var CannotAddTextValueError = class extends Error {
-  constructor() {
-    super("Cannot add a quantity with a text value.");
-    this.name = "CannotAddTextValueError";
-  }
-};
-var IncompatibleUnitsError = class extends Error {
-  constructor(unit1, unit2) {
-    super(
-      `Cannot add quantities with incompatible or unknown units: ${unit1} and ${unit2}`
-    );
-    this.name = "IncompatibleUnitsError";
-  }
-};
+var NO_UNIT = "__no-unit__";
+function resolveUnit(name = NO_UNIT, integerProtected = false) {
+  const normalizedUnit = normalizeUnit(name);
+  const resolvedUnit = normalizedUnit ? { ...normalizedUnit, name } : { name, type: "other", system: "none" };
+  return integerProtected ? { ...resolvedUnit, integerProtected: true } : resolvedUnit;
+}
+function isNoUnit(unit) {
+  if (!unit) return true;
+  return resolveUnit(unit.name).name === NO_UNIT;
+}
+
+// src/quantities/numeric.ts
+import Big from "big.js";
 function gcd(a2, b) {
   return b === 0 ? a2 : gcd(b, a2 % b);
 }
@@ -474,14 +450,23 @@ function simplifyFraction(num, den) {
     simplifiedDen = -simplifiedDen;
   }
   if (simplifiedDen === 1) {
-    return { type: "decimal", value: simplifiedNum };
+    return { type: "decimal", decimal: simplifiedNum };
   } else {
     return { type: "fraction", num: simplifiedNum, den: simplifiedDen };
   }
 }
+function getNumericValue(v) {
+  if (v.type === "decimal") {
+    return v.decimal;
+  }
+  return v.num / v.den;
+}
 function multiplyNumericValue(v, factor) {
   if (v.type === "decimal") {
-    return { type: "decimal", value: Big(v.value).times(factor).toNumber() };
+    return {
+      type: "decimal",
+      decimal: Big(v.decimal).times(factor).toNumber()
+    };
   }
   return simplifyFraction(Big(v.num).times(factor).toNumber(), v.den);
 }
@@ -491,36 +476,36 @@ function addNumericValues(val1, val2) {
   let num2;
   let den2;
   if (val1.type === "decimal") {
-    num1 = val1.value;
+    num1 = val1.decimal;
     den1 = 1;
   } else {
     num1 = val1.num;
     den1 = val1.den;
   }
   if (val2.type === "decimal") {
-    num2 = val2.value;
+    num2 = val2.decimal;
     den2 = 1;
   } else {
     num2 = val2.num;
     den2 = val2.den;
   }
   if (num1 === 0 && num2 === 0) {
-    return { type: "decimal", value: 0 };
+    return { type: "decimal", decimal: 0 };
   }
-  if (val1.type === "fraction" && val2.type === "fraction" || val1.type === "fraction" && val2.type === "decimal" && val2.value === 0 || val2.type === "fraction" && val1.type === "decimal" && val1.value === 0) {
+  if (val1.type === "fraction" && val2.type === "fraction" || val1.type === "fraction" && val2.type === "decimal" && val2.decimal === 0 || val2.type === "fraction" && val1.type === "decimal" && val1.decimal === 0) {
     const commonDen = den1 * den2;
     const sumNum = num1 * den2 + num2 * den1;
     return simplifyFraction(sumNum, commonDen);
   } else {
     return {
       type: "decimal",
-      value: Big(num1).div(den1).add(Big(num2).div(den2)).toNumber()
+      decimal: Big(num1).div(den1).add(Big(num2).div(den2)).toNumber()
     };
   }
 }
 var toRoundedDecimal = (v) => {
-  const value = v.type === "decimal" ? v.value : v.num / v.den;
-  return { type: "decimal", value: Math.floor(value * 100) / 100 };
+  const value = v.type === "decimal" ? v.decimal : v.num / v.den;
+  return { type: "decimal", decimal: Math.round(value * 1e3) / 1e3 };
 };
 function multiplyQuantityValue(value, factor) {
   if (value.type === "fixed") {
@@ -546,13 +531,139 @@ function multiplyQuantityValue(value, factor) {
     max: multiplyNumericValue(value.max, factor)
   };
 }
+function getAverageValue(q) {
+  if (q.type === "fixed") {
+    return q.value.type === "text" ? q.value.text : getNumericValue(q.value);
+  } else {
+    return (getNumericValue(q.min) + getNumericValue(q.max)) / 2;
+  }
+}
+
+// src/errors.ts
+var ReferencedItemCannotBeRedefinedError = class extends Error {
+  constructor(item_type, item_name, new_modifier) {
+    super(
+      `The referenced ${item_type} "${item_name}" cannot be redefined as ${new_modifier}.
+You can either remove the reference to create a new ${item_type} defined as ${new_modifier} or add the ${new_modifier} flag to the original definition of the ${item_type}`
+    );
+    this.name = "ReferencedItemCannotBeRedefinedError";
+  }
+};
+var NoProductCatalogForCartError = class extends Error {
+  constructor() {
+    super(
+      `Cannot build a cart without a product catalog. Please set one using setProductCatalog()`
+    );
+    this.name = "NoProductCatalogForCartError";
+  }
+};
+var NoShoppingListForCartError = class extends Error {
+  constructor() {
+    super(
+      `Cannot build a cart without a shopping list. Please set one using setShoppingList()`
+    );
+    this.name = "NoShoppingListForCartError";
+  }
+};
+var NoProductMatchError = class extends Error {
+  constructor(item_name, code) {
+    const messageMap = {
+      incompatibleUnits: `The units of the products in the catalogue are incompatible with ingredient ${item_name} in the shopping list.`,
+      noProduct: "No product was found linked to ingredient name ${item_name} in the shopping list",
+      textValue: `Ingredient ${item_name} has a text value as quantity and can therefore not be matched with any product in the catalogue.`,
+      noQuantity: `Ingredient ${item_name} has no quantity and can therefore not be matched with any product in the catalogue.`,
+      textValue_incompatibleUnits: `Multiple alternative quantities were provided for ingredient ${item_name} in the shopping list but they were either text values or no product in catalog were found to have compatible units`
+    };
+    super(messageMap[code]);
+    __publicField(this, "code");
+    this.code = code;
+    this.name = "NoProductMatchError";
+  }
+};
+var InvalidProductCatalogFormat = class extends Error {
+  constructor() {
+    super("Invalid product catalog format.");
+    this.name = "InvalidProductCatalogFormat";
+  }
+};
+var CannotAddTextValueError = class extends Error {
+  constructor() {
+    super("Cannot add a quantity with a text value.");
+    this.name = "CannotAddTextValueError";
+  }
+};
+var IncompatibleUnitsError = class extends Error {
+  constructor(unit1, unit2) {
+    super(
+      `Cannot add quantities with incompatible or unknown units: ${unit1} and ${unit2}`
+    );
+    this.name = "IncompatibleUnitsError";
+  }
+};
+var InvalidQuantityFormat = class extends Error {
+  constructor(value) {
+    super(`Invalid quantity format found in: ${value}`);
+    this.name = "InvalidQuantityFormat";
+  }
+};
+
+// src/utils/type_guards.ts
+function isGroup(x) {
+  return x && "type" in x;
+}
+function isOrGroup(x) {
+  return isGroup(x) && x.type === "or";
+}
+function isAndGroup(x) {
+  return isGroup(x) && x.type === "and";
+}
+function isQuantity(x) {
+  return x && typeof x === "object" && "quantity" in x;
+}
+function isNumericValueIntegerLike(v) {
+  if (v.type === "decimal") return Number.isInteger(v.decimal);
+  return v.num % v.den === 0;
+}
+function isValueIntegerLike(q) {
+  if (q.type === "fixed") {
+    if (q.value.type === "text") return false;
+    return isNumericValueIntegerLike(q.value);
+  }
+  return isNumericValueIntegerLike(q.min) && isNumericValueIntegerLike(q.max);
+}
+
+// src/quantities/mutations.ts
+function extendAllUnits(q) {
+  if (isGroup(q)) {
+    return { ...q, entries: q.entries.map(extendAllUnits) };
+  } else {
+    const newQ = {
+      quantity: q.quantity
+    };
+    if (q.unit) {
+      newQ.unit = { name: q.unit };
+    }
+    return newQ;
+  }
+}
+function normalizeAllUnits(q) {
+  if (isGroup(q)) {
+    return { ...q, entries: q.entries.map(normalizeAllUnits) };
+  } else {
+    const newQ = {
+      quantity: q.quantity,
+      unit: resolveUnit(q.unit)
+    };
+    return newQ;
+  }
+}
 var convertQuantityValue = (value, def, targetDef) => {
   if (def.name === targetDef.name) return value;
   const factor = def.toBase / targetDef.toBase;
   return multiplyQuantityValue(value, factor);
 };
 function getDefaultQuantityValue() {
-  return { type: "fixed", value: { type: "decimal", value: 0 } };
+  return { type: "fixed", value: { type: "decimal", decimal: 0 } };
 }
 function addQuantityValues(v1, v2) {
   if (v1.type === "fixed" && v1.value.type === "text" || v2.type === "fixed" && v2.value.type === "text") {
@@ -578,28 +689,31 @@ function addQuantityValues(v1, v2) {
   return { type: "range", min: newMin, max: newMax };
 }
 function addQuantities(q1, q2) {
-  const v1 = q1.value;
-  const v2 = q2.value;
+  const v1 = q1.quantity;
+  const v2 = q2.quantity;
   if (v1.type === "fixed" && v1.value.type === "text" || v2.type === "fixed" && v2.value.type === "text") {
     throw new CannotAddTextValueError();
   }
-  const unit1Def = normalizeUnit(q1.unit);
-  const unit2Def = normalizeUnit(q2.unit);
-  const addQuantityValuesAndSetUnit = (val1, val2, unit) => ({ value: addQuantityValues(val1, val2), unit });
-  if ((q1.unit === "" || q1.unit === void 0) && q2.unit !== void 0) {
+  const unit1Def = normalizeUnit(q1.unit?.name);
+  const unit2Def = normalizeUnit(q2.unit?.name);
+  const addQuantityValuesAndSetUnit = (val1, val2, unit) => ({
+    quantity: addQuantityValues(val1, val2),
+    unit
+  });
+  if ((q1.unit?.name === "" || q1.unit === void 0) && q2.unit !== void 0) {
     return addQuantityValuesAndSetUnit(v1, v2, q2.unit);
   }
-  if ((q2.unit === "" || q2.unit === void 0) && q1.unit !== void 0) {
+  if ((q2.unit?.name === "" || q2.unit === void 0) && q1.unit !== void 0) {
     return addQuantityValuesAndSetUnit(v1, v2, q1.unit);
   }
-  if (!q1.unit && !q2.unit || q1.unit && q2.unit && q1.unit.toLowerCase() === q2.unit.toLowerCase()) {
+  if (!q1.unit && !q2.unit || q1.unit && q2.unit && q1.unit.name.toLowerCase() === q2.unit.name.toLowerCase()) {
     return addQuantityValuesAndSetUnit(v1, v2, q1.unit);
   }
   if (unit1Def && unit2Def) {
     if (unit1Def.type !== unit2Def.type) {
       throw new IncompatibleUnitsError(
-        `${unit1Def.type} (${q1.unit})`,
-        `${unit2Def.type} (${q2.unit})`
+        `${unit1Def.type} (${q1.unit?.name})`,
+        `${unit2Def.type} (${q2.unit?.name})`
       );
     }
     let targetUnitDef;
@@ -613,27 +727,131 @@ function addQuantities(q1, q2) {
     }
     const convertedV1 = convertQuantityValue(v1, unit1Def, targetUnitDef);
     const convertedV2 = convertQuantityValue(v2, unit2Def, targetUnitDef);
-    return addQuantityValuesAndSetUnit(
-      convertedV1,
-      convertedV2,
-      targetUnitDef.name
-    );
+    const targetUnit = { name: targetUnitDef.name };
+    return addQuantityValuesAndSetUnit(convertedV1, convertedV2, targetUnit);
   }
-  throw new IncompatibleUnitsError(q1.unit, q2.unit);
+  throw new IncompatibleUnitsError(
+    q1.unit?.name,
+    q2.unit?.name
+  );
 }
-
-// src/errors.ts
-var ReferencedItemCannotBeRedefinedError = class extends Error {
-  constructor(item_type, item_name, new_modifier) {
-    super(
-      `The referenced ${item_type} "${item_name}" cannot be redefined as ${new_modifier}.
-You can either remove the reference to create a new ${item_type} defined as ${new_modifier} or add the ${new_modifier} flag to the original definition of the ${item_type}`
+function toPlainUnit(quantity) {
+  if (isQuantity(quantity))
+    return quantity.unit ? { ...quantity, unit: quantity.unit.name } : quantity;
+  else {
+    return {
+      ...quantity,
+      entries: quantity.entries.map(toPlainUnit)
+    };
+  }
+}
+function toExtendedUnit(q) {
+  if (isQuantity(q)) {
+    return q.unit ? { ...q, unit: { name: q.unit } } : q;
+  } else {
+    return {
+      ...q,
+      entries: q.entries.map(
+        (entry) => isQuantity(entry) ? toExtendedUnit(entry) : toExtendedUnit(entry)
+      )
+    };
+  }
+}
+function deNormalizeQuantity(q) {
+  const result = {
+    quantity: q.quantity
+  };
+  if (!isNoUnit(q.unit)) {
+    result.unit = { name: q.unit.name };
+  }
+  return result;
+}
+var flattenPlainUnitGroup = (summed) => {
+  if (isOrGroup(summed)) {
+    const entries = summed.entries;
+    const andGroupEntry = entries.find(
+      (e2) => isGroup(e2) && e2.type === "and"
     );
-    this.name = "ReferencedItemCannotBeRedefinedError";
+    if (andGroupEntry) {
+      const andEntries = [];
+      for (const entry of andGroupEntry.entries) {
+        if (isQuantity(entry)) {
+          andEntries.push({
+            quantity: entry.quantity,
+            unit: entry.unit
+          });
+        }
+      }
+      const equivalentsList = entries.filter((e2) => isQuantity(e2)).map((e2) => ({ quantity: e2.quantity, unit: e2.unit }));
+      if (equivalentsList.length > 0) {
+        return [
+          {
+            type: "and",
+            entries: andEntries,
+            equivalents: equivalentsList
+          }
+        ];
+      } else {
+        return andEntries.map((entry) => ({ groupQuantity: entry }));
+      }
+    }
+    const simpleEntries = entries.filter(
+      (e2) => isQuantity(e2)
+    );
+    if (simpleEntries.length > 0) {
+      const result = {
+        quantity: simpleEntries[0].quantity,
+        unit: simpleEntries[0].unit
+      };
+      if (simpleEntries.length > 1) {
+        result.equivalents = simpleEntries.slice(1);
+      }
+      return [{ groupQuantity: result }];
+    } else {
+      const first = entries[0];
+      return [
+        { groupQuantity: { quantity: first.quantity, unit: first.unit } }
+      ];
+    }
+  } else if (isGroup(summed)) {
+    const andEntries = [];
+    const equivalentsList = [];
+    for (const entry of summed.entries) {
+      if (isOrGroup(entry)) {
+        const orEntries = entry.entries.filter(
+          (e2) => isQuantity(e2)
+        );
+        if (orEntries.length > 0) {
+          andEntries.push({
+            quantity: orEntries[0].quantity,
+            unit: orEntries[0].unit
+          });
+          equivalentsList.push(...orEntries.slice(1));
+        }
+      } else if (isQuantity(entry)) {
+        andEntries.push({
+          quantity: entry.quantity,
+          unit: entry.unit
+        });
+      }
+    }
+    if (equivalentsList.length === 0) {
+      return andEntries.map((entry) => ({ groupQuantity: entry }));
+    }
+    const result = {
+      type: "and",
+      entries: andEntries,
+      equivalents: equivalentsList
+    };
+    return [result];
+  } else {
+    return [
+      { groupQuantity: { quantity: summed.quantity, unit: summed.unit } }
+    ];
   }
 };
 
-// src/parser_helpers.ts
+// src/utils/parser_helpers.ts
 function flushPendingNote(section, note) {
   if (note.length > 0) {
     section.content.push({ type: "note", note });
@@ -650,7 +868,7 @@ function flushPendingItems(section, items) {
   return false;
 }
 function findAndUpsertIngredient(ingredients, newIngredient, isReference) {
-  const { name, quantity, unit } = newIngredient;
+  const { name } = newIngredient;
   if (isReference) {
     const indexFind = ingredients.findIndex(
       (i2) => i2.name.toLowerCase() === name.toLowerCase()
@@ -661,52 +879,28 @@ function findAndUpsertIngredient(ingredients, newIngredient, isReference) {
       );
     }
     const existingIngredient = ingredients[indexFind];
-    for (const flag of newIngredient.flags) {
-      if (!existingIngredient.flags.includes(flag)) {
+    if (!newIngredient.flags) {
+      if (Array.isArray(existingIngredient.flags) && existingIngredient.flags.length > 0) {
         throw new ReferencedItemCannotBeRedefinedError(
           "ingredient",
           existingIngredient.name,
-          flag
+          existingIngredient.flags[0]
         );
       }
-    }
-    let quantityPartIndex = void 0;
-    if (quantity !== void 0) {
-      const currentQuantity = {
-        value: existingIngredient.quantity ?? getDefaultQuantityValue(),
-        unit: existingIngredient.unit ?? ""
-      };
-      const newQuantity = { value: quantity, unit: unit ?? "" };
-      try {
-        const total = addQuantities(currentQuantity, newQuantity);
-        existingIngredient.quantity = total.value;
-        existingIngredient.unit = total.unit || void 0;
-        if (existingIngredient.quantityParts) {
-          existingIngredient.quantityParts.push(
-            ...newIngredient.quantityParts
+    } else {
+      for (const flag of newIngredient.flags) {
+        if (existingIngredient.flags === void 0 || !existingIngredient.flags.includes(flag)) {
+          throw new ReferencedItemCannotBeRedefinedError(
+            "ingredient",
+            existingIngredient.name,
+            flag
           );
-        } else {
-          existingIngredient.quantityParts = newIngredient.quantityParts;
-        }
-        quantityPartIndex = existingIngredient.quantityParts.length - 1;
-      } catch (e2) {
-        if (e2 instanceof IncompatibleUnitsError || e2 instanceof CannotAddTextValueError) {
-          return {
-            ingredientIndex: ingredients.push(newIngredient) - 1,
-            quantityPartIndex: 0
-          };
         }
       }
     }
-    return {
-      ingredientIndex: indexFind,
-      quantityPartIndex
-    };
+    return indexFind;
   }
-  return {
-    ingredientIndex: ingredients.push(newIngredient) - 1,
-    quantityPartIndex: newIngredient.quantity ? 0 : void 0
-  };
+  return ingredients.push(newIngredient) - 1;
 }
 function findAndUpsertCookware(cookware, newCookware, isReference) {
   const { name, quantity } = newCookware;
@@ -720,58 +914,48 @@ function findAndUpsertCookware(cookware, newCookware, isReference) {
       );
     }
     const existingCookware = cookware[index];
-    for (const flag of newCookware.flags) {
-      if (!existingCookware.flags.includes(flag)) {
+    if (!newCookware.flags) {
+      if (Array.isArray(existingCookware.flags) && existingCookware.flags.length > 0) {
         throw new ReferencedItemCannotBeRedefinedError(
           "cookware",
           existingCookware.name,
-          flag
+          existingCookware.flags[0]
         );
       }
+    } else {
+      for (const flag of newCookware.flags) {
+        if (existingCookware.flags === void 0 || !existingCookware.flags.includes(flag)) {
+          throw new ReferencedItemCannotBeRedefinedError(
+            "cookware",
+            existingCookware.name,
+            flag
+          );
+        }
+      }
     }
-    let quantityPartIndex = void 0;
     if (quantity !== void 0) {
       if (!existingCookware.quantity) {
         existingCookware.quantity = quantity;
-        existingCookware.quantityParts = newCookware.quantityParts;
-        quantityPartIndex = 0;
       } else {
         try {
           existingCookware.quantity = addQuantityValues(
             existingCookware.quantity,
             quantity
           );
-          if (!existingCookware.quantityParts) {
-            existingCookware.quantityParts = newCookware.quantityParts;
-            quantityPartIndex = 0;
-          } else {
-            quantityPartIndex = existingCookware.quantityParts.push(
-              ...newCookware.quantityParts
-            ) - 1;
-          }
         } catch (e2) {
           if (e2 instanceof CannotAddTextValueError) {
-            return {
-              cookwareIndex: cookware.push(newCookware) - 1,
-              quantityPartIndex: 0
-            };
+            return cookware.push(newCookware) - 1;
           }
         }
       }
     }
-    return {
-      cookwareIndex: index,
-      quantityPartIndex
-    };
+    return index;
   }
-  return {
-    cookwareIndex: cookware.push(newCookware) - 1,
-    quantityPartIndex: quantity ? 0 : void 0
-  };
+  return cookware.push(newCookware) - 1;
 }
 var parseFixedValue = (input_str) => {
   if (!numberLikeRegex.test(input_str)) {
-    return { type: "text", value: input_str };
+    return { type: "text", text: input_str };
   }
   const s = input_str.trim().replace(",", ".");
   if (s.includes("/")) {
@@ -780,8 +964,22 @@ var parseFixedValue = (input_str) => {
     const den = Number(parts[1]);
     return { type: "fraction", num, den };
   }
-  return { type: "decimal", value: Number(s) };
+  return { type: "decimal", decimal: Number(s) };
 };
+function stringifyQuantityValue(quantity) {
+  if (quantity.type === "fixed") {
+    return stringifyFixedValue(quantity);
+  } else {
+    return `${stringifyFixedValue({ type: "fixed", value: quantity.min })}-${stringifyFixedValue({ type: "fixed", value: quantity.max })}`;
+  }
+}
+function stringifyFixedValue(quantity) {
+  if (quantity.value.type === "fraction")
+    return `${quantity.value.num}/${quantity.value.den}`;
+  else if (quantity.value.type === "decimal")
+    return String(quantity.value.decimal);
+  else return quantity.value.text;
+}
 function parseQuantityInput(input_str) {
   const clean_str = String(input_str).trim();
   if (rangeRegex.test(clean_str)) {
@@ -823,7 +1021,7 @@ function parseListMetaVar(content, varName) {
 function extractMetadata(content) {
   const metadata = {};
   let servings = void 0;
-  const metadataContent = content.match(metadataRegex)?.[1];
+  const metadataContent = content.match(metadataRegex)?.[2];
   if (!metadataContent) {
     return { metadata };
   }
@@ -868,74 +1066,1168 @@ function extractMetadata(content) {
   }
   return { metadata, servings };
 }
+function isPositiveIntegerString(str) {
+  return /^\d+$/.test(str);
+}
+function unionOfSets(s1, s2) {
+  const result = new Set(s1);
+  for (const item of s2) {
+    result.add(item);
+  }
+  return result;
+}
+function getAlternativeSignature(alternatives) {
+  if (!alternatives || alternatives.length === 0) return null;
+  return alternatives.map((a2) => a2.index).sort((a2, b) => a2 - b).join(",");
+}
 
-// src/classes/recipe.ts
-import Big2 from "big.js";
-var Recipe = class _Recipe {
+// src/classes/product_catalog.ts
+var ProductCatalog = class {
+  constructor(tomlContent) {
+    __publicField(this, "products", []);
+    if (tomlContent) this.parse(tomlContent);
+  }
   /**
-   * Creates a new Recipe instance.
-   * @param content - The recipe content to parse.
+   * Parses a TOML string into a list of product options.
+   * @param tomlContent - The TOML string to parse.
+   * @returns A parsed list of `ProductOption`.
    */
-  constructor(content) {
-    /**
-     * The parsed recipe metadata.
-     */
-    __publicField(this, "metadata", {});
-    /**
-     * The parsed recipe ingredients.
-     */
-    __publicField(this, "ingredients", []);
-    /**
-     * The parsed recipe sections.
-     */
-    __publicField(this, "sections", []);
-    /**
-     * The parsed recipe cookware.
-     */
-    __publicField(this, "cookware", []);
-    /**
-     * The parsed recipe timers.
-     */
-    __publicField(this, "timers", []);
-    /**
-     * The parsed recipe servings. Used for scaling. Parsed from one of
-     * {@link Metadata.servings}, {@link Metadata.yield} or {@link Metadata.serves}
-     * metadata fields.
-     *
-     * @see {@link Recipe.scaleBy | scaleBy()} and {@link Recipe.scaleTo | scaleTo()} methods
-     */
-    __publicField(this, "servings");
-    if (content) {
-      this.parse(content);
+  parse(tomlContent) {
+    const catalogRaw = TOML.parse(tomlContent);
+    this.products = [];
+    if (!this.isValidTomlContent(catalogRaw)) {
+      throw new InvalidProductCatalogFormat();
     }
+    for (const [ingredientName, ingredientData] of Object.entries(catalogRaw)) {
+      const ingredientTable = ingredientData;
+      const aliases = ingredientTable.aliases;
+      for (const [key, productData] of Object.entries(ingredientTable)) {
+        if (key === "aliases") {
+          continue;
+        }
+        const productId = key;
+        const { name, size, price, ...rest } = productData;
+        const sizeStrings = Array.isArray(size) ? size : [size];
+        const sizes = sizeStrings.map((sizeStr) => {
+          const sizeAndUnitRaw = sizeStr.split("%");
+          const sizeParsed = parseQuantityInput(
+            sizeAndUnitRaw[0]
+          );
+          const productSize = { size: sizeParsed };
+          if (sizeAndUnitRaw.length > 1) {
+            productSize.unit = sizeAndUnitRaw[1];
+          }
+          return productSize;
+        });
+        const productOption = {
+          id: productId,
+          productName: name,
+          ingredientName,
+          price,
+          sizes,
+          ...rest
+        };
+        if (aliases) {
+          productOption.ingredientAliases = aliases;
+        }
+        this.products.push(productOption);
+      }
+    }
+    return this.products;
   }
   /**
-   * Parses a recipe from a string.
-   * @param content - The recipe content to parse.
+   * Stringifies the catalog to a TOML string.
+   * @returns The TOML string representation of the catalog.
    */
-  parse(content) {
-    const cleanContent = content.replace(metadataRegex, "").replace(commentRegex, "").replace(blockCommentRegex, "").trim().split(/\r\n?|\n/);
-    const { metadata, servings } = extractMetadata(content);
-    this.metadata = metadata;
-    this.servings = servings;
-    let blankLineBefore = true;
-    let section = new Section();
-    const items = [];
-    let note = "";
-    let inNote = false;
-    for (const line of cleanContent) {
-      if (line.trim().length === 0) {
-        flushPendingItems(section, items);
-        note = flushPendingNote(section, note);
-        blankLineBefore = true;
-        inNote = false;
-        continue;
+  stringify() {
+    const grouped = {};
+    for (const product of this.products) {
+      const {
+        id,
+        ingredientName,
+        ingredientAliases,
+        sizes,
+        productName,
+        ...rest
+      } = product;
+      if (!grouped[ingredientName]) {
+        grouped[ingredientName] = {};
       }
-      if (line.startsWith("=")) {
-        flushPendingItems(section, items);
-        note = flushPendingNote(section, note);
-        if (this.sections.length === 0 && section.isBlank()) {
-          section.name = line.replace(/^=+|=+$/g, "").trim();
+      if (ingredientAliases && !grouped[ingredientName].aliases) {
+        grouped[ingredientName].aliases = ingredientAliases;
+      }
+      const sizeStrings = sizes.map(
+        (s) => s.unit ? `${stringifyQuantityValue(s.size)}%${s.unit}` : stringifyQuantityValue(s.size)
+      );
+      grouped[ingredientName][id] = {
+        ...rest,
+        name: productName,
+        // Use array if multiple sizes, otherwise single string
+        size: sizeStrings.length === 1 ? sizeStrings[0] : sizeStrings
+      };
+    }
+    return TOML.stringify(grouped);
+  }
+  /**
+   * Adds a product to the catalog.
+   * @param productOption - The product to add.
+   */
+  add(productOption) {
+    this.products.push(productOption);
+  }
+  /**
+   * Removes a product from the catalog by its ID.
+   * @param productId - The ID of the product to remove.
+   */
+  remove(productId) {
+    this.products = this.products.filter((product) => product.id !== productId);
+  }
+  isValidTomlContent(catalog) {
+    for (const productsRaw of Object.values(catalog)) {
+      if (typeof productsRaw !== "object" || productsRaw === null) {
+        return false;
+      }
+      for (const [id, obj] of Object.entries(productsRaw)) {
+        if (id === "aliases") {
+          if (!Array.isArray(obj)) {
+            return false;
+          }
+        } else {
+          if (!isPositiveIntegerString(id)) {
+            return false;
+          }
+          if (typeof obj !== "object" || obj === null) {
+            return false;
+          }
+          const record = obj;
+          const keys = Object.keys(record);
+          const mandatoryKeys = ["name", "size", "price"];
+          if (mandatoryKeys.some((key) => !keys.includes(key))) {
+            return false;
+          }
+          const hasProductName = typeof record.name === "string";
+          const hasSize = typeof record.size === "string" || Array.isArray(record.size) && record.size.every((s) => typeof s === "string");
+          const hasPrice = typeof record.price === "number";
+          if (!(hasProductName && hasSize && hasPrice)) {
+            return false;
+          }
+        }
+      }
+    }
+    return true;
+  }
+};
+
+// src/classes/section.ts
+var Section = class {
+  /**
+   * Creates an instance of Section.
+   * @param name - The name of the section. Defaults to an empty string.
+   */
+  constructor(name = "") {
+    /**
+     * The name of the section. Can be an empty string for the default (first) section.
+     * @defaultValue `""`
+     */
+    __publicField(this, "name");
+    /** An array of steps and notes that make up the content of the section. */
+    __publicField(this, "content", []);
+    this.name = name;
+  }
+  /**
+   * Checks if the section is blank (has no name and no content).
+   * Used during recipe parsing
+   * @returns `true` if the section is blank, otherwise `false`.
+   */
+  isBlank() {
+    return this.name === "" && this.content.length === 0;
+  }
+};
+
+// src/quantities/alternatives.ts
+import Big3 from "big.js";
+
+// src/units/conversion.ts
+import Big2 from "big.js";
+function getUnitRatio(q1, q2) {
+  const q1Value = getAverageValue(q1.quantity);
+  const q2Value = getAverageValue(q2.quantity);
+  const factor = "toBase" in q1.unit && "toBase" in q2.unit ? q1.unit.toBase / q2.unit.toBase : 1;
+  if (typeof q1Value !== "number" || typeof q2Value !== "number") {
+    throw Error(
+      "One of both values is not a number, so a ratio cannot be computed"
+    );
+  }
+  return Big2(q1Value).times(factor).div(q2Value);
+}
+function getBaseUnitRatio(q, qRef) {
+  if ("toBase" in q.unit && "toBase" in qRef.unit) {
+    return q.unit.toBase / qRef.unit.toBase;
+  } else {
+    return 1;
+  }
+}
+
+// src/units/lookup.ts
+function areUnitsCompatible(u1, u2) {
+  if (u1.name === u2.name) {
+    return true;
+  }
+  if (u1.type !== "other" && u1.type === u2.type && u1.system === u2.system) {
+    return true;
+  }
+  return false;
+}
+function findListWithCompatibleQuantity(list, quantity) {
+  const quantityWithUnitDef = {
+    ...quantity,
+    unit: resolveUnit(quantity.unit?.name)
+  };
+  return list.find(
+    (l) => l.some((lq) => areUnitsCompatible(lq.unit, quantityWithUnitDef.unit))
+  );
+}
+function findCompatibleQuantityWithinList(list, quantity) {
+  const quantityWithUnitDef = {
+    ...quantity,
+    unit: resolveUnit(quantity.unit?.name)
+  };
+  return list.find(
+    (q) => q.unit.name === quantityWithUnitDef.unit.name || q.unit.type === quantityWithUnitDef.unit.type && q.unit.type !== "other"
+  );
+}
+
+// src/utils/general.ts
+var legacyDeepClone = (v) => {
+  if (v === null || typeof v !== "object") {
+    return v;
+  }
+  if (v instanceof Map) {
+    return new Map(
+      Array.from(v.entries()).map(([k, val]) => [
+        legacyDeepClone(k),
+        legacyDeepClone(val)
+      ])
+    );
+  }
+  if (v instanceof Set) {
+    return new Set(Array.from(v).map((val) => legacyDeepClone(val)));
+  }
+  if (v instanceof Date) {
+    return new Date(v.getTime());
+  }
+  if (Array.isArray(v)) {
+    return v.map((item) => legacyDeepClone(item));
+  }
+  const cloned = {};
+  for (const key of Object.keys(v)) {
+    cloned[key] = legacyDeepClone(v[key]);
+  }
+  return cloned;
+};
+var deepClone = (v) => typeof structuredClone === "function" ? structuredClone(v) : legacyDeepClone(v);
+
+// src/quantities/alternatives.ts
+function getEquivalentUnitsLists(...quantities) {
+  const quantitiesCopy = deepClone(quantities);
+  const OrGroups = quantitiesCopy.filter(isOrGroup).filter((q) => q.entries.length > 1);
+  const unitLists = [];
+  const normalizeOrGroup = (og) => ({
+    ...og,
+    entries: og.entries.map((q) => ({
+      ...q,
+      unit: resolveUnit(q.unit?.name, q.unit?.integerProtected)
+    }))
+  });
+  function findLinkIndexForUnits(lists, unitsToCheck) {
+    return lists.findIndex((l) => {
+      const listItem = l.map((q) => resolveUnit(q.unit?.name));
+      return unitsToCheck.some(
+        (u) => listItem.some(
+          (lu) => lu.name === u?.name || lu.system === u?.system && lu.type === u?.type && lu.type !== "other"
+        )
+      );
+    });
+  }
+  function mergeOrGroupIntoList(lists, idx, og) {
+    let unitRatio;
+    const commonUnitList = lists[idx].reduce((acc, v) => {
+      const normalizedV = {
+        ...v,
+        unit: resolveUnit(v.unit?.name, v.unit?.integerProtected)
+      };
+      const commonQuantity = og.entries.find(
+        (q) => isQuantity(q) && areUnitsCompatible(q.unit, normalizedV.unit)
+      );
+      if (commonQuantity) {
+        acc.push(normalizedV);
+        unitRatio = getUnitRatio(normalizedV, commonQuantity);
+      }
+      return acc;
+    }, []);
+    for (const newQ of og.entries) {
+      if (commonUnitList.some((q) => areUnitsCompatible(q.unit, newQ.unit))) {
+        continue;
+      } else {
+        const scaledQuantity = multiplyQuantityValue(newQ.quantity, unitRatio);
+        lists[idx].push({ ...newQ, quantity: scaledQuantity });
+      }
+    }
+  }
+  for (const orGroup of OrGroups) {
+    const orGroupModified = normalizeOrGroup(orGroup);
+    const units2 = orGroupModified.entries.map((q) => q.unit);
+    const linkIndex = findLinkIndexForUnits(unitLists, units2);
+    if (linkIndex === -1) {
+      unitLists.push(orGroupModified.entries);
+    } else {
+      mergeOrGroupIntoList(unitLists, linkIndex, orGroupModified);
+    }
+  }
+  return unitLists;
+}
+function sortUnitList(list) {
+  if (!list || list.length <= 1) return list;
+  const priorityList = [];
+  const nonPriorityList = [];
+  for (const q of list) {
+    if (q.unit.integerProtected || q.unit.system === "none") {
+      priorityList.push(q);
+    } else {
+      nonPriorityList.push(q);
+    }
+  }
+  return priorityList.sort((a2, b) => {
+    const prefixA = a2.unit.integerProtected ? "___" : "";
+    const prefixB = b.unit.integerProtected ? "___" : "";
+    return (prefixA + a2.unit.name).localeCompare(prefixB + b.unit.name, "en");
+  }).concat(nonPriorityList);
+}
+function reduceOrsToFirstEquivalent(unitList, quantities) {
+  function reduceToQuantity(firstQuantity) {
+    const equivalentList = sortUnitList(
+      findListWithCompatibleQuantity(unitList, firstQuantity)
+    );
+    if (!equivalentList) return firstQuantity;
+    const firstQuantityInList = findCompatibleQuantityWithinList(
+      equivalentList,
+      firstQuantity
+    );
+    const normalizedFirstQuantity = {
+      ...firstQuantity,
+      unit: resolveUnit(firstQuantity.unit?.name)
+    };
+    if (firstQuantityInList.unit.integerProtected) {
+      const resultQuantity = {
+        quantity: firstQuantity.quantity
+      };
+      if (!isNoUnit(normalizedFirstQuantity.unit)) {
+        resultQuantity.unit = { name: normalizedFirstQuantity.unit.name };
+      }
+      return resultQuantity;
+    } else {
+      let nextProtected;
+      const equivalentListTemp = [...equivalentList];
+      while (nextProtected !== -1) {
+        nextProtected = equivalentListTemp.findIndex(
+          (eq) => eq.unit?.integerProtected
+        );
+        if (nextProtected !== -1) {
+          const unitRatio2 = getUnitRatio(
+            equivalentListTemp[nextProtected],
+            firstQuantityInList
+          );
+          const nextProtectedQuantityValue = multiplyQuantityValue(
+            firstQuantity.quantity,
+            unitRatio2
+          );
+          if (isValueIntegerLike(nextProtectedQuantityValue)) {
+            const nextProtectedQuantity = {
+              quantity: nextProtectedQuantityValue
+            };
+            if (!isNoUnit(equivalentListTemp[nextProtected].unit)) {
+              nextProtectedQuantity.unit = {
+                name: equivalentListTemp[nextProtected].unit.name
+              };
+            }
+            return nextProtectedQuantity;
+          } else {
+            equivalentListTemp.splice(nextProtected, 1);
+          }
+        }
+      }
+      const firstNonIntegerProtected = equivalentListTemp.filter(
+        (q) => !q.unit.integerProtected
+      )[0];
+      const unitRatio = getUnitRatio(
+        firstNonIntegerProtected,
+        firstQuantityInList
+      ).times(getBaseUnitRatio(normalizedFirstQuantity, firstQuantityInList));
+      const firstEqQuantity = {
+        quantity: firstNonIntegerProtected.unit.name === firstQuantity.unit.name ? firstQuantity.quantity : multiplyQuantityValue(firstQuantity.quantity, unitRatio)
+      };
+      if (!isNoUnit(firstNonIntegerProtected.unit)) {
+        firstEqQuantity.unit = { name: firstNonIntegerProtected.unit.name };
+      }
+      return firstEqQuantity;
+    }
+  }
+  return quantities.map((q) => {
+    if (isQuantity(q)) return reduceToQuantity(q);
+    const qListModified = sortUnitList(
+      q.entries.map((qq) => ({
+        ...qq,
+        unit: resolveUnit(qq.unit?.name, qq.unit?.integerProtected)
+      }))
+    );
+    return reduceToQuantity(qListModified[0]);
+  });
+}
+function addQuantitiesOrGroups(...quantities) {
+  if (quantities.length === 0)
+    return {
+      sum: {
+        quantity: getDefaultQuantityValue(),
+        unit: resolveUnit()
+      },
+      unitsLists: []
+    };
+  if (quantities.length === 1) {
+    if (isQuantity(quantities[0]))
+      return {
+        sum: {
+          ...quantities[0],
+          unit: resolveUnit(quantities[0].unit?.name)
+        },
+        unitsLists: []
+      };
+  }
+  const unitsLists = getEquivalentUnitsLists(...quantities);
+  const reducedQuantities = reduceOrsToFirstEquivalent(unitsLists, quantities);
+  const sum = [];
+  for (const nextQ of reducedQuantities) {
+    const existingQ = findCompatibleQuantityWithinList(sum, nextQ);
+    if (existingQ === void 0) {
+      sum.push({
+        ...nextQ,
+        unit: resolveUnit(nextQ.unit?.name)
+      });
+    } else {
+      const sumQ = addQuantities(existingQ, nextQ);
+      existingQ.quantity = sumQ.quantity;
+      existingQ.unit = resolveUnit(sumQ.unit?.name);
+    }
+  }
+  if (sum.length === 1) {
+    return { sum: sum[0], unitsLists };
+  }
+  return { sum: { type: "and", entries: sum }, unitsLists };
+}
+function regroupQuantitiesAndExpandEquivalents(sum, unitsLists) {
+  const sumQuantities = isGroup(sum) ? sum.entries : [sum];
+  const result = [];
+  const processedQuantities = /* @__PURE__ */ new Set();
+  for (const list of unitsLists) {
+    const listCopy = deepClone(list);
+    const main = [];
+    const mainCandidates = sumQuantities.filter(
+      (q) => !processedQuantities.has(q)
+    );
+    if (mainCandidates.length === 0) continue;
+    mainCandidates.forEach((q) => {
+      const mainInList = findCompatibleQuantityWithinList(listCopy, q);
+      if (mainInList !== void 0) {
+        processedQuantities.add(q);
+        main.push(q);
+        listCopy.splice(listCopy.indexOf(mainInList), 1);
+      }
+    });
+    const equivalents = sortUnitList(listCopy).map((equiv) => {
+      const initialValue = {
+        quantity: getDefaultQuantityValue()
+      };
+      if (equiv.unit) {
+        initialValue.unit = { name: equiv.unit.name };
+      }
+      return main.reduce((acc, v) => {
+        const mainInList = findCompatibleQuantityWithinList(list, v);
+        const newValue = {
+          quantity: multiplyQuantityValue(
+            v.quantity,
+            Big3(getAverageValue(equiv.quantity)).div(
+              getAverageValue(mainInList.quantity)
+            )
+          )
+        };
+        if (equiv.unit && !isNoUnit(equiv.unit)) {
+          newValue.unit = { name: equiv.unit.name };
+        }
+        return addQuantities(acc, newValue);
+      }, initialValue);
+    });
+    if (main.length + equivalents.length > 1) {
+      const resultMain = main.length > 1 ? {
+        type: "and",
+        entries: main.map(deNormalizeQuantity)
+      } : deNormalizeQuantity(main[0]);
+      result.push({
+        type: "or",
+        entries: [resultMain, ...equivalents]
+      });
+    } else {
+      result.push(deNormalizeQuantity(main[0]));
+    }
+  }
+  sumQuantities.filter((q) => !processedQuantities.has(q)).forEach((q) => result.push(deNormalizeQuantity(q)));
+  return result;
+}
+function addEquivalentsAndSimplify(...quantities) {
+  if (quantities.length === 1) {
+    return toPlainUnit(quantities[0]);
+  }
+  const { sum, unitsLists } = addQuantitiesOrGroups(...quantities);
+  const regrouped = regroupQuantitiesAndExpandEquivalents(sum, unitsLists);
+  if (regrouped.length === 1) {
+    return toPlainUnit(regrouped[0]);
+  } else {
+    return { type: "and", entries: regrouped.map(toPlainUnit) };
+  }
+}
+
+// src/classes/recipe.ts
+import Big4 from "big.js";
+var _Recipe = class _Recipe {
+  /**
+   * Creates a new Recipe instance.
+   * @param content - The recipe content to parse.
+   */
+  constructor(content) {
+    /**
+     * The parsed recipe metadata.
+     */
+    __publicField(this, "metadata", {});
+    /**
+     * The default or manual choice of alternative ingredients.
+     * Contains the full context including alternatives list and active selection index.
+     */
+    __publicField(this, "choices", {
+      ingredientItems: /* @__PURE__ */ new Map(),
+      ingredientGroups: /* @__PURE__ */ new Map()
+    });
+    /**
+     * The parsed recipe ingredients.
+     */
+    __publicField(this, "ingredients", []);
+    /**
+     * The parsed recipe sections.
+     */
+    __publicField(this, "sections", []);
+    /**
+     * The parsed recipe cookware.
+     */
+    __publicField(this, "cookware", []);
+    /**
+     * The parsed recipe timers.
+     */
+    __publicField(this, "timers", []);
+    /**
+     * The parsed recipe servings. Used for scaling. Parsed from one of
+     * {@link Metadata.servings}, {@link Metadata.yield} or {@link Metadata.serves}
+     * metadata fields.
+     *
+     * @see {@link Recipe.scaleBy | scaleBy()} and {@link Recipe.scaleTo | scaleTo()} methods
+     */
+    __publicField(this, "servings");
+    _Recipe.itemCounts.set(this, 0);
+    if (content) {
+      this.parse(content);
+    }
+  }
+  /**
+   * Gets the current item count for this recipe.
+   */
+  getItemCount() {
+    return _Recipe.itemCounts.get(this);
+  }
+  /**
+   * Gets the current item count and increments it.
+   */
+  getAndIncrementItemCount() {
+    const current = this.getItemCount();
+    _Recipe.itemCounts.set(this, current + 1);
+    return current;
+  }
+  _parseQuantityRecursive(quantityRaw) {
+    let quantityMatch = quantityRaw.match(quantityAlternativeRegex);
+    const quantities = [];
+    while (quantityMatch?.groups) {
+      const value = quantityMatch.groups.ingredientQuantityValue ? parseQuantityInput(quantityMatch.groups.ingredientQuantityValue) : void 0;
+      const unit = quantityMatch.groups.ingredientUnit;
+      if (value) {
+        const newQuantity = { quantity: value };
+        if (unit) {
+          if (unit.startsWith("=")) {
+            newQuantity.unit = {
+              name: unit.substring(1),
+              integerProtected: true
+            };
+          } else {
+            newQuantity.unit = { name: unit };
+          }
+        }
+        quantities.push(newQuantity);
+      } else {
+        throw new InvalidQuantityFormat(quantityRaw);
+      }
+      quantityMatch = quantityMatch.groups.ingredientAltQuantity ? quantityMatch.groups.ingredientAltQuantity.match(
+        quantityAlternativeRegex
+      ) : null;
+    }
+    return quantities;
+  }
+  _parseIngredientWithAlternativeRecursive(ingredientMatchString, items) {
+    const alternatives = [];
+    let testString = ingredientMatchString;
+    while (true) {
+      const match = testString.match(
+        alternatives.length > 0 ? inlineIngredientAlternativesRegex : ingredientWithAlternativeRegex
+      );
+      if (!match?.groups) break;
+      const groups = match.groups;
+      let name = groups.mIngredientName || groups.sIngredientName;
+      const preparation = groups.ingredientPreparation;
+      const modifiers = groups.ingredientModifiers;
+      const reference = modifiers !== void 0 && modifiers.includes("&");
+      const flags = [];
+      if (modifiers !== void 0 && modifiers.includes("?")) {
+        flags.push("optional");
+      }
+      if (modifiers !== void 0 && modifiers.includes("-")) {
+        flags.push("hidden");
+      }
+      if (modifiers !== void 0 && modifiers.includes("@") || groups.ingredientRecipeAnchor) {
+        flags.push("recipe");
+      }
+      let extras = void 0;
+      if (flags.includes("recipe")) {
+        extras = { path: `${name}.cook` };
+        name = name.substring(name.lastIndexOf("/") + 1);
+      }
+      const aliasMatch = name.match(ingredientAliasRegex);
+      let listName, displayName;
+      if (aliasMatch && aliasMatch.groups.ingredientListName.trim().length > 0 && aliasMatch.groups.ingredientDisplayName.trim().length > 0) {
+        listName = aliasMatch.groups.ingredientListName.trim();
+        displayName = aliasMatch.groups.ingredientDisplayName.trim();
+      } else {
+        listName = name;
+        displayName = name;
+      }
+      const newIngredient = {
+        name: listName
+      };
+      if (preparation) {
+        newIngredient.preparation = preparation;
+      }
+      if (flags.length > 0) {
+        newIngredient.flags = flags;
+      }
+      if (extras) {
+        newIngredient.extras = extras;
+      }
+      const idxInList = findAndUpsertIngredient(
+        this.ingredients,
+        newIngredient,
+        reference
+      );
+      let itemQuantity = void 0;
+      if (groups.ingredientQuantity) {
+        const parsedQuantities = this._parseQuantityRecursive(
+          groups.ingredientQuantity
+        );
+        const [primary, ...rest] = parsedQuantities;
+        if (primary) {
+          itemQuantity = {
+            ...primary,
+            scalable: groups.ingredientQuantityModifier !== "="
+          };
+          if (rest.length > 0) {
+            itemQuantity.equivalents = rest;
+          }
+        }
+      }
+      const alternative = {
+        index: idxInList,
+        displayName
+      };
+      const note = groups.ingredientNote?.trim();
+      if (note) {
+        alternative.note = note;
+      }
+      if (itemQuantity) {
+        alternative.itemQuantity = itemQuantity;
+      }
+      alternatives.push(alternative);
+      testString = groups.ingredientAlternative || "";
+    }
+    if (alternatives.length > 1) {
+      const alternativesIndexes = alternatives.map((alt) => alt.index);
+      for (const ingredientIndex of alternativesIndexes) {
+        const ingredient = this.ingredients[ingredientIndex];
+        if (ingredient) {
+          if (!ingredient.alternatives) {
+            ingredient.alternatives = new Set(
+              alternativesIndexes.filter((index) => index !== ingredientIndex)
+            );
+          } else {
+            ingredient.alternatives = unionOfSets(
+              ingredient.alternatives,
+              new Set(
+                alternativesIndexes.filter(
+                  (index) => index !== ingredientIndex
+                )
+              )
+            );
+          }
+        }
+      }
+    }
+    const id = `ingredient-item-${this.getAndIncrementItemCount()}`;
+    const newItem = {
+      type: "ingredient",
+      id,
+      alternatives
+    };
+    items.push(newItem);
+    if (alternatives.length > 1) {
+      this.choices.ingredientItems.set(id, alternatives);
+    }
+  }
+  _parseIngredientWithGroupKey(ingredientMatchString, items) {
+    const match = ingredientMatchString.match(ingredientWithGroupKeyRegex);
+    if (!match?.groups) return;
+    const groups = match.groups;
+    const groupKey = groups.gIngredientGroupKey;
+    let name = groups.gmIngredientName || groups.gsIngredientName;
+    const preparation = groups.gIngredientPreparation;
+    const modifiers = groups.gIngredientModifiers;
+    const reference = modifiers !== void 0 && modifiers.includes("&");
+    const flags = [];
+    if (modifiers !== void 0 && modifiers.includes("?")) {
+      flags.push("optional");
+    }
+    if (modifiers !== void 0 && modifiers.includes("-")) {
+      flags.push("hidden");
+    }
+    if (modifiers !== void 0 && modifiers.includes("@") || groups.gIngredientRecipeAnchor) {
+      flags.push("recipe");
+    }
+    let extras = void 0;
+    if (flags.includes("recipe")) {
+      extras = { path: `${name}.cook` };
+      name = name.substring(name.lastIndexOf("/") + 1);
+    }
+    const aliasMatch = name.match(ingredientAliasRegex);
+    let listName, displayName;
+    if (aliasMatch && aliasMatch.groups.ingredientListName.trim().length > 0 && aliasMatch.groups.ingredientDisplayName.trim().length > 0) {
+      listName = aliasMatch.groups.ingredientListName.trim();
+      displayName = aliasMatch.groups.ingredientDisplayName.trim();
+    } else {
+      listName = name;
+      displayName = name;
+    }
+    const newIngredient = {
+      name: listName
+    };
+    if (preparation) {
+      newIngredient.preparation = preparation;
+    }
+    if (flags.length > 0) {
+      newIngredient.flags = flags;
+    }
+    if (extras) {
+      newIngredient.extras = extras;
+    }
+    const idxInList = findAndUpsertIngredient(
+      this.ingredients,
+      newIngredient,
+      reference
+    );
+    let itemQuantity = void 0;
+    if (groups.gIngredientQuantity) {
+      const parsedQuantities = this._parseQuantityRecursive(
+        groups.gIngredientQuantity
+      );
+      const [primary, ...rest] = parsedQuantities;
+      itemQuantity = {
+        ...primary,
+        // there's necessarily a primary quantity as the match group was detected
+        scalable: groups.gIngredientQuantityModifier !== "="
+      };
+      if (rest.length > 0) {
+        itemQuantity.equivalents = rest;
+      }
+    }
+    const alternative = {
+      index: idxInList,
+      displayName
+    };
+    if (itemQuantity) {
+      alternative.itemQuantity = itemQuantity;
+    }
+    const existingAlternatives = this.choices.ingredientGroups.get(groupKey);
+    function upsertAlternativeToIngredient(ingredients, ingredientIdx, newAlternativeIdx) {
+      const ingredient = ingredients[ingredientIdx];
+      if (ingredient) {
+        if (ingredient.alternatives === void 0) {
+          ingredient.alternatives = /* @__PURE__ */ new Set([newAlternativeIdx]);
+        } else {
+          ingredient.alternatives.add(newAlternativeIdx);
+        }
+      }
+    }
+    if (existingAlternatives) {
+      for (const alt of existingAlternatives) {
+        upsertAlternativeToIngredient(this.ingredients, alt.index, idxInList);
+        upsertAlternativeToIngredient(this.ingredients, idxInList, alt.index);
+      }
+    }
+    const id = `ingredient-item-${this.getAndIncrementItemCount()}`;
+    const newItem = {
+      type: "ingredient",
+      id,
+      group: groupKey,
+      alternatives: [alternative]
+    };
+    items.push(newItem);
+    const choiceAlternative = deepClone(alternative);
+    choiceAlternative.itemId = id;
+    const existingChoice = this.choices.ingredientGroups.get(groupKey);
+    if (!existingChoice) {
+      this.choices.ingredientGroups.set(groupKey, [choiceAlternative]);
+    } else {
+      existingChoice.push(choiceAlternative);
+    }
+  }
+  /**
+   * Populates the `quantities` property for each ingredient based on
+   * how they appear in the recipe preparation. Only primary ingredients
+   * get quantities populated. Primary ingredients get `usedAsPrimary: true` flag.
+   *
+   * For inline alternatives (e.g. `\@a|b|c`), the first alternative is primary.
+   * For grouped alternatives (e.g. `\@|group|a`, `\@|group|b`), the first item in the group is primary.
+   *
+   * Quantities are grouped by their alternative signature and summed using addEquivalentsAndSimplify.
+   * @internal
+   */
+  _populate_ingredient_quantities() {
+    this.ingredients = this.ingredients.map((ing) => {
+      if (ing.quantities) {
+        delete ing.quantities;
+      }
+      if (ing.usedAsPrimary) {
+        delete ing.usedAsPrimary;
+      }
+      return ing;
+    });
+    const seenGroups = /* @__PURE__ */ new Set();
+    const ingredientGroups = /* @__PURE__ */ new Map();
+    for (const section of this.sections) {
+      for (const step of section.content.filter(
+        (item) => item.type === "step"
+      )) {
+        for (const item of step.items.filter(
+          (item2) => item2.type === "ingredient"
+        )) {
+          const isGroupedItem = "group" in item && item.group !== void 0;
+          const isFirstInGroup = isGroupedItem && !seenGroups.has(item.group);
+          if (isGroupedItem) {
+            seenGroups.add(item.group);
+          }
+          const isPrimary = !isGroupedItem || isFirstInGroup;
+          const alternative = item.alternatives[0];
+          if (isPrimary) {
+            const primaryIngredient = this.ingredients[alternative.index];
+            if (primaryIngredient) {
+              primaryIngredient.usedAsPrimary = true;
+            }
+          }
+          if (!isPrimary || !alternative.itemQuantity) continue;
+          const allQuantities = [
+            {
+              quantity: alternative.itemQuantity.quantity,
+              unit: alternative.itemQuantity.unit
+            }
+          ];
+          if (alternative.itemQuantity.equivalents) {
+            allQuantities.push(...alternative.itemQuantity.equivalents);
+          }
+          const quantityEntry = allQuantities.length === 1 ? allQuantities[0] : { type: "or", entries: allQuantities };
+          const hasInlineAlternatives = item.alternatives.length > 1;
+          const hasGroupedAlternatives = isGroupedItem && this.choices.ingredientGroups.has(item.group);
+          let alternativeRefs;
+          if (hasInlineAlternatives) {
+            alternativeRefs = [];
+            for (let j = 1; j < item.alternatives.length; j++) {
+              const otherAlt = item.alternatives[j];
+              const newRef = {
+                index: otherAlt.index
+              };
+              if (otherAlt.itemQuantity) {
+                const altQty = {
+                  quantity: otherAlt.itemQuantity.quantity
+                };
+                if (otherAlt.itemQuantity.unit) {
+                  altQty.unit = otherAlt.itemQuantity.unit.name;
+                }
+                if (otherAlt.itemQuantity.equivalents) {
+                  altQty.equivalents = otherAlt.itemQuantity.equivalents.map(
+                    (eq) => toPlainUnit(eq)
+                  );
+                }
+                newRef.alternativeQuantities = [altQty];
+              }
+              alternativeRefs.push(newRef);
+            }
+          } else if (hasGroupedAlternatives) {
+            const groupAlternatives = this.choices.ingredientGroups.get(
+              item.group
+            );
+            alternativeRefs = [];
+            for (let j = 1; j < groupAlternatives.length; j++) {
+              const otherAlt = groupAlternatives[j];
+              if (otherAlt.itemQuantity) {
+                const altQty = {
+                  quantity: otherAlt.itemQuantity.quantity
+                };
+                if (otherAlt.itemQuantity.unit) {
+                  altQty.unit = otherAlt.itemQuantity.unit.name;
+                }
+                if (otherAlt.itemQuantity.equivalents) {
+                  altQty.equivalents = otherAlt.itemQuantity.equivalents.map(
+                    (eq) => toPlainUnit(eq)
+                  );
+                }
+                alternativeRefs.push({
+                  index: otherAlt.index,
+                  alternativeQuantities: [altQty]
+                });
+              }
+            }
+            if (alternativeRefs.length === 0) {
+              alternativeRefs = void 0;
+            }
+          }
+          if (!ingredientGroups.has(alternative.index)) {
+            ingredientGroups.set(alternative.index, /* @__PURE__ */ new Map());
+          }
+          const groupsForIngredient = ingredientGroups.get(alternative.index);
+          const baseSignature = getAlternativeSignature(alternativeRefs);
+          const signature = isGroupedItem ? `group:${item.group}|${baseSignature ?? ""}` : baseSignature;
+          if (!groupsForIngredient.has(signature)) {
+            groupsForIngredient.set(signature, {
+              alternativeQuantities: /* @__PURE__ */ new Map(),
+              quantities: []
+            });
+          }
+          const group = groupsForIngredient.get(signature);
+          group.quantities.push(quantityEntry);
+          if (alternativeRefs) {
+            for (const ref of alternativeRefs) {
+              if (!group.alternativeQuantities.has(ref.index)) {
+                group.alternativeQuantities.set(ref.index, []);
+              }
+              if (ref.alternativeQuantities && ref.alternativeQuantities.length > 0) {
+                for (const altQty of ref.alternativeQuantities) {
+                  if (altQty.equivalents && altQty.equivalents.length > 0) {
+                    const entries = [
+                      toExtendedUnit({
+                        quantity: altQty.quantity,
+                        unit: altQty.unit
+                      }),
+                      ...altQty.equivalents.map((eq) => toExtendedUnit(eq))
+                    ];
+                    group.alternativeQuantities.get(ref.index).push({ type: "or", entries });
+                  } else {
+                    group.alternativeQuantities.get(ref.index).push(
+                      toExtendedUnit({
+                        quantity: altQty.quantity,
+                        unit: altQty.unit
+                      })
+                    );
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    for (const [index, groupsForIngredient] of ingredientGroups) {
+      const ingredient = this.ingredients[index];
+      const quantityGroups = [];
+      for (const [, group] of groupsForIngredient) {
+        const summedGroupQuantity = addEquivalentsAndSimplify(
+          ...group.quantities
+        );
+        const groupQuantities = flattenPlainUnitGroup(summedGroupQuantity);
+        let alternatives;
+        if (group.alternativeQuantities.size > 0) {
+          alternatives = [];
+          for (const [altIndex, altQuantities] of group.alternativeQuantities) {
+            const ref = { index: altIndex };
+            if (altQuantities.length > 0) {
+              const summedAltQuantity = addEquivalentsAndSimplify(
+                ...altQuantities
+              );
+              const flattenedAlt = flattenPlainUnitGroup(summedAltQuantity);
+              ref.alternativeQuantities = flattenedAlt.flatMap((item) => {
+                if ("groupQuantity" in item) {
+                  return [item.groupQuantity];
+                } else {
+                  return item.entries;
+                }
+              });
+            }
+            alternatives.push(ref);
+          }
+        }
+        for (const gq of groupQuantities) {
+          if ("type" in gq && gq.type === "and") {
+            const andGroup = {
+              type: "and",
+              entries: gq.entries
+            };
+            if (gq.equivalents && gq.equivalents.length > 0) {
+              andGroup.equivalents = gq.equivalents;
+            }
+            if (alternatives && alternatives.length > 0) {
+              andGroup.alternatives = alternatives;
+            }
+            quantityGroups.push(andGroup);
+          } else {
+            const quantityGroup = gq;
+            if (alternatives && alternatives.length > 0) {
+              quantityGroup.alternatives = alternatives;
+            }
+            quantityGroups.push(quantityGroup);
+          }
+        }
+      }
+      if (quantityGroups.length > 0) {
+        ingredient.quantities = quantityGroups;
+      }
+    }
+  }
+  /**
+   * Calculates ingredient quantities based on the provided choices.
+   * Returns a list of computed ingredients with their total quantities.
+   *
+   * @param choices - The recipe choices to apply when computing quantities.
+   *   If not provided, uses the default choices (first alternative for each item).
+   * @returns An array of ComputedIngredient with quantityTotal calculated based on choices.
+   */
+  calc_ingredient_quantities(choices) {
+    const effectiveChoices = choices || {
+      ingredientItems: new Map(
+        Array.from(this.choices.ingredientItems.keys()).map((k) => [k, 0])
+      ),
+      ingredientGroups: new Map(
+        Array.from(this.choices.ingredientGroups.keys()).map((k) => [k, 0])
+      )
+    };
+    const ingredientQuantities = /* @__PURE__ */ new Map();
+    const selectedIngredientIndices = /* @__PURE__ */ new Set();
+    for (const section of this.sections) {
+      for (const step of section.content.filter(
+        (item) => item.type === "step"
+      )) {
+        for (const item of step.items.filter(
+          (item2) => item2.type === "ingredient"
+        )) {
+          for (let i2 = 0; i2 < item.alternatives.length; i2++) {
+            const alternative = item.alternatives[i2];
+            const isAlternativeChoiceItem = effectiveChoices.ingredientItems?.get(item.id) === i2;
+            const alternativeChoiceGroupIdx = item.group ? effectiveChoices.ingredientGroups?.get(item.group) : void 0;
+            const alternativeChoiceGroup = item.group ? this.choices.ingredientGroups.get(item.group) : void 0;
+            const isAlternativeChoiceGroup = alternativeChoiceGroup && alternativeChoiceGroupIdx !== void 0 ? alternativeChoiceGroup[alternativeChoiceGroupIdx]?.itemId === item.id : false;
+            const isSelected = !("group" in item) && (item.alternatives.length === 1 || isAlternativeChoiceItem) || isAlternativeChoiceGroup;
+            if (isSelected) {
+              selectedIngredientIndices.add(alternative.index);
+              if (alternative.itemQuantity) {
+                const allQuantities = [
+                  {
+                    quantity: alternative.itemQuantity.quantity,
+                    unit: alternative.itemQuantity.unit
+                  }
+                ];
+                if (alternative.itemQuantity.equivalents) {
+                  allQuantities.push(...alternative.itemQuantity.equivalents);
+                }
+                const equivalents = allQuantities.length === 1 ? allQuantities[0] : {
+                  type: "or",
+                  entries: allQuantities
+                };
+                ingredientQuantities.set(alternative.index, [
+                  ...ingredientQuantities.get(alternative.index) || [],
+                  equivalents
+                ]);
+              }
+            }
+          }
+        }
+      }
+    }
+    const computedIngredients = [];
+    for (let index = 0; index < this.ingredients.length; index++) {
+      if (!selectedIngredientIndices.has(index)) continue;
+      const ing = this.ingredients[index];
+      const computed = {
+        name: ing.name
+      };
+      if (ing.preparation) {
+        computed.preparation = ing.preparation;
+      }
+      if (ing.flags) {
+        computed.flags = ing.flags;
+      }
+      if (ing.extras) {
+        computed.extras = ing.extras;
+      }
+      const quantities = ingredientQuantities.get(index);
+      if (quantities && quantities.length > 0) {
+        computed.quantityTotal = addEquivalentsAndSimplify(...quantities);
+      }
+      computedIngredients.push(computed);
+    }
+    return computedIngredients;
+  }
+  /**
+   * Parses a recipe from a string.
+   * @param content - The recipe content to parse.
+   */
+  parse(content) {
+    const cleanContent = content.replace(metadataRegex, "").replace(commentRegex, "").replace(blockCommentRegex, "").trim().split(/\r\n?|\n/);
+    const { metadata, servings } = extractMetadata(content);
+    this.metadata = metadata;
+    this.servings = servings;
+    let blankLineBefore = true;
+    let section = new Section();
+    const items = [];
+    let note = "";
+    let inNote = false;
+    for (const line of cleanContent) {
+      if (line.trim().length === 0) {
+        flushPendingItems(section, items);
+        note = flushPendingNote(section, note);
+        blankLineBefore = true;
+        inNote = false;
+        continue;
+      }
+      if (line.startsWith("=")) {
+        flushPendingItems(section, items);
+        note = flushPendingNote(section, note);
+        if (this.sections.length === 0 && section.isBlank()) {
+          section.name = line.replace(/^=+|=+$/g, "").trim();
         } else {
           if (!section.isBlank()) {
             this.sections.push(section);
@@ -972,12 +2264,13 @@ var Recipe = class _Recipe {
         }
         const groups = match.groups;
         if (groups.mIngredientName || groups.sIngredientName) {
-          let name = groups.mIngredientName || groups.sIngredientName;
-          const scalableQuantity = (groups.mIngredientQuantityModifier || groups.sIngredientQuantityModifier) !== "=";
-          const quantityRaw = groups.mIngredientQuantity || groups.sIngredientQuantity;
-          const unit = groups.mIngredientUnit || groups.sIngredientUnit;
-          const preparation = groups.mIngredientPreparation || groups.sIngredientPreparation;
-          const modifiers = groups.mIngredientModifiers || groups.sIngredientModifiers;
+          this._parseIngredientWithAlternativeRecursive(match[0], items);
+        } else if (groups.gmIngredientName || groups.gsIngredientName) {
+          this._parseIngredientWithGroupKey(match[0], items);
+        } else if (groups.mCookwareName || groups.sCookwareName) {
+          const name = groups.mCookwareName || groups.sCookwareName;
+          const modifiers = groups.cookwareModifiers;
+          const quantityRaw = groups.cookwareQuantity;
           const reference = modifiers !== void 0 && modifiers.includes("&");
           const flags = [];
           if (modifiers !== void 0 && modifiers.includes("?")) {
@@ -986,83 +2279,29 @@ var Recipe = class _Recipe {
           if (modifiers !== void 0 && modifiers.includes("-")) {
             flags.push("hidden");
           }
-          if (modifiers !== void 0 && modifiers.includes("@") || groups.mIngredientRecipeAnchor || groups.sIngredientRecipeAnchor) {
-            flags.push("recipe");
-          }
-          let extras = void 0;
-          if (flags.includes("recipe")) {
-            extras = { path: `${name}.cook` };
-            name = name.substring(name.lastIndexOf("/") + 1);
-          }
           const quantity = quantityRaw ? parseQuantityInput(quantityRaw) : void 0;
-          const aliasMatch = name.match(ingredientAliasRegex);
-          let listName, displayName;
-          if (aliasMatch && aliasMatch.groups.ingredientListName.trim().length > 0 && aliasMatch.groups.ingredientDisplayName.trim().length > 0) {
-            listName = aliasMatch.groups.ingredientListName.trim();
-            displayName = aliasMatch.groups.ingredientDisplayName.trim();
-          } else {
-            listName = name;
-            displayName = name;
-          }
-          const newIngredient = {
-            name: listName,
-            quantity,
-            quantityParts: quantity ? [
-              {
-                value: quantity,
-                unit,
-                scalable: scalableQuantity
-              }
-            ] : void 0,
-            unit,
-            preparation,
-            flags
+          const newCookware = {
+            name
           };
-          if (extras) {
-            newIngredient.extras = extras;
+          if (quantity) {
+            newCookware.quantity = quantity;
+          }
+          if (flags.length > 0) {
+            newCookware.flags = flags;
           }
-          const idxsInList = findAndUpsertIngredient(
-            this.ingredients,
-            newIngredient,
+          const idxInList = findAndUpsertCookware(
+            this.cookware,
+            newCookware,
             reference
           );
           const newItem = {
-            type: "ingredient",
-            index: idxsInList.ingredientIndex,
-            displayName
+            type: "cookware",
+            index: idxInList
           };
-          if (idxsInList.quantityPartIndex !== void 0) {
-            newItem.quantityPartIndex = idxsInList.quantityPartIndex;
+          if (quantity) {
+            newItem.quantity = quantity;
           }
           items.push(newItem);
-        } else if (groups.mCookwareName || groups.sCookwareName) {
-          const name = groups.mCookwareName || groups.sCookwareName;
-          const modifiers = groups.mCookwareModifiers || groups.sCookwareModifiers;
-          const quantityRaw = groups.mCookwareQuantity || groups.sCookwareQuantity;
-          const reference = modifiers !== void 0 && modifiers.includes("&");
-          const flags = [];
-          if (modifiers !== void 0 && modifiers.includes("?")) {
-            flags.push("optional");
-          }
-          if (modifiers !== void 0 && modifiers.includes("-")) {
-            flags.push("hidden");
-          }
-          const quantity = quantityRaw ? parseQuantityInput(quantityRaw) : void 0;
-          const idxsInList = findAndUpsertCookware(
-            this.cookware,
-            {
-              name,
-              quantity,
-              quantityParts: quantity ? [quantity] : void 0,
-              flags
-            },
-            reference
-          );
-          items.push({
-            type: "cookware",
-            index: idxsInList.cookwareIndex,
-            quantityPartIndex: idxsInList.quantityPartIndex
-          });
         } else {
           const durationStr = groups.timerQuantity.trim();
           const unit = (groups.timerUnit || "").trim();
@@ -1090,6 +2329,7 @@ var Recipe = class _Recipe {
     if (!section.isBlank()) {
       this.sections.push(section);
     }
+    this._populate_ingredient_quantities();
   }
   /**
    * Scales the recipe to a new number of servings. In practice, it calls
@@ -1104,7 +2344,7 @@ var Recipe = class _Recipe {
     if (originalServings === void 0 || originalServings === 0) {
       throw new Error("Error scaling recipe: no initial servings value set");
     }
-    const factor = Big2(newServings).div(originalServings);
+    const factor = Big4(newServings).div(originalServings);
     return this.scaleBy(factor);
   }
   /**
@@ -1119,44 +2359,62 @@ var Recipe = class _Recipe {
     if (originalServings === void 0 || originalServings === 0) {
       throw new Error("Error scaling recipe: no initial servings value set");
     }
-    newRecipe.ingredients = newRecipe.ingredients.map((ingredient) => {
-      if (ingredient.quantityParts) {
-        ingredient.quantityParts = ingredient.quantityParts.map(
-          (quantityPart) => {
-            if (quantityPart.value.type === "fixed" && quantityPart.value.value.type === "text") {
-              return quantityPart;
-            }
-            return {
-              ...quantityPart,
-              value: multiplyQuantityValue(
-                quantityPart.value,
-                quantityPart.scalable ? Big2(factor) : 1
-              )
-            };
+    function scaleAlternativesBy(alternatives, factor2) {
+      for (const alternative of alternatives) {
+        if (alternative.itemQuantity) {
+          const scaleFactor = alternative.itemQuantity.scalable ? Big4(factor2) : 1;
+          if (alternative.itemQuantity.quantity.type !== "fixed" || alternative.itemQuantity.quantity.value.type !== "text") {
+            alternative.itemQuantity.quantity = multiplyQuantityValue(
+              alternative.itemQuantity.quantity,
+              scaleFactor
+            );
+          }
+          if (alternative.itemQuantity.equivalents) {
+            alternative.itemQuantity.equivalents = alternative.itemQuantity.equivalents.map(
+              (altQuantity) => {
+                if (altQuantity.quantity.type === "fixed" && altQuantity.quantity.value.type === "text") {
+                  return altQuantity;
+                } else {
+                  return {
+                    ...altQuantity,
+                    quantity: multiplyQuantityValue(
+                      altQuantity.quantity,
+                      scaleFactor
+                    )
+                  };
+                }
+              }
+            );
           }
-        );
-        if (ingredient.quantityParts.length === 1) {
-          ingredient.quantity = ingredient.quantityParts[0].value;
-          ingredient.unit = ingredient.quantityParts[0].unit;
-        } else {
-          const totalQuantity = ingredient.quantityParts.reduce(
-            (acc, val) => addQuantities(acc, { value: val.value, unit: val.unit }),
-            { value: getDefaultQuantityValue() }
-          );
-          ingredient.quantity = totalQuantity.value;
-          ingredient.unit = totalQuantity.unit;
         }
       }
-      return ingredient;
-    }).filter((ingredient) => ingredient.quantity !== null);
-    newRecipe.servings = Big2(originalServings).times(factor).toNumber();
+    }
+    for (const section of newRecipe.sections) {
+      for (const step of section.content.filter(
+        (item) => item.type === "step"
+      )) {
+        for (const item of step.items.filter(
+          (item2) => item2.type === "ingredient"
+        )) {
+          scaleAlternativesBy(item.alternatives, factor);
+        }
+      }
+    }
+    for (const alternatives of newRecipe.choices.ingredientGroups.values()) {
+      scaleAlternativesBy(alternatives, factor);
+    }
+    for (const alternatives of newRecipe.choices.ingredientItems.values()) {
+      scaleAlternativesBy(alternatives, factor);
+    }
+    newRecipe._populate_ingredient_quantities();
+    newRecipe.servings = Big4(originalServings).times(factor).toNumber();
     if (newRecipe.metadata.servings && this.metadata.servings) {
       if (floatRegex.test(String(this.metadata.servings).replace(",", ".").trim())) {
         const servingsValue = parseFloat(
           String(this.metadata.servings).replace(",", ".")
         );
         newRecipe.metadata.servings = String(
-          Big2(servingsValue).times(factor).toNumber()
+          Big4(servingsValue).times(factor).toNumber()
         );
       }
     }
@@ -1166,7 +2424,7 @@ var Recipe = class _Recipe {
           String(this.metadata.yield).replace(",", ".")
         );
         newRecipe.metadata.yield = String(
-          Big2(yieldValue).times(factor).toNumber()
+          Big4(yieldValue).times(factor).toNumber()
         );
       }
     }
@@ -1176,7 +2434,7 @@ var Recipe = class _Recipe {
           String(this.metadata.serves).replace(",", ".")
         );
         newRecipe.metadata.serves = String(
-          Big2(servesValue).times(factor).toNumber()
+          Big4(servesValue).times(factor).toNumber()
         );
       }
     }
@@ -1199,19 +2457,27 @@ var Recipe = class _Recipe {
    */
   clone() {
     const newRecipe = new _Recipe();
-    newRecipe.metadata = JSON.parse(JSON.stringify(this.metadata));
-    newRecipe.ingredients = JSON.parse(
-      JSON.stringify(this.ingredients)
-    );
-    newRecipe.sections = JSON.parse(JSON.stringify(this.sections));
-    newRecipe.cookware = JSON.parse(
-      JSON.stringify(this.cookware)
-    );
-    newRecipe.timers = JSON.parse(JSON.stringify(this.timers));
+    newRecipe.choices = deepClone(this.choices);
+    _Recipe.itemCounts.set(newRecipe, this.getItemCount());
+    newRecipe.metadata = deepClone(this.metadata);
+    newRecipe.ingredients = deepClone(this.ingredients);
+    newRecipe.sections = this.sections.map((section) => {
+      const newSection = new Section(section.name);
+      newSection.content = deepClone(section.content);
+      return newSection;
+    });
+    newRecipe.cookware = deepClone(this.cookware);
+    newRecipe.timers = deepClone(this.timers);
     newRecipe.servings = this.servings;
     return newRecipe;
   }
 };
+/**
+ * External storage for item count (not a property on instances).
+ * Used for giving ID numbers to items during parsing.
+ */
+__publicField(_Recipe, "itemCounts", /* @__PURE__ */ new WeakMap());
+var Recipe = _Recipe;
 
 // src/classes/shopping_list.ts
 var ShoppingList = class {
@@ -1220,6 +2486,7 @@ var ShoppingList = class {
    * @param category_config_str - The category configuration to parse.
    */
   constructor(category_config_str) {
+    // TODO: backport type change
     /**
      * The ingredients in the shopping list.
      */
@@ -1242,6 +2509,33 @@ var ShoppingList = class {
   }
   calculate_ingredients() {
     this.ingredients = [];
+    const addIngredientQuantity = (name, quantityTotal) => {
+      const quantityTotalExtended = extendAllUnits(quantityTotal);
+      const newQuantities = isAndGroup(quantityTotalExtended) ? quantityTotalExtended.entries : [quantityTotalExtended];
+      const existing = this.ingredients.find((i2) => i2.name === name);
+      if (existing) {
+        if (!existing.quantityTotal) {
+          existing.quantityTotal = quantityTotal;
+          return;
+        }
+        try {
+          const existingQuantityTotalExtended = extendAllUnits(
+            existing.quantityTotal
+          );
+          const existingQuantities = isAndGroup(existingQuantityTotalExtended) ? existingQuantityTotalExtended.entries : [existingQuantityTotalExtended];
+          existing.quantityTotal = addEquivalentsAndSimplify(
+            ...existingQuantities,
+            ...newQuantities
+          );
+          return;
+        } catch {
+        }
+      }
+      this.ingredients.push({
+        name,
+        quantityTotal
+      });
+    };
     for (const addedRecipe of this.recipes) {
       let scaledRecipe;
       if ("factor" in addedRecipe) {
@@ -1250,62 +2544,47 @@ var ShoppingList = class {
       } else {
         scaledRecipe = addedRecipe.recipe.scaleTo(addedRecipe.servings);
       }
-      for (const ingredient of scaledRecipe.ingredients) {
+      const computedIngredients = scaledRecipe.calc_ingredient_quantities(
+        addedRecipe.choices
+      );
+      for (const ingredient of computedIngredients) {
         if (ingredient.flags && ingredient.flags.includes("hidden")) {
           continue;
         }
-        const existingIngredient = this.ingredients.find(
-          (i2) => i2.name === ingredient.name
-        );
-        let addSeparate = false;
-        try {
-          if (existingIngredient && ingredient.quantity) {
-            if (existingIngredient.quantity) {
-              const newQuantity = addQuantities(
-                {
-                  value: existingIngredient.quantity,
-                  unit: existingIngredient.unit ?? ""
-                },
-                {
-                  value: ingredient.quantity,
-                  unit: ingredient.unit ?? ""
-                }
-              );
-              existingIngredient.quantity = newQuantity.value;
-              if (newQuantity.unit) {
-                existingIngredient.unit = newQuantity.unit;
-              }
-            } else {
-              existingIngredient.quantity = ingredient.quantity;
-              if (ingredient.unit) {
-                existingIngredient.unit = ingredient.unit;
-              }
-            }
-          }
-        } catch {
-          addSeparate = true;
-        }
-        if (!existingIngredient || addSeparate) {
-          const newIngredient = { name: ingredient.name };
-          if (ingredient.quantity) {
-            newIngredient.quantity = ingredient.quantity;
-          }
-          if (ingredient.unit) {
-            newIngredient.unit = ingredient.unit;
-          }
-          this.ingredients.push(newIngredient);
+        if (ingredient.quantityTotal) {
+          addIngredientQuantity(ingredient.name, ingredient.quantityTotal);
+        } else if (!this.ingredients.some((i2) => i2.name === ingredient.name)) {
+          this.ingredients.push({ name: ingredient.name });
         }
       }
     }
   }
-  add_recipe(recipe, scaling) {
-    if (typeof scaling === "number" || scaling === void 0) {
-      this.recipes.push({ recipe, factor: scaling ?? 1 });
+  /**
+   * Adds a recipe to the shopping list, then automatically
+   * recalculates the quantities and recategorize the ingredients.
+   * @param recipe - The recipe to add.
+   * @param options - Options for adding the recipe.
+   */
+  add_recipe(recipe, options = {}) {
+    if (!options.scaling) {
+      this.recipes.push({
+        recipe,
+        factor: options.scaling ?? 1,
+        choices: options.choices
+      });
     } else {
-      if ("factor" in scaling) {
-        this.recipes.push({ recipe, factor: scaling.factor });
+      if ("factor" in options.scaling) {
+        this.recipes.push({
+          recipe,
+          factor: options.scaling.factor,
+          choices: options.choices
+        });
       } else {
-        this.recipes.push({ recipe, servings: scaling.servings });
+        this.recipes.push({
+          recipe,
+          servings: options.scaling.servings,
+          choices: options.choices
+        });
       }
     }
     this.calculate_ingredients();
@@ -1370,14 +2649,275 @@ var ShoppingList = class {
     this.categories = categories;
   }
 };
+
+// src/classes/shopping_cart.ts
+import { solve } from "yalps";
+var ShoppingCart = class {
+  /**
+   * Creates a new ShoppingCart instance
+   * @param options - {@link ShoppingCartOptions | Options} for the constructor
+   */
+  constructor(options) {
+    /**
+     * The product catalog to use for matching products
+     */
+    __publicField(this, "productCatalog");
+    /**
+     * The shopping list to build the cart from
+     */
+    __publicField(this, "shoppingList");
+    /**
+     * The content of the cart
+     */
+    __publicField(this, "cart", []);
+    /**
+     * The ingredients that were successfully matched with products
+     */
+    __publicField(this, "match", []);
+    /**
+     * The ingredients that could not be matched with products
+     */
+    __publicField(this, "misMatch", []);
+    /**
+     * Key information about the shopping cart
+     */
+    __publicField(this, "summary");
+    if (options?.catalog) this.productCatalog = options.catalog;
+    if (options?.list) this.shoppingList = options.list;
+    this.summary = { totalPrice: 0, totalItems: 0 };
+  }
+  /**
+   * Sets the product catalog to use for matching products
+   * To use if a catalog was not provided at the creation of the instance
+   * @param catalog - The {@link ProductCatalog} to set
+   */
+  setProductCatalog(catalog) {
+    this.productCatalog = catalog;
+  }
+  // TODO: harmonize recipe name to use underscores
+  /**
+   * Sets the shopping list to build the cart from.
+   * To use if a shopping list was not provided at the creation of the instance
+   * @param list - The {@link ShoppingList} to set
+   */
+  setShoppingList(list) {
+    this.shoppingList = list;
+  }
+  /**
+   * Builds the cart from the shopping list and product catalog
+   * @remarks
+   * - If a combination of product(s) is successfully found for a given ingredient, the latter will be listed in the {@link ShoppingCart.match | match} array
+   * in addition to that combination being added to the {@link ShoppingCart.cart | cart}.
+   * - Otherwise, the latter will be listed in the {@link ShoppingCart.misMatch | misMatch} array. Possible causes can be:
+   *   - No product is listed in the catalog for that ingredient
+   *   - The ingredient has no quantity, a text quantity
+   *   - The ingredient's quantity unit is incompatible with the units of the candidate products listed in the catalog
+   * @throws {@link NoProductCatalogForCartError} if no product catalog is set
+   * @throws {@link NoShoppingListForCartError} if no shopping list is set
+   * @returns `true` if all ingredients in the shopping list have been matched to products in the catalog, or `false` otherwise
+   */
+  buildCart() {
+    this.resetCart();
+    if (this.productCatalog === void 0) {
+      throw new NoProductCatalogForCartError();
+    } else if (this.shoppingList === void 0) {
+      throw new NoShoppingListForCartError();
+    }
+    for (const ingredient of this.shoppingList.ingredients) {
+      const productOptions = this.getProductOptions(ingredient);
+      try {
+        const optimumMatch = this.getOptimumMatch(ingredient, productOptions);
+        this.cart.push(...optimumMatch);
+        this.match.push({ ingredient, selection: optimumMatch });
+      } catch (error) {
+        if (error instanceof NoProductMatchError) {
+          this.misMatch.push({ ingredient, reason: error.code });
+        }
+      }
+    }
+    this.summarize();
+    return this.misMatch.length > 0;
+  }
+  /**
+   * Gets the product options for a given ingredient
+   * @param ingredient - The ingredient to get the product options for
+   * @returns An array of {@link ProductOption}
+   */
+  getProductOptions(ingredient) {
+    return this.productCatalog.products.filter(
+      (product) => product.ingredientName === ingredient.name || product.ingredientAliases?.includes(ingredient.name)
+    );
+  }
+  /**
+   * Gets the optimum match for a given ingredient and product option
+   * @param ingredient - The ingredient to match
+   * @param options - The product options to choose from
+   * @returns An array of {@link ProductSelection}
+   * @throws {@link NoProductMatchError} if no match can be found
+   */
+  getOptimumMatch(ingredient, options) {
+    if (options.length === 0)
+      throw new NoProductMatchError(ingredient.name, "noProduct");
+    if (!ingredient.quantityTotal)
+      throw new NoProductMatchError(ingredient.name, "noQuantity");
+    const normalizedOptions = options.map(
+      (option) => ({
+        ...option,
+        sizes: option.sizes.map((s) => {
+          const resolvedUnit = resolveUnit(s.unit);
+          return {
+            size: resolvedUnit && "toBase" in resolvedUnit ? multiplyQuantityValue(
+              s.size,
+              resolvedUnit.toBase
+            ) : s.size,
+            unit: resolvedUnit
+          };
+        })
+      })
+    );
+    const normalizedQuantityTotal = normalizeAllUnits(ingredient.quantityTotal);
+    function getOptimumMatchForQuantityParts(normalizedQuantities, normalizedOptions2, selection = []) {
+      if (isAndGroup(normalizedQuantities)) {
+        for (const q of normalizedQuantities.entries) {
+          const result = getOptimumMatchForQuantityParts(
+            q,
+            normalizedOptions2,
+            selection
+          );
+          selection.push(...result);
+        }
+      } else {
+        const alternativeUnitsOfQuantity = isOrGroup(normalizedQuantities) ? normalizedQuantities.entries : [normalizedQuantities];
+        const solutions = [];
+        const errors = /* @__PURE__ */ new Set();
+        for (const alternative of alternativeUnitsOfQuantity) {
+          if (alternative.quantity.type === "fixed" && alternative.quantity.value.type === "text") {
+            errors.add("textValue");
+            continue;
+          }
+          const scaledQuantity = multiplyQuantityValue(
+            alternative.quantity,
+            "toBase" in alternative.unit ? alternative.unit.toBase : 1
+          );
+          alternative.quantity = scaledQuantity;
+          const matchOptions = normalizedOptions2.filter(
+            (option) => option.sizes.some(
+              (s) => areUnitsCompatible(alternative.unit, s.unit)
+            )
+          );
+          if (matchOptions.length > 0) {
+            const findCompatibleSize = (option) => option.sizes.find(
+              (s) => areUnitsCompatible(alternative.unit, s.unit)
+            );
+            if (matchOptions.length == 1) {
+              const matchedOption = matchOptions[0];
+              const compatibleSize = findCompatibleSize(matchedOption);
+              const product = options.find(
+                (opt) => opt.id === matchedOption.id
+              );
+              const targetQuantity = scaledQuantity.type === "fixed" ? scaledQuantity.value : scaledQuantity.min;
+              const resQuantity = Math.ceil(
+                getNumericValue(targetQuantity) / getNumericValue(compatibleSize.size.value)
+              );
+              solutions.push([
+                {
+                  product,
+                  quantity: resQuantity,
+                  totalPrice: resQuantity * matchedOption.price
+                }
+              ]);
+              continue;
+            }
+            const model = {
+              direction: "minimize",
+              objective: "price",
+              integers: true,
+              constraints: {
+                size: {
+                  min: scaledQuantity.type === "fixed" ? getNumericValue(scaledQuantity.value) : getNumericValue(scaledQuantity.min)
+                }
+              },
+              variables: matchOptions.reduce(
+                (acc, option) => {
+                  const compatibleSize = findCompatibleSize(option);
+                  acc[option.id] = {
+                    price: option.price,
+                    size: getNumericValue(compatibleSize.size.value)
+                  };
+                  return acc;
+                },
+                {}
+              )
+            };
+            const solution = solve(model);
+            solutions.push(
+              solution.variables.map((variable) => {
+                const resProductSelection = {
+                  product: options.find((option) => option.id === variable[0]),
+                  quantity: variable[1]
+                };
+                return {
+                  ...resProductSelection,
+                  totalPrice: resProductSelection.quantity * resProductSelection.product.price
+                };
+              })
+            );
+          } else {
+            errors.add("incompatibleUnits");
+          }
+        }
+        if (solutions.length === 0) {
+          throw new NoProductMatchError(
+            ingredient.name,
+            errors.size === 1 ? errors.values().next().value : "textValue_incompatibleUnits"
+          );
+        } else {
+          return solutions.sort(
+            (a2, b) => a2.reduce((acc, item) => acc + item.totalPrice, 0) - b.reduce((acc, item) => acc + item.totalPrice, 0)
+          )[0];
+        }
+      }
+      return selection;
+    }
+    return getOptimumMatchForQuantityParts(
+      normalizedQuantityTotal,
+      normalizedOptions
+    );
+  }
+  /**
+   * Reset the cart's properties
+   */
+  resetCart() {
+    this.cart = [];
+    this.match = [];
+    this.misMatch = [];
+    this.summary = { totalPrice: 0, totalItems: 0 };
+  }
+  /**
+   * Calculate the cart's key info and store it in the cart's {@link ShoppingCart.summary | summary} property.
+   * This function is automatically invoked by {@link ShoppingCart.buildCart | buildCart() } method.
+   * @returns the total price and number of items in the cart
+   */
+  summarize() {
+    this.summary.totalPrice = this.cart.reduce(
+      (acc, item) => acc + item.totalPrice,
+      0
+    );
+    this.summary.totalItems = this.cart.length;
+    return this.summary;
+  }
+};
 export {
   CategoryConfig,
+  NoProductCatalogForCartError,
+  NoShoppingListForCartError,
+  ProductCatalog,
   Recipe,
   Section,
+  ShoppingCart,
   ShoppingList
 };
 /* v8 ignore else -- @preserve */
-/* v8 ignore else -- expliciting error types -- @preserve */
 /* v8 ignore else -- expliciting error type -- @preserve */
-/* v8 ignore else -- only set unit if it is given -- @preserve */
+/* v8 ignore if -- @preserve */
 //# sourceMappingURL=index.js.map