@tmlmt/cooklang-parser 1.0.8 → 1.1.0

package/dist/index.js

@@ -65,23 +65,233 @@ var AisleConfig = 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. */
     __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;
   }
 };
 
+// node_modules/.pnpm/human-regex@2.1.5_patch_hash=6d6bd9e233f99785a7c2187fd464edc114b76d47001dbb4eb6b5d72168de7460/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: "." });
+var n = Object.freeze({ zeroOrMore: "*", oneOrMore: "+", optional: "?" });
+var a = class {
+  constructor() {
+    this.parts = [], this.flags = /* @__PURE__ */ new Set();
+  }
+  digit() {
+    return this.add("\\d");
+  }
+  special() {
+    return this.add("(?=.*[!@#$%^&*])");
+  }
+  word() {
+    return this.add("\\w");
+  }
+  whitespace() {
+    return this.add("\\s");
+  }
+  nonWhitespace() {
+    return this.add("\\S");
+  }
+  literal(r2) {
+    return this.add((function(r3) {
+      t.has(r3) || t.set(r3, r3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+      return t.get(r3);
+    })(r2));
+  }
+  or() {
+    return this.add("|");
+  }
+  range(t2) {
+    const r2 = e[t2];
+    if (!r2) throw new Error(`Unknown range: ${t2}`);
+    return this.add(`[${r2}]`);
+  }
+  notRange(t2) {
+    const r2 = e[t2];
+    if (!r2) throw new Error(`Unknown range: ${t2}`);
+    return this.add(`[^${r2}]`);
+  }
+  anyOf(t2) {
+    return this.add(`[${t2}]`);
+  }
+  notAnyOf(t2) {
+    return this.add(`[^${t2}]`);
+  }
+  lazy() {
+    const t2 = this.parts.pop();
+    if (!t2) throw new Error("No quantifier to make lazy");
+    return this.add(`${t2}?`);
+  }
+  letter() {
+    return this.add("[a-zA-Z]");
+  }
+  anyCharacter() {
+    return this.add(".");
+  }
+  newline() {
+    return this.add("(?:\\r\\n|\\r|\\n)");
+  }
+  negativeLookahead(t2) {
+    return this.add(`(?!${t2})`);
+  }
+  positiveLookahead(t2) {
+    return this.add(`(?=${t2})`);
+  }
+  positiveLookbehind(t2) {
+    return this.add(`(?<=${t2})`);
+  }
+  negativeLookbehind(t2) {
+    return this.add(`(?<!${t2})`);
+  }
+  hasSpecialCharacter() {
+    return this.add("(?=.*[!@#$%^&*])");
+  }
+  hasDigit() {
+    return this.add("(?=.*\\d)");
+  }
+  hasLetter() {
+    return this.add("(?=.*[a-zA-Z])");
+  }
+  optional() {
+    return this.add(n.optional);
+  }
+  exactly(t2) {
+    return this.add(`{${t2}}`);
+  }
+  atLeast(t2) {
+    return this.add(`{${t2},}`);
+  }
+  atMost(t2) {
+    return this.add(`{0,${t2}}`);
+  }
+  between(t2, r2) {
+    return this.add(`{${t2},${r2}}`);
+  }
+  oneOrMore() {
+    return this.add(n.oneOrMore);
+  }
+  zeroOrMore() {
+    return this.add(n.zeroOrMore);
+  }
+  startNamedGroup(t2) {
+    return this.add(`(?<${t2}>`);
+  }
+  startGroup() {
+    return this.add("(?:");
+  }
+  startCaptureGroup() {
+    return this.add("(");
+  }
+  wordBoundary() {
+    return this.add("\\b");
+  }
+  nonWordBoundary() {
+    return this.add("\\B");
+  }
+  endGroup() {
+    return this.add(")");
+  }
+  startAnchor() {
+    return this.add("^");
+  }
+  endAnchor() {
+    return this.add("$");
+  }
+  global() {
+    return this.flags.add(r.GLOBAL), this;
+  }
+  nonSensitive() {
+    return this.flags.add(r.NON_SENSITIVE), this;
+  }
+  multiline() {
+    return this.flags.add(r.MULTILINE), this;
+  }
+  dotAll() {
+    return this.flags.add(r.DOT_ALL), this;
+  }
+  sticky() {
+    return this.flags.add(r.STICKY), this;
+  }
+  unicodeChar(t2) {
+    this.flags.add(r.UNICODE);
+    const e2 = /* @__PURE__ */ new Set(["u", "l", "t", "m", "o"]);
+    if (void 0 !== t2 && !e2.has(t2)) throw new Error(`Invalid Unicode letter variant: ${t2}`);
+    return this.add(`\\p{L${null != t2 ? t2 : ""}}`);
+  }
+  unicodeDigit() {
+    return this.flags.add(r.UNICODE), this.add("\\p{N}");
+  }
+  unicodePunctuation() {
+    return this.flags.add(r.UNICODE), this.add("\\p{P}");
+  }
+  unicodeSymbol() {
+    return this.flags.add(r.UNICODE), this.add("\\p{S}");
+  }
+  repeat(t2) {
+    if (0 === this.parts.length) throw new Error("No pattern to repeat");
+    const r2 = this.parts.pop();
+    return this.parts.push(`(${r2}){${t2}}`), this;
+  }
+  ipv4Octet() {
+    return this.add("(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)");
+  }
+  protocol() {
+    return this.add("https?://");
+  }
+  www() {
+    return this.add("(www\\.)?");
+  }
+  tld() {
+    return this.add("(com|org|net)");
+  }
+  path() {
+    return this.add("(/\\w+)*");
+  }
+  add(t2) {
+    return this.parts.push(t2), this;
+  }
+  toString() {
+    return this.parts.join("");
+  }
+  toRegExp() {
+    return new RegExp(this.toString(), [...this.flags].join(""));
+  }
+};
+var d = () => new a();
+var i = (() => {
+  const t2 = (t3) => {
+    const r2 = t3().toRegExp();
+    return () => new RegExp(r2.source, r2.flags);
+  };
+  return { email: t2((() => d().startAnchor().word().oneOrMore().literal("@").word().oneOrMore().startGroup().literal(".").word().oneOrMore().endGroup().zeroOrMore().literal(".").letter().atLeast(2).endAnchor())), url: t2((() => d().startAnchor().protocol().www().word().oneOrMore().literal(".").tld().path().endAnchor())), phoneInternational: t2((() => d().startAnchor().literal("+").digit().between(1, 3).literal("-").digit().between(3, 14).endAnchor())) };
+})();
+
 // src/regex.ts
-var metadataRegex = /---\n(.*?)\n---/s;
-var multiwordIngredient = /@(?<mIngredientModifier>[@\-&+*!?])?(?<mIngredientName>(?:[^\s@#~\[\]{(.,;:!?]+(?:\s+[^\s@#~\[\]{(.,;:!?]+)+))(?=\s*(?:\{|\}|\(\s*[^)]*\s*\)))(?:\{(?<mIngredientQuantity>\p{No}|(?:\p{Nd}+(?:[.,\/][\p{Nd}]+)?))?(?:%(?<mIngredientUnits>[^}]+?))?\})?(?:\((?<mIngredientPreparation>[^)]*?)\))?/gu;
-var singleWordIngredient = /@(?<sIngredientModifier>[@\-&+*!?])?(?<sIngredientName>[^\s@#~\[\]{(.,;:!?]+)(?:\{(?:(?<sIngredientQuantity>\p{No}|(?:\p{Nd}+(?:[.,\/][\p{Nd}]+)?))(?:%(?<sIngredientUnits>[^}]+?))?)?\})?(?:\((?<sIngredientPreparation>[^)]*?)\))?/gu;
-var multiwordCookware = /#(?<mCookwareModifier>[\-&+*!?])?(?<mCookwareName>(?:[^\s@#~\[\]{(.,;:!?]+(?:\s+[^\s@#~\[\]{(.,;:!?]+)+))(?=\s*(?:\{|\}|\(\s*[^)]*\s*\)))\{(?<mCookwareQuantity>.*?)\}/;
-var singleWordCookware = /#(?<sCookwareModifier>[\-&+*!?])?(?<sCookwareName>[^\s@#~\[\]{(.,;:!?]+)(?:\{(?<sCookwareQuantity>.*?)\})?/u;
-var timer = /~(?<timerName>.*?)(?:\{(?<timerQuantity>.*?)(?:%(?<timerUnits>.+?))?\})/;
+var metadataRegex = d().literal("---").newline().startCaptureGroup().anyCharacter().zeroOrMore().optional().endGroup().newline().literal("---").dotAll().toRegExp();
+var nonWordChar = "\\s@#~\\[\\]{(.,;:!?";
+var multiwordIngredient = d().literal("@").startNamedGroup("mIngredientModifier").anyOf("@\\-&?").endGroup().optional().startNamedGroup("mIngredientName").notAnyOf(nonWordChar).oneOrMore().startGroup().whitespace().oneOrMore().notAnyOf(nonWordChar).oneOrMore().endGroup().oneOrMore().endGroup().positiveLookahead("\\s*(?:\\{[^\\}]*\\}|\\([^)]*\\))").startGroup().literal("{").startNamedGroup("mIngredientQuantity").notAnyOf("}%").oneOrMore().endGroup().optional().startGroup().literal("%").startNamedGroup("mIngredientUnits").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("sIngredientModifier").anyOf("@\\-&?").endGroup().optional().startNamedGroup("sIngredientName").notAnyOf(nonWordChar).oneOrMore().endGroup().startGroup().literal("{").startNamedGroup("sIngredientQuantity").notAnyOf("}%").oneOrMore().endGroup().optional().startGroup().literal("%").startNamedGroup("sIngredientUnits").notAnyOf("}").oneOrMore().lazy().endGroup().endGroup().optional().literal("}").endGroup().optional().startGroup().literal("(").startNamedGroup("sIngredientPreparation").notAnyOf(")").oneOrMore().lazy().endGroup().literal(")").endGroup().optional().toRegExp();
+var multiwordCookware = d().literal("#").startNamedGroup("mCookwareModifier").anyOf("\\-&?").endGroup().optional().startNamedGroup("mCookwareName").notAnyOf(nonWordChar).oneOrMore().startGroup().whitespace().oneOrMore().notAnyOf(nonWordChar).oneOrMore().endGroup().oneOrMore().endGroup().positiveLookahead("\\s*(?:\\{[^\\}]*\\})").literal("{").startNamedGroup("mCookwareQuantity").anyCharacter().zeroOrMore().lazy().endGroup().literal("}").toRegExp();
+var singleWordCookware = d().literal("#").startNamedGroup("sCookwareModifier").anyOf("\\-&?").endGroup().optional().startNamedGroup("sCookwareName").notAnyOf(nonWordChar).oneOrMore().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("timerUnits").anyCharacter().oneOrMore().lazy().endGroup().endGroup().optional().literal("}").toRegExp();
 var tokensRegex = new RegExp(
   [
     multiwordIngredient,
@@ -89,11 +299,14 @@ var tokensRegex = new RegExp(
     multiwordCookware,
     singleWordCookware,
     timer
-  ].map((r) => r.source).join("|"),
+  ].map((r2) => r2.source).join("|"),
   "gu"
 );
-var commentRegex = /--.*/g;
-var blockCommentRegex = /\s*\[\-.*?\-\]\s*/g;
+var commentRegex = d().literal("--").anyCharacter().zeroOrMore().global().toRegExp();
+var blockCommentRegex = d().whitespace().zeroOrMore().literal("[-").anyCharacter().zeroOrMore().lazy().literal("-]").whitespace().zeroOrMore().global().toRegExp();
+var shoppingListRegex = d().literal("[").startNamedGroup("name").anyCharacter().oneOrMore().endGroup().literal("]").newline().startNamedGroup("items").anyCharacter().zeroOrMore().lazy().endGroup().startGroup().newline().newline().or().endAnchor().endGroup().global().toRegExp();
+var rangeRegex = d().startAnchor().digit().oneOrMore().startGroup().anyOf(".,/").exactly(1).digit().oneOrMore().endGroup().optional().literal("-").startGroup().anyOf(".,/").exactly(1).digit().oneOrMore().endGroup().optional().endAnchor().toRegExp();
+var numberLikeRegex = d().startAnchor().digit().oneOrMore().startGroup().anyOf(".,/").exactly(1).digit().oneOrMore().endGroup().optional().endAnchor().toRegExp();
 
 // src/units.ts
 var units = [
@@ -211,46 +424,148 @@ 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";
+  }
+};
+function gcd(a2, b) {
+  return b === 0 ? a2 : gcd(b, a2 % b);
+}
+function simplifyFraction(num, den) {
+  if (den === 0) {
+    throw new Error("Denominator cannot be zero.");
+  }
+  const commonDivisor = gcd(Math.abs(num), Math.abs(den));
+  let simplifiedNum = num / commonDivisor;
+  let simplifiedDen = den / commonDivisor;
+  if (simplifiedDen < 0) {
+    simplifiedNum = -simplifiedNum;
+    simplifiedDen = -simplifiedDen;
+  }
+  if (simplifiedDen === 1) {
+    return { type: "decimal", value: simplifiedNum };
+  } else {
+    return { type: "fraction", num: simplifiedNum, den: simplifiedDen };
+  }
+}
+function multiplyNumericValue(v, factor) {
+  if (v.type === "decimal") {
+    return { type: "decimal", value: v.value * factor };
+  }
+  return simplifyFraction(v.num * factor, v.den);
+}
+function addNumericValues(val1, val2) {
+  let num1;
+  let den1;
+  let num2;
+  let den2;
+  if (val1.type === "decimal") {
+    num1 = val1.value;
+    den1 = 1;
+  } else {
+    num1 = val1.num;
+    den1 = val1.den;
+  }
+  if (val2.type === "decimal") {
+    num2 = val2.value;
+    den2 = 1;
+  } else {
+    num2 = val2.num;
+    den2 = val2.den;
+  }
+  if (val1.type === "fraction" && val2.type === "fraction") {
+    const commonDen = den1 * den2;
+    const sumNum = num1 * den2 + num2 * den1;
+    return simplifyFraction(sumNum, commonDen);
+  } else {
+    return { type: "decimal", value: num1 / den1 + num2 / den2 };
+  }
+}
+var toRoundedDecimal = (v) => {
+  const value = v.type === "decimal" ? v.value : v.num / v.den;
+  return { type: "decimal", value: Math.floor(value * 100) / 100 };
+};
+function multiplyQuantityValue(value, factor) {
+  if (value.type === "fixed") {
+    return {
+      type: "fixed",
+      value: toRoundedDecimal(
+        multiplyNumericValue(
+          value.value,
+          factor
+        )
+      )
+    };
+  }
+  return {
+    type: "range",
+    min: toRoundedDecimal(
+      multiplyNumericValue(value.min, factor)
+    ),
+    max: toRoundedDecimal(
+      multiplyNumericValue(value.max, factor)
+    )
+  };
+}
+var convertQuantityValue = (value, def, targetDef) => {
+  if (def.name === targetDef.name) return value;
+  const factor = def.toBase / targetDef.toBase;
+  return multiplyQuantityValue(value, factor);
+};
 function addQuantities(q1, q2) {
+  const v1 = q1.value;
+  const v2 = q2.value;
+  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);
-  if (isNaN(Number(q1.value))) {
-    throw new Error(
-      `Cannot add quantity to string-quantified value: ${q1.value}`
+  const addQuantityValuesAndSetUnit = (val1, val2, unit) => {
+    if (val1.type === "fixed" && val2.type === "fixed") {
+      const res = addNumericValues(
+        val1.value,
+        val2.value
+      );
+      return { value: { type: "fixed", value: res }, unit };
+    }
+    const r1 = val1.type === "range" ? val1 : { type: "range", min: val1.value, max: val1.value };
+    const r2 = val2.type === "range" ? val2 : { type: "range", min: val2.value, max: val2.value };
+    const newMin = addNumericValues(
+      r1.min,
+      r2.min
     );
-  }
-  if (isNaN(Number(q2.value))) {
-    throw new Error(
-      `Cannot add quantity to string-quantified value: ${q2.value}`
+    const newMax = addNumericValues(
+      r1.max,
+      r2.max
     );
-  }
+    return { value: { type: "range", min: newMin, max: newMax }, unit };
+  };
   if (q1.unit === "" && unit2Def) {
-    return {
-      value: Math.round((q1.value + q2.value) * 100) / 100,
-      unit: q2.unit
-    };
+    return addQuantityValuesAndSetUnit(v1, v2, q2.unit);
   }
   if (q2.unit === "" && unit1Def) {
-    return {
-      value: Math.round((q1.value + q2.value) * 100) / 100,
-      unit: q1.unit
-    };
+    return addQuantityValuesAndSetUnit(v1, v2, q1.unit);
   }
   if (q1.unit.toLowerCase() === q2.unit.toLowerCase()) {
-    return {
-      value: Math.round((q1.value + q2.value) * 100) / 100,
-      unit: q1.unit
-    };
+    return addQuantityValuesAndSetUnit(v1, v2, q1.unit);
   }
   if (unit1Def && unit2Def) {
     if (unit1Def.type !== unit2Def.type) {
-      throw new Error(
-        `Cannot add quantities of different types: ${unit1Def.type} (${q1.unit}) and ${unit2Def.type} (${q2.unit})`
+      throw new IncompatibleUnitsError(
+        `${unit1Def.type} (${q1.unit})`,
+        `${unit2Def.type} (${q2.unit})`
       );
     }
-    const baseValue1 = q1.value * unit1Def.toBase;
-    const baseValue2 = q2.value * unit2Def.toBase;
-    const totalBaseValue = baseValue1 + baseValue2;
     let targetUnitDef;
     if (unit1Def.system !== unit2Def.system) {
       const metricUnitDef = unit1Def.system === "metric" ? unit1Def : unit2Def;
@@ -260,15 +575,15 @@ function addQuantities(q1, q2) {
     } else {
       targetUnitDef = unit1Def.toBase >= unit2Def.toBase ? unit1Def : unit2Def;
     }
-    const finalValue = totalBaseValue / targetUnitDef.toBase;
-    return {
-      value: Math.round(finalValue * 100) / 100,
-      unit: targetUnitDef.name
-    };
+    const convertedV1 = convertQuantityValue(v1, unit1Def, targetUnitDef);
+    const convertedV2 = convertQuantityValue(v2, unit2Def, targetUnitDef);
+    return addQuantityValuesAndSetUnit(
+      convertedV1,
+      convertedV2,
+      targetUnitDef.name
+    );
   }
-  throw new Error(
-    `Cannot add quantities with incompatible or unknown units: ${q1.unit} and ${q2.unit}`
-  );
+  throw new IncompatibleUnitsError(q1.unit, q2.unit);
 }
 
 // src/parser_helpers.ts
@@ -298,7 +613,7 @@ function findAndUpsertIngredient(ingredients, newIngredient, isReference) {
   const { name, quantity, unit } = newIngredient;
   if (isReference) {
     const index = ingredients.findIndex(
-      (i) => i.name.toLowerCase() === name.toLowerCase()
+      (i2) => i2.name.toLowerCase() === name.toLowerCase()
     );
     if (index === -1) {
       throw new Error(
@@ -308,13 +623,22 @@ function findAndUpsertIngredient(ingredients, newIngredient, isReference) {
     const existingIngredient = ingredients[index];
     if (quantity !== void 0) {
       const currentQuantity = {
-        value: existingIngredient.quantity ?? 0,
+        value: existingIngredient.quantity ?? {
+          type: "fixed",
+          value: { type: "decimal", value: 0 }
+        },
         unit: existingIngredient.unit ?? ""
       };
       const newQuantity = { value: quantity, unit: unit ?? "" };
-      const total = addQuantities(currentQuantity, newQuantity);
-      existingIngredient.quantity = total.value;
-      existingIngredient.unit = total.unit || void 0;
+      try {
+        const total = addQuantities(currentQuantity, newQuantity);
+        existingIngredient.quantity = total.value;
+        existingIngredient.unit = total.unit || void 0;
+      } catch (e2) {
+        if (e2 instanceof IncompatibleUnitsError || e2 instanceof CannotAddTextValueError) {
+          return ingredients.push(newIngredient) - 1;
+        }
+      }
     }
     return index;
   }
@@ -324,7 +648,7 @@ function findAndUpsertCookware(cookware, newCookware, isReference) {
   const { name } = newCookware;
   if (isReference) {
     const index = cookware.findIndex(
-      (i) => i.name.toLowerCase() === name.toLowerCase()
+      (i2) => i2.name.toLowerCase() === name.toLowerCase()
     );
     if (index === -1) {
       throw new Error(
@@ -335,13 +659,28 @@ function findAndUpsertCookware(cookware, newCookware, isReference) {
   }
   return cookware.push(newCookware) - 1;
 }
-function parseNumber(input_str) {
-  const clean_str = String(input_str).replace(",", ".");
-  if (!clean_str.startsWith("/") && clean_str.includes("/")) {
-    const [num, den] = clean_str.split("/").map(Number);
-    return num / den;
+var parseFixedValue = (input_str) => {
+  if (!numberLikeRegex.test(input_str)) {
+    return { type: "text", value: input_str };
   }
-  return Number(clean_str);
+  const s = input_str.trim().replace(",", ".");
+  if (s.includes("/")) {
+    const parts = s.split("/");
+    const num = Number(parts[0]);
+    const den = Number(parts[1]);
+    return { type: "fraction", num, den };
+  }
+  return { type: "decimal", value: Number(s) };
+};
+function parseQuantityInput(input_str) {
+  const clean_str = String(input_str).trim();
+  if (rangeRegex.test(clean_str)) {
+    const range_parts = clean_str.split("-");
+    const min = parseFixedValue(range_parts[0].trim());
+    const max = parseFixedValue(range_parts[1].trim());
+    return { type: "range", min, max };
+  }
+  return { type: "fixed", value: parseFixedValue(clean_str) };
 }
 function parseSimpleMetaVar(content, varName) {
   const varMatch = content.match(
@@ -534,7 +873,7 @@ var Recipe = class _Recipe {
           const hidden = modifier === "-";
           const reference = modifier === "&";
           const isRecipe = modifier === "@";
-          const quantity = quantityRaw ? parseNumber(quantityRaw) : void 0;
+          const quantity = quantityRaw ? parseQuantityInput(quantityRaw) : void 0;
           const idxInList = findAndUpsertIngredient(
             this.ingredients,
             {
@@ -561,12 +900,14 @@ var Recipe = class _Recipe {
         } else if (groups.mCookwareName || groups.sCookwareName) {
           const name = groups.mCookwareName || groups.sCookwareName;
           const modifier = groups.mCookwareModifier || groups.sCookwareModifier;
+          const quantityRaw = groups.mCookwareQuantity || groups.sCookwareQuantity;
           const optional = modifier === "?";
           const hidden = modifier === "-";
           const reference = modifier === "&";
+          const quantity = quantityRaw ? parseQuantityInput(quantityRaw) : void 0;
           const idxInList = findAndUpsertCookware(
             this.cookware,
-            { name, optional, hidden },
+            { name, quantity, optional, hidden },
             reference
           );
           items.push({ type: "cookware", value: idxInList });
@@ -577,7 +918,7 @@ var Recipe = class _Recipe {
             throw new Error("Timer missing units");
           }
           const name = groups.timerName || void 0;
-          const duration = parseNumber(durationStr);
+          const duration = parseQuantityInput(durationStr);
           const timerObj = {
             name,
             duration,
@@ -585,7 +926,7 @@ var Recipe = class _Recipe {
           };
           const idxInList = findOrPush(
             this.timers,
-            (t) => t.name === timerObj.name && t.duration === timerObj.duration && t.unit === timerObj.unit,
+            (t2) => t2.name === timerObj.name && t2.duration === timerObj.duration && t2.unit === timerObj.unit,
             () => timerObj
           );
           items.push({ type: "timer", value: idxInList });
@@ -628,8 +969,11 @@ var Recipe = class _Recipe {
       throw new Error("Error scaling recipe: no initial servings value set");
     }
     newRecipe.ingredients = newRecipe.ingredients.map((ingredient) => {
-      if (ingredient.quantity && !isNaN(Number(ingredient.quantity))) {
-        ingredient.quantity *= factor;
+      if (ingredient.quantity && !(ingredient.quantity.type === "fixed" && ingredient.quantity.value.type === "text")) {
+        ingredient.quantity = multiplyQuantityValue(
+          ingredient.quantity,
+          factor
+        );
       }
       return ingredient;
     }).filter((ingredient) => ingredient.quantity !== null);
@@ -654,6 +998,11 @@ var Recipe = class _Recipe {
     }
     return newRecipe;
   }
+  /**
+   * Gets the number of servings for the recipe.
+   * @private
+   * @returns The number of servings, or undefined if not set.
+   */
   getServings() {
     if (this.servings) {
       return this.servings;
@@ -716,7 +1065,7 @@ var ShoppingList = class {
           continue;
         }
         const existingIngredient = this.ingredients.find(
-          (i) => i.name === ingredient.name
+          (i2) => i2.name === ingredient.name
         );
         let addSeparate = false;
         try {
@@ -826,6 +1175,7 @@ var ShoppingList = class {
 export {
   AisleConfig,
   Recipe,
+  Section,
   ShoppingList
 };
 //# sourceMappingURL=index.js.map