@recipe-book/core 0.0.3 → 0.1.1

package/dist/recipe/parse.js

@@ -0,0 +1,854 @@
+// src/recipe/parse.ts
+import {
+  describeValue,
+  quote,
+  RecipeBookError
+} from "../errors.js";
+import { hasOwn, isRecord, warning } from "../issues.js";
+import { isPositive } from "../quantity/amount.js";
+import { matchAmount, readPositive, readQuantity } from "../quantity/parse.js";
+import {
+  asRecord,
+  checkFields,
+  error,
+  toResult
+} from "../validation.js";
+import { parseIsoDuration } from "./duration.js";
+import {
+  assignIds,
+  insertPending,
+  slugify
+} from "./ids.js";
+import { inferSystem } from "./infer.js";
+import { NUTRIENT_UNITS } from "./nutrient-units.js";
+import { parseNutrient } from "./nutrition.js";
+import { disallowedScheme } from "./url.js";
+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 label = recipe && quote(recipe.name);
+  return toResult("invalid_recipe", recipe, issues, label);
+}
+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 count = 0;
+  const read = (entry, entryPath) => readItem(issues, entry, entryPath, ++count);
+  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 issue of result.success ? result.warnings : result.error.issues) {
+      issues.push({ ...issue, path: [...path, ...issue.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 label = 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 (label === void 0 || minutes === void 0) {
+    return void 0;
+  }
+  return {
+    authored,
+    derived: slugify(label) || "time",
+    path,
+    position,
+    build: (id) => ({ id, label, 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;
+}
+export {
+  parseRecipe,
+  parseRecipeWith,
+  readLineOption
+};
+//# sourceMappingURL=parse.js.map