mcp-recipes 1.0.0

package/dist/recipe/scale.js

@@ -0,0 +1,1367 @@
+// src/recipe/language.ts
+var FRENCH_WORDS = /(?:^|[\s(])(?:de|du|des|à|au|aux|la|le|les|un|une|quelques|dans|avec|sans|pour|selon|environ)(?=[\s),.]|$)|\bd'|\bl'|\bqu'/iu;
+var ENGLISH_WORDS = /(?:^|[\s(])(?:of|an|the|and|with|without|for|into|about|each|per|plus|freshly|finely|roughly|coarsely|optional)(?=[\s),.]|$)/iu;
+var FRENCH_LETTERS = /[àâäçéèêëîïôöùûüœ]/iu;
+var FRENCH_FOODS = /\b(?:oeufs?|œufs?|sel|poivre|sucres?|farine|beurre|lait|crème|creme|huile|ail|oignons?|fromage|pain|poulet|boeuf|bœuf|riz|pâtes|pates|jambon|citrons?|pommes?|vin|eau|persil|thym|miel|jaunes?|blancs?)\b/iu;
+var ENGLISH_FOODS = /\b(?:eggs?|salt|pepper|sugar|flour|butter|milk|cream|oil|garlic|onions?|cheese|bread|chicken|beef|rice|pasta|ham|lemons?|apples?|wine|water|parsley|thyme|honey|yolks?|whites?)\b/iu;
+var STRUCTURAL = 3;
+var VOCABULARY = 2;
+var NAME = 1;
+function readLanguage(line, evidence = { frenchUnit: false, englishUnit: false }) {
+  let french = 0;
+  let english = 0;
+  if (FRENCH_WORDS.test(line)) french += STRUCTURAL;
+  if (FRENCH_LETTERS.test(line)) french += STRUCTURAL;
+  if (ENGLISH_WORDS.test(line)) english += STRUCTURAL;
+  if (evidence.frenchUnit) french += VOCABULARY;
+  if (evidence.englishUnit) english += VOCABULARY;
+  if (FRENCH_FOODS.test(line)) french += NAME;
+  if (ENGLISH_FOODS.test(line)) english += NAME;
+  return { language: french > english ? "fr" : "en", french, english };
+}
+
+// src/recipe/units.ts
+var SHARED_UNITS = {
+  mg: { canonical: "mg", kind: "measured", system: "metric", symbol: true },
+  g: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  gr: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  kg: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  kilo: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  kilos: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  ml: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  cl: { canonical: "cl", kind: "measured", system: "metric", symbol: true },
+  dl: { canonical: "dl", kind: "measured", system: "metric", symbol: true },
+  l: { canonical: "l", kind: "measured", system: "metric", symbol: true },
+  litre: { canonical: "l", kind: "measured", system: "metric", symbol: true },
+  litres: { canonical: "l", kind: "measured", system: "metric", symbol: true }
+};
+var FRENCH_UNITS = {
+  ...SHARED_UNITS,
+  gramme: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  grammes: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  kilogramme: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  kilogrammes: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  millilitre: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  millilitres: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  centilitre: { canonical: "cl", kind: "measured", system: "metric", symbol: true },
+  centilitres: { canonical: "cl", kind: "measured", system: "metric", symbol: true },
+  // Spoons and cups: real measures, but only in sensible fractions.
+  "cuillere a soupe": {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  "cuilleres a soupe": {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  "c a soupe": {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  "c a s": {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  cas: {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  "cuillere a cafe": {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  "cuilleres a cafe": {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  "c a cafe": {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  "c a c": {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  cac: {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  verre: { canonical: "verre", kind: "portioned", system: "none" },
+  verres: { canonical: "verre", kind: "portioned", system: "none" },
+  bol: { canonical: "bol", kind: "portioned", system: "none" },
+  bols: { canonical: "bol", kind: "portioned", system: "none" },
+  tasse: { canonical: "tasse", kind: "portioned", system: "none" },
+  tasses: { canonical: "tasse", kind: "portioned", system: "none" },
+  // Packaging and natural units: countable, so they round to whole things.
+  sachet: { canonical: "sachet", kind: "portioned", system: "none" },
+  sachets: { canonical: "sachet", kind: "portioned", system: "none" },
+  gousse: { canonical: "gousse", kind: "portioned", system: "none" },
+  gousses: { canonical: "gousse", kind: "portioned", system: "none" },
+  tranche: { canonical: "tranche", kind: "portioned", system: "none" },
+  tranches: { canonical: "tranche", kind: "portioned", system: "none" },
+  botte: { canonical: "botte", kind: "portioned", system: "none" },
+  bottes: { canonical: "botte", kind: "portioned", system: "none" },
+  boite: { canonical: "bo\xEEte", kind: "portioned", system: "none", plural: "bo\xEEtes" },
+  boites: { canonical: "bo\xEEte", kind: "portioned", system: "none", plural: "bo\xEEtes" },
+  pot: { canonical: "pot", kind: "portioned", system: "none" },
+  pots: { canonical: "pot", kind: "portioned", system: "none" },
+  brique: { canonical: "brique", kind: "portioned", system: "none" },
+  briques: { canonical: "brique", kind: "portioned", system: "none" },
+  feuille: { canonical: "feuille", kind: "portioned", system: "none" },
+  feuilles: { canonical: "feuille", kind: "portioned", system: "none" },
+  branche: { canonical: "branche", kind: "portioned", system: "none" },
+  branches: { canonical: "branche", kind: "portioned", system: "none" },
+  // Held to no better than a hand: the count scales, the size of one does not.
+  // `readPartitiveMeasure` explains what else lands here.
+  bouchon: { canonical: "bouchon", kind: "approximate", system: "none" },
+  bouchons: { canonical: "bouchon", kind: "approximate", system: "none" },
+  larme: { canonical: "larme", kind: "approximate", system: "none" },
+  larmes: { canonical: "larme", kind: "approximate", system: "none" },
+  doigt: { canonical: "doigt", kind: "approximate", system: "none" },
+  doigts: { canonical: "doigt", kind: "approximate", system: "none" },
+  nuage: { canonical: "nuage", kind: "approximate", system: "none" },
+  nuages: { canonical: "nuage", kind: "approximate", system: "none" },
+  louche: { canonical: "louche", kind: "approximate", system: "none" },
+  louches: { canonical: "louche", kind: "approximate", system: "none" },
+  lichette: { canonical: "lichette", kind: "approximate", system: "none" },
+  lichettes: { canonical: "lichette", kind: "approximate", system: "none" },
+  pointe: { canonical: "pointe", kind: "approximate", system: "none" },
+  pointes: { canonical: "pointe", kind: "approximate", system: "none" },
+  pincee: { canonical: "pinc\xE9e", kind: "approximate", system: "none", plural: "pinc\xE9es" },
+  pincees: { canonical: "pinc\xE9e", kind: "approximate", system: "none", plural: "pinc\xE9es" },
+  trait: { canonical: "trait", kind: "approximate", system: "none" },
+  traits: { canonical: "trait", kind: "approximate", system: "none" },
+  filet: { canonical: "filet", kind: "approximate", system: "none" },
+  filets: { canonical: "filet", kind: "approximate", system: "none" },
+  goutte: { canonical: "goutte", kind: "approximate", system: "none", plural: "gouttes" },
+  gouttes: { canonical: "goutte", kind: "approximate", system: "none", plural: "gouttes" },
+  poignee: { canonical: "poign\xE9e", kind: "approximate", system: "none", plural: "poign\xE9es" },
+  poignees: { canonical: "poign\xE9e", kind: "approximate", system: "none", plural: "poign\xE9es" },
+  // "noix" carries its own plural mark already.
+  noix: { canonical: "noix", kind: "approximate", system: "none", plural: "noix" },
+  soupcon: { canonical: "soup\xE7on", kind: "approximate", system: "none", plural: "soup\xE7ons" },
+  soupcons: { canonical: "soup\xE7on", kind: "approximate", system: "none", plural: "soup\xE7ons" }
+};
+var ENGLISH_UNITS = {
+  ...SHARED_UNITS,
+  milligram: { canonical: "mg", kind: "measured", system: "metric", symbol: true },
+  milligrams: { canonical: "mg", kind: "measured", system: "metric", symbol: true },
+  gram: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  grams: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  gramme: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  grammes: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  kilogram: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  kilograms: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  milliliter: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  milliliters: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  millilitre: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  millilitres: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  liter: { canonical: "l", kind: "measured", system: "metric", symbol: true },
+  liters: { canonical: "l", kind: "measured", system: "metric", symbol: true },
+  // Imperial mass
+  oz: { canonical: "oz", kind: "measured", system: "imperial", symbol: true },
+  ounce: { canonical: "ounce", kind: "measured", system: "imperial", plural: "ounces" },
+  ounces: { canonical: "ounce", kind: "measured", system: "imperial", plural: "ounces" },
+  lb: { canonical: "lb", kind: "measured", system: "imperial", symbol: true },
+  lbs: { canonical: "lb", kind: "measured", system: "imperial", symbol: true },
+  pound: { canonical: "pound", kind: "measured", system: "imperial", plural: "pounds" },
+  pounds: { canonical: "pound", kind: "measured", system: "imperial", plural: "pounds" },
+  // Imperial volume
+  "fl oz": { canonical: "fl oz", kind: "measured", system: "imperial", symbol: true },
+  "fluid ounce": {
+    canonical: "fluid ounce",
+    kind: "measured",
+    system: "imperial",
+    plural: "fluid ounces"
+  },
+  "fluid ounces": {
+    canonical: "fluid ounce",
+    kind: "measured",
+    system: "imperial",
+    plural: "fluid ounces"
+  },
+  pint: { canonical: "pint", kind: "measured", system: "imperial", plural: "pints" },
+  pints: { canonical: "pint", kind: "measured", system: "imperial", plural: "pints" },
+  quart: { canonical: "quart", kind: "measured", system: "imperial", plural: "quarts" },
+  quarts: { canonical: "quart", kind: "measured", system: "imperial", plural: "quarts" },
+  gallon: { canonical: "gallon", kind: "measured", system: "imperial", plural: "gallons" },
+  gallons: { canonical: "gallon", kind: "measured", system: "imperial", plural: "gallons" },
+  // Spoons and cups: real measures, but only in sensible fractions.
+  tsp: { canonical: "tsp", kind: "portioned", system: "imperial", symbol: true },
+  teaspoon: { canonical: "teaspoon", kind: "portioned", system: "imperial", plural: "teaspoons" },
+  teaspoons: { canonical: "teaspoon", kind: "portioned", system: "imperial", plural: "teaspoons" },
+  tbsp: { canonical: "Tbsp", kind: "portioned", system: "imperial", symbol: true },
+  tbs: { canonical: "Tbsp", kind: "portioned", system: "imperial", symbol: true },
+  tablespoon: {
+    canonical: "tablespoon",
+    kind: "portioned",
+    system: "imperial",
+    plural: "tablespoons"
+  },
+  tablespoons: {
+    canonical: "tablespoon",
+    kind: "portioned",
+    system: "imperial",
+    plural: "tablespoons"
+  },
+  cup: { canonical: "cup", kind: "portioned", system: "imperial", plural: "cups" },
+  cups: { canonical: "cup", kind: "portioned", system: "imperial", plural: "cups" },
+  // Packaging and natural units: countable, so they round to whole things.
+  can: { canonical: "can", kind: "portioned", system: "none" },
+  cans: { canonical: "can", kind: "portioned", system: "none" },
+  jar: { canonical: "jar", kind: "portioned", system: "none" },
+  jars: { canonical: "jar", kind: "portioned", system: "none" },
+  packet: { canonical: "packet", kind: "portioned", system: "none" },
+  packets: { canonical: "packet", kind: "portioned", system: "none" },
+  package: { canonical: "package", kind: "portioned", system: "none" },
+  packages: { canonical: "package", kind: "portioned", system: "none" },
+  sachet: { canonical: "sachet", kind: "portioned", system: "none" },
+  sachets: { canonical: "sachet", kind: "portioned", system: "none" },
+  clove: { canonical: "clove", kind: "portioned", system: "none" },
+  cloves: { canonical: "clove", kind: "portioned", system: "none" },
+  slice: { canonical: "slice", kind: "portioned", system: "none" },
+  slices: { canonical: "slice", kind: "portioned", system: "none" },
+  stick: { canonical: "stick", kind: "portioned", system: "none" },
+  sticks: { canonical: "stick", kind: "portioned", system: "none" },
+  stalk: { canonical: "stalk", kind: "portioned", system: "none" },
+  stalks: { canonical: "stalk", kind: "portioned", system: "none" },
+  sprig: { canonical: "sprig", kind: "portioned", system: "none" },
+  sprigs: { canonical: "sprig", kind: "portioned", system: "none" },
+  bunch: { canonical: "bunch", kind: "portioned", system: "none", plural: "bunches" },
+  bunches: { canonical: "bunch", kind: "portioned", system: "none", plural: "bunches" },
+  head: { canonical: "head", kind: "portioned", system: "none" },
+  heads: { canonical: "head", kind: "portioned", system: "none" },
+  sheet: { canonical: "sheet", kind: "portioned", system: "none" },
+  sheets: { canonical: "sheet", kind: "portioned", system: "none" },
+  leaf: { canonical: "leaf", kind: "portioned", system: "none", plural: "leaves" },
+  leaves: { canonical: "leaf", kind: "portioned", system: "none", plural: "leaves" },
+  ea: { canonical: "ea", kind: "portioned", system: "none", symbol: true },
+  // Held to no better than a hand: the count scales, the size of one does not.
+  // `readContainerLoad` explains what else lands here.
+  capful: { canonical: "capful", kind: "approximate", system: "none", plural: "capfuls" },
+  capfuls: { canonical: "capful", kind: "approximate", system: "none", plural: "capfuls" },
+  glug: { canonical: "glug", kind: "approximate", system: "none" },
+  glugs: { canonical: "glug", kind: "approximate", system: "none" },
+  dollop: { canonical: "dollop", kind: "approximate", system: "none" },
+  dollops: { canonical: "dollop", kind: "approximate", system: "none" },
+  squeeze: { canonical: "squeeze", kind: "approximate", system: "none" },
+  squeezes: { canonical: "squeeze", kind: "approximate", system: "none" },
+  sprinkle: { canonical: "sprinkle", kind: "approximate", system: "none" },
+  sprinkles: { canonical: "sprinkle", kind: "approximate", system: "none" },
+  sprinkling: { canonical: "sprinkling", kind: "approximate", system: "none" },
+  sprinklings: { canonical: "sprinkling", kind: "approximate", system: "none" },
+  grating: { canonical: "grating", kind: "approximate", system: "none" },
+  gratings: { canonical: "grating", kind: "approximate", system: "none" },
+  twist: { canonical: "twist", kind: "approximate", system: "none" },
+  twists: { canonical: "twist", kind: "approximate", system: "none" },
+  smidgen: { canonical: "smidgen", kind: "approximate", system: "none" },
+  smidgens: { canonical: "smidgen", kind: "approximate", system: "none" },
+  pinch: { canonical: "pinch", kind: "approximate", system: "none", plural: "pinches" },
+  pinches: { canonical: "pinch", kind: "approximate", system: "none", plural: "pinches" },
+  dash: { canonical: "dash", kind: "approximate", system: "none", plural: "dashes" },
+  dashes: { canonical: "dash", kind: "approximate", system: "none", plural: "dashes" },
+  splash: { canonical: "splash", kind: "approximate", system: "none", plural: "splashes" },
+  splashes: { canonical: "splash", kind: "approximate", system: "none", plural: "splashes" },
+  drizzle: { canonical: "drizzle", kind: "approximate", system: "none" },
+  drizzles: { canonical: "drizzle", kind: "approximate", system: "none" },
+  handful: { canonical: "handful", kind: "approximate", system: "none", plural: "handfuls" },
+  handfuls: { canonical: "handful", kind: "approximate", system: "none", plural: "handfuls" },
+  drop: { canonical: "drop", kind: "approximate", system: "none" },
+  drops: { canonical: "drop", kind: "approximate", system: "none" },
+  knob: { canonical: "knob", kind: "approximate", system: "none" },
+  knobs: { canonical: "knob", kind: "approximate", system: "none" }
+};
+var VOCABULARY2 = {
+  fr: FRENCH_UNITS,
+  en: ENGLISH_UNITS
+};
+function normalizeUnitKey(text) {
+  return text.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/\./g, " ").replace(/\((?:s|x|es)\)/g, "").replace(/\s+/g, " ").trim();
+}
+function orderedKeys(vocabulary) {
+  return Object.keys(vocabulary).sort(
+    (a, b) => b.split(" ").length - a.split(" ").length || b.length - a.length
+  );
+}
+var UNIT_KEYS = {
+  fr: orderedKeys(FRENCH_UNITS),
+  en: orderedKeys(ENGLISH_UNITS)
+};
+function unitKeys(language) {
+  return UNIT_KEYS[language];
+}
+function lookupUnit(text, language) {
+  return VOCABULARY2[language][normalizeUnitKey(text)] ?? null;
+}
+var EMBEDDED = {
+  fr: buildEmbedded("fr"),
+  en: buildEmbedded("en")
+};
+function buildEmbedded(language) {
+  const keys = UNIT_KEYS[language].map((key) => key.replace(/ /g, "\\s+"));
+  return new RegExp(`\\d[\\d.,/]*\\s*(?:${keys.join("|")})\\b`, "i");
+}
+function hasEmbeddedMeasure(text, language) {
+  return EMBEDDED[language].test(text);
+}
+var NOT_A_MEASURE = /* @__PURE__ */ new Set([
+  "peu",
+  "beaucoup",
+  "plus",
+  "moins",
+  "assez",
+  "trop",
+  "autant",
+  "tant",
+  "moitie",
+  "quart",
+  "tiers",
+  "reste",
+  "melange",
+  "ensemble"
+]);
+function readPartitiveMeasure(text) {
+  const match = new RegExp("^\\s*(\\p{L}+)\\s+(?=(?:de|du|des)\\s|d')", "u").exec(text);
+  if (!match) return null;
+  const word = match[1];
+  if (word.length < 3) return null;
+  if (NOT_A_MEASURE.has(normalizeUnitKey(word))) return null;
+  if (lookupUnit(word, "fr")) return null;
+  const canonical = frenchSingular(word);
+  return {
+    unit: {
+      canonical,
+      kind: "approximate",
+      system: "none",
+      plural: frenchPlural(canonical)
+    },
+    rest: text.slice(match[0].length)
+  };
+}
+function readContainerLoad(word) {
+  const key = normalizeUnitKey(word);
+  if (!/^[a-z]{3,}fuls?$/.test(key)) return null;
+  const canonical = key.endsWith("fuls") ? key.slice(0, -1) : key;
+  return { canonical, kind: "approximate", system: "none", plural: `${canonical}s` };
+}
+function frenchSingular(word) {
+  if (/eaux$/i.test(word)) return word.slice(0, -1);
+  if (/aux$/i.test(word)) return `${word.slice(0, -3)}al`;
+  if (/[aiou]s$/i.test(word)) return word;
+  if (/s$/i.test(word) && word.length > 3) return word.slice(0, -1);
+  return word;
+}
+function frenchPlural(word) {
+  if (/[sxz]$/i.test(word)) return word;
+  if (/eau$/i.test(word)) return `${word}x`;
+  if (/al$/i.test(word)) return `${word.slice(0, -2)}aux`;
+  return `${word}s`;
+}
+var APPROXIMATE_EQUIVALENT = {
+  capful: "commonly taken as about a tablespoon, the size of a bottle cap",
+  glug: "commonly taken as about two tablespoons poured free-hand",
+  dollop: "commonly taken as about a heaped tablespoon",
+  pinch: "commonly taken as about half a teaspoon",
+  dash: "commonly taken as about an eighth of a teaspoon",
+  splash: "commonly taken as about a tablespoon",
+  handful: "commonly taken as about a quarter of a cup",
+  knob: "commonly taken as about a tablespoon of butter",
+  drizzle: "commonly taken as about a teaspoon poured in a thin line",
+  pincee: "commonly taken as about half a teaspoon",
+  poignee: "commonly taken as about a quarter of a cup",
+  bouchon: "commonly taken as about a tablespoon, the size of a bottle cap",
+  goutte: "commonly taken as a single drop",
+  filet: "commonly taken as about a teaspoon poured in a thin line",
+  noix: "commonly taken as about a tablespoon of butter",
+  louche: "commonly taken as about half a cup",
+  soupcon: "commonly taken as the smallest amount a spoon tip carries"
+};
+function approximateEquivalent(unit) {
+  return APPROXIMATE_EQUIVALENT[normalizeUnitKey(unit.canonical)] ?? null;
+}
+var PROMOTIONS = {
+  mg: { to: "g", per: 1e3, language: "en" },
+  g: { to: "kg", per: 1e3, language: "en" },
+  ml: { to: "l", per: 1e3, language: "en" },
+  cl: { to: "l", per: 100, language: "en" },
+  dl: { to: "l", per: 10, language: "en" },
+  oz: { to: "lb", per: 16, language: "en" },
+  ounce: { to: "pound", per: 16, language: "en" },
+  "fl oz": { to: "pint", per: 20, language: "en" },
+  pint: { to: "quart", per: 2, language: "en" },
+  quart: { to: "gallon", per: 4, language: "en" }
+};
+var DEMOTIONS = {
+  // Spoons and cups hold a fixed volume, so a share of one is stated in the
+  // smaller spoon rather than as a fraction no measuring set carries. The
+  // spelling of the step matches the spelling of the unit it comes from, so a
+  // line written in abbreviations stays in abbreviations, and a French line
+  // stays in French.
+  cup: { to: "tablespoon", per: 16, language: "en" },
+  tablespoon: { to: "teaspoon", per: 3, language: "en" },
+  tbsp: { to: "tsp", per: 3, language: "en" },
+  "cuillere a soupe": { to: "cuillere a cafe", per: 3, language: "fr" },
+  tasse: { to: "cuillere a soupe", per: 16, language: "fr" },
+  kg: { to: "g", per: 1e3, language: "en" },
+  g: { to: "mg", per: 1e3, language: "en" },
+  l: { to: "cl", per: 100, language: "en" },
+  dl: { to: "cl", per: 10, language: "en" },
+  cl: { to: "ml", per: 10, language: "en" },
+  lb: { to: "oz", per: 16, language: "en" },
+  pound: { to: "ounce", per: 16, language: "en" },
+  gallon: { to: "quart", per: 4, language: "en" },
+  quart: { to: "pint", per: 2, language: "en" },
+  pint: { to: "fl oz", per: 20, language: "en" }
+};
+function demoteUnit(unit) {
+  const step = DEMOTIONS[normalizeUnitKey(unit.canonical)];
+  if (!step) return null;
+  const target = lookupUnit(step.to, step.language);
+  return target ? { unit: target, per: step.per } : null;
+}
+function isSpoonMeasure(unit) {
+  return /^(cup|tablespoon|Tbsp|teaspoon|tsp|cuillère à soupe|cuillère à café|tasse)$/.test(
+    unit.canonical
+  );
+}
+function unitDivisibility(unit) {
+  return QUARTERED_MEASURE.test(unit.canonical) ? "quarter" : "half";
+}
+var QUARTERED_MEASURE = /\b(pots?|bouteilles?|bottles?|jars?|blocs?|blocks?|gousses?|tranches?|slices?)\b/i;
+function countsBarePieces(unit) {
+  return unit.canonical === "ea";
+}
+function chooseReadableUnit(unit, amount) {
+  if (unit.kind !== "measured" || !Number.isFinite(amount) || amount <= 0) {
+    return { unit, ratio: 1 };
+  }
+  let current = unit;
+  let ratio = 1;
+  while (amount * ratio < 1) {
+    const step = demoteUnit(current);
+    if (!step) break;
+    ratio *= step.per;
+    current = step.unit;
+  }
+  const up = PROMOTIONS[normalizeUnitKey(current.canonical)];
+  if (up && amount * ratio >= up.per) {
+    const target = lookupUnit(up.to, up.language);
+    if (target) {
+      ratio /= up.per;
+      current = target;
+    }
+  }
+  return { unit: current, ratio };
+}
+function formatUnit(unit, amount, language) {
+  if (unit.symbol) return unit.canonical;
+  const singular = language === "fr" ? amount < 2 : amount <= 1;
+  if (singular) return unit.canonical;
+  return unit.plural ?? `${unit.canonical}s`;
+}
+
+// src/recipe/quantity.ts
+var VULGAR_FRACTIONS = {
+  "\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 VULGAR_CLASS = Object.keys(VULGAR_FRACTIONS).join("");
+function parseLeadingQuantity(text, language) {
+  const trimmed = text.trimStart();
+  const offset = text.length - trimmed.length;
+  const mixedGlyph = new RegExp(`^(\\d+)\\s*([${VULGAR_CLASS}])`).exec(trimmed);
+  if (mixedGlyph) {
+    const whole = Number(mixedGlyph[1]);
+    const fraction2 = VULGAR_FRACTIONS[mixedGlyph[2]];
+    return { amount: whole + fraction2, length: offset + mixedGlyph[0].length };
+  }
+  const mixed = /^(\d+)\s+(\d+)\s*\/\s*(\d+)/.exec(trimmed);
+  if (mixed) {
+    const denominator = Number(mixed[3]);
+    if (denominator !== 0) {
+      return {
+        amount: Number(mixed[1]) + Number(mixed[2]) / denominator,
+        length: offset + mixed[0].length
+      };
+    }
+  }
+  const fraction = /^(\d+)\s*\/\s*(\d+)/.exec(trimmed);
+  if (fraction) {
+    const denominator = Number(fraction[2]);
+    if (denominator === 0) return null;
+    return { amount: Number(fraction[1]) / denominator, length: offset + fraction[0].length };
+  }
+  const glyph = trimmed[0];
+  if (glyph && glyph in VULGAR_FRACTIONS) {
+    return { amount: VULGAR_FRACTIONS[glyph], length: offset + 1 };
+  }
+  const decimal = (language === "fr" ? /^(\d+(?:[.,]\d+)?)/ : /^(\d{1,3}(?:,\d{3})+(?:\.\d+)?|\d+(?:\.\d+)?)/).exec(trimmed);
+  if (decimal) {
+    const written = decimal[1];
+    const amount = Number(
+      language === "fr" ? written.replace(",", ".") : written.replace(/,/g, "")
+    );
+    if (Number.isFinite(amount)) return { amount, length: offset + decimal[0].length };
+  }
+  if (language === "en") {
+    const written = parseWrittenFraction(trimmed);
+    if (written) return { amount: written.amount, length: offset + written.length };
+  }
+  return null;
+}
+var WRITTEN_NUMERATORS = { a: 1, an: 1, one: 1, two: 2, three: 3 };
+var WRITTEN_DENOMINATORS = {
+  half: 2,
+  halves: 2,
+  third: 3,
+  thirds: 3,
+  quarter: 4,
+  quarters: 4,
+  fourth: 4,
+  fourths: 4
+};
+function parseWrittenFraction(text) {
+  const match = /^(?:(a|an|one|two|three)[\s-]+)?(halves|half|thirds|third|quarters|quarter|fourths|fourth)\b/i.exec(
+    text
+  );
+  if (!match) return null;
+  const numerator = match[1] ? WRITTEN_NUMERATORS[match[1].toLowerCase()] : 1;
+  const denominator = WRITTEN_DENOMINATORS[match[2].toLowerCase()];
+  if (!numerator || !denominator) return null;
+  const rest = text.slice(match[0].length).replace(/^\s*of\s+/i, "").trimStart();
+  if (!/^an?\s/i.test(rest) && !takeUnit(rest, "en").unit) return null;
+  return { amount: numerator / denominator, length: match[0].length };
+}
+function parseLeadingRange(text, language) {
+  const low = parseLeadingQuantity(text, language);
+  if (!low) return null;
+  const after = text.slice(low.length);
+  const written = language === "fr" ? /^\s+(à|a|ou)\s+/i : /^\s+(to|or)\s+/i;
+  const separator = written.exec(after) ?? /^\s*(–|—|-)\s*/.exec(after);
+  if (!separator) return null;
+  const high = parseLeadingQuantity(after.slice(separator[0].length), language);
+  if (!high || high.amount <= low.amount) return null;
+  return {
+    amount: low.amount,
+    max: high.amount,
+    separator: separator[1],
+    length: low.length + separator[0].length + high.length
+  };
+}
+var FRENCH_ARTICLES = { un: 1, une: 1, quelques: 3 };
+function takeUnit(text, language) {
+  const normalized = normalizeUnitKey(text);
+  for (const key of unitKeys(language)) {
+    if (normalized !== key && !normalized.startsWith(`${key} `)) continue;
+    const unit = lookupUnit(key, language);
+    if (!unit) continue;
+    const wordCount = key.split(" ").length;
+    const words = text.trim().split(/\s+/);
+    return { unit, rest: words.slice(wordCount).join(" ") };
+  }
+  if (language === "en") {
+    const words = text.trimStart().split(/\s+/);
+    const load = words[0] ? readContainerLoad(words[0]) : null;
+    if (load) return { unit: load, rest: words.slice(1).join(" ") };
+  }
+  return { unit: null, rest: text };
+}
+function takeUnitEitherLanguage(text, language) {
+  const first = takeUnit(text, language);
+  if (first.unit) return first;
+  return takeUnit(text, language === "fr" ? "en" : "fr");
+}
+function detectLanguage(line) {
+  const text = line.trim();
+  const afterFigures = text.replace(/^[\s\d.,/½⅓⅔¼¾⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞\-–—]+/u, "").trimStart();
+  const afterArticle = afterFigures.replace(/^(?:un|une|quelques|of\s+an?|an?)\s+/iu, "");
+  const frenchUnit = takeUnit(afterArticle, "fr").unit !== null;
+  const englishUnit = takeUnit(afterArticle, "en").unit !== null;
+  return readLanguage(text, { frenchUnit, englishUnit }).language;
+}
+function parseIngredient(line, choice = "auto") {
+  const original = line;
+  const text = line.trim();
+  const language = choice === "auto" ? detectLanguage(text) : choice;
+  const empty = {
+    original,
+    language,
+    amount: null,
+    amountMax: null,
+    rangeSeparator: null,
+    unit: null,
+    alternates: [],
+    alternateStyle: null,
+    item: text,
+    articleWord: null,
+    countMultiplier: null
+  };
+  const range = parseLeadingRange(text, language);
+  const article = range ? null : readArticle(text, language);
+  const quantity = range ?? parseLeadingQuantity(text, language) ?? article;
+  if (!quantity) return empty;
+  let rest = text.slice(quantity.length).trimStart();
+  if (language === "en") rest = rest.replace(/^(?:of\s+)?an?\s+/i, "");
+  const multiplier = readCountMultiplier(rest);
+  if (multiplier) rest = multiplier.rest;
+  const times = multiplier?.times ?? 1;
+  const leading = takeLeadingUnit(rest, language, quantity === article);
+  rest = leading.rest;
+  const bracketed = takeAlternates(rest, language);
+  rest = bracketed.rest;
+  const slashed = bracketed.measures.length > 0 ? null : takeSlashAlternates(rest, language);
+  if (slashed) rest = slashed.rest;
+  return {
+    original,
+    language,
+    amount: quantity.amount * times,
+    amountMax: range === null ? null : range.max * times,
+    rangeSeparator: range?.separator ?? null,
+    unit: leading.unit,
+    alternates: slashed ? slashed.measures : bracketed.measures,
+    alternateStyle: slashed ? "slash" : bracketed.measures.length > 0 ? "bracket" : null,
+    item: stripItemLead(rest, language),
+    articleWord: quantity === article ? article?.word ?? null : null,
+    countMultiplier: multiplier?.times ?? null
+  };
+}
+function readArticle(text, language) {
+  const counts = (rest) => takeLeadingUnit(rest, language, true).unit !== null || readCountMultiplier(rest) !== null;
+  if (language === "fr") {
+    const match = /^\s*(un|une|quelques)\b\s*/i.exec(text);
+    if (!match) return null;
+    if (!counts(text.slice(match[0].length))) return null;
+    const word = match[1];
+    return { amount: FRENCH_ARTICLES[word.toLowerCase()], length: match[0].length, word };
+  }
+  const article = /^an?\s+/i.exec(text);
+  if (!article) return null;
+  if (!counts(text.slice(article[0].length))) return null;
+  return { amount: 1, length: article[0].length, word: article[0].trim() };
+}
+var COUNT_MULTIPLIERS = {
+  dozen: 12,
+  dozens: 12,
+  douzaine: 12,
+  douzaines: 12
+};
+function readCountMultiplier(text) {
+  const match = new RegExp("^\\s*(\\p{L}+)\\s+", "u").exec(text);
+  if (!match) return null;
+  const times = COUNT_MULTIPLIERS[normalizeUnitKey(match[1])];
+  if (times === void 0) return null;
+  return { times, rest: text.slice(match[0].length) };
+}
+function takeLeadingUnit(text, language, fromArticle) {
+  const taken = takeUnit(text, language);
+  if (taken.unit) return taken;
+  if (language === "fr" && fromArticle) {
+    const measure = readPartitiveMeasure(text);
+    if (measure) return { unit: measure.unit, rest: measure.rest };
+  }
+  return taken;
+}
+function stripItemLead(text, language) {
+  if (language === "fr") {
+    return text.replace(/^(?:de\s+la\s+|de\s+l'|d'|de\s+|du\s+|des\s+)/i, "").replace(/^(?:une|un)\s+/i, "").trim();
+  }
+  return text.replace(/^of\s+/i, "").replace(/^an?\s+/i, "").trim();
+}
+function takeAlternates(text, language) {
+  if (!text.startsWith("(")) return { measures: [], rest: text };
+  const close = text.indexOf(")");
+  if (close < 0) return { measures: [], rest: text };
+  const inside = text.slice(1, close);
+  const parts = inside.split("/").map((part) => part.trim());
+  const measures = [];
+  for (const part of parts) {
+    const range = parseLeadingRange(part, language);
+    const quantity = range ?? parseLeadingQuantity(part, language);
+    if (!quantity) return { measures: [], rest: text };
+    const after = takeUnitEitherLanguage(part.slice(quantity.length).trimStart(), language);
+    if (!after.unit || after.rest.trim() !== "") return { measures: [], rest: text };
+    measures.push({
+      amount: quantity.amount,
+      amountMax: range?.max ?? null,
+      rangeSeparator: range?.separator ?? null,
+      unit: after.unit
+    });
+  }
+  if (measures.length === 0) return { measures: [], rest: text };
+  return { measures, rest: text.slice(close + 1).trimStart() };
+}
+function takeSlashAlternates(text, language) {
+  const measures = [];
+  let rest = text;
+  while (rest.startsWith("/")) {
+    const after = rest.slice(1).trimStart();
+    const range = parseLeadingRange(after, language);
+    const quantity = range ?? parseLeadingQuantity(after, language);
+    if (!quantity) break;
+    const taken = takeUnitEitherLanguage(after.slice(quantity.length).trimStart(), language);
+    if (!taken.unit) break;
+    measures.push({
+      amount: quantity.amount,
+      amountMax: range?.max ?? null,
+      rangeSeparator: range?.separator ?? null,
+      unit: taken.unit
+    });
+    rest = taken.rest.trimStart();
+  }
+  return measures.length > 0 ? { measures, rest } : null;
+}
+function formatAmount(amount, language, options = {}) {
+  const decimal = (value) => {
+    const rounded = value !== 0 && Math.abs(value) < 0.01 ? Number(value.toPrecision(2)) : Math.round(value * 100) / 100;
+    const rendered = String(rounded);
+    return language === "fr" ? rendered.replace(".", ",") : rendered;
+  };
+  if (!Number.isFinite(amount)) return "";
+  if (Number.isInteger(amount)) return String(amount);
+  if (options.fractions === false) return decimal(amount);
+  const whole = Math.floor(amount);
+  const rest = amount - whole;
+  const known = [
+    [0.25, "1/4"],
+    [1 / 3, "1/3"],
+    [0.5, "1/2"],
+    [2 / 3, "2/3"],
+    [0.75, "3/4"]
+  ];
+  for (const [value, label] of known) {
+    if (Math.abs(rest - value) < 0.02) return whole > 0 ? `${whole} ${label}` : label;
+  }
+  return decimal(amount);
+}
+
+// src/recipe/scale.ts
+function roundTo(value, step) {
+  return Math.round(Math.round(value / step) * step * 100) / 100;
+}
+function roundMeasured(value) {
+  if (value >= 100) return roundTo(value, 5);
+  if (value >= 10) return roundTo(value, 1);
+  if (value >= 1) return roundTo(value, 0.1);
+  return Math.round(value * 100) / 100;
+}
+var SMALLEST_USABLE_FRACTION = 0.25;
+var SMALLEST_USABLE = {
+  whole: 1,
+  half: 0.5,
+  quarter: 0.25
+};
+function isHalfStep(value) {
+  return Math.abs(value * 2 - Math.round(value * 2)) < 1e-9;
+}
+function trim(value) {
+  return Math.round(value * 100) / 100;
+}
+function roundCountable(value, divisibility, ceiling) {
+  if (value <= 0) return { value: 0, clamped: false };
+  const floor = SMALLEST_USABLE[divisibility];
+  if (divisibility !== "whole" && value >= floor && isHalfStep(value)) {
+    return { value: trim(value), clamped: false };
+  }
+  if (divisibility === "whole") {
+    if (value < 0.5) return { value: floor, clamped: true };
+    return { value: Math.round(value), clamped: false };
+  }
+  if (value < floor) return { value: floor, clamped: true };
+  if (value < 1) {
+    const steps = divisibility === "quarter" ? [0.25, 1 / 3, 0.5, 2 / 3, 0.75, 1] : [0.5, 1];
+    const candidates = steps.filter(
+      (candidate) => candidate >= floor && candidate <= Math.max(ceiling, floor)
+    );
+    let closest = candidates[0];
+    for (const candidate of candidates) {
+      if (Math.abs(value - candidate) < Math.abs(value - closest)) closest = candidate;
+    }
+    return { value: trim(closest), clamped: false };
+  }
+  return { value: Math.round(value), clamped: false };
+}
+function roundSpoon(value, ceiling) {
+  if (value <= 0) return { value: 0, clamped: false };
+  if (value < 1) {
+    const candidates = [SMALLEST_USABLE_FRACTION, 1 / 3, 0.5, 2 / 3, 0.75, 1].filter(
+      (candidate) => candidate <= Math.max(ceiling, SMALLEST_USABLE_FRACTION)
+    );
+    let closest = candidates[0];
+    for (const candidate of candidates) {
+      if (Math.abs(value - candidate) < Math.abs(value - closest)) closest = candidate;
+    }
+    return { value: trim(closest), clamped: value < SMALLEST_USABLE_FRACTION };
+  }
+  return { value: roundTo(value, 0.5), clamped: false };
+}
+function stepDownSpoon(unit, reference) {
+  let current = unit;
+  let ratio = 1;
+  while (reference * ratio < 1 && !isHalfStep(reference * ratio)) {
+    const step = demoteUnit(current);
+    if (!step) break;
+    ratio *= step.per;
+    current = step.unit;
+  }
+  return { unit: current, ratio };
+}
+var EXACT_WITHIN = 0.01;
+var EXACT_SHARE = 5e-3;
+function landedExactly(exact, amount) {
+  const gap = Math.abs(exact - amount);
+  if (gap > EXACT_WITHIN) return false;
+  return exact === 0 || gap / Math.abs(exact) <= EXACT_SHARE;
+}
+function scaleMeasure(low, high, unit, factor, divisibility) {
+  const raws = high === null ? [low * factor] : [low * factor, high * factor];
+  const sources = high === null ? [low] : [low, high];
+  const positive = raws.filter((raw) => raw > 0);
+  const reference = positive.length > 0 ? Math.min(...positive) : raws[0];
+  const inUnit = (target, ratio) => ({
+    bounds: raws.map((raw, index) => {
+      const exact = raw * ratio;
+      const rounded = roundMeasured(exact);
+      const usable = rounded === 0 && exact > 0 ? Number(exact.toPrecision(2)) : rounded;
+      const ceiling = factor < 1 ? sources[index] * ratio : Number.POSITIVE_INFINITY;
+      return {
+        amount: Math.min(usable, ceiling),
+        exact,
+        clamped: false,
+        raw
+      };
+    }),
+    unit: target
+  });
+  if (unit && unit.kind === "measured") {
+    const chosen = chooseReadableUnit(unit, reference);
+    return inUnit(chosen.unit, chosen.ratio);
+  }
+  if (unit && isSpoonMeasure(unit)) {
+    const stepped = stepDownSpoon(unit, reference);
+    if (stepped.ratio !== 1) return inUnit(stepped.unit, stepped.ratio);
+    const bounds2 = raws.map((raw, index) => {
+      const ceiling = factor < 1 ? sources[index] : Number.POSITIVE_INFINITY;
+      const rounded = roundSpoon(raw, ceiling);
+      return { amount: rounded.value, exact: raw, clamped: rounded.clamped, raw };
+    });
+    return { bounds: bounds2, unit };
+  }
+  const bounds = raws.map((raw, index) => {
+    const ceiling = factor < 1 ? sources[index] : Number.POSITIVE_INFINITY;
+    const rounded = roundCountable(raw, divisibility, ceiling);
+    return { amount: rounded.value, exact: raw, clamped: rounded.clamped, raw };
+  });
+  return { bounds, unit };
+}
+var PORTION_SIZED_ITEM = new RegExp(
+  "\\b(?:shrimps?|prawns?|langoustines?|mussels?|hazelnuts?|peppercorns?|junipers?|grains?|anise|crevettes?|gambas|moules?|noisettes?|geni\xE8vres?|genievres?|anis)\\b",
+  "iu"
+);
+var QUARTERED_ITEM = new RegExp(
+  "\\b(?:onions?|shallots?|potatoes|potato|carrots?|apples?|pears?|lemons?|limes?|oranges?|tomato(?:es)?|cucumbers?|courgettes?|zucchinis?|aubergines?|eggplants?|squash(?:es)?|pumpkins?|cabbages?|melons?|watermelons?|peppers?|beets?|turnips?|parsnips?|leeks?|bananas?|mango(?:e?s)?|avocados?|legs? of lamb|lamb legs?|baguettes?|camemberts?|cheeses?|chorizos?|pineapples?|peach(?:es)?|apricots?|milk|chickens?|guinea fowls?|roasts?|oignons?|\xE9chalotes?|echalotes?|pommes? de terre|carottes?|pommes?|poires?|citrons?|tomates?|concombres?|courgettes?|aubergines?|potirons?|choux?|chou|melons?|poivrons?|betteraves?|navets?|panais|poireaux?|bananes?|mangues?|avocats?|past\xE8ques?|pasteques?|gigots?|fromages?|ch\xE8vres?|chevres?|ananas|p\xEAches?|peches?|abricots?|laits?|poulets?|pintades?|reblochons?|b\xFBches?|buches?|r\xF4tis?|rotis?)\\b",
+  "iu"
+);
+var HALVED_ITEM = /\b(?:jus|juices?)\b/iu;
+var WHOLE_ITEM = /\b(?:eggs?|yolks?|egg\s+whites?|oeufs?|œufs?|jaunes?\s+d['e]|clous?|zestes?|zests?)\b/iu;
+var HALVED_CUT = /\b(?:breasts?|thighs?|drumsticks?|wings?|cutlets?|cuisses?|ailes?|pilons?|escalopes?|magrets?)\b/iu;
+function cloveDivisibility(unit, item) {
+  const counted = unit ? unit.canonical === "clove" : /\bcloves?\b/i.test(item);
+  if (!counted) return null;
+  return /\bgarlic\b/i.test(item) ? "quarter" : "whole";
+}
+var BLANC_OF = /\bblancs?\s+d(?:e\s|['’])/iu;
+var BLANC_OF_EGG = /\bblancs?\s+d(?:e\s|['’])\s*(?:oeufs?|œufs?)\b/iu;
+function blancDivisibility(item) {
+  if (!BLANC_OF.test(item)) return null;
+  return BLANC_OF_EGG.test(item) ? "whole" : "half";
+}
+function divisibilityOf(unit, item) {
+  const clove = cloveDivisibility(unit, item);
+  if (clove) return clove;
+  if (unit && !countsBarePieces(unit)) return unitDivisibility(unit);
+  const blanc = blancDivisibility(item);
+  if (blanc) return blanc;
+  if (WHOLE_ITEM.test(item)) return "whole";
+  if (PORTION_SIZED_ITEM.test(item)) return "whole";
+  if (HALVED_ITEM.test(item)) return "half";
+  if (HALVED_CUT.test(item)) return "half";
+  if (QUARTERED_MEASURE.test(item)) return "quarter";
+  return QUARTERED_ITEM.test(item) ? "quarter" : "half";
+}
+var INVARIABLE_ITEM = /* @__PURE__ */ new Set([
+  "anise",
+  "ananas",
+  "asparagus",
+  "bacon",
+  "basil",
+  "beef",
+  "bison",
+  "broccoli",
+  "butter",
+  "celery",
+  "cilantro",
+  "citrus",
+  "cinnamon",
+  "cocoa",
+  "cod",
+  "coriander",
+  "corn",
+  "cornstarch",
+  "couscous",
+  "cream",
+  "deer",
+  "fish",
+  "flour",
+  "gambas",
+  "garlic",
+  "ginger",
+  "ham",
+  "honey",
+  "hummus",
+  "jus",
+  "kale",
+  "lamb",
+  "macaroni",
+  "milk",
+  "miso",
+  "musk",
+  "moose",
+  "mutton",
+  "nutmeg",
+  "oil",
+  "okra",
+  "oregano",
+  "parsley",
+  "pasta",
+  "pork",
+  "quinoa",
+  "rice",
+  "rosemary",
+  "saffron",
+  "salmon",
+  "salt",
+  "shrimp",
+  "spinach",
+  "squid",
+  "sugar",
+  "thyme",
+  "tofu",
+  "trout",
+  "tuna",
+  "vanilla",
+  "veal",
+  "venison",
+  "vinegar",
+  "water",
+  "yeast",
+  "yogurt"
+]);
+var IRREGULAR_PLURAL = {
+  calf: "calves",
+  chili: "chilies",
+  chilli: "chillies",
+  goose: "geese",
+  half: "halves",
+  knife: "knives",
+  leaf: "leaves",
+  loaf: "loaves",
+  mango: "mangoes",
+  potato: "potatoes",
+  shelf: "shelves",
+  tomato: "tomatoes"
+};
+var IRREGULAR_SINGULAR = Object.fromEntries(
+  Object.entries(IRREGULAR_PLURAL).map(([one, many]) => [many, one])
+);
+function matchCase(source, replacement) {
+  if (source[0] === source[0]?.toUpperCase() && source.slice(1) === source.slice(1).toLowerCase()) {
+    return replacement[0].toUpperCase() + replacement.slice(1);
+  }
+  return replacement;
+}
+function toEnglishPlural(word) {
+  const key = word.toLowerCase();
+  if (INVARIABLE_ITEM.has(key)) return word;
+  const irregular = IRREGULAR_PLURAL[key];
+  if (irregular) return matchCase(word, irregular);
+  if (/(?:ch|sh|s|x|z)$/i.test(word)) return `${word}es`;
+  if (/[^aeiou]y$/i.test(word)) return `${word.slice(0, -1)}ies`;
+  if (/(?:[^f]f|fe)$/i.test(word)) return `${word.replace(/fe?$/i, "")}ves`;
+  return `${word}s`;
+}
+function toEnglishSingular(word) {
+  const key = word.toLowerCase();
+  if (INVARIABLE_ITEM.has(key)) return word;
+  const irregular = IRREGULAR_SINGULAR[key];
+  if (irregular) return matchCase(word, irregular);
+  if (/ies$/i.test(word) && word.length > 4) return `${word.slice(0, -3)}y`;
+  if (/(?:ch|sh|s|x|z)es$/i.test(word)) return word.slice(0, -2);
+  if (/ss$/i.test(word)) return word;
+  if (/s$/i.test(word)) return word.slice(0, -1);
+  return word;
+}
+function agreeInEnglish(item, amount) {
+  if (!item) return item;
+  const comma = item.indexOf(",");
+  const head = comma < 0 ? item : item.slice(0, comma);
+  const tail = comma < 0 ? "" : item.slice(comma);
+  const preposition = / of /i.exec(head);
+  if (preposition) {
+    const counted = agreeInEnglish(head.slice(0, preposition.index), amount);
+    return `${counted}${head.slice(preposition.index)}${tail}`;
+  }
+  const words = head.trimEnd().split(" ");
+  const last = words[words.length - 1] ?? "";
+  if (!/^[A-Za-z]+$/.test(last) || last.length <= 2) return item;
+  const wantsPlural = amount > 1;
+  const plural = toEnglishPlural(last);
+  const singular = toEnglishSingular(last);
+  const isPlural = last.toLowerCase() !== singular.toLowerCase();
+  if (wantsPlural && !isPlural) words[words.length - 1] = plural;
+  else if (!wantsPlural && isPlural) words[words.length - 1] = singular;
+  else return item;
+  return `${words.join(" ")}${tail}`;
+}
+var INVARIABLE_FRENCH_NOUN = /* @__PURE__ */ new Set([
+  "ananas",
+  "anis",
+  "brebis",
+  "cassis",
+  "colis",
+  "coulis",
+  "couscous",
+  "gambas",
+  "houmous",
+  "jus",
+  "mais",
+  "pastis",
+  "pois",
+  "radis",
+  "ris",
+  "souris",
+  "tamis",
+  "tapas"
+]);
+var AGREEABLE_ADJECTIVES = /* @__PURE__ */ new Set([
+  "entier",
+  "entiere",
+  "etoile",
+  "etoilee",
+  "moyen",
+  "moyenne",
+  "petit",
+  "petite",
+  "grand",
+  "grande",
+  "mur",
+  "mure",
+  "vert",
+  "verte",
+  "rouge",
+  "jaune",
+  "noir",
+  "noire",
+  "blanc",
+  "blanche",
+  "rond",
+  "ronde",
+  "hache",
+  "hachee",
+  "coupe",
+  "coupee",
+  "rape",
+  "rapee",
+  "pele",
+  "pelee",
+  "epluche",
+  "epluchee",
+  "denoyaute",
+  "denoyautee",
+  "emince",
+  "emincee"
+]);
+function foldWord(word) {
+  return word.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "");
+}
+function agreeTrailingAdjective(word, wantsPlural) {
+  const folded = foldWord(word);
+  const isPlural = folded.endsWith("s");
+  const singular = isPlural ? word.slice(0, -1) : word;
+  if (!AGREEABLE_ADJECTIVES.has(foldWord(singular))) return null;
+  if (wantsPlural === isPlural) return null;
+  return wantsPlural ? `${word}s` : singular;
+}
+function agreeInFrench(item, amount) {
+  if (!item) return item;
+  const words = item.split(" ");
+  const head = words[0] ?? "";
+  if (head.length <= 3) return item;
+  const wantsPlural = amount >= 2;
+  const isPlural = /s$|eaux$|aux$/i.test(head);
+  if (wantsPlural && !isPlural) {
+    if (/[sxz]$/i.test(head)) {
+    } else if (/eau$/i.test(head)) words[0] = `${head}x`;
+    else if (/al$/i.test(head)) words[0] = `${head.slice(0, -2)}aux`;
+    else words[0] = `${head}s`;
+  } else if (!wantsPlural && isPlural) {
+    if (/eaux$/i.test(head)) words[0] = head.slice(0, -1);
+    else if (/aux$/i.test(head)) words[0] = `${head.slice(0, -3)}al`;
+    else if (INVARIABLE_FRENCH_NOUN.has(foldWord(head))) {
+    } else words[0] = head.slice(0, -1);
+  }
+  const last = words.length - 1;
+  if (last > 0) {
+    const adjective = agreeTrailingAdjective(words[last], wantsPlural);
+    if (adjective) words[last] = adjective;
+  }
+  return words.join(" ");
+}
+function agreeWithAmount(item, amount, language) {
+  return language === "fr" ? agreeInFrench(item, amount) : agreeInEnglish(item, amount);
+}
+var MUTE_H_WORDS = /^(?:huile|huiles|huitre|huitres|huître|huîtres|herbe|herbes|hysope)\b/i;
+function joinItem(item, language) {
+  if (!item) return "";
+  if (language === "en") return ` ${item}`;
+  const elides = /^[aeiouàâäéèêëîïôöûü]/i.test(item) || MUTE_H_WORDS.test(item);
+  return elides ? ` d'${item}` : ` de ${item}`;
+}
+var BRANCH_SEPARATORS = {
+  en: /\s+or\s+/gi,
+  fr: /\s+ou\s+/gi
+};
+function splitBranch(text, parsed) {
+  const itemStart = parsed.item ? text.indexOf(parsed.item) : text.length;
+  if (itemStart < 0) return null;
+  const separator = BRANCH_SEPARATORS[parsed.language];
+  separator.lastIndex = 0;
+  for (let match = separator.exec(text); match; match = separator.exec(text)) {
+    if (match.index < itemStart) continue;
+    const tail = text.slice(match.index + match[0].length);
+    if (parseIngredient(tail, parsed.language).amount === null) continue;
+    return { head: text.slice(0, match.index), separator: match[0], tail };
+  }
+  return null;
+}
+function scaleIngredient(line, options) {
+  const { factor } = options;
+  if (factor === 1) return passthroughIngredient(line, options.language);
+  const text = line.trim();
+  const parsed = parseIngredient(text, options.language ?? "auto");
+  const branch = splitBranch(text, parsed);
+  if (branch) return scaleBranchedLine(line, branch, { ...options, language: parsed.language });
+  return scaleSingleLine(line, options);
+}
+function scaleBranchedLine(line, branch, options) {
+  const head = scaleSingleLine(branch.head, options);
+  if (head.scaling === "unscaled") return { ...head, text: line.trim(), original: line };
+  const tail = scaleAlternative(branch.tail, options);
+  const result = {
+    ...head,
+    original: line,
+    text: `${head.text}${branch.separator}${tail.text}`,
+    scaling: "rounded"
+  };
+  const branchNote = tail.rewritten ? "This line offers a choice between two quantities, and each was scaled on its own. How far one stands for the other is the page's own claim." : "This line carries a further quantity after the first one, and only the first was scaled. Read the rest as published.";
+  result.note = head.note ? `${head.note} ${branchNote}` : branchNote;
+  return result;
+}
+function scaleAlternative(tail, options) {
+  const parsed = parseIngredient(tail, options.language ?? "auto");
+  const published = tail.trim();
+  if (parsed.amount === null) return { text: published, rewritten: false };
+  const largest = (parsed.amountMax ?? parsed.amount) * options.factor;
+  if (largest < 1) return { text: published, rewritten: false };
+  return { text: scaleIngredient(tail, options).text, rewritten: true };
+}
+function scaleSingleLine(line, options) {
+  const { factor } = options;
+  const parsed = parseIngredient(line, options.language ?? "auto");
+  const language = parsed.language;
+  if (parsed.amount === null) {
+    return {
+      text: parsed.original,
+      original: parsed.original,
+      scaling: "unscaled",
+      amount: null,
+      amountMax: null,
+      unit: null,
+      language,
+      note: "No quantity given; adjust to taste."
+    };
+  }
+  const divisibility = divisibilityOf(parsed.unit, parsed.item);
+  const primary = scaleMeasure(parsed.amount, parsed.amountMax, parsed.unit, factor, divisibility);
+  const alternates = parsed.alternates.map((measure) => renderMeasure(measure, factor, language));
+  const primaryBounds = primary.bounds;
+  const alternateBounds = alternates.flatMap((entry) => entry.bounds);
+  const movedPrimary = primaryBounds.some((b) => !landedExactly(b.exact, b.amount));
+  const movedAlternate = alternateBounds.some((b) => !landedExactly(b.exact, b.amount));
+  const clamped = [...primaryBounds, ...alternateBounds].find((bound) => bound.clamped) ?? null;
+  const restated = parsed.alternateStyle === "slash";
+  const low = primaryBounds[0];
+  const high = primaryBounds[1] ?? null;
+  const unit = primary.unit;
+  const shown = high?.amount ?? low.amount;
+  const asText = (value) => formatAmount(value, language, { fractions: unit?.kind !== "measured" });
+  const collapsed = high !== null && high.amount === low.amount;
+  const amountText = renderRange(
+    asText(low.amount),
+    high === null || collapsed ? null : asText(high.amount),
+    parsed.rangeSeparator
+  );
+  const named = unit && !countsBarePieces(unit) ? unit : null;
+  const unitLabel = named ? ` ${formatUnit(named, shown, language)}` : "";
+  const alternateTexts = alternates.map((entry) => entry.text);
+  const altLabel = alternates.length === 0 ? "" : parsed.alternateStyle === "slash" ? ` / ${alternateTexts.join(" / ")}` : ` (${alternateTexts.join(" / ")})`;
+  const counted = agreeWithAmount(parsed.item, shown, language);
+  const itemLabel = named ? joinItem(parsed.item, language) : counted ? ` ${counted}` : "";
+  const result = {
+    text: `${amountText}${unitLabel}${altLabel}${itemLabel}`.trim(),
+    original: parsed.original,
+    scaling: movedPrimary || movedAlternate || restated ? "rounded" : "scaled",
+    amount: low.amount,
+    amountMax: collapsed ? null : high?.amount ?? null,
+    unit: named?.canonical ?? null,
+    language
+  };
+  const asPublished = (value, source) => `${formatAmount(value, language, { fractions: false })}${source ? ` ${formatUnit(source, value, language)}` : ""}`;
+  const sentences = [];
+  if (clamped) {
+    sentences.push(
+      `Clamped up to ${formatAmount(clamped.amount, language)} from ${formatAmount(Math.round(clamped.raw * 1e3) / 1e3, language)}, the smallest amount worth measuring. This line no longer holds its share of the recipe.`
+    );
+  } else if (movedPrimary) {
+    const moved = primaryBounds.filter((bound) => !landedExactly(bound.exact, bound.amount));
+    sentences.push(
+      moved.map(
+        (bound) => `Rounded ${bound.amount > bound.exact ? "up" : "down"} from ${asPublished(bound.raw, parsed.unit)}.`
+      ).join(" ")
+    );
+  } else if (movedAlternate) {
+    sentences.push(
+      `The amount is exact; the equivalent ${restated ? "beside it" : "in brackets"} was rounded to stay readable.`
+    );
+  } else if (restated) {
+    sentences.push(
+      "This line states one quantity twice, and both readings were scaled. They agree as closely as the page wrote them, and no closer."
+    );
+  }
+  if (hasEmbeddedMeasure(parsed.item, language)) {
+    sentences.push(
+      "This line carries a further quantity after the first one, and only the first was scaled. Read the rest as published."
+    );
+  }
+  if (collapsed) {
+    sentences.push("The page gave a range, and at this size both ends come to the same amount.");
+  }
+  if (unit?.kind === "measured" && low.amount > 0 && low.amount < 0.05) {
+    sentences.push(
+      "This is smaller than a kitchen scale resolves. Make a larger batch, or measure it by eye."
+    );
+  }
+  if (sentences.length > 0) result.note = sentences.join(" ");
+  if (parsed.unit && parsed.unit.kind === "approximate") {
+    result.note = withApproximateNote(parsed.unit, result.note);
+  }
+  if (parsed.articleWord) {
+    const stood = (parsed.amount ?? 0) / (parsed.countMultiplier ?? 1);
+    const read = `"${parsed.articleWord}" read as ${formatAmount(stood, language)}.`;
+    result.note = result.note ? `${read} ${result.note}` : read;
+  }
+  return result;
+}
+function withApproximateNote(unit, existing) {
+  const equivalence = approximateEquivalent(unit);
+  const sentence = `A ${unit.canonical} is an approximate measure${equivalence ? `, ${equivalence}` : ""}. The count was scaled and the size of one is the cook's.`;
+  return existing ? `${existing} ${sentence}` : sentence;
+}
+function renderMeasure(measure, factor, language) {
+  const scaled = scaleMeasure(
+    measure.amount,
+    measure.amountMax,
+    measure.unit,
+    factor,
+    divisibilityOf(measure.unit, "")
+  );
+  const low = scaled.bounds[0];
+  const high = scaled.bounds[1] ?? null;
+  const unit = scaled.unit;
+  const shown = high?.amount ?? low.amount;
+  const asText = (value) => formatAmount(value, language, { fractions: unit?.kind !== "measured" });
+  return {
+    text: `${renderRange(
+      asText(low.amount),
+      high === null ? null : asText(high.amount),
+      measure.rangeSeparator
+    )}${unit ? ` ${formatUnit(unit, shown, language)}` : ""}`,
+    bounds: scaled.bounds
+  };
+}
+function renderRange(low, high, separator) {
+  if (high === null || separator === null) return low;
+  return /^[-–—]$/.test(separator) ? `${low}${separator}${high}` : `${low} ${separator} ${high}`;
+}
+function scaleIngredients(lines, options) {
+  return lines.map((line) => scaleIngredient(line, options));
+}
+function passthroughIngredient(line, language = "auto") {
+  const parsed = parseIngredient(line, language);
+  const result = {
+    text: parsed.original,
+    original: parsed.original,
+    scaling: parsed.amount === null ? "unscaled" : "scaled",
+    amount: parsed.amount,
+    amountMax: parsed.amountMax,
+    unit: parsed.unit?.canonical ?? null,
+    language: parsed.language
+  };
+  if (parsed.amount === null) result.note = "No quantity given; adjust to taste.";
+  else if (parsed.unit?.kind === "approximate") {
+    result.note = withApproximateNote(parsed.unit, void 0);
+  }
+  return result;
+}
+function passthroughIngredients(lines, language = "auto") {
+  return lines.map((line) => passthroughIngredient(line, language));
+}
+export {
+  passthroughIngredient,
+  passthroughIngredients,
+  scaleIngredient,
+  scaleIngredients
+};
+//# sourceMappingURL=scale.js.map