soustack 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,2009 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var Ajv = require('ajv');
+var addFormats = require('ajv-formats');
+var cheerio = require('cheerio');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+var addFormats__default = /*#__PURE__*/_interopDefault(addFormats);
+
+// src/parser.ts
+function scaleRecipe(recipe, targetYieldAmount) {
+  const baseYield = recipe.yield?.amount || 1;
+  const multiplier = targetYieldAmount / baseYield;
+  const flatIngredients = flattenIngredients(recipe.ingredients);
+  const scaledIngredientsMap = /* @__PURE__ */ new Map();
+  flatIngredients.forEach((ing) => {
+    if (isIndependent(ing.scaling?.type)) {
+      const computed = calculateIngredient(ing, multiplier);
+      scaledIngredientsMap.set(ing.id || ing.item, computed);
+    }
+  });
+  flatIngredients.forEach((ing) => {
+    if (!isIndependent(ing.scaling?.type)) {
+      if (ing.scaling?.type === "bakers_percentage" && ing.scaling.referenceId) {
+        const refIng = scaledIngredientsMap.get(ing.scaling.referenceId);
+        if (refIng) refIng.amount;
+      }
+      const computed = calculateIngredient(ing, multiplier);
+      scaledIngredientsMap.set(ing.id || ing.item, computed);
+    }
+  });
+  const flatInstructions = flattenInstructions(recipe.instructions);
+  const computedInstructions = flatInstructions.map(
+    (inst) => calculateInstruction(inst, multiplier)
+  );
+  const timing = computedInstructions.reduce(
+    (acc, step) => {
+      if (step.type === "active") acc.active += step.durationMinutes;
+      else acc.passive += step.durationMinutes;
+      acc.total += step.durationMinutes;
+      return acc;
+    },
+    { active: 0, passive: 0, total: 0 }
+  );
+  return {
+    metadata: {
+      targetYield: targetYieldAmount,
+      baseYield,
+      multiplier
+    },
+    ingredients: Array.from(scaledIngredientsMap.values()),
+    instructions: computedInstructions,
+    timing
+  };
+}
+function isIndependent(type) {
+  return !type || type === "linear" || type === "fixed" || type === "discrete";
+}
+function calculateIngredient(ing, multiplier, referenceValue) {
+  const baseAmount = ing.quantity?.amount || 0;
+  const type = ing.scaling?.type || "linear";
+  let newAmount = baseAmount;
+  switch (type) {
+    case "linear":
+      newAmount = baseAmount * multiplier;
+      break;
+    case "fixed":
+      newAmount = baseAmount;
+      break;
+    case "discrete":
+      const raw = baseAmount * multiplier;
+      const step = ing.scaling.roundTo || 1;
+      newAmount = Math.round(raw / step) * step;
+      break;
+    case "bakers_percentage":
+      newAmount = baseAmount * multiplier;
+      break;
+  }
+  const unit = ing.quantity?.unit || "";
+  const ingredientName = ing.name || extractNameFromItem(ing.item);
+  const text = `${parseFloat(newAmount.toFixed(2))}${unit ? " " + unit : ""} ${ingredientName}`;
+  return {
+    id: ing.id || ing.item,
+    name: ingredientName,
+    amount: newAmount,
+    unit: ing.quantity?.unit || null,
+    text,
+    notes: ing.notes
+  };
+}
+function extractNameFromItem(item) {
+  const match = item.match(/^\s*\d+(?:\.\d+)?\s*\w*\s*(.+)$/);
+  return match ? match[1].trim() : item;
+}
+function calculateInstruction(inst, multiplier) {
+  const baseDuration = inst.timing?.duration || 0;
+  const scalingType = inst.timing?.scaling || "fixed";
+  let newDuration = baseDuration;
+  if (scalingType === "linear") {
+    newDuration = baseDuration * multiplier;
+  } else if (scalingType === "sqrt") {
+    newDuration = baseDuration * Math.sqrt(multiplier);
+  }
+  return {
+    id: inst.id || "step",
+    text: inst.text,
+    durationMinutes: Math.ceil(newDuration),
+    type: inst.timing?.type || "active"
+  };
+}
+function flattenIngredients(items) {
+  const result = [];
+  items.forEach((item) => {
+    if (typeof item === "string") {
+      result.push({ item, quantity: { amount: 0, unit: null }, scaling: { type: "fixed" } });
+    } else if ("subsection" in item) {
+      result.push(...flattenIngredients(item.items));
+    } else {
+      result.push(item);
+    }
+  });
+  return result;
+}
+function flattenInstructions(items) {
+  const result = [];
+  items.forEach((item) => {
+    if (typeof item === "string") {
+      result.push({ text: item, timing: { duration: 0, type: "active" } });
+    } else if ("subsection" in item) {
+      result.push(...flattenInstructions(item.items));
+    } else {
+      result.push(item);
+    }
+  });
+  return result;
+}
+
+// src/schema.json
+var schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.1",
+  title: "Soustack Recipe Schema v0.1",
+  description: "A portable, scalable, interoperable recipe format.",
+  type: "object",
+  required: ["name", "ingredients", "instructions"],
+  properties: {
+    id: {
+      type: "string",
+      description: "Unique identifier (slug or UUID)"
+    },
+    name: {
+      type: "string",
+      description: "The title of the recipe"
+    },
+    version: {
+      type: "string",
+      pattern: "^\\d+\\.\\d+\\.\\d+$",
+      description: "Semantic versioning (e.g., 1.0.0)"
+    },
+    description: {
+      type: "string"
+    },
+    category: {
+      type: "string",
+      examples: ["Main Course", "Dessert"]
+    },
+    tags: {
+      type: "array",
+      items: { type: "string" }
+    },
+    image: {
+      type: "string",
+      format: "uri"
+    },
+    dateAdded: {
+      type: "string",
+      format: "date-time"
+    },
+    source: {
+      type: "object",
+      properties: {
+        author: { type: "string" },
+        url: { type: "string", format: "uri" },
+        name: { type: "string" },
+        adapted: { type: "boolean" }
+      }
+    },
+    yield: {
+      $ref: "#/definitions/yield"
+    },
+    time: {
+      $ref: "#/definitions/time"
+    },
+    equipment: {
+      type: "array",
+      items: { $ref: "#/definitions/equipment" }
+    },
+    ingredients: {
+      type: "array",
+      items: {
+        anyOf: [
+          { type: "string" },
+          { $ref: "#/definitions/ingredient" },
+          { $ref: "#/definitions/ingredientSubsection" }
+        ]
+      }
+    },
+    instructions: {
+      type: "array",
+      items: {
+        anyOf: [
+          { type: "string" },
+          { $ref: "#/definitions/instruction" },
+          { $ref: "#/definitions/instructionSubsection" }
+        ]
+      }
+    },
+    storage: {
+      $ref: "#/definitions/storage"
+    },
+    substitutions: {
+      type: "array",
+      items: { $ref: "#/definitions/substitution" }
+    }
+  },
+  definitions: {
+    yield: {
+      type: "object",
+      required: ["amount", "unit"],
+      properties: {
+        amount: { type: "number" },
+        unit: { type: "string" },
+        servings: { type: "number" },
+        description: { type: "string" }
+      }
+    },
+    time: {
+      oneOf: [
+        {
+          type: "object",
+          properties: {
+            prep: { type: "number" },
+            active: { type: "number" },
+            passive: { type: "number" },
+            total: { type: "number" }
+          }
+        },
+        {
+          type: "object",
+          properties: {
+            prepTime: { type: "string" },
+            cookTime: { type: "string" }
+          }
+        }
+      ]
+    },
+    quantity: {
+      type: "object",
+      required: ["amount"],
+      properties: {
+        amount: { type: "number" },
+        unit: { type: ["string", "null"] }
+      }
+    },
+    scaling: {
+      type: "object",
+      required: ["type"],
+      properties: {
+        type: {
+          type: "string",
+          enum: ["linear", "discrete", "proportional", "fixed", "bakers_percentage"]
+        },
+        factor: { type: "number" },
+        referenceId: { type: "string" },
+        roundTo: { type: "number" },
+        min: { type: "number" },
+        max: { type: "number" }
+      },
+      if: {
+        properties: { type: { const: "bakers_percentage" } }
+      },
+      then: {
+        required: ["referenceId"]
+      }
+    },
+    ingredient: {
+      type: "object",
+      required: ["item"],
+      properties: {
+        id: { type: "string" },
+        item: { type: "string" },
+        quantity: { $ref: "#/definitions/quantity" },
+        name: { type: "string" },
+        aisle: { type: "string" },
+        prep: { type: "string" },
+        prepAction: { type: "string" },
+        prepTime: { type: "number" },
+        destination: { type: "string" },
+        scaling: { $ref: "#/definitions/scaling" },
+        critical: { type: "boolean" },
+        optional: { type: "boolean" },
+        notes: { type: "string" }
+      }
+    },
+    ingredientSubsection: {
+      type: "object",
+      required: ["subsection", "items"],
+      properties: {
+        subsection: { type: "string" },
+        items: {
+          type: "array",
+          items: { $ref: "#/definitions/ingredient" }
+        }
+      }
+    },
+    equipment: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        id: { type: "string" },
+        name: { type: "string" },
+        required: { type: "boolean" },
+        label: { type: "string" },
+        capacity: { $ref: "#/definitions/quantity" },
+        scalingLimit: { type: "number" },
+        alternatives: {
+          type: "array",
+          items: { type: "string" }
+        }
+      }
+    },
+    instruction: {
+      type: "object",
+      required: ["text"],
+      properties: {
+        id: { type: "string" },
+        text: { type: "string" },
+        destination: { type: "string" },
+        dependsOn: {
+          type: "array",
+          items: { type: "string" }
+        },
+        inputs: {
+          type: "array",
+          items: { type: "string" }
+        },
+        timing: {
+          type: "object",
+          required: ["duration", "type"],
+          properties: {
+            duration: { type: "number" },
+            type: { type: "string", enum: ["active", "passive"] },
+            scaling: { type: "string", enum: ["linear", "fixed", "sqrt"] }
+          }
+        }
+      }
+    },
+    instructionSubsection: {
+      type: "object",
+      required: ["subsection", "items"],
+      properties: {
+        subsection: { type: "string" },
+        items: {
+          type: "array",
+          items: {
+            anyOf: [
+              { type: "string" },
+              { $ref: "#/definitions/instruction" }
+            ]
+          }
+        }
+      }
+    },
+    storage: {
+      type: "object",
+      properties: {
+        roomTemp: { $ref: "#/definitions/storageMethod" },
+        refrigerated: { $ref: "#/definitions/storageMethod" },
+        frozen: {
+          allOf: [
+            { $ref: "#/definitions/storageMethod" },
+            {
+              type: "object",
+              properties: { thawing: { type: "string" } }
+            }
+          ]
+        },
+        reheating: { type: "string" },
+        makeAhead: {
+          type: "array",
+          items: {
+            allOf: [
+              { $ref: "#/definitions/storageMethod" },
+              {
+                type: "object",
+                required: ["component", "storage"],
+                properties: {
+                  component: { type: "string" },
+                  storage: { type: "string", enum: ["roomTemp", "refrigerated", "frozen"] }
+                }
+              }
+            ]
+          }
+        }
+      }
+    },
+    storageMethod: {
+      type: "object",
+      required: ["duration"],
+      properties: {
+        duration: { type: "string", pattern: "^P" },
+        method: { type: "string" },
+        notes: { type: "string" }
+      }
+    },
+    substitution: {
+      type: "object",
+      required: ["ingredient"],
+      properties: {
+        ingredient: { type: "string" },
+        critical: { type: "boolean" },
+        notes: { type: "string" },
+        alternatives: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["name", "ratio"],
+            properties: {
+              name: { type: "string" },
+              ratio: { type: "string" },
+              notes: { type: "string" },
+              impact: { type: "string" },
+              dietary: {
+                type: "array",
+                items: { type: "string" }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/validator.ts
+var ajv = new Ajv__default.default();
+addFormats__default.default(ajv);
+var validate = ajv.compile(schema_default);
+function validateRecipe(data) {
+  const isValid = validate(data);
+  if (!isValid) {
+    throw new Error(JSON.stringify(validate.errors, null, 2));
+  }
+  return true;
+}
+
+// src/parsers/ingredient.ts
+var FRACTION_DECIMALS = {
+  "\xBD": 0.5,
+  "\u2153": 1 / 3,
+  "\u2154": 2 / 3,
+  "\xBC": 0.25,
+  "\xBE": 0.75,
+  "\u2155": 0.2,
+  "\u2156": 0.4,
+  "\u2157": 0.6,
+  "\u2158": 0.8,
+  "\u2159": 1 / 6,
+  "\u215A": 5 / 6,
+  "\u215B": 0.125,
+  "\u215C": 0.375,
+  "\u215D": 0.625,
+  "\u215E": 0.875
+};
+var NUMBER_WORDS = {
+  zero: 0,
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10,
+  eleven: 11,
+  twelve: 12,
+  thirteen: 13,
+  fourteen: 14,
+  fifteen: 15,
+  sixteen: 16,
+  seventeen: 17,
+  eighteen: 18,
+  nineteen: 19,
+  twenty: 20,
+  thirty: 30,
+  forty: 40,
+  fifty: 50,
+  sixty: 60,
+  seventy: 70,
+  eighty: 80,
+  ninety: 90,
+  hundred: 100,
+  half: 0.5,
+  quarter: 0.25
+};
+var UNIT_SYNONYMS = {
+  cup: "cup",
+  cups: "cup",
+  c: "cup",
+  tbsp: "tbsp",
+  tablespoon: "tbsp",
+  tablespoons: "tbsp",
+  tbs: "tbsp",
+  tsp: "tsp",
+  teaspoon: "tsp",
+  teaspoons: "tsp",
+  t: "tsp",
+  gram: "g",
+  grams: "g",
+  g: "g",
+  kilogram: "kg",
+  kilograms: "kg",
+  kg: "kg",
+  milliliter: "ml",
+  milliliters: "ml",
+  ml: "ml",
+  liter: "l",
+  liters: "l",
+  l: "l",
+  ounce: "oz",
+  ounces: "oz",
+  oz: "oz",
+  pound: "lb",
+  pounds: "lb",
+  lb: "lb",
+  lbs: "lb",
+  pint: "pint",
+  pints: "pint",
+  quart: "quart",
+  quarts: "quart",
+  stick: "stick",
+  sticks: "stick",
+  dash: "dash",
+  pinches: "pinch",
+  pinch: "pinch"
+};
+var PREP_PHRASES = [
+  "diced",
+  "finely diced",
+  "roughly diced",
+  "minced",
+  "finely minced",
+  "chopped",
+  "finely chopped",
+  "roughly chopped",
+  "sliced",
+  "thinly sliced",
+  "thickly sliced",
+  "grated",
+  "finely grated",
+  "zested",
+  "sifted",
+  "softened",
+  "at room temperature",
+  "room temperature",
+  "room temp",
+  "melted",
+  "toasted",
+  "drained",
+  "drained and rinsed",
+  "beaten",
+  "divided",
+  "cut into cubes",
+  "cut into pieces",
+  "cut into strips",
+  "cut into chunks",
+  "cut into bite-size pieces"
+].map((value) => value.toLowerCase());
+var COUNT_DESCRIPTORS = /* @__PURE__ */ new Set([
+  "clove",
+  "cloves",
+  "can",
+  "cans",
+  "stick",
+  "sticks",
+  "sprig",
+  "sprigs",
+  "bunch",
+  "bunches",
+  "slice",
+  "slices",
+  "package",
+  "packages"
+]);
+var DESCRIPTOR_NOTE_SET = /* @__PURE__ */ new Set(["can", "cans", "jar", "jars", "package", "packages", "bottle", "bottles"]);
+var WEIGHT_PRIORITY_UNITS = /* @__PURE__ */ new Set(["g", "kg", "oz", "lb", "ml", "l"]);
+var SPICE_KEYWORDS = [
+  "salt",
+  "pepper",
+  "paprika",
+  "cumin",
+  "coriander",
+  "turmeric",
+  "chili powder",
+  "garlic powder",
+  "onion powder",
+  "cayenne",
+  "cinnamon",
+  "nutmeg",
+  "allspice",
+  "ginger",
+  "oregano",
+  "thyme",
+  "rosemary",
+  "basil",
+  "sage",
+  "clove",
+  "spice",
+  "seasoning"
+];
+var PURPOSE_KEYWORDS = ["frying", "greasing", "drizzling", "garnish", "serving", "brushing"];
+var RANGE_REGEX = /^((?:\d+\s+)?\d+\/\d+|\d+\/\d+|\d+(?:\.\d+)?)(?:\s*(?:-|to)\s*((?:\d+\s+)?\d+\/\d+|\d+\/\d+|\d+(?:\.\d+)?))/i;
+var NUMBER_REGEX = /^((?:\d+\s+)?\d+\/\d+|\d+\/\d+|\d+(?:\.\d+)?)/i;
+var QUALIFIER_REGEX = /^(about|around|approximately|approx\.?|roughly)\s+/i;
+var FLAVOR_NOTE_REGEX = /\b(to taste|as needed|as necessary)\b/gi;
+var VAGUE_QUANTITY_PATTERNS = [
+  { regex: /^(a\s+pinch|pinch)\b/i, note: "a pinch" },
+  { regex: /^(a\s+handful|handful)\b/i, note: "a handful" },
+  { regex: /^(a\s+dash|dash)\b/i, note: "a dash" },
+  { regex: /^(a\s+sprinkle|sprinkle)\b/i, note: "a sprinkle" },
+  { regex: /^(some)\b/i, note: "some" },
+  { regex: /^(few\s+sprigs)/i, note: "few sprigs" },
+  { regex: /^(a\s+few|few)\b/i, note: "a few" },
+  { regex: /^(several)\b/i, note: "several" }
+];
+var JUICE_PREFIXES = ["juice of", "zest of"];
+function normalizeIngredientInput(input) {
+  if (!input) return "";
+  let result = input.replace(/\u00A0/g, " ").trim();
+  result = replaceDashes(result);
+  result = replaceUnicodeFractions(result);
+  result = replaceNumberWords(result);
+  result = result.replace(/\s+/g, " ").trim();
+  return result;
+}
+function parseIngredient(text) {
+  const original = text ?? "";
+  const normalized = normalizeIngredientInput(original);
+  if (!normalized) {
+    return {
+      item: original,
+      scaling: { type: "linear" }
+    };
+  }
+  let working = normalized;
+  const notes = [];
+  let optional = false;
+  if (/\boptional\b/i.test(working)) {
+    optional = true;
+    working = working.replace(/\(?\s*optional\s*\)?/gi, "").trim();
+    working = working.replace(/\(\s*\)/g, " ").trim();
+  }
+  const flavorExtraction = extractFlavorNotes(working);
+  working = flavorExtraction.cleaned;
+  notes.push(...flavorExtraction.notes);
+  const parenthetical = extractParentheticals(working);
+  working = parenthetical.cleaned;
+  notes.push(...parenthetical.notes);
+  optional = optional || parenthetical.optional;
+  const purposeExtraction = extractPurposeNotes(working);
+  working = purposeExtraction.cleaned;
+  notes.push(...purposeExtraction.notes);
+  const juiceExtraction = extractJuicePhrase(working);
+  if (juiceExtraction) {
+    working = juiceExtraction.cleaned;
+    notes.push(juiceExtraction.note);
+  }
+  const vagueQuantity = extractVagueQuantity(working);
+  let quantityResult;
+  if (vagueQuantity) {
+    notes.push(vagueQuantity.note);
+    quantityResult = {
+      amount: null,
+      unit: null,
+      descriptor: void 0,
+      remainder: vagueQuantity.remainder,
+      notes: [],
+      originalAmount: null
+    };
+  } else {
+    quantityResult = extractQuantity(working);
+  }
+  working = quantityResult.remainder;
+  const { quantity, usedParenthetical } = mergeQuantities(quantityResult, parenthetical.measurement);
+  if (usedParenthetical && quantityResult.originalAmount !== null && quantityResult.originalAmount > 1 && quantityResult.descriptor && DESCRIPTOR_NOTE_SET.has(quantityResult.descriptor.toLowerCase())) {
+    notes.push(formatCountNote(quantityResult.originalAmount, quantityResult.descriptor));
+  }
+  notes.push(...quantityResult.notes);
+  working = working.replace(/^[,.\s-]+/, "").trim();
+  working = working.replace(/^of\s+/i, "").trim();
+  if (quantityResult.descriptor && /^cans?$/i.test(quantityResult.descriptor) && working && !/^canned\b/i.test(working)) {
+    working = `canned ${working}`.trim();
+  }
+  const nameExtraction = extractNameAndPrep(working);
+  notes.push(...nameExtraction.notes);
+  const name = nameExtraction.name || void 0;
+  const scaling = inferScaling(
+    name,
+    quantity.unit,
+    quantity.amount,
+    notes,
+    quantityResult.descriptor
+  );
+  const mergedNotes = formatNotes(notes);
+  const parsed = {
+    item: original,
+    quantity,
+    ...name ? { name } : {},
+    ...nameExtraction.prep ? { prep: nameExtraction.prep } : {},
+    ...optional ? { optional: true } : {},
+    scaling
+  };
+  if (mergedNotes) {
+    parsed.notes = mergedNotes;
+  }
+  return parsed;
+}
+function replaceDashes(value) {
+  return value.replace(/[\u2012\u2013\u2014\u2212]/g, "-");
+}
+function replaceUnicodeFractions(value) {
+  return value.replace(/(\d+)?(?:\s+)?([½⅓⅔¼¾⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞])/g, (_match, whole, fraction) => {
+    const fractionValue = FRACTION_DECIMALS[fraction];
+    if (fractionValue === void 0) return _match;
+    const base = whole ? parseInt(whole, 10) : 0;
+    const combined = base + fractionValue;
+    return formatDecimal(combined);
+  });
+}
+function replaceNumberWords(value) {
+  return value.replace(
+    /\b(zero|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety|hundred|half|quarter)(?:-(one|two|three|four|five|six|seven|eight|nine))?\b/gi,
+    (match, word, hyphenPart) => {
+      const lower = word.toLowerCase();
+      const baseValue = NUMBER_WORDS[lower];
+      if (baseValue === void 0) return match;
+      if (!hyphenPart) {
+        return formatDecimal(baseValue);
+      }
+      const hyphenValue = NUMBER_WORDS[hyphenPart.toLowerCase()];
+      if (hyphenValue === void 0) {
+        return formatDecimal(baseValue);
+      }
+      return formatDecimal(baseValue + hyphenValue);
+    }
+  );
+}
+function formatDecimal(value) {
+  if (Number.isInteger(value)) {
+    return value.toString();
+  }
+  return parseFloat(value.toFixed(3)).toString().replace(/\.0+$/, "");
+}
+function extractFlavorNotes(value) {
+  const notes = [];
+  const cleaned = value.replace(FLAVOR_NOTE_REGEX, (_, phrase) => {
+    notes.push(phrase.toLowerCase());
+    return "";
+  });
+  return {
+    cleaned: cleaned.replace(/\s+/g, " ").trim(),
+    notes
+  };
+}
+function extractPurposeNotes(value) {
+  const notes = [];
+  let working = value.trim();
+  let match = working.match(/\bfor\s+(frying|greasing|drizzling|garnish|serving|brushing)\b\.?$/i);
+  if (match) {
+    notes.push(`for ${match[1].toLowerCase()}`);
+    working = working.slice(0, match.index).trim();
+  }
+  return { cleaned: working, notes };
+}
+function extractJuicePhrase(value) {
+  const lower = value.toLowerCase();
+  for (const prefix of JUICE_PREFIXES) {
+    if (lower.startsWith(prefix)) {
+      const remainder = value.slice(prefix.length).trim();
+      if (!remainder) break;
+      const cleanedSource = remainder.replace(/^of\s+/i, "").trim();
+      if (!cleanedSource) break;
+      const sourceForName = cleanedSource.replace(
+        /^(?:\d+(?:\.\d+)?|\d+\s+\d+\/\d+|\d+\/\d+|one|two|three|four|five|six|seven|eight|nine|ten|a|an)\s+/i,
+        ""
+      ).replace(/^(?:large|small|medium)\s+/i, "").trim();
+      const baseName = sourceForName || cleanedSource;
+      const singular = singularize(baseName);
+      const suffix = prefix.startsWith("zest") ? "zest" : "juice";
+      return {
+        cleaned: `${singular} ${suffix}`.trim(),
+        note: `from ${cleanedSource}`
+      };
+    }
+  }
+  return void 0;
+}
+function extractVagueQuantity(value) {
+  for (const pattern of VAGUE_QUANTITY_PATTERNS) {
+    const match = value.match(pattern.regex);
+    if (match) {
+      let remainder = value.slice(match[0].length).trim();
+      remainder = remainder.replace(/^of\s+/i, "").trim();
+      return {
+        remainder,
+        note: pattern.note
+      };
+    }
+  }
+  return void 0;
+}
+function extractParentheticals(value) {
+  let optional = false;
+  let measurement;
+  const notes = [];
+  const cleaned = value.replace(/\(([^)]+)\)/g, (_match, group) => {
+    const trimmed = String(group).trim();
+    if (!trimmed) return "";
+    if (/optional/i.test(trimmed)) {
+      optional = true;
+      return "";
+    }
+    const maybeMeasurement = parseMeasurement(trimmed);
+    if (maybeMeasurement && !measurement) {
+      measurement = maybeMeasurement;
+      return "";
+    }
+    notes.push(trimmed);
+    return "";
+  });
+  return {
+    cleaned: cleaned.replace(/\s+/g, " ").trim(),
+    measurement,
+    notes,
+    optional
+  };
+}
+function parseMeasurement(value) {
+  const stripped = value.replace(/^(about|around|approximately|approx\.?|roughly)\s+/i, "").trim();
+  const match = stripped.match(
+    /^((?:\d+\s+)?\d+\/\d+|\d+\/\d+|\d+(?:\.\d+)?)(?:\s*)([a-zA-Z]+)?$/
+  );
+  if (!match) return void 0;
+  const amount = parseNumber(match[1]);
+  if (amount === null) return void 0;
+  const unit = match[2] ? normalizeUnit(match[2]) ?? match[2].toLowerCase() : null;
+  return { amount, unit };
+}
+function extractQuantity(value) {
+  let working = value.trim();
+  const notes = [];
+  let amount = null;
+  let originalAmount = null;
+  let unit = null;
+  let descriptor;
+  while (QUALIFIER_REGEX.test(working)) {
+    working = working.replace(QUALIFIER_REGEX, "").trim();
+  }
+  const rangeMatch = working.match(RANGE_REGEX);
+  if (rangeMatch) {
+    amount = parseNumber(rangeMatch[1]);
+    originalAmount = amount;
+    const rangeText = rangeMatch[0].trim();
+    const afterRange = working.slice(rangeMatch[0].length).trim();
+    const descriptorMatch = afterRange.match(/^([a-zA-Z]+)/);
+    if (descriptorMatch && COUNT_DESCRIPTORS.has(descriptorMatch[1].toLowerCase())) {
+      notes.push(`${rangeText} ${descriptorMatch[1]}`);
+    } else {
+      notes.push(rangeText);
+    }
+    working = afterRange;
+  } else {
+    const numberMatch = working.match(NUMBER_REGEX);
+    if (numberMatch) {
+      amount = parseNumber(numberMatch[1]);
+      originalAmount = amount;
+      working = working.slice(numberMatch[0].length).trim();
+    }
+  }
+  if (working) {
+    const unitMatch = working.match(/^([a-zA-Z]+)\b/);
+    if (unitMatch) {
+      const normalized = normalizeUnit(unitMatch[1]);
+      if (normalized) {
+        unit = normalized;
+        working = working.slice(unitMatch[0].length).trim();
+      } else if (COUNT_DESCRIPTORS.has(unitMatch[1].toLowerCase())) {
+        descriptor = unitMatch[1];
+        working = working.slice(unitMatch[0].length).trim();
+      }
+    }
+  }
+  return {
+    amount,
+    unit,
+    descriptor,
+    remainder: working.trim(),
+    notes,
+    originalAmount
+  };
+}
+function parseNumber(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (/^\d+\s+\d+\/\d+$/.test(trimmed)) {
+    const [whole, fraction] = trimmed.split(/\s+/);
+    return parseInt(whole, 10) + parseFraction(fraction);
+  }
+  if (/^\d+\/\d+$/.test(trimmed)) {
+    return parseFraction(trimmed);
+  }
+  const parsed = Number(trimmed);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function parseFraction(value) {
+  const [numerator, denominator] = value.split("/").map(Number);
+  if (!denominator) return numerator;
+  return numerator / denominator;
+}
+function normalizeUnit(raw) {
+  const lower = raw.toLowerCase();
+  if (UNIT_SYNONYMS[lower]) {
+    return UNIT_SYNONYMS[lower];
+  }
+  if (raw === "T") return "tbsp";
+  if (raw === "t") return "tsp";
+  if (raw === "C") return "cup";
+  return null;
+}
+function mergeQuantities(extracted, measurement) {
+  const quantity = {
+    amount: extracted.amount ?? null,
+    unit: extracted.unit ?? null
+  };
+  if (!measurement) {
+    return { quantity, usedParenthetical: false };
+  }
+  const measurementUnit = measurement.unit?.toLowerCase() ?? null;
+  const shouldPrefer = !quantity.unit || measurementUnit !== null && WEIGHT_PRIORITY_UNITS.has(measurementUnit);
+  if (shouldPrefer) {
+    return {
+      quantity: {
+        amount: measurement.amount,
+        unit: measurement.unit ?? null
+      },
+      usedParenthetical: true
+    };
+  }
+  return { quantity, usedParenthetical: false };
+}
+function extractNameAndPrep(value) {
+  let working = value.trim();
+  const notes = [];
+  let prep;
+  const lastComma = working.lastIndexOf(",");
+  if (lastComma >= 0) {
+    const trailing = working.slice(lastComma + 1).trim();
+    if (isPrepPhrase(trailing)) {
+      prep = trailing;
+      working = working.slice(0, lastComma).trim();
+    }
+  }
+  working = working.replace(/^[,.\s-]+/, "").trim();
+  working = working.replace(/^of\s+/i, "").trim();
+  if (!working) {
+    return { name: void 0, prep, notes };
+  }
+  let name = cleanupIngredientName(working);
+  return {
+    name: name || void 0,
+    prep,
+    notes
+  };
+}
+function cleanupIngredientName(value) {
+  let result = value.trim();
+  if (/^cans?\b/i.test(result)) {
+    result = result.replace(/^cans?\b/i, "canned").trim();
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    if (/^of\s+/i.test(result)) {
+      result = result.replace(/^of\s+/i, "").trim();
+      changed = true;
+      continue;
+    }
+    const match = result.match(/^(clove|cloves|sprig|sprigs|bunch|bunches|stick|sticks|slice|slices)\b/i);
+    if (match) {
+      result = result.slice(match[0].length).trim();
+      changed = true;
+    }
+  }
+  return result;
+}
+function isPrepPhrase(value) {
+  const normalized = value.toLowerCase();
+  return PREP_PHRASES.includes(normalized);
+}
+function inferScaling(name, unit, amount, notes, descriptor) {
+  const lowerName = name?.toLowerCase() ?? "";
+  const normalizedNotes = notes.map((note) => note.toLowerCase());
+  const descriptorLower = descriptor?.toLowerCase();
+  if (lowerName.includes("egg") || descriptorLower === "clove" || descriptorLower === "cloves" || normalizedNotes.some((note) => note.includes("clove"))) {
+    return { type: "discrete", roundTo: 1 };
+  }
+  if (descriptorLower === "stick" || descriptorLower === "sticks") {
+    return { type: "discrete", roundTo: 1 };
+  }
+  if (normalizedNotes.some((note) => PURPOSE_KEYWORDS.some((keyword) => note.includes(keyword)))) {
+    return { type: "fixed" };
+  }
+  const isSpice = SPICE_KEYWORDS.some((keyword) => lowerName.includes(keyword));
+  const smallUnit = unit ? ["tsp", "tbsp", "dash", "pinch"].includes(unit) : false;
+  if (normalizedNotes.some((note) => note.includes("to taste")) || isSpice && (smallUnit || amount !== null && amount <= 1)) {
+    return { type: "proportional", factor: 0.7 };
+  }
+  return { type: "linear" };
+}
+function formatNotes(notes) {
+  const cleaned = Array.from(
+    new Set(
+      notes.map((note) => note.trim()).filter(Boolean)
+    )
+  );
+  return cleaned.length ? cleaned.join("; ") : void 0;
+}
+function formatCountNote(amount, descriptor) {
+  const lower = descriptor.toLowerCase();
+  const singular = lower.endsWith("s") ? lower.slice(0, -1) : lower;
+  const word = amount === 1 ? singular : singular.endsWith("ch") || singular.endsWith("sh") || singular.endsWith("s") || singular.endsWith("x") || singular.endsWith("z") ? `${singular}es` : singular.endsWith("y") && !/[aeiou]y$/.test(singular) ? `${singular.slice(0, -1)}ies` : `${singular}s`;
+  return `${formatDecimal(amount)} ${word}`;
+}
+function singularize(value) {
+  const trimmed = value.trim();
+  if (trimmed.endsWith("ies")) {
+    return `${trimmed.slice(0, -3)}y`;
+  }
+  if (/(ches|shes|sses|xes|zes)$/i.test(trimmed)) {
+    return trimmed.slice(0, -2);
+  }
+  if (trimmed.endsWith("s")) {
+    return trimmed.slice(0, -1);
+  }
+  return trimmed;
+}
+
+// src/converters/ingredient.ts
+function parseIngredientLine(line) {
+  const parsed = parseIngredient(line);
+  const ingredient = {
+    item: parsed.item,
+    scaling: parsed.scaling ?? { type: "linear" }
+  };
+  if (parsed.name) {
+    ingredient.name = parsed.name;
+  }
+  if (parsed.prep) {
+    ingredient.prep = parsed.prep;
+  }
+  if (parsed.optional) {
+    ingredient.optional = true;
+  }
+  if (parsed.notes) {
+    ingredient.notes = parsed.notes;
+  }
+  const quantity = buildQuantity(parsed.quantity);
+  if (quantity) {
+    ingredient.quantity = quantity;
+  }
+  return ingredient;
+}
+function buildQuantity(parsedQuantity) {
+  if (!parsedQuantity) {
+    return void 0;
+  }
+  if (parsedQuantity.amount === null || Number.isNaN(parsedQuantity.amount)) {
+    return void 0;
+  }
+  return {
+    amount: parsedQuantity.amount,
+    unit: parsedQuantity.unit ?? null
+  };
+}
+
+// src/converters/yield.ts
+function parseYield(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    return {
+      amount: value,
+      unit: "servings"
+    };
+  }
+  if (Array.isArray(value)) {
+    return parseYield(value[0]);
+  }
+  if (typeof value === "object") {
+    const maybeYield = value;
+    if (typeof maybeYield.amount === "number") {
+      return {
+        amount: maybeYield.amount,
+        unit: typeof maybeYield.unit === "string" ? maybeYield.unit : "servings",
+        description: typeof maybeYield.description === "string" ? maybeYield.description : void 0
+      };
+    }
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    const match = trimmed.match(/(\d+(?:\.\d+)?)/);
+    if (match) {
+      const amount = parseFloat(match[1]);
+      const unit = trimmed.slice(match.index + match[1].length).trim();
+      return {
+        amount,
+        unit: unit || "servings",
+        description: trimmed
+      };
+    }
+  }
+  return void 0;
+}
+function formatYield(yieldValue) {
+  if (!yieldValue) return void 0;
+  if (!yieldValue.amount && !yieldValue.unit) {
+    return void 0;
+  }
+  const amount = yieldValue.amount ?? "";
+  const unit = yieldValue.unit ? ` ${yieldValue.unit}` : "";
+  return `${amount}${unit}`.trim() || yieldValue.description;
+}
+
+// src/parsers/duration.ts
+var ISO_DURATION_REGEX = /^P(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/i;
+var HUMAN_OVERNIGHT = 8 * 60;
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function parseDuration(iso) {
+  if (!iso || typeof iso !== "string") return null;
+  const trimmed = iso.trim();
+  if (!trimmed) return null;
+  const match = trimmed.match(ISO_DURATION_REGEX);
+  if (!match) return null;
+  const [, daysRaw, hoursRaw, minutesRaw, secondsRaw] = match;
+  if (!daysRaw && !hoursRaw && !minutesRaw && !secondsRaw) {
+    return null;
+  }
+  let total = 0;
+  if (daysRaw) total += parseFloat(daysRaw) * 24 * 60;
+  if (hoursRaw) total += parseFloat(hoursRaw) * 60;
+  if (minutesRaw) total += parseFloat(minutesRaw);
+  if (secondsRaw) total += Math.ceil(parseFloat(secondsRaw) / 60);
+  return Math.round(total);
+}
+function formatDuration(minutes) {
+  if (!isFiniteNumber(minutes) || minutes <= 0) {
+    return "PT0M";
+  }
+  const rounded = Math.round(minutes);
+  const days = Math.floor(rounded / (24 * 60));
+  const afterDays = rounded % (24 * 60);
+  const hours = Math.floor(afterDays / 60);
+  const mins = afterDays % 60;
+  let result = "P";
+  if (days > 0) {
+    result += `${days}D`;
+  }
+  if (hours > 0 || mins > 0) {
+    result += "T";
+    if (hours > 0) {
+      result += `${hours}H`;
+    }
+    if (mins > 0) {
+      result += `${mins}M`;
+    }
+  }
+  if (result === "P") {
+    return "PT0M";
+  }
+  return result;
+}
+function parseHumanDuration(text) {
+  if (!text || typeof text !== "string") return null;
+  const normalized = text.toLowerCase().trim();
+  if (!normalized) return null;
+  if (normalized === "overnight") {
+    return HUMAN_OVERNIGHT;
+  }
+  let total = 0;
+  const hourRegex = /(\d+(?:\.\d+)?)\s*(?:hours?|hrs?|hr|h)\b/g;
+  let hourMatch;
+  while ((hourMatch = hourRegex.exec(normalized)) !== null) {
+    total += parseFloat(hourMatch[1]) * 60;
+  }
+  const minuteRegex = /(\d+(?:\.\d+)?)\s*(?:minutes?|mins?|min|m)\b/g;
+  let minuteMatch;
+  while ((minuteMatch = minuteRegex.exec(normalized)) !== null) {
+    total += parseFloat(minuteMatch[1]);
+  }
+  if (total <= 0) {
+    return null;
+  }
+  return Math.round(total);
+}
+function smartParseDuration(input) {
+  const iso = parseDuration(input);
+  if (iso !== null) {
+    return iso;
+  }
+  return parseHumanDuration(input);
+}
+
+// src/fromSchemaOrg.ts
+function fromSchemaOrg(input) {
+  const recipeNode = extractRecipeNode(input);
+  if (!recipeNode) {
+    return null;
+  }
+  const ingredients = convertIngredients(recipeNode.recipeIngredient);
+  const instructions = convertInstructions(recipeNode.recipeInstructions);
+  const time = convertTime(recipeNode);
+  const recipeYield = parseYield(recipeNode.recipeYield);
+  const tags = collectTags(recipeNode.recipeCuisine, recipeNode.keywords);
+  const category = extractFirst(recipeNode.recipeCategory);
+  const image = convertImage(recipeNode.image);
+  const source = convertSource(recipeNode);
+  const nutrition = recipeNode.nutrition && typeof recipeNode.nutrition === "object" ? recipeNode.nutrition : void 0;
+  return {
+    name: recipeNode.name.trim(),
+    description: recipeNode.description?.trim() || void 0,
+    image,
+    category,
+    tags: tags.length ? tags : void 0,
+    source,
+    dateAdded: recipeNode.datePublished || void 0,
+    dateModified: recipeNode.dateModified || void 0,
+    yield: recipeYield,
+    time,
+    ingredients,
+    instructions,
+    nutrition
+  };
+}
+function extractRecipeNode(input) {
+  if (!input) return null;
+  if (Array.isArray(input)) {
+    for (const entry of input) {
+      const found = extractRecipeNode(entry);
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  if (typeof input !== "object") {
+    return null;
+  }
+  const record = input;
+  if (record["@graph"]) {
+    const fromGraph = extractRecipeNode(record["@graph"]);
+    if (fromGraph) {
+      return fromGraph;
+    }
+  }
+  if (!hasRecipeType(record["@type"])) {
+    return null;
+  }
+  if (!isValidName(record.name)) {
+    return null;
+  }
+  return record;
+}
+function hasRecipeType(value) {
+  if (!value) return false;
+  const types = Array.isArray(value) ? value : [value];
+  return types.some(
+    (entry) => typeof entry === "string" && entry.toLowerCase() === "recipe"
+  );
+}
+function isValidName(name) {
+  return typeof name === "string" && Boolean(name.trim());
+}
+function convertIngredients(value) {
+  if (!value) return [];
+  const normalized = Array.isArray(value) ? value : [value];
+  return normalized.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean).map((line) => parseIngredientLine(line));
+}
+function convertInstructions(value) {
+  if (!value) return [];
+  const normalized = Array.isArray(value) ? value : [value];
+  const result = [];
+  for (const entry of normalized) {
+    if (!entry) continue;
+    if (typeof entry === "string") {
+      const text = entry.trim();
+      if (text) {
+        result.push(text);
+      }
+      continue;
+    }
+    if (isHowToSection(entry)) {
+      const subsectionItems = extractSectionItems(entry.itemListElement);
+      if (subsectionItems.length) {
+        result.push({
+          subsection: entry.name?.trim() || "Section",
+          items: subsectionItems
+        });
+      }
+      continue;
+    }
+    if (isHowToStep(entry)) {
+      const text = extractInstructionText(entry);
+      if (text) {
+        result.push(text);
+      }
+    }
+  }
+  return result;
+}
+function extractSectionItems(items = []) {
+  const result = [];
+  for (const item of items) {
+    if (!item) continue;
+    if (typeof item === "string") {
+      const text = item.trim();
+      if (text) {
+        result.push(text);
+      }
+      continue;
+    }
+    if (isHowToStep(item)) {
+      const text = extractInstructionText(item);
+      if (text) {
+        result.push(text);
+      }
+      continue;
+    }
+    if (isHowToSection(item)) {
+      result.push(...extractSectionItems(item.itemListElement));
+    }
+  }
+  return result;
+}
+function extractInstructionText(value) {
+  const text = typeof value.text === "string" ? value.text : value.name;
+  return typeof text === "string" ? text.trim() || void 0 : void 0;
+}
+function isHowToStep(value) {
+  return Boolean(value) && typeof value === "object" && value["@type"] === "HowToStep";
+}
+function isHowToSection(value) {
+  return Boolean(value) && typeof value === "object" && value["@type"] === "HowToSection" && Array.isArray(value.itemListElement);
+}
+function convertTime(recipe) {
+  const prep = smartParseDuration(recipe.prepTime ?? "");
+  const cook = smartParseDuration(recipe.cookTime ?? "");
+  const total = smartParseDuration(recipe.totalTime ?? "");
+  const structured = {};
+  if (prep !== null && prep !== void 0) structured.prep = prep;
+  if (cook !== null && cook !== void 0) structured.active = cook;
+  if (total !== null && total !== void 0) structured.total = total;
+  return Object.keys(structured).length ? structured : void 0;
+}
+function collectTags(cuisine, keywords) {
+  const tags = /* @__PURE__ */ new Set();
+  flattenStrings(cuisine).forEach((tag) => tags.add(tag));
+  if (typeof keywords === "string") {
+    splitKeywords(keywords).forEach((tag) => tags.add(tag));
+  } else {
+    flattenStrings(keywords).forEach((tag) => tags.add(tag));
+  }
+  return Array.from(tags);
+}
+function splitKeywords(value) {
+  return value.split(/[,|]/).map((part) => part.trim()).filter(Boolean);
+}
+function flattenStrings(value) {
+  if (!value) return [];
+  if (typeof value === "string") return [value.trim()].filter(Boolean);
+  if (Array.isArray(value)) {
+    return value.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean);
+  }
+  return [];
+}
+function extractFirst(value) {
+  const arr = flattenStrings(value);
+  return arr.length ? arr[0] : void 0;
+}
+function convertImage(value) {
+  if (!value) return void 0;
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const url = typeof item === "string" ? item : extractImageUrl(item);
+      if (url) return url;
+    }
+    return void 0;
+  }
+  return extractImageUrl(value);
+}
+function extractImageUrl(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const candidate = typeof record.url === "string" ? record.url : typeof record.contentUrl === "string" ? record.contentUrl : void 0;
+  return candidate?.trim() || void 0;
+}
+function convertSource(recipe) {
+  const author = extractEntityName(recipe.author);
+  const publisher = extractEntityName(recipe.publisher);
+  const url = (recipe.url || recipe.mainEntityOfPage)?.trim();
+  const source = {};
+  if (author) source.author = author;
+  if (publisher) source.name = publisher;
+  if (url) source.url = url;
+  return Object.keys(source).length ? source : void 0;
+}
+function extractEntityName(value) {
+  if (!value) return void 0;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || void 0;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const name = extractEntityName(entry);
+      if (name) {
+        return name;
+      }
+    }
+    return void 0;
+  }
+  if (typeof value === "object" && typeof value.name === "string") {
+    const trimmed = value.name.trim();
+    return trimmed || void 0;
+  }
+  return void 0;
+}
+
+// src/converters/toSchemaOrg.ts
+function convertBasicMetadata(recipe) {
+  return cleanOutput({
+    "@context": "https://schema.org",
+    "@type": "Recipe",
+    name: recipe.name,
+    description: recipe.description,
+    image: recipe.image,
+    url: recipe.source?.url,
+    datePublished: recipe.dateAdded,
+    dateModified: recipe.dateModified
+  });
+}
+function convertIngredients2(ingredients = []) {
+  const result = [];
+  ingredients.forEach((ingredient) => {
+    if (!ingredient) {
+      return;
+    }
+    if (typeof ingredient === "string") {
+      const value2 = ingredient.trim();
+      if (value2) {
+        result.push(value2);
+      }
+      return;
+    }
+    if ("subsection" in ingredient) {
+      ingredient.items.forEach((item) => {
+        if (!item) {
+          return;
+        }
+        if (typeof item === "string") {
+          const value2 = item.trim();
+          if (value2) {
+            result.push(value2);
+          }
+        } else if (item.item) {
+          const value2 = item.item.trim();
+          if (value2) {
+            result.push(value2);
+          }
+        }
+      });
+      return;
+    }
+    const value = ingredient.item?.trim();
+    if (value) {
+      result.push(value);
+    }
+  });
+  return result;
+}
+function convertInstructions2(instructions = []) {
+  return instructions.map((entry) => convertInstruction(entry)).filter((value) => Boolean(value));
+}
+function convertInstruction(entry) {
+  if (!entry) {
+    return null;
+  }
+  if (typeof entry === "string") {
+    return createHowToStep(entry);
+  }
+  if ("subsection" in entry) {
+    const steps = entry.items.map((item) => typeof item === "string" ? createHowToStep(item) : createHowToStep(item.text)).filter((step) => Boolean(step));
+    if (!steps.length) {
+      return null;
+    }
+    return {
+      "@type": "HowToSection",
+      name: entry.subsection,
+      itemListElement: steps
+    };
+  }
+  if ("text" in entry) {
+    return createHowToStep(entry.text);
+  }
+  return createHowToStep(String(entry));
+}
+function createHowToStep(text) {
+  if (!text) return null;
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+  return {
+    "@type": "HowToStep",
+    text: trimmed
+  };
+}
+function convertTime2(time) {
+  if (!time) {
+    return {};
+  }
+  if (isStructuredTime(time)) {
+    const result2 = {};
+    if (time.prep !== void 0) {
+      result2.prepTime = formatDuration(time.prep);
+    }
+    if (time.active !== void 0) {
+      result2.cookTime = formatDuration(time.active);
+    }
+    if (time.total !== void 0) {
+      result2.totalTime = formatDuration(time.total);
+    }
+    return result2;
+  }
+  const result = {};
+  if (time.prepTime) {
+    result.prepTime = time.prepTime;
+  }
+  if (time.cookTime) {
+    result.cookTime = time.cookTime;
+  }
+  return result;
+}
+function convertYield(yld) {
+  if (!yld) {
+    return void 0;
+  }
+  return formatYield(yld);
+}
+function convertAuthor(source) {
+  if (!source) {
+    return {};
+  }
+  const result = {};
+  if (source.author) {
+    result.author = {
+      "@type": "Person",
+      name: source.author
+    };
+  }
+  if (source.name) {
+    result.publisher = {
+      "@type": "Organization",
+      name: source.name
+    };
+  }
+  if (source.url) {
+    result.url = source.url;
+  }
+  return result;
+}
+function convertCategoryTags(category, tags) {
+  const result = {};
+  if (category) {
+    result.recipeCategory = category;
+  }
+  if (tags && tags.length > 0) {
+    result.keywords = tags.filter(Boolean).join(", ");
+  }
+  return result;
+}
+function convertNutrition(nutrition) {
+  if (!nutrition) {
+    return void 0;
+  }
+  return {
+    ...nutrition,
+    "@type": "NutritionInformation"
+  };
+}
+function cleanOutput(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, value]) => value !== void 0)
+  );
+}
+function toSchemaOrg(recipe) {
+  const base = convertBasicMetadata(recipe);
+  const ingredients = convertIngredients2(recipe.ingredients);
+  const instructions = convertInstructions2(recipe.instructions);
+  const nutrition = convertNutrition(recipe.nutrition);
+  return cleanOutput({
+    ...base,
+    recipeIngredient: ingredients.length ? ingredients : void 0,
+    recipeInstructions: instructions.length ? instructions : void 0,
+    recipeYield: convertYield(recipe.yield),
+    ...convertTime2(recipe.time),
+    ...convertAuthor(recipe.source),
+    ...convertCategoryTags(recipe.category, recipe.tags),
+    nutrition
+  });
+}
+function isStructuredTime(time) {
+  return typeof time.prep !== "undefined" || typeof time.active !== "undefined" || typeof time.passive !== "undefined" || typeof time.total !== "undefined";
+}
+
+// src/scraper/fetch.ts
+var DEFAULT_USER_AGENTS = [
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0"
+];
+var fetchImpl = null;
+async function ensureFetch() {
+  if (!fetchImpl) {
+    fetchImpl = import('node-fetch').then((mod) => mod.default);
+  }
+  return fetchImpl;
+}
+function chooseUserAgent(provided) {
+  if (provided) return provided;
+  const index = Math.floor(Math.random() * DEFAULT_USER_AGENTS.length);
+  return DEFAULT_USER_AGENTS[index];
+}
+function isClientError(error) {
+  if (typeof error.status === "number") {
+    return error.status >= 400 && error.status < 500;
+  }
+  return error.message.includes("HTTP 4");
+}
+async function wait(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function fetchPage(url, options = {}) {
+  const {
+    timeout = 1e4,
+    userAgent,
+    maxRetries = 2
+  } = options;
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const fetch = await ensureFetch();
+      const headers = {
+        "User-Agent": chooseUserAgent(userAgent),
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.5"
+      };
+      const response = await fetch(url, {
+        headers,
+        signal: controller.signal,
+        redirect: "follow"
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = new Error(
+          `HTTP ${response.status}: ${response.statusText}`
+        );
+        error.status = response.status;
+        throw error;
+      }
+      return await response.text();
+    } catch (err) {
+      clearTimeout(timeoutId);
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (isClientError(lastError)) {
+        throw lastError;
+      }
+      if (attempt < maxRetries) {
+        await wait(1e3 * (attempt + 1));
+        continue;
+      }
+    }
+  }
+  throw lastError ?? new Error("Failed to fetch page");
+}
+
+// src/scraper/extractors/utils.ts
+var RECIPE_TYPES = /* @__PURE__ */ new Set([
+  "recipe",
+  "https://schema.org/recipe",
+  "http://schema.org/recipe"
+]);
+function isRecipeNode(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const type = value["@type"];
+  if (typeof type === "string") {
+    return RECIPE_TYPES.has(type.toLowerCase());
+  }
+  if (Array.isArray(type)) {
+    return type.some(
+      (entry) => typeof entry === "string" && RECIPE_TYPES.has(entry.toLowerCase())
+    );
+  }
+  return false;
+}
+function safeJsonParse(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function normalizeText(value) {
+  if (!value) return void 0;
+  const trimmed = value.replace(/\s+/g, " ").trim();
+  return trimmed || void 0;
+}
+
+// src/scraper/extractors/jsonld.ts
+function extractJsonLd(html) {
+  const $ = cheerio.load(html);
+  const scripts = $('script[type="application/ld+json"]');
+  const candidates = [];
+  scripts.each((_, element) => {
+    const content = $(element).html();
+    if (!content) return;
+    const parsed = safeJsonParse(content);
+    if (!parsed) return;
+    collectCandidates(parsed, candidates);
+  });
+  return candidates[0] ?? null;
+}
+function collectCandidates(payload, bucket) {
+  if (!payload) return;
+  if (Array.isArray(payload)) {
+    payload.forEach((entry) => collectCandidates(entry, bucket));
+    return;
+  }
+  if (typeof payload !== "object") {
+    return;
+  }
+  if (isRecipeNode(payload)) {
+    bucket.push(payload);
+    return;
+  }
+  const graph = payload["@graph"];
+  if (Array.isArray(graph)) {
+    graph.forEach((entry) => collectCandidates(entry, bucket));
+  }
+}
+var SIMPLE_PROPS = [
+  "name",
+  "description",
+  "image",
+  "recipeYield",
+  "prepTime",
+  "cookTime",
+  "totalTime"
+];
+function extractMicrodata(html) {
+  const $ = cheerio.load(html);
+  const recipeEl = $('[itemscope][itemtype*="schema.org/Recipe"]').first();
+  if (!recipeEl.length) {
+    return null;
+  }
+  const recipe = {
+    "@type": "Recipe"
+  };
+  SIMPLE_PROPS.forEach((prop) => {
+    const value = findPropertyValue($, recipeEl, prop);
+    if (value) {
+      recipe[prop] = value;
+    }
+  });
+  const ingredients = [];
+  recipeEl.find('[itemprop="recipeIngredient"]').each((_, el) => {
+    const text = normalizeText($(el).attr("content") || $(el).text());
+    if (text) ingredients.push(text);
+  });
+  if (ingredients.length) {
+    recipe.recipeIngredient = ingredients;
+  }
+  const instructions = [];
+  recipeEl.find('[itemprop="recipeInstructions"]').each((_, el) => {
+    const text = normalizeText($(el).attr("content")) || normalizeText($(el).find('[itemprop="text"]').first().text()) || normalizeText($(el).text());
+    if (text) instructions.push(text);
+  });
+  if (instructions.length) {
+    recipe.recipeInstructions = instructions;
+  }
+  if (recipe.name || ingredients.length) {
+    return recipe;
+  }
+  return null;
+}
+function findPropertyValue($, context, prop) {
+  const node = context.find(`[itemprop="${prop}"]`).first();
+  if (!node.length) return void 0;
+  return normalizeText(node.attr("content")) || normalizeText(node.attr("href")) || normalizeText(node.attr("src")) || normalizeText(node.text());
+}
+
+// src/scraper/extractors/index.ts
+function extractRecipe(html) {
+  const jsonLdRecipe = extractJsonLd(html);
+  if (jsonLdRecipe) {
+    return { recipe: jsonLdRecipe, source: "jsonld" };
+  }
+  const microdataRecipe = extractMicrodata(html);
+  if (microdataRecipe) {
+    return { recipe: microdataRecipe, source: "microdata" };
+  }
+  return { recipe: null, source: null };
+}
+
+// src/scraper/index.ts
+async function scrapeRecipe(url, options = {}) {
+  const html = await fetchPage(url, options);
+  const { recipe } = extractRecipe(html);
+  if (!recipe) {
+    throw new Error("No Schema.org recipe data found in page");
+  }
+  const soustackRecipe = fromSchemaOrg(recipe);
+  if (!soustackRecipe) {
+    throw new Error("Schema.org data did not include a valid recipe");
+  }
+  return soustackRecipe;
+}
+
+// bin/cli.ts
+var [, , command, ...args] = process.argv;
+async function main() {
+  try {
+    switch (command) {
+      case "validate":
+        await handleValidate(args);
+        break;
+      case "scale":
+        await handleScale(args);
+        break;
+      case "import":
+        await handleImport(args);
+        break;
+      case "export":
+        await handleExport(args);
+        break;
+      case "scrape":
+        await handleScrape(args);
+        break;
+      default:
+        printUsage();
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(`\u274C ${error.message}`);
+    process.exit(1);
+  }
+}
+function printUsage() {
+  console.log("Usage:");
+  console.log("  npx soustack validate <soustack.json>");
+  console.log("  npx soustack scale <soustack.json> <multiplier>");
+  console.log("  npx soustack import <schema-org.jsonld> -o <soustack.json>");
+  console.log("  npx soustack export <soustack.json> -o <schema-org.jsonld>");
+  console.log("  npx soustack scrape <url> -o <soustack.json>");
+}
+async function handleValidate(args2) {
+  const filePath = args2[0];
+  if (!filePath) throw new Error("Path to recipe JSON is required");
+  const recipe = readJsonFile(filePath);
+  validateRecipe(recipe);
+  console.log("\u2705 Valid Soustack Recipe");
+}
+async function handleScale(args2) {
+  const filePath = args2[0];
+  const multiplier = args2[1] ? parseFloat(args2[1]) : 1;
+  if (!filePath || Number.isNaN(multiplier)) {
+    throw new Error("Scale usage: scale <soustack.json> <multiplier>");
+  }
+  const recipe = readJsonFile(filePath);
+  console.log(`
+\u2696\uFE0F  Scaling "${recipe.name}" by ${multiplier}x...
+`);
+  const baseYield = recipe.yield?.amount || 1;
+  const targetYield = baseYield * multiplier;
+  const result = scaleRecipe(recipe, targetYield);
+  console.log("--- INGREDIENTS ---");
+  result.ingredients.forEach((ing) => {
+    console.log(`\u2022 ${ing.text}`);
+  });
+  console.log("\n--- TIMING ---");
+  console.log(`Total Time: ${result.timing.total} minutes`);
+  console.log(`(Active: ${result.timing.active}m | Passive: ${result.timing.passive}m)`);
+}
+async function handleImport(args2) {
+  const filePath = args2[0];
+  const outputPath = resolveOutputPath(args2.slice(1));
+  if (!filePath) throw new Error("Import usage: import <schema-org.json> -o <soustack.json>");
+  const schemaOrg = readJsonFile(filePath);
+  const soustack = fromSchemaOrg(schemaOrg);
+  if (!soustack) {
+    throw new Error("No valid Schema.org recipe found in input");
+  }
+  writeOutput(soustack, outputPath);
+  console.log(`\u2705 Converted Schema.org \u2192 Soustack${outputPath ? ` (${outputPath})` : ""}`);
+}
+async function handleExport(args2) {
+  const filePath = args2[0];
+  const outputPath = resolveOutputPath(args2.slice(1));
+  if (!filePath) throw new Error("Export usage: export <soustack.json> -o <schema-org.jsonld>");
+  const soustack = readJsonFile(filePath);
+  const schemaOrg = toSchemaOrg(soustack);
+  writeOutput(schemaOrg, outputPath);
+  console.log(`\u2705 Converted Soustack \u2192 Schema.org${outputPath ? ` (${outputPath})` : ""}`);
+}
+async function handleScrape(args2) {
+  const url = args2[0];
+  const outputPath = resolveOutputPath(args2.slice(1));
+  if (!url) throw new Error("Scrape usage: scrape <url> -o <soustack.json>");
+  const recipe = await scrapeRecipe(url);
+  writeOutput(recipe, outputPath);
+  console.log(`\u2705 Scraped recipe from ${url}${outputPath ? ` (${outputPath})` : ""}`);
+}
+function readJsonFile(relativePath) {
+  const absolutePath = path__namespace.resolve(relativePath);
+  if (!fs__namespace.existsSync(absolutePath)) {
+    throw new Error(`File not found: ${absolutePath}`);
+  }
+  const content = fs__namespace.readFileSync(absolutePath, "utf-8");
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(`Unable to parse JSON in ${absolutePath}`);
+  }
+}
+function resolveOutputPath(args2) {
+  const index = args2.findIndex((arg) => arg === "-o" || arg === "--output");
+  if (index === -1) return void 0;
+  const target = args2[index + 1];
+  if (!target) {
+    throw new Error("Output flag provided without a path");
+  }
+  return target;
+}
+function writeOutput(data, outputPath) {
+  const serialized = JSON.stringify(data, null, 2);
+  if (!outputPath) {
+    console.log(serialized);
+    return;
+  }
+  const absolutePath = path__namespace.resolve(outputPath);
+  fs__namespace.writeFileSync(absolutePath, serialized, "utf-8");
+}
+main();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map