@recipe-book/core 0.0.3 → 0.1.1

package/dist/chunk-D5CV3UF7.cjs

@@ -0,0 +1,2754 @@
+'use strict';
+
+// src/errors.ts
+var DOCS_ORIGIN = "https://recipe-book.siraj.page";
+var ERROR_CODES = /* @__PURE__ */ new Set([
+  "invalid_recipe",
+  "invalid_quantity",
+  "invalid_ingredient",
+  "invalid_argument",
+  "incompatible_units",
+  "unknown_unit",
+  "missing_parent"
+]);
+var ERROR_NAMES = /* @__PURE__ */ new Set([
+  "RecipeBookError",
+  "RecipeValidationError"
+]);
+var RecipeBookError = class extends Error {
+  constructor(code, message, options) {
+    const docsUrl = `${DOCS_ORIGIN}/errors/${code}`;
+    super(`${message}
+See ${docsUrl}`, options);
+    this.name = "RecipeBookError";
+    this.code = code;
+    this.docsUrl = docsUrl;
+  }
+};
+function isRecipeBookError(error2) {
+  if (typeof error2 !== "object" || error2 === null) {
+    return false;
+  }
+  try {
+    const { name, code } = error2;
+    return ERROR_NAMES.has(name) && ERROR_CODES.has(code);
+  } catch {
+    return false;
+  }
+}
+var MAX_ECHOED = 60;
+function describeValue(value) {
+  if (typeof value === "string") {
+    return quote(value);
+  }
+  if (typeof value === "function") {
+    return "a function";
+  }
+  if (value === null || typeof value !== "object") {
+    return quote(String(value)).slice(1, -1);
+  }
+  return Array.isArray(value) ? "an array" : "an object";
+}
+var UNESCAPED_BY_JSON = /[\x80-\x9f\u061c\u200e\u200f\u2028-\u202e\u2066-\u2069]/g;
+function quote(text) {
+  return JSON.stringify(truncate(text)).replace(
+    UNESCAPED_BY_JSON,
+    (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`
+  );
+}
+function truncate(text) {
+  if (text.length <= MAX_ECHOED) {
+    return text;
+  }
+  let end = MAX_ECHOED - 1;
+  const last = text.charCodeAt(end - 1);
+  if (last >= 55296 && last <= 56319) {
+    end--;
+  }
+  return `${text.slice(0, end)}\u2026`;
+}
+
+// src/issues.ts
+function warning(issues, code, path, message, suggestion) {
+  issues.push(issue("warning", code, path, message, suggestion));
+}
+function issue(severity, code, path, message, suggestion) {
+  return {
+    code,
+    severity,
+    path,
+    message,
+    ...suggestion !== void 0 && { suggestion }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+
+// src/units/registry.ts
+var TSP_ML = 4.92892159375;
+var OZ_G = 28.349523125;
+function definitions() {
+  return {
+    mg: {
+      dimension: "mass",
+      systems: ["metric"],
+      toBase: 1e-3,
+      aliases: ["milligram", "milligrams", "milligramme", "milligrammes"],
+      labels: { short: invariable("mg"), long: label("milligram") }
+    },
+    g: {
+      dimension: "mass",
+      systems: ["metric"],
+      toBase: 1,
+      aliases: ["gram", "grams", "gramme", "grammes"],
+      labels: { short: invariable("g"), long: label("gram") }
+    },
+    kg: {
+      dimension: "mass",
+      systems: ["metric"],
+      toBase: 1e3,
+      aliases: [
+        "kgs",
+        "kilo",
+        "kilos",
+        "kilogram",
+        "kilograms",
+        "kilogramme",
+        "kilogrammes"
+      ],
+      labels: { short: invariable("kg"), long: label("kilogram") }
+    },
+    oz: {
+      dimension: "mass",
+      systems: ["us"],
+      toBase: OZ_G,
+      aliases: ["ounce", "ounces"],
+      labels: { short: invariable("oz"), long: label("ounce") }
+    },
+    lb: {
+      dimension: "mass",
+      systems: ["us"],
+      toBase: 16 * OZ_G,
+      aliases: ["lbs", "pound", "pounds"],
+      labels: { short: invariable("lb"), long: label("pound") }
+    },
+    ml: {
+      dimension: "volume",
+      systems: ["metric"],
+      toBase: 1,
+      aliases: ["mL", "milliliter", "milliliters", "millilitre", "millilitres"],
+      labels: { short: invariable("mL"), long: label("milliliter") }
+    },
+    cl: {
+      dimension: "volume",
+      systems: ["metric"],
+      toBase: 10,
+      aliases: ["cL", "centiliter", "centiliters", "centilitre", "centilitres"],
+      labels: { short: invariable("cL"), long: label("centiliter") }
+    },
+    dl: {
+      dimension: "volume",
+      systems: ["metric"],
+      toBase: 100,
+      aliases: ["dL", "deciliter", "deciliters", "decilitre", "decilitres"],
+      labels: { short: invariable("dL"), long: label("deciliter") }
+    },
+    l: {
+      dimension: "volume",
+      systems: ["metric"],
+      toBase: 1e3,
+      aliases: ["L", "liter", "liters", "litre", "litres"],
+      labels: { short: invariable("L"), long: label("liter") }
+    },
+    tsp: {
+      dimension: "volume",
+      systems: ["metric", "us"],
+      toBase: TSP_ML,
+      aliases: ["t", "tsps", "teaspoon", "teaspoons"],
+      labels: { short: invariable("tsp"), long: label("teaspoon") }
+    },
+    tbsp: {
+      dimension: "volume",
+      systems: ["metric", "us"],
+      toBase: 3 * TSP_ML,
+      aliases: ["T", "tbs", "tbsps", "tablespoon", "tablespoons"],
+      labels: { short: invariable("tbsp"), long: label("tablespoon") }
+    },
+    "fl-oz": {
+      dimension: "volume",
+      systems: ["us"],
+      toBase: 6 * TSP_ML,
+      aliases: ["fl oz", "fluid ounce", "fluid ounces"],
+      labels: { short: invariable("fl oz"), long: label("fluid ounce") }
+    },
+    cup: {
+      dimension: "volume",
+      systems: ["us"],
+      toBase: 48 * TSP_ML,
+      aliases: ["cups", "c"],
+      labels: { short: label("cup"), long: label("cup") }
+    },
+    pint: {
+      dimension: "volume",
+      systems: ["us"],
+      toBase: 96 * TSP_ML,
+      aliases: ["pt", "pts", "pints"],
+      labels: { short: invariable("pt"), long: label("pint") }
+    },
+    quart: {
+      dimension: "volume",
+      systems: ["us"],
+      toBase: 192 * TSP_ML,
+      aliases: ["qt", "qts", "quarts"],
+      labels: { short: invariable("qt"), long: label("quart") }
+    },
+    gallon: {
+      dimension: "volume",
+      systems: ["us"],
+      toBase: 768 * TSP_ML,
+      aliases: ["gal", "gals", "gallons"],
+      labels: { short: invariable("gal"), long: label("gallon") }
+    },
+    pinch: count("pinch", ["pinches"]),
+    dash: count("dash", ["dashes"]),
+    clove: count("clove", ["cloves"]),
+    slice: count("slice", ["slices"]),
+    piece: count("piece", ["pieces", "pc", "pcs"]),
+    can: count("can", ["cans"]),
+    package: count("package", ["packages", "pkg", "pkgs"]),
+    stick: count("stick", ["sticks"]),
+    sprig: count("sprig", ["sprigs"]),
+    bunch: count("bunch", ["bunches"]),
+    head: count("head", ["heads"])
+  };
+}
+function label(one, other = `${one}s`) {
+  return { one, other };
+}
+function invariable(one) {
+  return { one, other: one };
+}
+function count(one, aliases) {
+  return {
+    dimension: "count",
+    systems: ["metric", "us"],
+    aliases,
+    labels: { short: label(one, aliases[0]), long: label(one, aliases[0]) }
+  };
+}
+var units = /* @__PURE__ */ buildRegistry();
+function lookupUnit(id) {
+  return typeof id === "string" && hasOwn(units, id) ? units[id] : void 0;
+}
+function buildRegistry() {
+  return Object.freeze(
+    Object.fromEntries(
+      Object.entries(definitions()).map(
+        ([id, spec]) => [
+          id,
+          Object.freeze({
+            id,
+            ...spec,
+            systems: Object.freeze(spec.systems),
+            aliases: Object.freeze([id, ...spec.aliases]),
+            labels: Object.freeze({
+              short: Object.freeze(spec.labels.short),
+              long: Object.freeze(spec.labels.long)
+            })
+          })
+        ]
+      )
+    )
+  );
+}
+
+// src/suggest.ts
+function closestMatch(text, candidates) {
+  const input = text.trim().toLowerCase();
+  const maxDistance = input.length < 3 ? 0 : input.length < 6 ? 1 : 2;
+  let best;
+  let bestDistance = Infinity;
+  let bestGap = 0;
+  for (const candidate of candidates) {
+    const lengthGap = Math.abs(candidate.length - input.length);
+    if (lengthGap > maxDistance) {
+      continue;
+    }
+    const distance = editDistance(input, candidate.toLowerCase());
+    if (distance <= maxDistance && (distance < bestDistance || distance === bestDistance && lengthGap < bestGap)) {
+      best = candidate;
+      bestDistance = distance;
+      bestGap = lengthGap;
+    }
+  }
+  return best;
+}
+function editDistance(a, b) {
+  let twoAbove = [];
+  let above = [0];
+  for (let j = 1; j <= b.length; j++) {
+    above[j] = j;
+  }
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      let distance = Math.min(
+        above[j] + 1,
+        row[j - 1] + 1,
+        above[j - 1] + cost
+      );
+      if (a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        distance = Math.min(distance, twoAbove[j - 2] + 0.5);
+      }
+      row[j] = distance;
+    }
+    twoAbove = above;
+    above = row;
+  }
+  return above[b.length];
+}
+
+// src/units/lookup.ts
+var aliasIndex;
+var CASE_SENSITIVE = /^[Ttc]$/;
+function foldKey(key) {
+  const lower = key.toLowerCase();
+  return lower === "t" || lower === "c" ? key : lower;
+}
+function findUnit(text) {
+  if (typeof text !== "string") {
+    return void 0;
+  }
+  const key = unitKey(text);
+  if (!aliasIndex) {
+    const index = /* @__PURE__ */ new Map();
+    for (const unit of Object.values(units)) {
+      for (const alias of unit.aliases) {
+        index.set(foldKey(unitKey(alias)), unit.id);
+      }
+    }
+    aliasIndex = index;
+  }
+  return aliasIndex.get(key) ?? aliasIndex.get(foldKey(key));
+}
+function unitKey(text) {
+  return text.trim().replace(/\s+/g, " ").replace(/(\p{L}) ?\.(?= |$)/gu, "$1");
+}
+function getUnit(id) {
+  if (!lookupUnit(id)) {
+    throw unknownUnitError(id);
+  }
+  return units[id];
+}
+function unknownUnitError(value) {
+  if (typeof value !== "string") {
+    return new RecipeBookError(
+      "unknown_unit",
+      `Expected a unit id such as "g", "ml", or "cup", received ${describeValue(value)}.`
+    );
+  }
+  const name = value.toLowerCase();
+  if (hasOwn(SYSTEM_NAMES, name)) {
+    return new RecipeBookError(
+      "unknown_unit",
+      `${quote(value)} is a measurement system, not a unit. To convert a quantity into a system, use toSystem(quantity, "${SYSTEM_NAMES[name]}").`
+    );
+  }
+  const id = findUnit(value);
+  if (id) {
+    return new RecipeBookError(
+      "unknown_unit",
+      `${quote(value)} is not a unit id. Use the id "${id}"; findUnit(${quote(value)}) converts author text to ids.`
+    );
+  }
+  const suggestion = suggestUnit(value);
+  return new RecipeBookError(
+    "unknown_unit",
+    suggestion ? (
+      // The caller wants an id, so "cupz" suggests "cup" rather than the alias "cups".
+      `Unknown unit ${quote(value)}. Did you mean "${findUnit(suggestion)}"?`
+    ) : `Unknown unit ${quote(value)}. Use a unit id such as "g", "ml", or "cup".`
+  );
+}
+var SYSTEM_NAMES = {
+  metric: "metric",
+  us: "us"
+};
+function suggestUnit(text) {
+  return closestMatch(
+    unitKey(text).replace(/(^|\P{P})\p{P}+$/u, "$1"),
+    Object.values(units).flatMap((unit) => unit.aliases).filter((alias) => !CASE_SENSITIVE.test(alias))
+  );
+}
+
+// src/validation.ts
+var RecipeValidationError = class extends RecipeBookError {
+  /**
+   * @param subject - What was validated, shown as given at the start of the
+   *   message, e.g. `'"Buttermilk pancakes"'`. Recipe Book's own errors quote
+   *   the recipe's name or the input text like a JSON string, cut with "…"
+   *   when longer than 60 UTF-16 code units.
+   */
+  constructor(code, issues, subject = code === "invalid_recipe" ? "Recipe" : code === "invalid_quantity" ? "Quantity" : "Ingredient") {
+    super(code, summarize(subject, issues));
+    Object.assign(this, { name: "RecipeValidationError" });
+    this.issues = issues;
+  }
+};
+var MAX_LISTED = 10;
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function summarize(subject, issues) {
+  const count2 = issues.length;
+  const header = `${subject} has ${count2} ${count2 === 1 ? "problem" : "problems"}:`;
+  const listed = issues.slice(0, MAX_LISTED);
+  const paths = listed.map((issue2) => formatPath(issue2.path));
+  const width = Math.max(0, ...paths.map((path) => path.length));
+  const lines = listed.map(
+    (issue2, i) => `  ${issue2.severity === "error" ? "\u2716" : "\u26A0"} ${paths[i].padEnd(width)}  ${issue2.message}`
+  );
+  if (count2 > listed.length) {
+    lines.push(
+      `  \u2026and ${count2 - listed.length} more. error.issues lists them all.`
+    );
+  }
+  return [header, ...lines].join("\n");
+}
+function formatPath(path) {
+  if (path.length === 0) {
+    return "(root)";
+  }
+  return path.reduce(
+    (text, segment) => typeof segment === "number" ? `${text}[${segment}]` : IDENTIFIER.test(segment) ? text ? `${text}.${truncate(segment)}` : truncate(segment) : `${text}[${quote(segment)}]`,
+    ""
+  );
+}
+function error(issues, code, path, message, suggestion) {
+  issues.push(issue("error", code, path, message, suggestion));
+  return void 0;
+}
+function toResult(code, data, issues, subject) {
+  if (data === void 0 || issues.some((issue2) => issue2.severity === "error")) {
+    return {
+      success: false,
+      error: new RecipeValidationError(code, issues, subject)
+    };
+  }
+  return { success: true, data, warnings: issues };
+}
+function asRecord(value) {
+  return isRecord(value) ? Object.assign(/* @__PURE__ */ Object.create(null), value) : void 0;
+}
+function checkFields(issues, record, fields, path) {
+  for (const key of Object.keys(record)) {
+    if (hasOwn(fields, key)) {
+      continue;
+    }
+    const suggestion = closestMatch(
+      key.replace(/Content$/, ""),
+      Object.keys(fields)
+    );
+    warning(
+      issues,
+      "unknown_field",
+      [...path, key],
+      suggestion ? `Unknown field. Did you mean "${suggestion}"?` : "Unknown field. It is ignored.",
+      suggestion
+    );
+  }
+}
+
+// src/quantity/amount.ts
+function mapAmount(amount, fn) {
+  return typeof amount === "number" ? fn(amount) : { min: fn(amount.min), max: fn(amount.max) };
+}
+function amountEnds(amount) {
+  return typeof amount === "number" ? [amount] : [amount.min, amount.max];
+}
+function checkQuantity(fn, quantity) {
+  if (typeof quantity !== "object" || quantity === null || !("amount" in quantity)) {
+    throw invalidArgument(
+      `${fn}: expected a quantity such as { amount: 2, unit: "cup" }, received ${describeValue(quantity)}.`
+    );
+  }
+  if (quantity.max !== void 0) {
+    throw invalidArgument(
+      `${fn}: a quantity has no max; use amount: { min, max }, or formatServings or formatYield.`
+    );
+  }
+  const { amount } = quantity;
+  if (typeof amount === "number") {
+    if (!isPositive(amount)) {
+      throw invalidArgument(
+        `${fn}: amount must be a finite number greater than 0, received ${describeValue(amount)}.`
+      );
+    }
+    return amount;
+  }
+  if (typeof amount === "object" && amount !== null && "min" in amount && "max" in amount) {
+    const { min, max } = amount;
+    if (!isPositive(min) || !isPositive(max)) {
+      throw invalidArgument(
+        `${fn}: range ends must be finite numbers greater than 0, received { min: ${describeValue(min)}, max: ${describeValue(max)} }.`
+      );
+    }
+    if (min >= max) {
+      throw invalidArgument(
+        `${fn}: range minimum (${min}) must be less than maximum (${max}). Use a plain number when both ends are equal.`
+      );
+    }
+    return { min, max };
+  }
+  throw invalidArgument(
+    `${fn}: amount must be a number or a { min, max } range, received ${describeValue(amount)}.`
+  );
+}
+function checkResult(fn, amount) {
+  for (const value of amountEnds(amount)) {
+    if (!isPositive(value)) {
+      throw invalidArgument(
+        `${fn}: the result must be a finite number greater than 0, but it is ${describeValue(value)}.`
+      );
+    }
+  }
+  return amount;
+}
+function checkFactor(fn, name, value) {
+  if (!isPositive(value)) {
+    throw invalidArgument(
+      `${fn}: ${name} must be a finite number greater than 0, received ${describeValue(value)}.`
+    );
+  }
+}
+function isPositive(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function invalidArgument(message) {
+  return new RecipeBookError("invalid_argument", message);
+}
+
+// src/quantity/parse.ts
+var VULGAR = "[\xBC-\xBE\u2150-\u215E]";
+var ARTICLE = /^an?\s+(?=\D)/i;
+var amountPattern;
+function parseQuantity(text) {
+  const issues = [];
+  if (typeof text !== "string") {
+    error(
+      issues,
+      "invalid_type",
+      [],
+      `Expected quantity text such as "1 \xBD cups", received ${describeValue(text)}.`
+    );
+    return toResult("invalid_quantity", void 0, issues);
+  }
+  const quantity = readQuantityText(issues, text, []);
+  return toResult("invalid_quantity", quantity, issues, quote(text));
+}
+function readQuantity(issues, value, path) {
+  if (typeof value === "string") {
+    const quantity = readQuantityText(issues, value, path);
+    return quantity && readTextAmount(issues, quantity.amount, path) ? quantity : void 0;
+  }
+  if (typeof value === "number") {
+    const amount = readPositive(issues, value, path);
+    return amount === void 0 ? void 0 : { amount };
+  }
+  const record = asRecord(value);
+  if (record) {
+    checkFields(issues, record, { amount: true, unit: true }, path);
+    const amount = readAmount(issues, record.amount, [...path, "amount"]);
+    const { unit } = record;
+    if (unit === void 0) {
+      return amount === void 0 ? void 0 : { amount };
+    }
+    if (typeof unit !== "string") {
+      return error(
+        issues,
+        "invalid_type",
+        [...path, "unit"],
+        `Expected a unit such as "g" or "cup", received ${describeValue(unit)}.`
+      );
+    }
+    const id = findUnit(unit);
+    if (!id) {
+      const problem = unknownUnit(
+        unit,
+        amount === void 0 ? void 0 : typeof amount === "number" ? String(amount) : `{ amount: { min: ${amount.min}, max: ${amount.max} } }`
+      );
+      return error(
+        issues,
+        problem.code,
+        [...path, "unit"],
+        problem.message,
+        problem.suggestion
+      );
+    }
+    return amount === void 0 ? void 0 : { amount, unit: id };
+  }
+  return error(
+    issues,
+    "invalid_type",
+    path,
+    `Expected a quantity such as "2 cups", 2, or { amount: 2, unit: "cup" }, received ${describeValue(value)}.`
+  );
+}
+function readQuantityText(issues, text, path) {
+  const result = parseText(text.replace(/\s+/g, " ").trim());
+  if ("code" in result) {
+    return error(issues, result.code, path, result.message, result.suggestion);
+  }
+  return result;
+}
+function parseText(text) {
+  const match = matchAmount(text);
+  if (!match) {
+    const unit2 = findUnit(text);
+    return unit2 ? {
+      code: "invalid_quantity",
+      message: `${quote(text)} has no amount. Write a full quantity, e.g. "1 ${units[unit2].labels.short.one}".`
+    } : unreadable(text);
+  }
+  if ("code" in match) {
+    return match;
+  }
+  const { amount, amountText, rest: unitText } = match;
+  if (unitText === "") {
+    return { amount };
+  }
+  if (/\d/.test(unitText) || !/\p{L}/u.test(unitText)) {
+    return unreadable(text);
+  }
+  const unit = findUnit(unitText);
+  if (unit) {
+    return { amount, unit };
+  }
+  return unknownUnit(
+    unitText,
+    amountText.length <= MAX_ECHOED && /^\d+(?:\.\d+)?$/.test(amountText) ? amountText : quote(amountText)
+  );
+}
+function matchAmount(text, allowZero) {
+  if (/\d,\d/.test(text)) {
+    return {
+      code: "invalid_quantity",
+      message: `Couldn't read ${quote(text)}. Write decimals with a period, e.g. "1.5", and leave out thousands separators.`
+    };
+  }
+  const article = ARTICLE.exec(text);
+  if (article) {
+    return { amount: 1, amountText: "1", rest: text.slice(article[0].length) };
+  }
+  if (!amountPattern) {
+    const number = String.raw`(?:\d+\s+)?\d+\s*[/⁄]\s*\d+|(?:\d+\s*)?${VULGAR}|\d+(?:\.\d+)?|\.\d+`;
+    amountPattern = new RegExp(
+      String.raw`^(${number})(?:(?:\s*[-–—]\s*|\s+to\s+)(${number}))?`,
+      "i"
+    );
+  }
+  const match = amountPattern.exec(text);
+  if (!match) {
+    return void 0;
+  }
+  const [matched, lowText = "", highText] = match;
+  const low = toNumber(lowText);
+  const high = highText === void 0 ? low : toNumber(highText);
+  if (low === Infinity || high === Infinity) {
+    return {
+      code: "invalid_amount",
+      message: `${quote(text)} has an amount too large to read. Check it for extra digits.`
+    };
+  }
+  if (!(isPositive(low) || allowZero && low === 0) || !(isPositive(high) || allowZero && high === 0)) {
+    return {
+      code: "invalid_amount",
+      message: `Expected a positive amount, received ${quote(text)}.`
+    };
+  }
+  if (low > high) {
+    const mixedHint = /^\d+$/.test(lowText) && high < 1 ? ` To write a mixed number, use ${quote(`${lowText} ${highText}`)}.` : "";
+    return {
+      code: "invalid_range",
+      message: `Range minimum (${truncateNumber(lowText)}) must be less than maximum (${truncateNumber(highText)}).${mixedHint}`
+    };
+  }
+  return {
+    amount: low === high ? low : { min: low, max: high },
+    amountText: matched,
+    rest: text.slice(matched.length).trim()
+  };
+}
+function unknownUnit(unitText, quantity) {
+  const suggestion = suggestUnit(unitText);
+  const move = quantity === void 0 ? "move the word into the name" : `move the word into the name: { name: ${quote(unitText)}, quantity: ${quantity} }`;
+  return {
+    code: "unknown_unit",
+    message: suggestion ? `Unknown unit ${quote(unitText)}. Did you mean "${suggestion}"?` : `Unknown unit ${quote(unitText)}. Use a known unit, or ${move}.`,
+    ...suggestion && { suggestion }
+  };
+}
+function truncateNumber(text) {
+  return text.length > 20 ? `${text.slice(0, 19)}\u2026` : text;
+}
+function unreadable(text) {
+  return {
+    code: "invalid_quantity",
+    message: text === "" ? 'Expected a quantity such as "1 \xBD cups", received an empty string.' : `Couldn't read ${quote(text)}. Use a number or fraction, e.g. "1 \xBD cups".`
+  };
+}
+var fractions = /* @__PURE__ */ new Map();
+function toNumber(text) {
+  const ascii = /^(?:(\d+)\s+)?(\d+)\s*[/⁄]\s*(\d+)$/.exec(text);
+  if (ascii) {
+    const [, whole = "0", numerator, denominator] = ascii;
+    return Number(whole) + Number(numerator) / (Number(denominator) || NaN);
+  }
+  const last = text.slice(-1);
+  if (last > "9") {
+    let fraction = fractions.get(last);
+    if (fraction === void 0) {
+      const [numerator, denominator] = last.normalize("NFKD").split("\u2044");
+      fraction = Number(numerator) / Number(denominator);
+      fractions.set(last, fraction);
+    }
+    return Number(text.slice(0, -1)) + fraction;
+  }
+  return Number(text);
+}
+function readAmount(issues, value, path) {
+  if (value === void 0) {
+    return error(
+      issues,
+      "missing_field",
+      path,
+      'Add an amount, e.g. { amount: 2, unit: "cup" }.'
+    );
+  }
+  if (typeof value === "number") {
+    return readPositive(issues, value, path);
+  }
+  const range = asRecord(value);
+  if (range && "min" in range && "max" in range) {
+    checkFields(issues, range, { min: true, max: true }, path);
+    const min = readPositive(issues, range.min, [...path, "min"]);
+    const max = readPositive(issues, range.max, [...path, "max"]);
+    if (min === void 0 || max === void 0) {
+      return void 0;
+    }
+    if (min > max) {
+      return error(
+        issues,
+        "invalid_range",
+        path,
+        `Range minimum (${min}) must be less than maximum (${max}).`
+      );
+    }
+    return min === max ? min : { min, max };
+  }
+  return error(
+    issues,
+    "invalid_type",
+    path,
+    `Expected a number or { min, max }, received ${describeValue(value)}.`
+  );
+}
+function readPositive(issues, value, path) {
+  if (isPositive(value) && value >= 1e-300 && value <= 1e290) {
+    return value;
+  }
+  return error(
+    issues,
+    typeof value === "number" ? "invalid_amount" : "invalid_type",
+    path,
+    isPositive(value) ? `Expected a number from 1e-300 to 1e290, received ${describeValue(value)}.` : `Expected a positive number, received ${describeValue(value)}.`
+  );
+}
+function readTextAmount(issues, amount, path) {
+  return (typeof amount === "number" ? [amount] : [amount.min, amount.max]).every((end) => readPositive(issues, end, path) !== void 0);
+}
+
+// src/recipe/duration.ts
+var ISO_DURATION = /^P(?!$)(?:(\d+(?:[.,]\d+)?)W)?(?:(\d+(?:[.,]\d+)?)D)?(?:T(?=\d)(?:(\d+(?:[.,]\d+)?)H)?(?:(\d+(?:[.,]\d+)?)M)?(?:(\d+(?:[.,]\d+)?)S)?)?$/i;
+var SECONDS = [604800, 86400, 3600, 60, 1];
+function parseIsoDuration(text) {
+  const match = ISO_DURATION.exec(text.trim());
+  if (!match) {
+    return void 0;
+  }
+  let seconds = 0;
+  let fractional = false;
+  let group = 0;
+  for (const unitSeconds of SECONDS) {
+    const part = match[++group];
+    if (part === void 0) {
+      continue;
+    }
+    if (fractional) {
+      return void 0;
+    }
+    fractional = /[.,]/.test(part);
+    seconds += Number(part.replace(",", ".")) * unitSeconds;
+  }
+  return Number.isFinite(seconds) ? seconds / 60 : void 0;
+}
+
+// src/recipe/ids.ts
+function slugify(text) {
+  return text.normalize("NFKD").replace(/(\p{Script=Latin})\p{M}+/gu, "$1").toLowerCase().normalize("NFC").replace(/(^|[^\p{L}\p{M}])\p{M}+/gu, "$1").replace(/[^\p{L}\p{M}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "");
+}
+function assignIds(requests, pending) {
+  const used = /* @__PURE__ */ new Set();
+  const nextSuffix = /* @__PURE__ */ new Map();
+  const ids = requests.map(({ authored }) => {
+    if (authored === void 0 || used.has(authored)) {
+      return void 0;
+    }
+    used.add(authored);
+    return authored;
+  });
+  return requests.map((request, i) => {
+    const claimed = ids[i];
+    if (claimed !== void 0) {
+      return claimed;
+    }
+    const base = request.authored ?? request.derived;
+    let id = base;
+    if (used.has(id)) {
+      let n = nextSuffix.get(base) ?? 2;
+      while (used.has(id = `${base}-${n}`)) {
+        n++;
+      }
+      nextSuffix.set(base, n + 1);
+    }
+    used.add(id);
+    if (request.authored !== void 0) {
+      pending.push({
+        position: request.position,
+        issue: issue(
+          "warning",
+          "duplicate_id",
+          [...request.path, "id"],
+          `${quote(request.authored)} is already used; renamed to ${quote(id)}.`
+        )
+      });
+    }
+    return id;
+  });
+}
+function insertPending(issues, pending) {
+  if (pending.length === 0) {
+    return;
+  }
+  const sorted = [...pending].sort((a, b) => a.position - b.position);
+  const original = issues.splice(0);
+  let next = 0;
+  for (const { position, issue: issue2 } of sorted) {
+    while (next < position) {
+      issues.push(original[next++]);
+    }
+    issues.push(issue2);
+  }
+  while (next < original.length) {
+    issues.push(original[next++]);
+  }
+}
+
+// src/recipe/infer.ts
+function inferSystem(sections) {
+  const counts = { metric: 0, us: 0 };
+  let first;
+  for (const { items } of sections) {
+    for (const { quantity } of items) {
+      const systems = quantity?.unit ? units[quantity.unit].systems : [];
+      if (systems.length === 1) {
+        const system = systems[0];
+        counts[system]++;
+        first ?? (first = system);
+      }
+    }
+  }
+  if (counts.metric !== counts.us) {
+    return counts.metric > counts.us ? "metric" : "us";
+  }
+  return first;
+}
+
+// src/recipe/nutrient-units.ts
+var NUTRIENT_UNITS = {
+  calories: "kcal",
+  fat: "g",
+  saturatedFat: "g",
+  transFat: "g",
+  unsaturatedFat: "g",
+  carbohydrates: "g",
+  sugar: "g",
+  fiber: "g",
+  protein: "g",
+  sodium: "mg",
+  cholesterol: "mg"
+};
+
+// src/recipe/nutrition.ts
+function parseNutrient(text, unit) {
+  const match = matchAmount(text.replace(/\s+/g, " "), true);
+  if (match && "code" in match) {
+    return match.code === "invalid_quantity" ? match : void 0;
+  }
+  const amount = match && typeof match.amount === "number" ? convert(match.amount, match.rest, unit) : void 0;
+  return Number.isFinite(amount) ? amount : void 0;
+}
+function convert(amount, unitText, unit) {
+  if (unitText === "") {
+    return amount;
+  }
+  if (unit === "kcal") {
+    return /^(?:k?cals?|(?:kilo)?calories?)\.?$/i.test(unitText) ? amount : /^(?:kj|kilojoules?)\.?$/i.test(unitText) ? amount / 4.184 : void 0;
+  }
+  const mass = lookupUnit(findUnit(unitText));
+  return mass?.dimension === "mass" && mass.toBase !== void 0 ? amount * (unit === "mg" ? mass.toBase * 1e3 : mass.toBase) : void 0;
+}
+
+// src/recipe/url.ts
+function disallowedScheme(url) {
+  const scheme = /^[\0- ]*[a-z][\d+.a-z\t\n\r-]*:/i.exec(url)?.[0].replace(/[\0- ]+/g, "").toLowerCase();
+  return scheme === "http:" || scheme === "https:" ? void 0 : scheme;
+}
+
+// src/recipe/parse.ts
+var RECIPE_FIELDS = {
+  id: true,
+  name: true,
+  description: true,
+  image: true,
+  servings: true,
+  yield: true,
+  system: true,
+  times: true,
+  ingredients: true,
+  steps: true,
+  notes: true,
+  equipment: true,
+  nutrition: true
+};
+var INGREDIENT_FIELDS = {
+  id: true,
+  name: true,
+  plural: true,
+  quantity: true,
+  equivalents: true,
+  note: true,
+  url: true,
+  optional: true
+};
+var SECTION_FIELDS = {
+  id: true,
+  title: true,
+  items: true
+};
+var STEP_FIELDS = {
+  id: true,
+  text: true,
+  name: true,
+  image: true
+};
+var SERVINGS_FIELDS = {
+  amount: true,
+  max: true
+};
+var YIELD_FIELDS = {
+  amount: true,
+  max: true,
+  unit: true,
+  plural: true
+};
+var TIMES_FIELDS = {
+  prep: true,
+  cook: true,
+  total: true,
+  custom: true
+};
+var CUSTOM_TIME_FIELDS = {
+  id: true,
+  label: true,
+  minutes: true
+};
+var NOTE_FIELDS = {
+  id: true,
+  title: true,
+  text: true
+};
+var EQUIPMENT_FIELDS = {
+  id: true,
+  name: true,
+  plural: true,
+  quantity: true,
+  url: true,
+  note: true
+};
+var NUTRIENT_EXAMPLES = {
+  kcal: 'kcal, e.g. 250, "250 kcal", or "1046 kJ"',
+  g: 'grams, e.g. 12 or "12 g"',
+  mg: 'milligrams, e.g. 300, "300 mg", or "0.3 g"'
+};
+function parseRecipe(input, options) {
+  return parseRecipeWith(
+    input,
+    readLineOption("parseRecipe", options) ?? "pass parseIngredientLine: parseRecipe(input, { parseIngredientLine })"
+  );
+}
+function parseRecipeWith(input, lines) {
+  const issues = [];
+  const recipe = readRecipe(issues, input, lines);
+  const label2 = recipe && quote(recipe.name);
+  return toResult("invalid_recipe", recipe, issues, label2);
+}
+function readLineOption(fn, options) {
+  const reader = asRecord(options)?.parseIngredientLine;
+  if (reader !== void 0 && typeof reader !== "function") {
+    throw new RecipeBookError(
+      "invalid_argument",
+      `${fn}: parseIngredientLine must be a function such as parseIngredientLine, received ${describeValue(reader)}.`
+    );
+  }
+  return reader;
+}
+function readRecipe(issues, value, lines) {
+  const input = asRecord(value);
+  if (!input) {
+    return error(
+      issues,
+      "invalid_type",
+      [],
+      `Expected a recipe object such as { name, ingredients, steps }, received ${describeValue(value)}.`
+    );
+  }
+  const pending = [];
+  const id = readText(issues, input.id, ["id"]);
+  const name = readText(
+    issues,
+    input.name,
+    ["name"],
+    "Add a name for the recipe."
+  );
+  const description = readText(issues, input.description, ["description"]);
+  const image = readUrl(issues, input.image, ["image"]);
+  const servings = readServings(issues, input.servings, ["servings"]);
+  const recipeYield = readYield(issues, input.yield, ["yield"]);
+  const authoredSystem = readSystem(issues, input.system, ["system"]);
+  const times = readTimes(issues, pending, input.times, ["times"]);
+  const ingredients = readList(
+    issues,
+    pending,
+    input.ingredients,
+    ["ingredients"],
+    "ingredients",
+    (issues2, value2, path) => readIngredient(issues2, value2, path, lines)
+  );
+  const steps = readList(
+    issues,
+    pending,
+    input.steps,
+    ["steps"],
+    "steps",
+    readStep
+  );
+  const notes = readItems(
+    issues,
+    pending,
+    input.notes,
+    ["notes"],
+    "notes",
+    readNote
+  );
+  const equipment = readItems(
+    issues,
+    pending,
+    input.equipment,
+    ["equipment"],
+    "equipment",
+    readEquipment
+  );
+  const nutrition = readNutrition(issues, input.nutrition, ["nutrition"]);
+  checkFields(issues, input, RECIPE_FIELDS, []);
+  insertPending(issues, pending);
+  if (name === void 0) {
+    return void 0;
+  }
+  const system = authoredSystem ?? inferSystem(ingredients);
+  return defined({
+    id: id ?? (slugify(name) || "recipe"),
+    name,
+    description,
+    image,
+    servings,
+    yield: recipeYield,
+    system,
+    times,
+    ingredients,
+    steps,
+    notes,
+    equipment,
+    nutrition
+  });
+}
+function readList(issues, pending, value, path, noun, readItem) {
+  const sections = [];
+  let loose;
+  let count2 = 0;
+  const read = (entry, entryPath) => readItem(issues, entry, entryPath, ++count2);
+  const visit = (entry, i) => {
+    const entryPath = [...path, i];
+    const section = asSection(entry);
+    if (section) {
+      loose = void 0;
+      sections.push(readSection(issues, section, entryPath, noun, read));
+      return;
+    }
+    if (!loose) {
+      loose = {
+        authored: void 0,
+        derived: noun,
+        path: entryPath,
+        position: issues.length,
+        title: void 0,
+        items: []
+      };
+      sections.push(loose);
+    }
+    const item = read(entry, entryPath);
+    if (item) {
+      loose.items.push(item);
+    }
+  };
+  if (value !== void 0 && !readArray(issues, value, path, noun, visit)) {
+    return [];
+  }
+  if (sections.length === 0) {
+    warning(issues, "empty_list", path, `Recipe has no ${noun}.`);
+    return [];
+  }
+  const sectionIds = assignIds(sections, pending);
+  const itemIds = assignIds(
+    sections.flatMap((section) => section.items),
+    pending
+  );
+  let next = 0;
+  return sections.map(
+    (section, i) => defined({
+      id: sectionIds[i],
+      title: section.title,
+      items: section.items.map((item) => item.build(itemIds[next++]))
+    })
+  );
+}
+function asSection(entry) {
+  const record = asRecord(entry);
+  return record && "items" in record ? record : void 0;
+}
+function readSection(issues, record, path, noun, read) {
+  const position = issues.length;
+  const authored = readText(issues, record.id, [...path, "id"]);
+  const title = readText(issues, record.title, [...path, "title"]);
+  const items = [];
+  const itemsPath = [...path, "items"];
+  let visited = 0;
+  const entries = readArray(
+    issues,
+    record.items,
+    itemsPath,
+    noun,
+    (entry, j) => {
+      visited++;
+      const itemPath = [...itemsPath, j];
+      if (asSection(entry)) {
+        error(
+          issues,
+          "invalid_type",
+          itemPath,
+          `Sections can't be nested. Make this a top-level section in ${noun}.`
+        );
+        return;
+      }
+      const item = read(entry, itemPath);
+      if (item) {
+        items.push(item);
+      }
+    }
+  );
+  if (entries && visited === 0) {
+    warning(issues, "empty_list", itemsPath, `Section has no ${noun}.`);
+  }
+  checkFields(issues, record, SECTION_FIELDS, path);
+  return {
+    authored,
+    derived: title && slugify(title) || noun,
+    path,
+    position,
+    title,
+    items
+  };
+}
+function readItems(issues, pending, value, path, noun, readItem) {
+  let n = 0;
+  const drafts = value === void 0 ? [] : readArray(
+    issues,
+    value,
+    path,
+    noun,
+    (entry, i) => readItem(issues, entry, [...path, i], ++n)
+  );
+  if (!drafts) {
+    return [];
+  }
+  const ids = assignIds(drafts, pending);
+  return drafts.map((draft, i) => draft.build(ids[i]));
+}
+function readArray(issues, value, path, noun, read) {
+  if (!Array.isArray(value)) {
+    return error(
+      issues,
+      "invalid_type",
+      path,
+      `Expected a list of ${noun}, received ${describeValue(value)}.`
+    );
+  }
+  const kept = [];
+  for (let i = 0, n = value.length; i < n; i++) {
+    if (i in value) {
+      const entry = value[i];
+      const result = hasOwn(value, i) && read(entry, i);
+      if (result) {
+        kept.push(result);
+      }
+    }
+  }
+  return kept;
+}
+function readIngredient(issues, value, path, lines) {
+  if (typeof value === "string" && typeof lines === "function") {
+    const result = lines(value);
+    for (const issue2 of result.success ? result.warnings : result.error.issues) {
+      issues.push({ ...issue2, path: [...path, ...issue2.path] });
+    }
+    return result.success ? readIngredient(issues, result.data, path) : void 0;
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return error(
+      issues,
+      "invalid_type",
+      path,
+      `Expected an ingredient such as ${typeof lines === "function" ? '"2 cups flour" or ' : ""}{ name: "flour", quantity: "2 cups" }, received ${describeValue(value)}.${typeof value === "string" && typeof lines === "string" ? ` To read ingredient lines, ${lines}.` : ""}`
+    );
+  }
+  const position = issues.length;
+  const authored = readText(issues, record.id, [...path, "id"]);
+  const name = readText(
+    issues,
+    record.name,
+    [...path, "name"],
+    'Add a name, e.g. name: "flour".'
+  );
+  const plural = readText(issues, record.plural, [...path, "plural"]);
+  const quantity = record.quantity === void 0 ? void 0 : readQuantity(issues, record.quantity, [...path, "quantity"]);
+  const equivalents = readEquivalents(issues, record.equivalents, [
+    ...path,
+    "equivalents"
+  ]);
+  const note = readText(issues, record.note, [...path, "note"]);
+  const url = readUrl(issues, record.url, [...path, "url"]);
+  const optional = readBoolean(issues, record.optional, [...path, "optional"]);
+  if (equivalents.length > 0 && record.quantity === void 0) {
+    error(
+      issues,
+      "missing_field",
+      [...path, "quantity"],
+      "Add a quantity. Equivalents are alternatives to it, so they need one."
+    );
+  }
+  checkFields(issues, record, INGREDIENT_FIELDS, path);
+  if (name === void 0) {
+    return void 0;
+  }
+  return {
+    authored,
+    derived: slugify(name) || "ingredient",
+    path,
+    position,
+    build: (id) => defined({ id, name, plural, quantity, equivalents, note, url, optional })
+  };
+}
+function readEquivalents(issues, value, path) {
+  return value !== void 0 && readArray(
+    issues,
+    value,
+    path,
+    'quantities, e.g. ["190 g"]',
+    (entry, i) => readQuantity(issues, entry, [...path, i])
+  ) || [];
+}
+function readStep(issues, value, path, n) {
+  const isText = typeof value === "string";
+  const record = asRecord(isText ? { text: value } : value);
+  if (!record) {
+    return error(
+      issues,
+      "invalid_type",
+      path,
+      `Expected a string or { text }, received ${describeValue(value)}.`
+    );
+  }
+  const position = issues.length;
+  const authored = readText(issues, record.id, [...path, "id"]);
+  const text = readText(
+    issues,
+    record.text,
+    isText ? path : [...path, "text"],
+    "Add the step text."
+  );
+  const name = readText(issues, record.name, [...path, "name"]);
+  const image = readUrl(issues, record.image, [...path, "image"]);
+  checkFields(issues, record, STEP_FIELDS, path);
+  if (text === void 0) {
+    return void 0;
+  }
+  return {
+    authored,
+    derived: name && slugify(name) || `step-${n}`,
+    path,
+    position,
+    build: (id) => defined({ id, text, name, image })
+  };
+}
+function readNote(issues, value, path, n) {
+  const isText = typeof value === "string";
+  const record = asRecord(isText ? { text: value } : value);
+  if (!record) {
+    return error(
+      issues,
+      "invalid_type",
+      path,
+      `Expected a string or { text }, received ${describeValue(value)}.`
+    );
+  }
+  const position = issues.length;
+  const authored = readText(issues, record.id, [...path, "id"]);
+  const title = readText(issues, record.title, [...path, "title"]);
+  const text = readText(
+    issues,
+    record.text,
+    isText ? path : [...path, "text"],
+    "Add the note text."
+  );
+  checkFields(issues, record, NOTE_FIELDS, path);
+  if (text === void 0) {
+    return void 0;
+  }
+  return {
+    authored,
+    derived: title && slugify(title) || `note-${n}`,
+    path,
+    position,
+    build: (id) => defined({ id, title, text })
+  };
+}
+function readEquipment(issues, value, path) {
+  const isText = typeof value === "string";
+  const record = asRecord(isText ? { name: value } : value);
+  if (!record) {
+    return error(
+      issues,
+      "invalid_type",
+      path,
+      `Expected a string or { name }, received ${describeValue(value)}.`
+    );
+  }
+  const position = issues.length;
+  const authored = readText(issues, record.id, [...path, "id"]);
+  const name = readText(
+    issues,
+    record.name,
+    isText ? path : [...path, "name"],
+    `Add a name, e.g. ${isText ? "" : "name: "}"whisk".`
+  );
+  const plural = readText(issues, record.plural, [...path, "plural"]);
+  const quantity = record.quantity === void 0 ? void 0 : readCount(issues, record.quantity, [...path, "quantity"]);
+  const url = readUrl(issues, record.url, [...path, "url"]);
+  const note = readText(issues, record.note, [...path, "note"]);
+  checkFields(issues, record, EQUIPMENT_FIELDS, path);
+  if (name === void 0) {
+    return void 0;
+  }
+  return {
+    authored,
+    derived: slugify(name) || "equipment",
+    path,
+    position,
+    build: (id) => defined({ id, name, plural, quantity, url, note })
+  };
+}
+function defined(fields) {
+  const copy = {};
+  for (const key in fields) {
+    if (hasOwn(fields, key) && fields[key] !== void 0) {
+      copy[key] = fields[key];
+    }
+  }
+  return copy;
+}
+function readCount(issues, value, path) {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  return error(
+    issues,
+    typeof value === "number" ? "invalid_amount" : "invalid_type",
+    path,
+    `Expected a whole number greater than 0, received ${describeValue(value)}.`
+  );
+}
+function readServings(issues, value, path) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    const amount = readPositive(issues, value, path);
+    return amount === void 0 ? void 0 : { amount };
+  }
+  const expected = `Expected a number of servings, e.g. 4 or "4\u20136", received ${describeValue(value)}.`;
+  if (typeof value === "string") {
+    const match = readRangeText(issues, value, path, expected);
+    if (match?.rest) {
+      return error(issues, "invalid_quantity", path, expected);
+    }
+    return match?.range;
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return error(issues, "invalid_type", path, expected);
+  }
+  const range = readRange(
+    issues,
+    record,
+    path,
+    "Add an amount, e.g. { amount: 4, max: 6 }."
+  );
+  checkFields(issues, record, SERVINGS_FIELDS, path);
+  return range;
+}
+function readYield(issues, value, path) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const isText = typeof value === "string";
+  const expected = `Expected a batch such as "24 cookies" or ${isText ? '"3\u20134 loaves"' : "{ amount, unit }"}, received ${describeValue(value)}.`;
+  if (isText) {
+    const match = readRangeText(issues, value, path, expected);
+    if (!match) {
+      return void 0;
+    }
+    const { range: range2, rest } = match;
+    if (!rest) {
+      return error(
+        issues,
+        "missing_field",
+        path,
+        `Add what the recipe makes, e.g. "24 cookies".${servingsHint(range2)}`
+      );
+    }
+    if (!/\p{L}/u.test(rest) || /^(?:[-–—&]|(?:[\d.,/\p{No}]+|or|to|x|and)(?:\s|$))/iu.test(rest)) {
+      const suggestion = suggestJoinedYield(value, range2, rest);
+      return error(
+        issues,
+        "invalid_quantity",
+        path,
+        suggestion ? `${expected} Did you mean "${suggestion}"?` : expected,
+        suggestion
+      );
+    }
+    return { ...range2, unit: rest };
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return error(
+      issues,
+      "invalid_type",
+      path,
+      `${expected}${isPositive(value) ? servingsHint({ amount: value }) : ""}`
+    );
+  }
+  const range = readRange(
+    issues,
+    record,
+    path,
+    'Add an amount, e.g. { amount: 24, unit: "cookie" }.'
+  );
+  const unit = readText(
+    issues,
+    record.unit,
+    [...path, "unit"],
+    `Add a unit, e.g. { amount: 24, unit: "cookie" }.${servingsHint(range)}`
+  );
+  const plural = readText(issues, record.plural, [...path, "plural"]);
+  checkFields(issues, record, YIELD_FIELDS, path);
+  if (range === void 0 || unit === void 0) {
+    return void 0;
+  }
+  return defined({ ...range, unit, plural });
+}
+function suggestJoinedYield(text, { amount }, rest) {
+  const joiner = /^(?:and|&)\s*/i.exec(rest);
+  const next = joiner && matchAmount(rest.slice(joiner[0].length));
+  if (!next || "code" in next || typeof next.amount !== "number") {
+    return void 0;
+  }
+  const isFraction = next.amount < 1;
+  if (!isFraction && !Number.isInteger(next.amount)) {
+    return void 0;
+  }
+  const head = text.replace(/\s+/g, " ").trim().slice(0, -rest.length);
+  const suggestion = `${head.trim()}${isFraction ? " " : "-"}${next.amountText} ${next.rest}`;
+  const parsed = readYield([], suggestion, []);
+  return parsed && (isFraction ? parsed.amount === amount + next.amount && parsed.max === void 0 : parsed.amount === amount && parsed.max === next.amount) ? suggestion : void 0;
+}
+function readRangeText(issues, text, path, expected) {
+  const match = matchAmount(text.replace(/\s+/g, " ").trim());
+  if (!match) {
+    return error(issues, "invalid_quantity", path, expected);
+  }
+  if ("code" in match) {
+    return error(issues, match.code, path, match.message);
+  }
+  const { amount, rest } = match;
+  const range = typeof amount === "number" ? { amount } : { amount: amount.min, max: amount.max };
+  if (readPositive(issues, range.amount, path) === void 0 || range.max !== void 0 && readPositive(issues, range.max, path) === void 0) {
+    return void 0;
+  }
+  return { range, rest };
+}
+function readRange(issues, record, path, missingAmount) {
+  const value = record.amount;
+  const amount = value === void 0 ? error(issues, "missing_field", [...path, "amount"], missingAmount) : isRecord(value) && hasOwn(value, "min") && hasOwn(value, "max") ? error(
+    issues,
+    "invalid_type",
+    [...path, "amount"],
+    "Expected a positive number, received an object. Write a range as { amount: 4, max: 6 }."
+  ) : readPositive(issues, value, [...path, "amount"]);
+  const max = record.max === void 0 ? void 0 : readPositive(issues, record.max, [...path, "max"]);
+  if (amount === void 0) {
+    return void 0;
+  }
+  if (max !== void 0 && max < amount) {
+    return error(
+      issues,
+      "invalid_range",
+      [...path, "max"],
+      `Expected a maximum greater than the amount (${amount}), received ${max}.`
+    );
+  }
+  return max === void 0 || max === amount ? { amount } : { amount, max };
+}
+function servingsHint(servings) {
+  if (!servings) {
+    return "";
+  }
+  const { amount, max } = servings;
+  return ` For a number of servings, use servings: ${max === void 0 ? amount : quote(`${amount}\u2013${max}`)}.`;
+}
+function readSystem(issues, value, path) {
+  if (value === void 0 || value === "metric" || value === "us") {
+    return value;
+  }
+  const suggestion = value === "imperial" ? "us" : void 0;
+  return error(
+    issues,
+    "invalid_type",
+    path,
+    `Expected "metric" or "us", received ${describeValue(value)}.${suggestion ? ` Did you mean "${suggestion}"?` : ""}`,
+    suggestion
+  );
+}
+function readTimes(issues, pending, value, path) {
+  if (value === void 0) {
+    return { custom: [] };
+  }
+  const record = asRecord(value);
+  if (!record) {
+    error(
+      issues,
+      "invalid_type",
+      path,
+      `Expected { prep, cook, total, custom }, received ${describeValue(value)}.`
+    );
+    return { custom: [] };
+  }
+  const prep = readDuration(issues, record.prep, [...path, "prep"]);
+  const cook = readDuration(issues, record.cook, [...path, "cook"]);
+  const total = readDuration(issues, record.total, [...path, "total"]);
+  const custom = readItems(
+    issues,
+    pending,
+    record.custom,
+    [...path, "custom"],
+    "custom times",
+    readCustomTime
+  );
+  checkFields(issues, record, TIMES_FIELDS, path);
+  return defined({ prep, cook, total, custom });
+}
+function readCustomTime(issues, value, path) {
+  const record = asRecord(value);
+  if (!record) {
+    return error(
+      issues,
+      "invalid_type",
+      path,
+      `Expected { label, minutes }, e.g. { label: "Chill", minutes: 60 }, received ${describeValue(value)}.`
+    );
+  }
+  const position = issues.length;
+  const authored = readText(issues, record.id, [...path, "id"]);
+  const label2 = readText(
+    issues,
+    record.label,
+    [...path, "label"],
+    'Add a label, e.g. label: "Chill".'
+  );
+  const minutes = record.minutes === void 0 ? error(
+    issues,
+    "missing_field",
+    [...path, "minutes"],
+    'Add the time, e.g. minutes: 60 or minutes: "PT1H".'
+  ) : readDuration(issues, record.minutes, [...path, "minutes"]);
+  checkFields(issues, record, CUSTOM_TIME_FIELDS, path);
+  if (label2 === void 0 || minutes === void 0) {
+    return void 0;
+  }
+  return {
+    authored,
+    derived: slugify(label2) || "time",
+    path,
+    position,
+    build: (id) => ({ id, label: label2, minutes })
+  };
+}
+function readDuration(issues, value, path) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const minutes = typeof value === "number" ? nonNegative(value) : typeof value === "string" ? parseIsoDuration(value) : void 0;
+  if (minutes === void 0) {
+    return error(
+      issues,
+      "invalid_duration",
+      path,
+      `Expected minutes or an ISO 8601 duration like "PT30M", received ${describeValue(value)}.`
+    );
+  }
+  return minutes;
+}
+function readNutrition(issues, value, path) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return error(
+      issues,
+      "invalid_type",
+      path,
+      `Expected nutrition for one serving, e.g. { calories: 250, fat: "12 g" }, received ${describeValue(value)}.`
+    );
+  }
+  const nutrition = {};
+  const servingSize = readText(issues, record.servingSize, [
+    ...path,
+    "servingSize"
+  ]);
+  if (servingSize !== void 0) {
+    nutrition.servingSize = servingSize;
+  }
+  for (const key of Object.keys(NUTRIENT_UNITS)) {
+    const amount = readNutrient(
+      issues,
+      record[key],
+      [...path, key],
+      NUTRIENT_UNITS[key]
+    );
+    if (amount !== void 0) {
+      nutrition[key] = amount;
+    }
+  }
+  checkFields(issues, record, { servingSize: true, ...NUTRIENT_UNITS }, path);
+  return Object.keys(nutrition).length > 0 ? nutrition : void 0;
+}
+function readNutrient(issues, value, path, unit) {
+  const text = typeof value === "string" ? value.trim() : void 0;
+  if (value === void 0 || text === "") {
+    return void 0;
+  }
+  const amount = typeof value === "number" ? nonNegative(value) : text === void 0 ? void 0 : parseNutrient(text, unit);
+  if (typeof amount === "number") {
+    return amount;
+  }
+  return error(
+    issues,
+    typeof value === "number" ? "invalid_amount" : text === void 0 ? "invalid_type" : "invalid_quantity",
+    path,
+    amount?.message ?? `Expected ${NUTRIENT_EXAMPLES[unit]}, received ${describeValue(value)}.`
+  );
+}
+function nonNegative(value) {
+  return Number.isFinite(value) && value >= 0 ? Math.abs(value) : void 0;
+}
+function readText(issues, value, path, requiredMessage) {
+  if (value !== void 0 && typeof value !== "string") {
+    return error(
+      issues,
+      "invalid_type",
+      path,
+      `Expected text, received ${describeValue(value)}.`
+    );
+  }
+  const text = value?.trim();
+  if (!text) {
+    return requiredMessage === void 0 ? void 0 : error(issues, "missing_field", path, requiredMessage);
+  }
+  return text;
+}
+function readUrl(issues, value, path) {
+  const url = readText(issues, value, path);
+  const scheme = url === void 0 ? void 0 : disallowedScheme(url);
+  return scheme === void 0 ? url : error(
+    issues,
+    "invalid_url",
+    path,
+    `Expected an http or https URL, or a relative one, received ${quote(`${scheme}\u2026`)}.`
+  );
+}
+function readBoolean(issues, value, path) {
+  if (value === void 0 || typeof value === "boolean") {
+    return value ?? false;
+  }
+  error(
+    issues,
+    "invalid_type",
+    path,
+    `Expected true or false, received ${describeValue(value)}.`
+  );
+  return false;
+}
+
+// src/ingredient/parse.ts
+var NUMBER_WORDS = "one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve";
+var DASH = "[ \u2013\u2014-]";
+var OPTIONAL = /(?:\(optional\)|optional\b ?:?) ?/iy;
+var ABOUT = /(about|approx(?:imately|\.)?) /iy;
+var PHRASE = /((?:an? )?(?:handful|few|couple|little|splash|drizzle|knob|squeeze|sprinkle|dollop))(?: of)? /iy;
+var HYPHENATED_MIXED = /^(\d+)-(?=(\d+)[/⁄](\d+)(?![\d/⁄]))/;
+var AMOUNT_CHARS = /(?:an? )?(?:[\d .,/⁄¼-¾⅐-⅞–—-]|to )*/iy;
+var TIMES = / ?[x×] ?(?=\d)/iy;
+var UNREAD = / ?(?:(?:or|to|and|plus|half)(?![\p{L}\p{M}\d_])|[-–—/+&]|\d+(?:\.\d+)?(?= |$))/iuy;
+var UNREAD_AFTER_UNIT = / (?:or|to|[-–—&])(?= )|[-–—+&](?=\d)/iy;
+var PAREN = / ?\(([^()]*)\)/y;
+var PARENS = / ?\(([^()]*)\)/g;
+var MODIFIER = / ?(heaping|heaped|level|scant|rounded|generous|good|small|medium|large|big)(?= )/iy;
+var JOIN = /(?: (plus|and|\+)(?![\p{L}\p{M}]))? ?/iuy;
+var SEPARATOR = / ?[;/] ?/y;
+var OF = / ?of(?: (?:an?|the))?(?= |$)/iy;
+var NAMED = /(?!(?:for|to|an?|yields?|total)(?![\p{L}\p{M}\d_])|(?:makes|serv(?:es|ings?)(?: size)?|protein|carbs|carbohydrates?|fiber|fibre|sodium|cholesterol|saturated fat|fat) ?:)([^\d:]+):/iuy;
+var PHRASE_NOTE = / (?=to taste|as needed|as required|plus more|plus extra|or more|or to taste|for (?:serving|garnish|dusting|greasing|frying|drizzling|decoration))/i;
+var OPTIONAL_NOTE = /(?:^|,) ?optional(?= ?(?:,|$))/gi;
+var OPTIONAL_PAREN = /^optional\b[,;:]? ?/i;
+var CONTAINER = /^(?:stalk|rib|ear|sheet|loa(?:f|ves)|knob|strip|bag|box|jar|bottle|packet|envelope|tin|block|ball|handful)(?:e?s)?$/i;
+var BONELESS = /(?:^|[^a-z])(?:bone|skin)less$/i;
+var patterns;
+function getPatterns() {
+  return patterns ?? (patterns = compilePatterns());
+}
+function compilePatterns() {
+  const word = String.raw`([a-z]+(?:-[a-z]+)?)\.?`;
+  const end = String.raw`(?=[ ,;()/]|[-–—+&]\d|$)`;
+  return {
+    count: new RegExp(`(an?|${NUMBER_WORDS}) (?=\\S)`, "iy"),
+    unit: new RegExp(`${DASH}?${word}${end}`, "iy"),
+    twoWordUnit: new RegExp(`${DASH}?${word} ${word}${end}`, "iy")
+  };
+}
+function parseIngredientLine(text) {
+  const issues = [];
+  if (typeof text !== "string") {
+    error(
+      issues,
+      "invalid_type",
+      [],
+      `Expected ingredient text such as "2 cups flour", received ${describeValue(text)}.`
+    );
+    return toResult("invalid_ingredient", void 0, issues);
+  }
+  const line = text.replace(/[\s\u200b]+/g, " ").trim();
+  if (line === "") {
+    error(
+      issues,
+      "missing_field",
+      [],
+      'Add the ingredient text, e.g. "2 cups flour".'
+    );
+    return toResult(
+      "invalid_ingredient",
+      void 0,
+      issues,
+      quote(text)
+    );
+  }
+  let ingredient = readLine(line);
+  if (isProblem(ingredient)) {
+    warning(
+      issues,
+      ingredient.code,
+      [],
+      `${ingredient.message} The whole line is kept as the name.`
+    );
+    ingredient = { name: line };
+  }
+  return toResult("invalid_ingredient", ingredient, issues);
+}
+function readLine(line) {
+  const p = getPatterns();
+  const notes = [];
+  const equivalents = [];
+  let optional = false;
+  let quantity;
+  let amount;
+  let unitText = "";
+  let i = 0;
+  let match;
+  const eat = (pattern) => {
+    const found = exec(pattern, line, i);
+    if (found) {
+      i = pattern.lastIndex;
+    }
+    return found;
+  };
+  const addNote = (text) => {
+    const note = /[^ ,](?:.*[^ ,])?/s.exec(text);
+    if (note) {
+      notes.push(note[0]);
+    }
+  };
+  const readParen = (content, keep) => {
+    const text = content.replace(OPTIONAL_PAREN, () => {
+      optional = true;
+      return "";
+    });
+    const measures = text ? readMeasures(text) : void 0;
+    if (measures) {
+      quantity ?? (quantity = measures.shift());
+      for (const measure of measures) {
+        equivalents.push(measure);
+      }
+      return "";
+    }
+    if (keep && text) {
+      return ` (${text})`;
+    }
+    addNote(text);
+    return "";
+  };
+  if (eat(OPTIONAL)) {
+    optional = true;
+  }
+  match = exec(ABOUT, line, i);
+  if (match && readAmount2(line, ABOUT.lastIndex)) {
+    addNote(match[1]);
+    i = ABOUT.lastIndex;
+  }
+  if (match = eat(PHRASE)) {
+    addNote(match[1]);
+  } else if (match = eat(p.count)) {
+    amount = NUMBER_WORDS.split("|").indexOf(match[1].toLowerCase()) + 1 || 1;
+  } else {
+    const found = readAmount2(line, i, true);
+    if (isProblem(found)) {
+      return found;
+    }
+    if (found) {
+      [amount, i] = found;
+    } else {
+      const modifier = exec(MODIFIER, line, i);
+      const unit = readUnit(line, modifier ? MODIFIER.lastIndex : i);
+      if (unit && exec(OF, line, unit[1])) {
+        if (modifier) {
+          addNote(modifier[1]);
+        }
+        quantity = { amount: 1, unit: unit[0] };
+        i = unit[1];
+      } else if (match = exec(NAMED, line, i)) {
+        const measure = readMeasure(line, NAMED.lastIndex, false);
+        if (measure && (line[measure[1]] ?? ",") === ",") {
+          quantity = measure[0];
+          line = match[1] + line.slice(measure[1]);
+          i = 0;
+        }
+      }
+    }
+  }
+  if (amount !== void 0) {
+    let each;
+    eat(TIMES);
+    if (match = eat(PAREN)) {
+      each = readMeasures(match[1]);
+      if (!each) {
+        readParen(match[1], false);
+      }
+    } else {
+      const measure = readMeasure(line, i, false);
+      if (measure) {
+        each = [measure[0]];
+        i = measure[1];
+      }
+    }
+    const start = i;
+    const modifier = eat(MODIFIER);
+    const unit = readUnit(line, i);
+    if (unit) {
+      if (modifier) {
+        addNote(modifier[1]);
+      }
+      unitText = line.slice(i, unit[1]);
+      quantity = { amount, unit: unit[0] };
+      i = unit[1];
+      const size = !each && units[unit[0]].dimension === "count" && readMeasure(line, i, false);
+      if (size) {
+        equivalents.push(size[0]);
+        i = size[1];
+      } else if (!each) {
+        const extended = extend(line, [quantity, i]);
+        if (isProblem(extended)) {
+          return extended;
+        }
+        [quantity, i] = extended;
+      }
+      while (match = eat(SEPARATOR)) {
+        const measure = readMeasure(line, i, true);
+        if (!measure) {
+          return noMeasure(quote(match[0].trim()), "100 g/3\xBD oz");
+        }
+        equivalents.push(measure[0]);
+        i = measure[1];
+      }
+    } else {
+      i = start;
+      quantity = { amount };
+    }
+    if (exec(unit ? UNREAD_AFTER_UNIT : UNREAD, line, i)) {
+      return {
+        code: "invalid_quantity",
+        message: `Couldn't read the quantity in ${quote(line)}. Write one amount or range before the unit, e.g. "2-3 eggs" or "2 \xBD cups".`
+      };
+    }
+    for (const item of each ?? []) {
+      const total = combine(amount, item.amount, (a, b) => a * b);
+      if (isProblem(total)) {
+        return total;
+      }
+      equivalents.push({ ...item, amount: total });
+    }
+  }
+  const of = quantity !== void 0 && eat(OF);
+  const rest = line.slice(i).trim();
+  const comma = topLevelComma(rest);
+  let name = rest.slice(0, comma).replace(PARENS, (_, content) => readParen(content, false));
+  const phrase = PHRASE_NOTE.exec(name);
+  if (phrase) {
+    addNote(name.slice(phrase.index));
+    name = name.slice(0, phrase.index);
+  }
+  addNote(
+    rest.slice(comma + 1).replace(PARENS, (_, content) => readParen(content, true)).replace(OPTIONAL_NOTE, () => {
+      optional = true;
+      return "";
+    })
+  );
+  name = name.trim();
+  if (!name) {
+    if (of || !unitText || !quantity?.unit || units[quantity.unit].dimension !== "count") {
+      return {
+        code: "missing_field",
+        message: 'Add a name after the quantity, e.g. "2 cups flour".'
+      };
+    }
+    name = unitText.replace(/^[ –—-]/, "");
+    quantity = { amount: quantity.amount };
+  }
+  let plural;
+  if (quantity && !quantity.unit) {
+    const many = typeof quantity.amount !== "number" || quantity.amount > 1;
+    [name, plural] = countForms(name, many);
+  }
+  return {
+    name,
+    ...plural !== void 0 && { plural },
+    ...quantity && { quantity },
+    ...equivalents.length > 0 && { equivalents },
+    ...notes.length > 0 && { note: notes.join(", ") },
+    ...optional && { optional }
+  };
+}
+function exec(pattern, text, start) {
+  pattern.lastIndex = start;
+  return pattern.exec(text);
+}
+function readAmount2(text, start, whole) {
+  exec(AMOUNT_CHARS, text, start);
+  const rest = text.slice(start, whole ? void 0 : AMOUNT_CHARS.lastIndex + 1).replace(
+    HYPHENATED_MIXED,
+    (dash, whole2, numerator, denominator) => Number(numerator) < Number(denominator) ? `${whole2} ` : dash
+  );
+  const comma = rest.search(/\d,\d/);
+  const head = comma < 0 ? rest : rest.slice(0, comma).trimEnd();
+  const match = matchAmount(head);
+  if (comma >= 0 && (match ? !("code" in match) && !match.rest : !head)) {
+    return matchAmount(rest);
+  }
+  if (!match || "code" in match) {
+    return match;
+  }
+  return [match.amount, start + head.length - match.rest.length];
+}
+function isProblem(value) {
+  return typeof value === "object" && value !== null && "code" in value;
+}
+function readUnit(text, start) {
+  const { twoWordUnit, unit } = getPatterns();
+  for (const pattern of [twoWordUnit, unit]) {
+    const match = exec(pattern, text, start);
+    const id = match && findUnit(match.slice(1).join(" "));
+    if (id) {
+      return [id, pattern.lastIndex];
+    }
+  }
+  return void 0;
+}
+function readMeasure(text, start, compound) {
+  const amount = readAmount2(text, text[start] === " " ? start + 1 : start);
+  if (!amount || isProblem(amount)) {
+    return void 0;
+  }
+  const unit = readUnit(text, amount[1]);
+  if (!unit) {
+    return void 0;
+  }
+  const measure = [
+    { amount: amount[0], unit: unit[0] },
+    unit[1]
+  ];
+  const extended = compound ? extend(text, measure) : measure;
+  return isProblem(extended) ? void 0 : extended;
+}
+function extend(text, measure) {
+  const [{ amount, unit }, end] = measure;
+  const connector = exec(JOIN, text, end)[1];
+  const extra = readMeasure(text, JOIN.lastIndex, false);
+  const from = units[unit];
+  const to = extra && units[extra[0].unit];
+  if (!from.toBase || !to?.toBase || from.dimension !== to.dimension) {
+    return connector ? noMeasure(
+      `${quote(connector)} in the same kind of unit`,
+      "1 cup plus 2 tbsp"
+    ) : measure;
+  }
+  const ratio = to.toBase / from.toBase;
+  const total = combine(amount, extra[0].amount, (a, b) => a + b * ratio);
+  return isProblem(total) ? total : [{ amount: total, unit }, extra[1]];
+}
+function noMeasure(after, example) {
+  return {
+    code: "invalid_quantity",
+    message: `Expected a measure after ${after}, e.g. "${example}".`
+  };
+}
+function readMeasures(text) {
+  const measures = [];
+  let i = 0;
+  for (; ; ) {
+    const measure = readMeasure(text, i, true);
+    if (!measure) {
+      return void 0;
+    }
+    measures.push(measure[0]);
+    i = measure[1];
+    if (i === text.length) {
+      return measures;
+    }
+    if (!exec(SEPARATOR, text, i)) {
+      return void 0;
+    }
+    i = SEPARATOR.lastIndex;
+  }
+}
+function combine(a, b, op) {
+  const [aMin, aMax] = typeof a === "number" ? [a, a] : [a.min, a.max];
+  const [bMin, bMax] = typeof b === "number" ? [b, b] : [b.min, b.max];
+  const min = op(aMin, bMin);
+  const max = op(aMax, bMax);
+  if (!isPositive(min) || !isPositive(max)) {
+    return {
+      code: "invalid_amount",
+      message: 'The total amount is out of range. Write it as one amount, e.g. "800 g".'
+    };
+  }
+  return min < max ? { min, max } : min;
+}
+function topLevelComma(text) {
+  let depth = 0;
+  for (let j = 0; j < text.length; j++) {
+    const char = text[j];
+    if (char === "(") {
+      depth++;
+    } else if (char === ")") {
+      depth = Math.max(0, depth - 1);
+    } else if (char === "," && depth === 0 && !BONELESS.test(text.slice(0, j).slice(-9))) {
+      return j;
+    }
+  }
+  return text.length;
+}
+function countForms(name, many) {
+  const words = name.split(" ");
+  let k = words.indexOf("of") - 1;
+  if (k < 0) {
+    k = CONTAINER.test(words[0]) ? 0 : words.length - 1;
+  }
+  const word = words[k];
+  const other = many ? word.replace(
+    /(?:(lea|hal|loa)ves|([rtdv])ies|(o|ch|sh|x|ss|chill?i)es|([^su])s)$/i,
+    (_, f, y, es, s) => f ? `${f}f` : y ? `${y}y` : es ?? s
+  ) : word.replace(
+    /(?:(lea|hal|loa)f|([^aeiou])y|(ch|sh|x|z|tomato|potato|mango|chill?i)|[a-rt-z])$/i,
+    (match, f, y, es) => f ? `${f}ves` : y ? `${y}ies` : es ? `${es}es` : `${match}s`
+  );
+  if (other === word) {
+    return [name, void 0];
+  }
+  words[k] = other;
+  const swapped = words.join(" ");
+  return many ? [swapped, name] : [name, swapped];
+}
+
+// src/quantity/scale.ts
+function scaleQuantity(quantity, factor) {
+  const amount = checkQuantity("scaleQuantity", quantity);
+  checkFactor("scaleQuantity", "factor", factor);
+  const result = multiply({ amount, unit: quantity.unit }, factor);
+  checkResult("scaleQuantity", result.amount);
+  return result;
+}
+function multiply(quantity, factor) {
+  const amount = mapAmount(quantity.amount, (value) => value * factor);
+  return quantity.unit === void 0 ? { amount } : { amount, unit: quantity.unit };
+}
+
+// src/units/system.ts
+var STEP_TOLERANCE = 0.05;
+var FLOAT_TOLERANCE = 1e-9;
+var LADDERS = {
+  metric: {
+    mass: [{ unit: "kg", min: 1 }, { unit: "g" }],
+    volume: [{ unit: "l", min: 1 }, { unit: "ml" }]
+  },
+  us: {
+    mass: [{ unit: "lb", min: 1 }, { unit: "oz" }],
+    volume: [
+      { unit: "cup", min: 0.25, steps: [4, 3], stepsBelow: 1 },
+      { unit: "tbsp", min: 1, steps: [2] },
+      { unit: "tsp" }
+    ]
+  }
+};
+function inSystem(quantity, system) {
+  const source = lookupUnit(quantity.unit);
+  if (source?.toBase === void 0 || source.dimension === "count" || source.systems.includes(system)) {
+    return quantity;
+  }
+  return onLadder(
+    quantity,
+    source.toBase,
+    LADDERS[system][source.dimension],
+    system
+  );
+}
+function rebalance(quantity, system) {
+  const source = lookupUnit(quantity.unit);
+  if (source?.toBase === void 0 || source.dimension === "count" || !source.systems.includes(system)) {
+    return quantity;
+  }
+  for (const owner of source.systems) {
+    const ladder = LADDERS[owner][source.dimension];
+    if (ladder.some((rung) => rung.unit === source.id)) {
+      return onLadder(quantity, source.toBase, ladder, system);
+    }
+  }
+  return quantity;
+}
+function isSystem(value) {
+  return value === "metric" || value === "us";
+}
+function checkSystem(fn, system) {
+  if (!isSystem(system)) {
+    throw new RecipeBookError(
+      "invalid_argument",
+      `${fn}: system must be "metric" or "us", received ${describeValue(system)}.`
+    );
+  }
+}
+function onLadder(quantity, fromBase, ladder, system) {
+  const base = mapAmount(quantity.amount, (value) => value * fromBase);
+  for (const rung of ladder) {
+    const unit = lookupUnit(rung.unit);
+    if (!unit.systems.includes(system)) {
+      continue;
+    }
+    const amount = mapAmount(base, (value) => value / unit.toBase);
+    const ends = amountEnds(amount);
+    const low = ends[0];
+    const tolerance = rung.steps ? STEP_TOLERANCE : FLOAT_TOLERANCE;
+    const meetsMin = rung.min === void 0 || low >= rung.min * (1 - tolerance);
+    const fitsSteps = !rung.steps || ends.every(
+      (value) => rung.stepsBelow !== void 0 && value >= rung.stepsBelow || rung.steps.some(
+        (denominator) => nearMultiple(value, 1 / denominator)
+      )
+    );
+    if (meetsMin && fitsSteps) {
+      return unit.id === quantity.unit ? quantity : { amount, unit: unit.id };
+    }
+  }
+  return quantity;
+}
+function nearMultiple(value, step) {
+  return Math.abs(value - Math.round(value / step) * step) <= STEP_TOLERANCE * value;
+}
+
+// src/resolve.ts
+function resolveRecipe(recipe, options) {
+  const {
+    servings,
+    scale: requestedScale,
+    system: requestedSystem,
+    rebalance: rebalance2
+  } = options ?? {};
+  const servingsIsBase = isPositive(recipe.servings?.amount);
+  const base = [recipe.servings?.amount, recipe.yield?.amount].find(isPositive) ?? 1;
+  const ratio = isServingsFor(servings, base) ? Math.min(Math.max(servings / base, 1e-6), 1e6) : Number.NaN;
+  const exactServings = isScale(requestedScale) || !isScale(ratio) || isUnity(ratio) ? void 0 : servings;
+  const scale = isScale(requestedScale) ? requestedScale : isScale(ratio) ? ratio : 1;
+  const system = [requestedSystem, recipe.system].find(isSystem) ?? "metric";
+  const shouldRebalance = rebalance2 !== false;
+  let number = 0;
+  function resize(range, isBase) {
+    if (exactServings !== void 0 && isBase) {
+      return withRange(range, exactServings);
+    }
+    return isUnity(scale) ? range : withRange(range, range.amount * scale, (range.max ?? 0) * scale);
+  }
+  return {
+    recipe,
+    scale,
+    ...recipe.servings && {
+      servings: resize(recipe.servings, servingsIsBase)
+    },
+    ...recipe.yield && { yield: resize(recipe.yield, !servingsIsBase) },
+    system,
+    canConvert: recipe.ingredients.some(
+      (section) => section.items.some(
+        (item) => lookupUnit(item.quantity?.unit)?.systems.length === 1
+      )
+    ),
+    ingredients: recipe.ingredients.map((section) => ({
+      id: section.id,
+      ...section.title !== void 0 && { title: section.title },
+      items: section.items.map(
+        (ingredient) => resolveLine(ingredient, scale, system, shouldRebalance)
+      )
+    })),
+    steps: recipe.steps.map((section) => ({
+      id: section.id,
+      ...section.title !== void 0 && { title: section.title },
+      items: section.items.map((step) => ({ ...step, number: ++number }))
+    }))
+  };
+}
+function resolveIngredient(ingredient, options) {
+  checkFactor("resolveIngredient", "scale", options?.scale);
+  checkSystem("resolveIngredient", options.system);
+  return resolveLine(
+    ingredient,
+    options.scale,
+    options.system,
+    options.rebalance !== false
+  );
+}
+function resolveLine(ingredient, scale, system, shouldRebalance) {
+  const { id, quantity } = ingredient;
+  if (quantity === void 0) {
+    return { id, ingredient, origin: "authored" };
+  }
+  const candidates = [quantity, ...ingredient.equivalents];
+  const native = candidates.findIndex(
+    (candidate) => isNative(candidate, system)
+  );
+  const chosen = candidates[native] ?? quantity;
+  const scaled = isUnity(scale) ? chosen : multiply(chosen, scale);
+  if (native < 0) {
+    return {
+      id,
+      ingredient,
+      quantity: withEnds(inSystem(scaled, system)),
+      origin: "converted"
+    };
+  }
+  return {
+    id,
+    ingredient,
+    quantity: withEnds(
+      shouldRebalance && !isUnity(scale) ? rebalance(scaled, system) : scaled
+    ),
+    origin: native === 0 ? "authored" : "equivalent"
+  };
+}
+function withRange(range, amount, max = 0) {
+  const { max: authoredMax, ...rest } = range;
+  return { ...rest, amount, ...max > amount && { max } };
+}
+function withEnds(quantity) {
+  const { amount } = quantity;
+  return typeof amount === "number" || amount.min < amount.max ? quantity : { ...quantity, amount: amount.min };
+}
+function isServingsFor(servings, base) {
+  const [mantissa, exponent] = base.toExponential().split("e");
+  const shift = (places) => Number(`${mantissa}e${Number(exponent) + places}`);
+  return isPositive(servings) && servings >= shift(-6) && servings <= shift(6);
+}
+function isScale(value) {
+  return typeof value === "number" && value >= 1e-6 && value <= 1e6;
+}
+function isUnity(scale) {
+  return Math.abs(scale - 1) <= 1e-9;
+}
+function isNative(quantity, system) {
+  const unit = lookupUnit(quantity.unit);
+  return unit === void 0 || unit.systems.includes(system);
+}
+
+// src/format/number.ts
+var POWERS = [
+  1,
+  10,
+  100,
+  1e3,
+  1e4,
+  1e5,
+  1e6,
+  1e7,
+  1e8,
+  1e9,
+  1e10,
+  1e11,
+  1e12,
+  1e13,
+  1e14,
+  1e15
+];
+var MAX_DIGITS = 15;
+var NBSP = "\xA0";
+function round(value, digits) {
+  const power = POWERS[digits];
+  const magnitude = Math.abs(value);
+  const scaled = magnitude * power;
+  const rounded = scaled < 1e15 ? Math.round(Number(scaled.toPrecision(15))) / power : Math.round(magnitude);
+  return value < 0 && rounded !== 0 ? -rounded : rounded;
+}
+function roundAboveZero(value, digits) {
+  for (let used = digits; used <= MAX_DIGITS; used++) {
+    const rounded = round(value, used);
+    if (rounded > 0) {
+      return [rounded, used];
+    }
+  }
+  return [1e-15, MAX_DIGITS];
+}
+var writers = /* @__PURE__ */ new Map();
+var MAX_WRITERS = 32;
+function numberWriter(fn, locale = "en-US") {
+  if (typeof locale !== "string") {
+    throw invalidLocale(fn, locale);
+  }
+  if (/^en(?:-(?:[a-z]{2}|\d{3}))?$/i.test(locale) || typeof Intl === "undefined") {
+    return englishNumber;
+  }
+  let writer = writers.get(locale);
+  if (!writer) {
+    writer = intlNumber(fn, locale);
+    if (writer !== englishNumber) {
+      if (writers.size >= MAX_WRITERS) {
+        writers.clear();
+      }
+      writers.set(locale, writer);
+    }
+  }
+  return writer;
+}
+function pluralForm(value) {
+  return Math.abs(value) === 1 ? "one" : "other";
+}
+function intlNumber(fn, locale) {
+  let supported;
+  try {
+    supported = Intl.NumberFormat.supportedLocalesOf(locale);
+  } catch {
+    throw invalidLocale(fn, locale);
+  }
+  if (supported.length === 0) {
+    return englishNumber;
+  }
+  const formats = [];
+  return (value, digits) => {
+    let format = formats[digits];
+    if (!format) {
+      format = new Intl.NumberFormat(locale, {
+        useGrouping: false,
+        maximumFractionDigits: digits
+      });
+      formats[digits] = format;
+    }
+    return format.format(value);
+  };
+}
+function englishNumber(value, digits) {
+  const magnitude = Math.abs(value);
+  const units2 = Math.round(magnitude * POWERS[digits]);
+  const sign = value < 0 ? "-" : "";
+  if (digits === 0 || units2 > Number.MAX_SAFE_INTEGER) {
+    return sign + integerText(magnitude);
+  }
+  const text = String(units2).padStart(digits + 1, "0");
+  const whole = text.slice(0, -digits);
+  const fraction = text.slice(-digits).replace(/0+$/, "");
+  return sign + (fraction ? `${whole}.${fraction}` : whole);
+}
+function integerText(value) {
+  const text = String(value);
+  const match = /^(\d)(?:\.(\d+))?e\+(\d+)$/.exec(text);
+  if (!match) {
+    return text;
+  }
+  const [, head, tail = "", exponent] = match;
+  return head + tail.padEnd(Number(exponent), "0");
+}
+function invalidLocale(fn, locale) {
+  return new RecipeBookError(
+    "invalid_argument",
+    `${fn}: locale must be a language tag that Intl accepts, such as "en-US", received ${describeValue(locale)}.`
+  );
+}
+
+// src/format/options.ts
+function readSettings(fn, options) {
+  return {
+    number: numberWriter(fn, options?.locale),
+    unitDisplay: option(fn, "unitDisplay", options?.unitDisplay, [
+      "short",
+      "long"
+    ])
+  };
+}
+function option(fn, name, value, allowed) {
+  if (value === void 0) {
+    return allowed[0];
+  }
+  if (allowed.includes(value)) {
+    return value;
+  }
+  const choices = allowed.map((choice) => JSON.stringify(choice));
+  const last = choices.pop();
+  throw new RecipeBookError(
+    "invalid_argument",
+    `${fn}: ${name} must be ${choices.join(", ")}${choices.length > 1 ? "," : ""} or ${last}, received ${describeValue(value)}.`
+  );
+}
+
+// src/format/quantity.ts
+var EIGHTHS_AND_THIRDS = [
+  [1, 8, "\u215B"],
+  [1, 4, "\xBC"],
+  [1, 3, "\u2153"],
+  [3, 8, "\u215C"],
+  [1, 2, "\xBD"],
+  [5, 8, "\u215D"],
+  [2, 3, "\u2154"],
+  [3, 4, "\xBE"],
+  [7, 8, "\u215E"],
+  [1, 1, ""]
+];
+var QUARTERS = [
+  [1, 4, "\xBC"],
+  [1, 2, "\xBD"],
+  [3, 4, "\xBE"],
+  [1, 1, ""]
+];
+function formatQuantity(quantity, options) {
+  const fn = "formatQuantity";
+  return joinParts(
+    quantityParts(fn, quantity, readQuantitySettings(fn, options)).parts
+  );
+}
+function formatQuantityToParts(quantity, options) {
+  const fn = "formatQuantityToParts";
+  return quantityParts(fn, quantity, readQuantitySettings(fn, options)).parts;
+}
+function readQuantitySettings(fn, options) {
+  return {
+    ...readSettings(fn, options),
+    fractions: option(fn, "fractions", options?.fractions, [true, false]),
+    rounding: option(fn, "rounding", options?.rounding, ["kitchen", "none"])
+  };
+}
+function quantityParts(fn, quantity, settings) {
+  const amount = checkQuantity(fn, quantity);
+  const unit = quantity.unit === void 0 ? void 0 : formatUnit(fn, quantity.unit);
+  const [low, high = low] = amountEnds(amount).map(
+    (value) => showAmount(value, settings, unit && unitSteps(unit, value))
+  );
+  const isRange = high.text !== low.text;
+  const plural = isRange ? "other" : low.plural;
+  const parts = [{ type: "amount", value: low.text }];
+  if (isRange) {
+    parts.push(
+      { type: "rangeSeparator", value: "\u2013" },
+      { type: "amount", value: high.text }
+    );
+  }
+  if (unit) {
+    parts.push(
+      { type: "literal", value: NBSP },
+      { type: "unit", value: unit.labels[settings.unitDisplay][plural] }
+    );
+  }
+  return { parts, plural };
+}
+function formatUnit(fn, id) {
+  const unit = lookupUnit(id);
+  if (!unit) {
+    throw new RecipeBookError(
+      "unknown_unit",
+      `${fn}: unit must be a unit id such as "g", "ml", or "cup", received ${describeValue(id)}. findUnit converts author text to ids; parseQuantity also suggests a fix for a misspelling.`
+    );
+  }
+  return unit;
+}
+function joinParts(parts) {
+  return parts.map((part) => part.value).join("");
+}
+function showAmount(value, settings, steps = QUARTERS) {
+  const { rounding, fractions: fractions2 } = settings;
+  if (rounding === "none") {
+    return decimal(value, 3, settings);
+  }
+  if (typeof steps === "number") {
+    return decimal(value, steps, settings);
+  }
+  const [numerator, denominator] = steps[0];
+  if (value < numerator / denominator * (1 - 1e-9)) {
+    return decimal(value, 1, settings);
+  }
+  const [whole, part, glyph] = snap(value, steps);
+  if (!fractions2) {
+    return decimal(whole + part, 2, settings);
+  }
+  const wholeText = settings.number(whole, 0);
+  const text = glyph === "" ? wholeText : whole === 0 ? glyph : `${wholeText}${NBSP}${glyph}`;
+  return { text, plural: whole + part <= 1 ? "one" : "other" };
+}
+function unitSteps(unit, value) {
+  if (unit.dimension === "count") {
+    return QUARTERS;
+  }
+  if (unit.systems.includes("us")) {
+    return EIGHTHS_AND_THIRDS;
+  }
+  switch (unit.id) {
+    case "mg":
+      return 0;
+    case "kg":
+    case "l":
+      return 2;
+    default:
+      return value < 10 ? 1 : 0;
+  }
+}
+function snap(value, steps) {
+  const floor = Math.floor(value);
+  const part = value - floor;
+  let nearest = 0;
+  let nearestGlyph = "";
+  for (const [numerator, denominator, glyph] of steps) {
+    const step = numerator / denominator;
+    if (Math.abs(part - step) <= Math.abs(part - nearest) + 1e-9) {
+      nearest = step;
+      nearestGlyph = glyph;
+    }
+  }
+  return nearest === 1 ? [floor + 1, 0, ""] : [floor, nearest, nearestGlyph];
+}
+function decimal(value, digits, settings) {
+  const [rounded, used] = roundAboveZero(value, digits);
+  return { text: settings.number(rounded, used), plural: pluralForm(rounded) };
+}
+
+// src/format/ingredient.ts
+function formatIngredient(item, options) {
+  const fn = "formatIngredient";
+  const ingredient = item?.ingredient;
+  if (typeof ingredient?.name !== "string") {
+    throw new RecipeBookError(
+      "invalid_argument",
+      `${fn}: expected { ingredient, quantity? }, such as a resolved ingredient, received ${describeValue(item)}.`
+    );
+  }
+  for (const key of ["plural", "note"]) {
+    const value = ingredient[key];
+    if (value !== void 0 && typeof value !== "string") {
+      throw new RecipeBookError(
+        "invalid_argument",
+        `${fn}: ingredient.${key} must be a string, received ${describeValue(value)}.`
+      );
+    }
+  }
+  const settings = readQuantitySettings(fn, options);
+  const quantity = item.quantity ?? ingredient.quantity;
+  const { note } = ingredient;
+  const noteText = note ? `, ${note}` : "";
+  if (!quantity) {
+    const { name: name2 } = ingredient;
+    return { name: name2, ...note && { note }, text: name2 + noteText };
+  }
+  const { parts, plural } = quantityParts(fn, quantity, settings);
+  const quantityText = joinParts(parts);
+  const isCount = quantity.unit === void 0;
+  const name = isCount && plural === "other" ? ingredient.plural ?? ingredient.name : ingredient.name;
+  return {
+    quantity: quantityText,
+    name,
+    ...note && { note },
+    text: `${quantityText}${isCount ? NBSP : " "}${name}${noteText}`
+  };
+}
+
+// src/format/servings.ts
+function formatServings(servings, options) {
+  const fn = "formatServings";
+  return showRange(
+    fn,
+    servings,
+    "servings such as { amount: 4, max: 6 }",
+    readQuantitySettings(fn, options)
+  ).text;
+}
+function formatYield(yield_, options) {
+  const fn = "formatYield";
+  const { text, plural } = showRange(
+    fn,
+    yield_,
+    'a yield such as { amount: 24, unit: "cookie" }',
+    readQuantitySettings(fn, options)
+  );
+  if (typeof yield_.unit !== "string") {
+    throw new RecipeBookError(
+      "invalid_argument",
+      `${fn}: unit must be a string such as "cookie", received ${describeValue(yield_.unit)}.`
+    );
+  }
+  if (yield_.plural !== void 0 && typeof yield_.plural !== "string") {
+    throw new RecipeBookError(
+      "invalid_argument",
+      `${fn}: plural must be a string, received ${describeValue(yield_.plural)}.`
+    );
+  }
+  return `${text}${NBSP}${plural === "other" ? yield_.plural ?? yield_.unit : yield_.unit}`;
+}
+function showRange(fn, value, expected, settings) {
+  if (typeof value !== "object" || value === null) {
+    throw new RecipeBookError(
+      "invalid_argument",
+      `${fn}: expected ${expected}, received ${describeValue(value)}.`
+    );
+  }
+  const { amount, max } = value;
+  if (!isPositive(amount)) {
+    throw new RecipeBookError(
+      "invalid_argument",
+      `${fn}: amount must be a finite number greater than 0, received ${describeValue(amount)}.`
+    );
+  }
+  if (max !== void 0 && !(isPositive(max) && max > amount)) {
+    throw new RecipeBookError(
+      "invalid_argument",
+      `${fn}: max must be a finite number greater than amount (${amount}), received ${describeValue(max)}. Leave max out for a single amount.`
+    );
+  }
+  const low = showAmount(amount, settings);
+  const high = max === void 0 ? low : showAmount(max, settings);
+  return high.text === low.text ? low : { text: `${low.text}\u2013${high.text}`, plural: "other" };
+}
+
+exports.NBSP = NBSP;
+exports.NUTRIENT_UNITS = NUTRIENT_UNITS;
+exports.RecipeBookError = RecipeBookError;
+exports.RecipeValidationError = RecipeValidationError;
+exports.asRecord = asRecord;
+exports.checkQuantity = checkQuantity;
+exports.checkResult = checkResult;
+exports.checkSystem = checkSystem;
+exports.describeValue = describeValue;
+exports.disallowedScheme = disallowedScheme;
+exports.findUnit = findUnit;
+exports.formatIngredient = formatIngredient;
+exports.formatQuantity = formatQuantity;
+exports.formatQuantityToParts = formatQuantityToParts;
+exports.formatServings = formatServings;
+exports.formatYield = formatYield;
+exports.getUnit = getUnit;
+exports.hasOwn = hasOwn;
+exports.inSystem = inSystem;
+exports.isNative = isNative;
+exports.isRecipeBookError = isRecipeBookError;
+exports.isRecord = isRecord;
+exports.issue = issue;
+exports.lookupUnit = lookupUnit;
+exports.mapAmount = mapAmount;
+exports.matchAmount = matchAmount;
+exports.multiply = multiply;
+exports.option = option;
+exports.parseIngredientLine = parseIngredientLine;
+exports.parseIsoDuration = parseIsoDuration;
+exports.parseQuantity = parseQuantity;
+exports.parseRecipe = parseRecipe;
+exports.parseRecipeWith = parseRecipeWith;
+exports.pluralForm = pluralForm;
+exports.quote = quote;
+exports.readLineOption = readLineOption;
+exports.readSettings = readSettings;
+exports.resolveIngredient = resolveIngredient;
+exports.resolveRecipe = resolveRecipe;
+exports.round = round;
+exports.scaleQuantity = scaleQuantity;
+exports.toResult = toResult;
+exports.units = units;
+exports.unknownUnitError = unknownUnitError;
+exports.warning = warning;
+//# sourceMappingURL=chunk-D5CV3UF7.cjs.map
+//# sourceMappingURL=chunk-D5CV3UF7.cjs.map