@tmlmt/cooklang-parser 1.4.4 → 2.0.1

package/README.md

@@ -60,7 +60,10 @@ console.log(recipe.timers); // [{ duration: 15, unit: "minutes", name: undefined
 
 ## Future plans
 
-I plan to further develop features depending on the needs or bugs I will encounter in using this library in a practical application.
+I plan to further develop features depending on the needs or bugs I will encounter in using this library in a practical application. Current backlog is as follows:
+
+- Fixing non-compliance with spec for recipe referencing by path
+- Pantry parsing and basic functions (e.g. take pantry into account when creating a shopping list)
 
 ## Test coverage
 

package/dist/index.cjs

@@ -316,13 +316,14 @@ var i = (() => {
 
 // src/regex.ts
 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 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().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).oneOrMore().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 ingredientAliasRegex = d().startAnchor().startNamedGroup("ingredientListName").notAnyOf("|").oneOrMore().endGroup().literal("|").startNamedGroup("ingredientDisplayName").notAnyOf("|").oneOrMore().endGroup().endAnchor().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 multiwordCookware = d().literal("#").startNamedGroup("mCookwareModifiers").anyOf("\\-&?").zeroOrMore().endGroup().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("sCookwareModifiers").anyOf("\\-&?").zeroOrMore().endGroup().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("timerUnit").anyCharacter().oneOrMore().lazy().endGroup().endGroup().optional().literal("}").toRegExp();
 var tokensRegex = new RegExp(
   [
     multiwordIngredient,
@@ -338,6 +339,7 @@ var blockCommentRegex = d().whitespace().zeroOrMore().literal("[-").anyCharacter
 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("-").digit().oneOrMore().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();
+var floatRegex = d().startAnchor().digit().oneOrMore().startGroup().anyOf(".").exactly(1).digit().oneOrMore().endGroup().optional().endAnchor().toRegExp();
 
 // src/units.ts
 var units = [
@@ -452,7 +454,7 @@ for (const unit of units) {
     unitMap.set(alias.toLowerCase(), unit);
   }
 }
-function normalizeUnit(unit) {
+function normalizeUnit(unit = "") {
   return unitMap.get(unit.toLowerCase().trim());
 }
 var CannotAddTextValueError = class extends Error {
@@ -514,7 +516,10 @@ function addNumericValues(val1, val2) {
     num2 = val2.num;
     den2 = val2.den;
   }
-  if (val1.type === "fraction" && val2.type === "fraction") {
+  if (num1 === 0 && num2 === 0) {
+    return { type: "decimal", value: 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) {
     const commonDen = den1 * den2;
     const sumNum = num1 * den2 + num2 * den1;
     return simplifyFraction(sumNum, commonDen);
@@ -555,6 +560,32 @@ var convertQuantityValue = (value, def, targetDef) => {
   const factor = def.toBase / targetDef.toBase;
   return multiplyQuantityValue(value, factor);
 };
+function getDefaultQuantityValue() {
+  return { type: "fixed", value: { type: "decimal", value: 0 } };
+}
+function addQuantityValues(v1, v2) {
+  if (v1.type === "fixed" && v1.value.type === "text" || v2.type === "fixed" && v2.value.type === "text") {
+    throw new CannotAddTextValueError();
+  }
+  if (v1.type === "fixed" && v2.type === "fixed") {
+    const res = addNumericValues(
+      v1.value,
+      v2.value
+    );
+    return { type: "fixed", value: res };
+  }
+  const r1 = v1.type === "range" ? v1 : { type: "range", min: v1.value, max: v1.value };
+  const r2 = v2.type === "range" ? v2 : { type: "range", min: v2.value, max: v2.value };
+  const newMin = addNumericValues(
+    r1.min,
+    r2.min
+  );
+  const newMax = addNumericValues(
+    r1.max,
+    r2.max
+  );
+  return { type: "range", min: newMin, max: newMax };
+}
 function addQuantities(q1, q2) {
   const v1 = q1.value;
   const v2 = q2.value;
@@ -563,33 +594,14 @@ function addQuantities(q1, q2) {
   }
   const unit1Def = normalizeUnit(q1.unit);
   const unit2Def = normalizeUnit(q2.unit);
-  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
-    );
-    const newMax = addNumericValues(
-      r1.max,
-      r2.max
-    );
-    return { value: { type: "range", min: newMin, max: newMax }, unit };
-  };
-  if (q1.unit === "" && unit2Def) {
+  const addQuantityValuesAndSetUnit = (val1, val2, unit) => ({ value: addQuantityValues(val1, val2), unit });
+  if ((q1.unit === "" || q1.unit === void 0) && q2.unit !== void 0) {
     return addQuantityValuesAndSetUnit(v1, v2, q2.unit);
   }
-  if (q2.unit === "" && unit1Def) {
+  if ((q2.unit === "" || q2.unit === void 0) && q1.unit !== void 0) {
     return addQuantityValuesAndSetUnit(v1, v2, q1.unit);
   }
-  if (q1.unit.toLowerCase() === q2.unit.toLowerCase()) {
+  if (!q1.unit && !q2.unit || q1.unit && q2.unit && q1.unit.toLowerCase() === q2.unit.toLowerCase()) {
     return addQuantityValuesAndSetUnit(v1, v2, q1.unit);
   }
   if (unit1Def && unit2Def) {
@@ -619,6 +631,17 @@ function addQuantities(q1, q2) {
   throw new IncompatibleUnitsError(q1.unit, q2.unit);
 }
 
+// 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";
+  }
+};
+
 // src/parser_helpers.ts
 function flushPendingNote(section, note) {
   if (note.length > 0) {
@@ -638,21 +661,28 @@ function flushPendingItems(section, items) {
 function findAndUpsertIngredient(ingredients, newIngredient, isReference) {
   const { name, quantity, unit } = newIngredient;
   if (isReference) {
-    const index = ingredients.findIndex(
+    const indexFind = ingredients.findIndex(
       (i2) => i2.name.toLowerCase() === name.toLowerCase()
     );
-    if (index === -1) {
+    if (indexFind === -1) {
       throw new Error(
         `Referenced ingredient "${name}" not found. A referenced ingredient must be declared before being referenced with '&'.`
       );
     }
-    const existingIngredient = ingredients[index];
+    const existingIngredient = ingredients[indexFind];
+    for (const flag of newIngredient.flags) {
+      if (!existingIngredient.flags.includes(flag)) {
+        throw new ReferencedItemCannotBeRedefinedError(
+          "ingredient",
+          existingIngredient.name,
+          flag
+        );
+      }
+    }
+    let quantityPartIndex = void 0;
     if (quantity !== void 0) {
       const currentQuantity = {
-        value: existingIngredient.quantity ?? {
-          type: "fixed",
-          value: { type: "decimal", value: 0 }
-        },
+        value: existingIngredient.quantity ?? getDefaultQuantityValue(),
         unit: existingIngredient.unit ?? ""
       };
       const newQuantity = { value: quantity, unit: unit ?? "" };
@@ -660,18 +690,35 @@ function findAndUpsertIngredient(ingredients, newIngredient, isReference) {
         const total = addQuantities(currentQuantity, newQuantity);
         existingIngredient.quantity = total.value;
         existingIngredient.unit = total.unit || void 0;
+        if (existingIngredient.quantityParts) {
+          existingIngredient.quantityParts.push(
+            ...newIngredient.quantityParts
+          );
+        } else {
+          existingIngredient.quantityParts = newIngredient.quantityParts;
+        }
+        quantityPartIndex = existingIngredient.quantityParts.length - 1;
       } catch (e2) {
         if (e2 instanceof IncompatibleUnitsError || e2 instanceof CannotAddTextValueError) {
-          return ingredients.push(newIngredient) - 1;
+          return {
+            ingredientIndex: ingredients.push(newIngredient) - 1,
+            quantityPartIndex: 0
+          };
         }
       }
     }
-    return index;
+    return {
+      ingredientIndex: indexFind,
+      quantityPartIndex
+    };
   }
-  return ingredients.push(newIngredient) - 1;
+  return {
+    ingredientIndex: ingredients.push(newIngredient) - 1,
+    quantityPartIndex: 0
+  };
 }
 function findAndUpsertCookware(cookware, newCookware, isReference) {
-  const { name } = newCookware;
+  const { name, quantity } = newCookware;
   if (isReference) {
     const index = cookware.findIndex(
       (i2) => i2.name.toLowerCase() === name.toLowerCase()
@@ -681,9 +728,55 @@ function findAndUpsertCookware(cookware, newCookware, isReference) {
         `Referenced cookware "${name}" not found. A referenced cookware must be declared before being referenced with '&'.`
       );
     }
-    return index;
+    const existingCookware = cookware[index];
+    for (const flag of newCookware.flags) {
+      if (!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 {
+      cookwareIndex: index,
+      quantityPartIndex
+    };
   }
-  return cookware.push(newCookware) - 1;
+  return {
+    cookwareIndex: cookware.push(newCookware) - 1,
+    quantityPartIndex: quantity ? 0 : void 0
+  };
 }
 var parseFixedValue = (input_str) => {
   if (!numberLikeRegex.test(input_str)) {
@@ -715,9 +808,7 @@ function parseSimpleMetaVar(content, varName) {
   return varMatch ? varMatch[1]?.trim().replace(/\s*\r?\n\s+/g, " ") : void 0;
 }
 function parseScalingMetaVar(content, varName) {
-  const varMatch = content.match(
-    new RegExp(`^${varName}:[\\t ]*(([^,\\n]*),? ?(?:.*)?)`, "m")
-  );
+  const varMatch = content.match(scalingMetaValueRegex(varName));
   if (!varMatch) return void 0;
   if (isNaN(Number(varMatch[2]?.trim()))) {
     throw new Error("Scaling variables should be numbers");
@@ -773,7 +864,7 @@ function extractMetadata(content) {
     const stringMetaValue = parseSimpleMetaVar(metadataContent, metaVar);
     if (stringMetaValue) metadata[metaVar] = stringMetaValue;
   }
-  for (const metaVar of ["servings", "yield", "serves"]) {
+  for (const metaVar of ["serves", "yield", "servings"]) {
     const scalingMetaValue = parseScalingMetaVar(metadataContent, metaVar);
     if (scalingMetaValue && scalingMetaValue[1]) {
       metadata[metaVar] = scalingMetaValue[1];
@@ -889,15 +980,28 @@ var Recipe = class _Recipe {
         }
         const groups = match.groups;
         if (groups.mIngredientName || groups.sIngredientName) {
-          const name = groups.mIngredientName || groups.sIngredientName;
+          let name = groups.mIngredientName || groups.sIngredientName;
+          const scalableQuantity = (groups.mIngredientQuantityModifier || groups.sIngredientQuantityModifier) !== "=";
           const quantityRaw = groups.mIngredientQuantity || groups.sIngredientQuantity;
-          const units2 = groups.mIngredientUnits || groups.sIngredientUnits;
+          const unit = groups.mIngredientUnit || groups.sIngredientUnit;
           const preparation = groups.mIngredientPreparation || groups.sIngredientPreparation;
-          const modifier = groups.mIngredientModifier || groups.sIngredientModifier;
-          const optional = modifier === "?";
-          const hidden = modifier === "-";
-          const reference = modifier === "&";
-          const isRecipe = modifier === "@";
+          const modifiers = groups.mIngredientModifiers || groups.sIngredientModifiers;
+          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.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;
@@ -908,50 +1012,70 @@ var Recipe = class _Recipe {
             listName = name;
             displayName = name;
           }
-          const idxInList = findAndUpsertIngredient(
+          const newIngredient = {
+            name: listName,
+            quantity,
+            quantityParts: quantity ? [
+              {
+                value: quantity,
+                unit,
+                scalable: scalableQuantity
+              }
+            ] : void 0,
+            unit,
+            preparation,
+            flags
+          };
+          if (extras) {
+            newIngredient.extras = extras;
+          }
+          const idxsInList = findAndUpsertIngredient(
             this.ingredients,
-            {
-              name: listName,
-              quantity,
-              unit: units2,
-              optional,
-              hidden,
-              preparation,
-              isRecipe
-            },
+            newIngredient,
             reference
           );
           const newItem = {
             type: "ingredient",
-            value: idxInList,
-            itemQuantity: quantity,
-            itemUnit: units2,
+            index: idxsInList.ingredientIndex,
             displayName
           };
+          if (idxsInList.quantityPartIndex !== void 0) {
+            newItem.quantityPartIndex = idxsInList.quantityPartIndex;
+          }
           items.push(newItem);
         } else if (groups.mCookwareName || groups.sCookwareName) {
           const name = groups.mCookwareName || groups.sCookwareName;
-          const modifier = groups.mCookwareModifier || groups.sCookwareModifier;
+          const modifiers = groups.mCookwareModifiers || groups.sCookwareModifiers;
           const quantityRaw = groups.mCookwareQuantity || groups.sCookwareQuantity;
-          const optional = modifier === "?";
-          const hidden = modifier === "-";
-          const reference = modifier === "&";
+          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 idxInList = findAndUpsertCookware(
+          const idxsInList = findAndUpsertCookware(
             this.cookware,
-            { name, quantity, optional, hidden },
+            {
+              name,
+              quantity,
+              quantityParts: quantity ? [quantity] : void 0,
+              flags
+            },
             reference
           );
           items.push({
             type: "cookware",
-            value: idxInList,
-            itemQuantity: quantity
+            index: idxsInList.cookwareIndex,
+            quantityPartIndex: idxsInList.quantityPartIndex
           });
-        } else if (groups.timerQuantity !== void 0) {
+        } else {
           const durationStr = groups.timerQuantity.trim();
-          const unit = (groups.timerUnits || "").trim();
+          const unit = (groups.timerUnit || "").trim();
           if (!unit) {
-            throw new Error("Timer missing units");
+            throw new Error("Timer missing unit");
           }
           const name = groups.timerName || void 0;
           const duration = parseQuantityInput(durationStr);
@@ -960,7 +1084,7 @@ var Recipe = class _Recipe {
             duration,
             unit
           };
-          items.push({ type: "timer", value: this.timers.push(timerObj) - 1 });
+          items.push({ type: "timer", index: this.timers.push(timerObj) - 1 });
         }
         cursor = idx + match[0].length;
       }
@@ -1003,30 +1127,57 @@ var Recipe = class _Recipe {
       throw new Error("Error scaling recipe: no initial servings value set");
     }
     newRecipe.ingredients = newRecipe.ingredients.map((ingredient) => {
-      if (ingredient.quantity && !(ingredient.quantity.type === "fixed" && ingredient.quantity.value.type === "text")) {
-        ingredient.quantity = multiplyQuantityValue(
-          ingredient.quantity,
-          factor
+      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 ? factor : 1
+              )
+            };
+          }
         );
+        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 = originalServings * factor;
     if (newRecipe.metadata.servings && this.metadata.servings) {
-      const servingsValue = parseFloat(this.metadata.servings);
-      if (!isNaN(servingsValue)) {
+      if (floatRegex.test(String(this.metadata.servings).replace(",", ".").trim())) {
+        const servingsValue = parseFloat(
+          String(this.metadata.servings).replace(",", ".")
+        );
         newRecipe.metadata.servings = String(servingsValue * factor);
       }
     }
     if (newRecipe.metadata.yield && this.metadata.yield) {
-      const yieldValue = parseFloat(this.metadata.yield);
-      if (!isNaN(yieldValue)) {
+      if (floatRegex.test(String(this.metadata.yield).replace(",", ".").trim())) {
+        const yieldValue = parseFloat(
+          String(this.metadata.yield).replace(",", ".")
+        );
         newRecipe.metadata.yield = String(yieldValue * factor);
       }
     }
     if (newRecipe.metadata.serves && this.metadata.serves) {
-      const servesValue = parseFloat(this.metadata.serves);
-      if (!isNaN(servesValue)) {
+      if (floatRegex.test(String(this.metadata.serves).replace(",", ".").trim())) {
+        const servesValue = parseFloat(
+          String(this.metadata.serves).replace(",", ".")
+        );
         newRecipe.metadata.serves = String(servesValue * factor);
       }
     }
@@ -1095,7 +1246,7 @@ var ShoppingList = class {
     for (const { recipe, factor } of this.recipes) {
       const scaledRecipe = factor === 1 ? recipe : recipe.scaleBy(factor);
       for (const ingredient of scaledRecipe.ingredients) {
-        if (ingredient.hidden) {
+        if (ingredient.flags && ingredient.flags.includes("hidden")) {
           continue;
         }
         const existingIngredient = this.ingredients.find(
@@ -1103,8 +1254,8 @@ var ShoppingList = class {
         );
         let addSeparate = false;
         try {
-          if (existingIngredient) {
-            if (existingIngredient.quantity && ingredient.quantity) {
+          if (existingIngredient && ingredient.quantity) {
+            if (existingIngredient.quantity) {
               const newQuantity = addQuantities(
                 {
                   value: existingIngredient.quantity,
@@ -1119,7 +1270,7 @@ var ShoppingList = class {
               if (newQuantity.unit) {
                 existingIngredient.unit = newQuantity.unit;
               }
-            } else if (ingredient.quantity) {
+            } else {
               existingIngredient.quantity = ingredient.quantity;
               if (ingredient.unit) {
                 existingIngredient.unit = ingredient.unit;
@@ -1219,4 +1370,8 @@ var ShoppingList = class {
   Section,
   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 */
 //# sourceMappingURL=index.cjs.map