@recipe-book/core 0.0.3 → 0.1.1

package/dist/schema-org.cjs

@@ -0,0 +1,1062 @@
+'use strict';
+
+var chunkD5CV3UF7_cjs = require('./chunk-D5CV3UF7.cjs');
+
+// src/schema-org/find.ts
+var MAX_DEPTH = 32;
+function locate(documents) {
+  const direct = scan(documents, false);
+  return direct.recipes.length > 0 ? direct : scan(documents, true);
+}
+function scan(documents, lists) {
+  const recipes = [];
+  const ids = /* @__PURE__ */ new Map();
+  const recipeIds = /* @__PURE__ */ new Map();
+  const visit = (value, path, reach = "any") => {
+    if (path.length > MAX_DEPTH) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const [entry, entryPath] of entriesOf(value, path)) {
+        visit(entry, entryPath, reach);
+      }
+      return;
+    }
+    const fields = chunkD5CV3UF7_cjs.asRecord(value);
+    if (!fields) {
+      return;
+    }
+    const isRecipe = hasType(fields, "Recipe");
+    const isList = lists && hasType(fields, "ItemList");
+    if (reach !== "any" && !isRecipe) {
+      if (isList && reach === "mainEntity") {
+        visit(fields.itemListElement, [...path, "itemListElement"], "entry");
+      } else if (lists && reach === "entry" && hasType(fields, "ListItem")) {
+        visit(fields.item, [...path, "item"], "item");
+      }
+      return;
+    }
+    const located = { node: value, path };
+    const id = fields["@id"] || void 0;
+    if (typeof id === "string" && !ids.has(id)) {
+      ids.set(id, located);
+    }
+    if (isRecipe) {
+      const earlier = recipeIds.get(id);
+      if (!earlier) {
+        recipes.push(located);
+        if (typeof id === "string") {
+          recipeIds.set(id, hasContent(fields) || located);
+        }
+      } else if (earlier !== true && hasContent(fields)) {
+        Object.assign(earlier, located);
+        recipeIds.set(id, true);
+      }
+    } else {
+      visit(fields["@graph"], [...path, "@graph"]);
+      visit(fields.mainEntity, [...path, "mainEntity"], "mainEntity");
+      if (isList) {
+        visit(fields.itemListElement, [...path, "itemListElement"], "entry");
+      }
+    }
+  };
+  for (const document of documents) {
+    visit(document, []);
+  }
+  return { recipes, ids };
+}
+var TYPES = {
+  Recipe: /(?:^|[/:#])Recipe$/,
+  ItemList: /(?:^|[/:#])ItemList$/,
+  ListItem: /(?:^|[/:#])ListItem$/
+};
+function hasType(node, name) {
+  return entriesOf(node["@type"], []).some(
+    ([type]) => typeof type === "string" && TYPES[name].test(type)
+  );
+}
+function hasContent(node) {
+  return Object.keys(node).some((key) => !key.startsWith("@"));
+}
+function entriesOf(value, path) {
+  if (!Array.isArray(value)) {
+    return [[value, path]];
+  }
+  const entries = [];
+  for (let i = 0; i < value.length; i++) {
+    if (chunkD5CV3UF7_cjs.hasOwn(value, i)) {
+      entries.push([value[i], [...path, i]]);
+    }
+  }
+  return entries;
+}
+function findRecipeJsonLd(html) {
+  if (typeof html !== "string") {
+    throw new chunkD5CV3UF7_cjs.RecipeBookError(
+      "invalid_argument",
+      `findRecipeJsonLd: html must be a string, such as await response.text(), received ${chunkD5CV3UF7_cjs.describeValue(html)}.`
+    );
+  }
+  const documents = [];
+  for (const [, element, attributes = "", body = ""] of html.matchAll(
+    /<(script|style|textarea)(?=[\s/>])(?=((?:=\s*(?:"[^"]*"|'[^']*')|[^<>])*))\2>([\s\S]*?)(?:<\/\1\s*>|$)|<!--(?:-?>|[\s\S]*?(?:--!?>|$))|<\/?[a-z][^\s/>]*(?:=\s*(?:"[^"]*"|'[^']*')|[^<>])*/gi
+  )) {
+    if (element?.toLowerCase() === "script" && /[\s/]type\s*=\s*["']?application\/ld\+json\b/i.test(attributes)) {
+      const text2 = body.replace(/^\s*(?:\/\/\s*)?(?:<!--|<!\[CDATA\[)/, "").replace(/(?:\/\/\s*)?(?:-->|\]\]>)\s*$/, "");
+      const json = parseJson(text2) ?? parseJson(
+        text2.replace(
+          /"(?:[^"\\]|\\[\s\S]?)*(?:"|$)/g,
+          (string) => string.replace(/[\n\r\t]/g, (c) => JSON.stringify(c).slice(1, -1))
+        )
+      );
+      documents.push(json);
+    }
+  }
+  const { recipes, ids } = locate(documents);
+  return recipes.map(({ node }) => withImages(node, ids));
+}
+function withImages(node, ids) {
+  const follow = (value) => {
+    const id = chunkD5CV3UF7_cjs.isRecord(value) && Object.keys(value).join() === "@id" && value["@id"];
+    const target = typeof id === "string" && ids.get(id)?.node;
+    return target && target !== node ? target : value;
+  };
+  const images = (value) => Array.isArray(value) ? value.map(follow) : follow(value);
+  const copy = (value, depth, keys) => {
+    if (depth > MAX_DEPTH) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((entry) => copy(entry, depth + 1, keys));
+    }
+    const fields = chunkD5CV3UF7_cjs.asRecord(value);
+    if (!fields) {
+      return value;
+    }
+    const result = { ...fields };
+    for (const key of keys) {
+      if (fields[key] !== void 0) {
+        result[key] = key === "image" ? images(fields[key]) : copy(fields[key], depth + 1, ["itemListElement", "item", "image"]);
+      }
+    }
+    return result;
+  };
+  return copy(node, 0, ["image", "recipeInstructions"]);
+}
+function parseJson(text2) {
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/schema-org/nutrients.ts
+var NUTRIENTS = {
+  servingSize: "servingSize",
+  calories: "calories",
+  fat: "fatContent",
+  saturatedFat: "saturatedFatContent",
+  transFat: "transFatContent",
+  unsaturatedFat: "unsaturatedFatContent",
+  carbohydrates: "carbohydrateContent",
+  sugar: "sugarContent",
+  fiber: "fiberContent",
+  protein: "proteinContent",
+  sodium: "sodiumContent",
+  cholesterol: "cholesterolContent"
+};
+
+// src/schema-org/text.ts
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+  ensp: " ",
+  emsp: " ",
+  thinsp: " ",
+  shy: "",
+  zwj: "",
+  zwnj: "",
+  deg: "\xB0",
+  colon: ":",
+  Tab: "	",
+  NewLine: "\n",
+  euro: "\u20AC",
+  pound: "\xA3",
+  yen: "\xA5",
+  cent: "\xA2",
+  half: "\xBD",
+  frac12: "\xBD",
+  frac14: "\xBC",
+  frac34: "\xBE",
+  frac13: "\u2153",
+  frac23: "\u2154",
+  frac15: "\u2155",
+  frac25: "\u2156",
+  frac35: "\u2157",
+  frac45: "\u2158",
+  frac16: "\u2159",
+  frac56: "\u215A",
+  frac18: "\u215B",
+  frac38: "\u215C",
+  frac58: "\u215D",
+  frac78: "\u215E",
+  frasl: "\u2044",
+  ndash: "\u2013",
+  mdash: "\u2014",
+  minus: "\u2212",
+  hellip: "\u2026",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  sbquo: "\u201A",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  bdquo: "\u201E",
+  laquo: "\xAB",
+  raquo: "\xBB",
+  times: "\xD7",
+  divide: "\xF7",
+  middot: "\xB7",
+  bull: "\u2022",
+  micro: "\xB5",
+  sup1: "\xB9",
+  sup2: "\xB2",
+  sup3: "\xB3",
+  ordm: "\xBA",
+  ordf: "\xAA",
+  copy: "\xA9",
+  reg: "\xAE",
+  trade: "\u2122",
+  iexcl: "\xA1",
+  iquest: "\xBF",
+  szlig: "\xDF",
+  aelig: "\xE6",
+  AElig: "\xC6",
+  oelig: "\u0153",
+  OElig: "\u0152",
+  oslash: "\xF8",
+  Oslash: "\xD8"
+};
+var MARKS = {
+  grave: "\u0300",
+  acute: "\u0301",
+  circ: "\u0302",
+  tilde: "\u0303",
+  uml: "\u0308",
+  ring: "\u030A",
+  cedil: "\u0327"
+};
+var MARKUP = /<!--[\s\S]*?(?:-->|$)|<(script|style)(?=[\s/>])(?=((?:=\s*(?:"(?:[^"<]|<(?![a-z/!?]))*"|'(?:[^'<]|<(?![a-z/!?]))*')|[^<>])*))\2>[\s\S]*?(?:<\/\1\s*>|$)|<(?:(\/?(?:br|p|li|div|h[1-6])\b)|[/!?]?[a-z])(?=((?:=\s*(?:"(?:[^"<]|<(?![a-z/!?]))*"|'(?:[^'<]|<(?![a-z/!?]))*')|[^<>])*))\4>/gi;
+var MAX_PASSES = 8;
+function cleanText(text2) {
+  return cleanLines(text2).join(" ");
+}
+function cleanLines(text2) {
+  return stripTags(text2).replace(
+    /&(?:#(\d{1,7})|#x([\da-f]{1,6})|([a-z][a-z\d]*));/gi,
+    (entity, decimal, hex, name) => {
+      if (name === void 0) {
+        const code = decimal === void 0 ? parseInt(hex, 16) : +decimal;
+        return code > 0 && code <= 1114111 && (code < 55296 || code > 57343) ? String.fromCodePoint(code) : entity;
+      }
+      if (chunkD5CV3UF7_cjs.hasOwn(NAMED_ENTITIES, name)) {
+        return NAMED_ENTITIES[name];
+      }
+      const accent = /^([aceinouyACEINOUY])([a-z]+)$/.exec(name);
+      return accent && chunkD5CV3UF7_cjs.hasOwn(MARKS, accent[2]) ? `${accent[1]}${MARKS[accent[2]]}`.normalize("NFC") : entity;
+    }
+  ).split(/[\n\r\u2028\u2029]/).map((line) => line.replace(/\s+/g, " ").trim()).filter(Boolean);
+}
+function stripTags(text2) {
+  let stripped = text2;
+  for (let pass = 0; pass < MAX_PASSES; pass++) {
+    const next = stripped.replace(
+      MARKUP,
+      (_, _element, _attributes, block) => block ? "\n" : ""
+    );
+    if (next === stripped) {
+      break;
+    }
+    stripped = next;
+  }
+  const end = stripped.lastIndexOf(">") + 1;
+  return stripped.slice(0, end).replace(/<+([/!?a-z]?)/gi, (run, next) => next || run) + stripped.slice(end);
+}
+
+// src/schema-org/from-json-ld.ts
+var READ_FIELDS = [
+  "@context",
+  "@type",
+  "name",
+  "description",
+  "image",
+  "recipeYield",
+  "prepTime",
+  "cookTime",
+  "totalTime",
+  "recipeIngredient",
+  "recipeInstructions",
+  "tool",
+  "nutrition"
+];
+var TIMES = [
+  ["prep", "prepTime"],
+  ["cook", "cookTime"],
+  ["total", "totalTime"]
+];
+var MAX_URL_LENGTH = 4096;
+var SERVINGS_WORD = /^(?:servings?|portions?|(?:serving|portion)\(s\)|people|persons?)\.?$/i;
+function fromJsonLd(input) {
+  const { recipes, ids } = locate([input]);
+  const [found] = recipes;
+  if (!found) {
+    return {
+      ...chunkD5CV3UF7_cjs.toResult("invalid_recipe", void 0, [
+        chunkD5CV3UF7_cjs.issue(
+          "error",
+          "invalid_type",
+          [],
+          `Expected a schema.org Recipe, or an array, @graph, mainEntity, or ItemList that holds one, received ${chunkD5CV3UF7_cjs.describeValue(input)}.`
+        )
+      ]),
+      extra: {}
+    };
+  }
+  const node = chunkD5CV3UF7_cjs.asRecord(found.node);
+  const reader = {
+    recipe: found.node,
+    ids,
+    warnings: [],
+    sources: /* @__PURE__ */ new Map(),
+    droppable: /* @__PURE__ */ new Set(),
+    images: [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()],
+    repeated: 0,
+    deepest: 0
+  };
+  const name = text(node.name);
+  if (recipes.length > 1) {
+    chunkD5CV3UF7_cjs.warning(
+      reader.warnings,
+      "ignored_value",
+      [],
+      `Found ${recipes.length} recipes. Only the first${typeof name === "string" ? `, ${chunkD5CV3UF7_cjs.quote(name)},` : ""} is read.`
+    );
+  }
+  const model = readRecipe(reader, node, found.path);
+  const parse = () => chunkD5CV3UF7_cjs.parseRecipeWith(model, chunkD5CV3UF7_cjs.parseIngredientLine);
+  let result = parse();
+  const dropped = [];
+  if (!result.success) {
+    const targets = [];
+    for (const error of result.error.issues) {
+      const target = error.severity === "error" ? droppableAt(reader, error.path) : void 0;
+      if (target) {
+        targets.push(target);
+        dropped.push({
+          ...error,
+          severity: "warning",
+          message: `${error.message} It is ignored.`
+        });
+      }
+    }
+    targets.sort((a, b) => b.length - a.length).forEach((target) => remove(model, target));
+    if (dropped.length > 0) {
+      result = parse();
+    }
+  }
+  const order = ({ code, path }) => [
+    path.length > found.path.length ? READ_FIELDS.indexOf(String(path[found.path.length])) : -1,
+    ...path.slice(found.path.length + 1).filter((key) => typeof key === "number"),
+    ...code === "unknown_field" ? [Infinity] : []
+  ];
+  const issues = [
+    ...reader.warnings,
+    ...[
+      ...dropped,
+      ...result.success ? result.warnings : result.error.issues
+    ].map((issue2) => ({ ...issue2, path: sourceOf(reader, issue2.path) }))
+  ].sort((a, b) => compareOrder(order(a), order(b)));
+  const checked = /* @__PURE__ */ new Map();
+  const extra = Object.fromEntries(
+    Object.entries(node).filter(([key, value]) => {
+      if (READ_FIELDS.includes(key)) {
+        return false;
+      }
+      const path = [...found.path, key];
+      if (tooDeep(value, path.length, checked)) {
+        chunkD5CV3UF7_cjs.warning(
+          issues,
+          "invalid_type",
+          path,
+          `Expected a value to keep in extra, received ${chunkD5CV3UF7_cjs.describeValue(value)} nested more than ${MAX_DEPTH} levels deep. It is ignored.`
+        );
+        return false;
+      }
+      return true;
+    })
+  );
+  return {
+    ...chunkD5CV3UF7_cjs.toResult(
+      "invalid_recipe",
+      result.success ? result.data : void 0,
+      issues,
+      typeof name === "string" ? chunkD5CV3UF7_cjs.quote(name) : void 0
+    ),
+    extra
+  };
+}
+function tooDeep(value, length, checked) {
+  if (length > MAX_DEPTH) {
+    return true;
+  }
+  if (typeof value !== "object" || value === null || (checked.get(value) ?? 0) >= length) {
+    return false;
+  }
+  const deep = Object.values(value).some(
+    (child) => tooDeep(child, length + 1, checked)
+  );
+  if (!deep) {
+    checked.set(value, length);
+  }
+  return deep;
+}
+function readRecipe(reader, node, base) {
+  const at = (...path) => [...base, ...path];
+  const model = {
+    name: text(node.name),
+    description: text(node.description)
+  };
+  link(reader, [], base);
+  link(reader, ["name"], at("name"));
+  link(reader, ["description"], at("description"), true);
+  const image = readImage(reader, node.image, at("image"));
+  if (image) {
+    model.image = image.url;
+    link(reader, ["image"], image.source, true);
+  }
+  readYield(reader, model, node.recipeYield, at("recipeYield"));
+  const times = {};
+  for (const [key, field] of TIMES) {
+    const minutes = readTime(reader, node[field], at(field));
+    if (minutes !== void 0) {
+      times[key] = minutes;
+    }
+  }
+  model.times = times;
+  model.ingredients = readList(
+    reader,
+    "ingredients",
+    node.recipeIngredient,
+    at("recipeIngredient"),
+    readLine,
+    'an ingredient line such as "2 cups flour"'
+  );
+  model.steps = readList(
+    reader,
+    "steps",
+    node.recipeInstructions,
+    at("recipeInstructions"),
+    readStep,
+    'a step such as "Whisk the eggs." or a HowToStep'
+  );
+  model.equipment = readTools(reader, node.tool, at("tool"));
+  model.nutrition = readNutrition(reader, node.nutrition, at("nutrition"));
+  return model;
+}
+function readImage(reader, value, source) {
+  if (isAbsent(value)) {
+    return void 0;
+  }
+  const warnings = reader.warnings.length + reader.repeated;
+  const image = findImage(reader, value, source);
+  if (!image && reader.warnings.length + reader.repeated === warnings) {
+    ignore(
+      reader,
+      "invalid_type",
+      source,
+      `Expected an image URL, an ImageObject with a url, or a list of them, received ${chunkD5CV3UF7_cjs.describeValue(value)}.`
+    );
+  }
+  return image;
+}
+function findImage(reader, value, source, referenced = false) {
+  reader.deepest = Math.max(reader.deepest, source.length);
+  if (source.length > MAX_DEPTH) {
+    if (!isAbsent(value)) {
+      ignore(
+        reader,
+        "invalid_type",
+        source,
+        `Expected an image URL, an ImageObject with a url, or a list of them, received ${chunkD5CV3UF7_cjs.describeValue(value)} nested more than ${MAX_DEPTH} levels deep.`
+      );
+    }
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const url = cleanText(value);
+    const scheme = chunkD5CV3UF7_cjs.disallowedScheme(url);
+    if (scheme) {
+      ignore(
+        reader,
+        "invalid_url",
+        source,
+        `Expected an http or https URL, or a relative one, received ${chunkD5CV3UF7_cjs.quote(`${scheme}\u2026`)}.`
+      );
+      return void 0;
+    }
+    if (url.length > MAX_URL_LENGTH) {
+      ignore(
+        reader,
+        "invalid_url",
+        source,
+        `Expected a URL of at most ${MAX_URL_LENGTH} UTF-16 code units, received ${url.length}.`
+      );
+      return void 0;
+    }
+    return url ? { url, source } : void 0;
+  }
+  if (Array.isArray(value)) {
+    for (const [entry, entrySource] of entriesOf(value, source)) {
+      const image2 = findImage(reader, entry, entrySource, referenced);
+      if (image2) {
+        return image2;
+      }
+    }
+    return void 0;
+  }
+  const images = reader.images[referenced ? 1 : 0];
+  const reads = images.get(value) ?? [];
+  const read = reads.find(
+    ([, , depth, length]) => length === source.length || Math.max(length, source.length) + depth <= MAX_DEPTH
+  );
+  if (read) {
+    reader.repeated += read[1];
+    reader.deepest = Math.max(reader.deepest, source.length + read[2]);
+    return read[0];
+  }
+  const record = chunkD5CV3UF7_cjs.asRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  images.set(value, reads);
+  const warnings = reader.warnings.length + reader.repeated;
+  const deepest = reader.deepest;
+  reader.deepest = source.length;
+  const id = record["@id"];
+  const target = typeof id === "string" && !referenced ? reader.ids.get(id) : void 0;
+  let image = findImage(reader, record.url, [...source, "url"], referenced) ?? findImage(reader, record.contentUrl, [...source, "contentUrl"], referenced);
+  if (!image && target?.node === reader.recipe) {
+    ignore(
+      reader,
+      "invalid_type",
+      source,
+      "Expected an image URL, an ImageObject with a url, or a list of them, received a reference to the recipe itself."
+    );
+  } else if (!image && target) {
+    image = findImage(reader, target.node, target.path, true);
+  }
+  reads.push([
+    image,
+    reader.warnings.length + reader.repeated - warnings,
+    reader.deepest - source.length,
+    source.length
+  ]);
+  reader.deepest = Math.max(reader.deepest, deepest);
+  return image;
+}
+function readYield(reader, model, value, source) {
+  const batches = entriesOf(value, source).flatMap(
+    ([entry, entrySource]) => (typeof entry === "string" ? entry.split(/,\s+/) : [entry]).map(
+      (part) => readBatch(reader, part, entrySource)
+    )
+  ).filter((batch) => batch !== void 0);
+  const yields = batches.filter((batch) => batch.yield !== void 0);
+  const servings = batches.filter((batch) => batch.servings !== void 0);
+  const kept = yields.find((batch) => !batch.article) ?? yields.find((batch) => batch.article);
+  const keptServings = servings.find((batch) => batch.worded) ?? servings.find((batch) => batch.amount !== kept?.amount);
+  for (const batch of servings) {
+    if (keptServings && batch.amount !== keptServings.amount && (batch.worded || batch.amount !== kept?.amount)) {
+      chunkD5CV3UF7_cjs.warning(
+        reader.warnings,
+        "ignored_value",
+        batch.source,
+        `Only one number of servings is read, ${chunkD5CV3UF7_cjs.quote(keptServings.label)}, so this one is ignored.`
+      );
+    }
+  }
+  for (const batch of yields) {
+    if (batch !== kept) {
+      chunkD5CV3UF7_cjs.warning(
+        reader.warnings,
+        "ignored_value",
+        batch.source,
+        `Only one yield is read, ${chunkD5CV3UF7_cjs.quote(kept.label)}, so this one is ignored.`
+      );
+    }
+  }
+  if (keptServings) {
+    model.servings = keptServings.servings;
+    link(reader, ["servings"], keptServings.source, true);
+  }
+  if (kept) {
+    model.yield = kept.yield;
+    link(reader, ["yield"], kept.source, true);
+  }
+}
+function readBatch(reader, value, source) {
+  if (typeof value === "number") {
+    return { source, label: String(value), amount: value, servings: value };
+  }
+  if (typeof value === "string") {
+    const label = cleanText(value);
+    if (!label) {
+      return void 0;
+    }
+    const text2 = label.replace(
+      /^(?:(?:serves|servings?|yields?|makes)\s*:?\s*)?(?:about\s+)?/i,
+      ""
+    );
+    const match = chunkD5CV3UF7_cjs.matchAmount(text2);
+    if (!match || "code" in match) {
+      ignore(
+        reader,
+        match?.code ?? "invalid_quantity",
+        source,
+        match?.message ?? `Expected a batch such as "24 cookies" or "3\u20134 loaves", received ${chunkD5CV3UF7_cjs.describeValue(label)}.`
+      );
+      return void 0;
+    }
+    const amount2 = typeof match.amount === "number" ? match.amount : match.amount.min;
+    const rest = match.rest.trim();
+    return !rest || SERVINGS_WORD.test(rest) ? { source, label, amount: amount2, servings: match.amountText, worded: !!rest } : { source, label, amount: amount2, yield: text2, article: /^an?\s/i.test(text2) };
+  }
+  const record = chunkD5CV3UF7_cjs.asRecord(value);
+  const amount = toNumber(record?.value ?? record?.minValue);
+  if (record && amount !== void 0) {
+    const max = toNumber(record.maxValue);
+    const unit = typeof record.unitText === "string" ? cleanText(record.unitText) : "";
+    const range = {
+      amount,
+      ...max !== void 0 && max !== amount && { max }
+    };
+    const label = `${amount}${max !== amount && max ? `\u2013${max}` : ""}${unit && ` ${unit}`}`;
+    return !unit || SERVINGS_WORD.test(unit) ? { source, label, amount, servings: range, worded: !!unit } : { source, label, amount, yield: { ...range, unit } };
+  }
+  if (!isAbsent(value)) {
+    ignore(
+      reader,
+      "invalid_type",
+      source,
+      `Expected a yield such as "4 servings" or "24 cookies", received ${chunkD5CV3UF7_cjs.describeValue(value)}.`
+    );
+  }
+  return void 0;
+}
+function readTime(reader, value, source) {
+  if (isAbsent(value)) {
+    return void 0;
+  }
+  const minutes = typeof value === "string" ? chunkD5CV3UF7_cjs.parseIsoDuration(cleanText(value)) : void 0;
+  if (minutes === void 0 || minutes > Number.MAX_SAFE_INTEGER) {
+    ignore(
+      reader,
+      "invalid_duration",
+      source,
+      `Expected an ISO 8601 duration such as "PT30M", received ${chunkD5CV3UF7_cjs.describeValue(value)}${minutes === void 0 ? "" : ", which is too long"}.`
+    );
+    return void 0;
+  }
+  return minutes > 0 ? minutes : void 0;
+}
+function readList(reader, key, value, source, readItem, expected) {
+  const list = [];
+  link(reader, [key], source);
+  const add = (items, path, entry, entrySource, inSection) => {
+    if (isAbsent(entry)) {
+      return;
+    }
+    if (entrySource.length > MAX_DEPTH) {
+      ignore(
+        reader,
+        "invalid_type",
+        entrySource,
+        `Expected ${expected}, received ${chunkD5CV3UF7_cjs.describeValue(entry)} nested more than ${MAX_DEPTH} levels deep.`
+      );
+      return;
+    }
+    if (Array.isArray(entry)) {
+      const elements2 = entriesOf(entry, entrySource);
+      const positions = elements2.map(
+        ([element]) => toNumber(chunkD5CV3UF7_cjs.asRecord(element)?.position)
+      );
+      const order = [...elements2.keys()];
+      if (!positions.includes(void 0)) {
+        order.sort((a, b) => positions[a] - positions[b]);
+      }
+      for (const i of order) {
+        const [element, elementSource] = elements2[i];
+        add(items, path, element, elementSource, inSection);
+      }
+      return;
+    }
+    const record = chunkD5CV3UF7_cjs.asRecord(entry);
+    const elements = [...entrySource, "itemListElement"];
+    if (record?.itemListElement !== void 0 && record.text === void 0) {
+      const title = typeof record.name === "string" ? cleanText(record.name) : "";
+      if (title && !inSection) {
+        const section = { title, items: [] };
+        const sectionPath = [key, list.length];
+        list.push(section);
+        link(reader, sectionPath, entrySource);
+        link(reader, [...sectionPath, "title"], [...entrySource, "name"]);
+        add(
+          section.items,
+          [...sectionPath, "items"],
+          record.itemListElement,
+          elements,
+          true
+        );
+      } else {
+        add(items, path, record.itemListElement, elements, inSection);
+      }
+      return;
+    }
+    if (record && !isAbsent(record.item)) {
+      add(items, path, record.item, [...entrySource, "item"], inSection);
+      return;
+    }
+    const read = readItem(reader, entry, entrySource);
+    if (!read) {
+      ignore(
+        reader,
+        "invalid_type",
+        entrySource,
+        `Expected ${expected}, received ${chunkD5CV3UF7_cjs.describeValue(entry)}.`
+      );
+      return;
+    }
+    for (const item of read) {
+      const itemPath = [...path, items.length];
+      items.push(item.value);
+      link(reader, itemPath, item.source, true);
+      for (const [field, fieldSource, droppable] of item.fields) {
+        link(reader, [...itemPath, field], fieldSource, droppable);
+      }
+    }
+  };
+  add(list, [key], value, source, false);
+  return list;
+}
+function readLine(reader, value, source) {
+  if (typeof value === "string") {
+    return cleanLines(value).map((line) => ({
+      value: line,
+      source,
+      fields: []
+    }));
+  }
+  const record = chunkD5CV3UF7_cjs.asRecord(value);
+  const parts = [record?.value, record?.unitText, record?.name ?? record?.text].filter((part) => typeof part === "string" || typeof part === "number").join(" ");
+  return parts ? cleanLines(parts).map((line) => ({ value: line, source, fields: [] })) : void 0;
+}
+function readStep(reader, value, source) {
+  if (typeof value === "string") {
+    return cleanLines(value).map((line) => ({
+      value: line,
+      source,
+      fields: []
+    }));
+  }
+  const record = chunkD5CV3UF7_cjs.asRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  const name = typeof record.name === "string" ? cleanText(record.name) : "";
+  const body = text(record.text) ?? name;
+  const image = readImage(reader, record.image, [...source, "image"]);
+  const lead = name.replace(/(?:…|\.\.\.)$/, "").trim();
+  const hasName = typeof body === "string" && !body.startsWith(lead) && !/^step\s*\d*[.:]?$/i.test(name);
+  const fields = [
+    ["text", [...source, name && body === name ? "name" : "text"], false]
+  ];
+  if (image) {
+    fields.push(["image", image.source, true]);
+  }
+  return [
+    {
+      value: {
+        text: body,
+        ...hasName && { name },
+        ...image && { image: image.url }
+      },
+      source,
+      fields
+    }
+  ];
+}
+function readTools(reader, value, source) {
+  const equipment = [];
+  link(reader, ["equipment"], source);
+  for (const [entry, entrySource] of entriesOf(value, source)) {
+    const record = chunkD5CV3UF7_cjs.asRecord(entry);
+    const item = record ? {
+      name: text(record.name),
+      ...record.requiredQuantity !== void 0 && {
+        quantity: toNumber(
+          chunkD5CV3UF7_cjs.asRecord(record.requiredQuantity)?.value ?? record.requiredQuantity
+        ) ?? record.requiredQuantity
+      },
+      ...record.url !== void 0 && { url: text(record.url) }
+    } : text(entry);
+    if (item === void 0) {
+      continue;
+    }
+    const path = ["equipment", equipment.length];
+    equipment.push(item);
+    link(reader, path, entrySource, true);
+    link(reader, [...path, "name"], [...entrySource, "name"]);
+    link(
+      reader,
+      [...path, "quantity"],
+      [...entrySource, "requiredQuantity"],
+      true
+    );
+    link(reader, [...path, "url"], [...entrySource, "url"], true);
+  }
+  return equipment;
+}
+function readNutrition(reader, value, source) {
+  link(reader, ["nutrition"], source);
+  if (isAbsent(value)) {
+    return void 0;
+  }
+  const record = chunkD5CV3UF7_cjs.asRecord(value);
+  if (!record) {
+    ignore(
+      reader,
+      "invalid_type",
+      source,
+      `Expected NutritionInformation, such as { "calories": "250 kcal" }, received ${chunkD5CV3UF7_cjs.describeValue(value)}.`
+    );
+    return void 0;
+  }
+  const nutrition = {};
+  const keys = Object.keys(NUTRIENTS);
+  for (const [field, amount] of Object.entries(record)) {
+    const key = keys.find((key2) => NUTRIENTS[key2] === field);
+    if (key) {
+      nutrition[key] = text(amount);
+      link(reader, ["nutrition", key], [...source, field], true);
+    } else if (!field.startsWith("@")) {
+      ignore(reader, "unknown_field", [...source, field], "Unknown field.");
+    }
+  }
+  return nutrition;
+}
+function text(value) {
+  return typeof value === "string" ? cleanText(value) || void 0 : value ?? void 0;
+}
+function toNumber(value) {
+  const number = typeof value === "string" && value.trim() ? Number(value) : value;
+  return typeof number === "number" && Number.isFinite(number) ? number : void 0;
+}
+function isAbsent(value) {
+  return value === void 0 || value === null || typeof value === "string" && !value.trim();
+}
+function ignore(reader, code, path, message) {
+  chunkD5CV3UF7_cjs.warning(reader.warnings, code, path, `${message} It is ignored.`);
+}
+function link(reader, path, source, droppable = false) {
+  const key = JSON.stringify(path);
+  reader.sources.set(key, source);
+  if (droppable) {
+    reader.droppable.add(key);
+  }
+}
+function sourceOf(reader, path) {
+  for (let n = path.length; n >= 0; n--) {
+    const source = reader.sources.get(JSON.stringify(path.slice(0, n)));
+    if (source) {
+      return source;
+    }
+  }
+  return [];
+}
+function compareOrder(a, b) {
+  for (const [i, n] of a.entries()) {
+    if (i === b.length) {
+      return 1;
+    }
+    const m = b[i];
+    if (n !== m) {
+      return n - m;
+    }
+  }
+  return a.length - b.length;
+}
+function droppableAt(reader, path) {
+  for (let n = path.length; n > 0; n--) {
+    const at = path.slice(0, n);
+    if (reader.droppable.has(JSON.stringify(at))) {
+      return at;
+    }
+  }
+  return void 0;
+}
+function remove(model, path) {
+  const parent = path.slice(0, -1).reduce(
+    (value, key) => value?.[key],
+    model
+  );
+  if (parent) {
+    delete parent[path[path.length - 1]];
+  }
+}
+
+// src/schema-org/to-json-ld.ts
+function toJsonLd(recipe, options) {
+  const { servings, system, url, extra } = options ?? {};
+  const resolved = chunkD5CV3UF7_cjs.resolveRecipe(recipe, { servings, system });
+  const page = typeof url === "string" ? url.replace(/#.*/s, "") : void 0;
+  const yields = [
+    ...resolved.servings ? servingsText(resolved.servings) : [],
+    ...resolved.yield ? [chunkD5CV3UF7_cjs.formatYield(resolved.yield, { fractions: false })] : []
+  ];
+  const ingredients = resolved.ingredients.flatMap(
+    ({ items }) => items.map((item) => ingredientLine(item, resolved.scale, resolved.system))
+  );
+  const steps = resolved.steps.flatMap(
+    ({ title, items }) => {
+      const howToSteps = items.map((step) => ({
+        "@type": "HowToStep",
+        ...step.name !== void 0 && { name: step.name },
+        text: step.text,
+        ...step.image !== void 0 && { image: step.image },
+        ...page !== void 0 && {
+          // encodeURIComponent throws on a lone surrogate. With the u flag,
+          // \p{Cs} matches only those, as a pair reads as one code point.
+          url: `${page}#${encodeURIComponent(step.id.replace(/\p{Cs}/gu, "\uFFFD"))}`
+        }
+      }));
+      return title === void 0 || howToSteps.length === 0 ? howToSteps : [
+        {
+          "@type": "HowToSection",
+          name: title,
+          itemListElement: howToSteps
+        }
+      ];
+    }
+  );
+  const { description, image, times, equipment, nutrition } = recipe;
+  const warnings = [];
+  const written = {
+    "@context": "https://schema.org",
+    "@type": "Recipe",
+    name: recipe.name,
+    ...description !== void 0 && { description },
+    ...image !== void 0 && { image },
+    ...yields.length > 0 && { recipeYield: yields.map(plainSpaces) },
+    ...duration(warnings, "prep", times.prep),
+    ...duration(warnings, "cook", times.cook),
+    ...duration(warnings, "total", times.total),
+    ...ingredients.length > 0 && { recipeIngredient: ingredients },
+    ...steps.length > 0 && { recipeInstructions: steps },
+    ...equipment.length > 0 && { tool: equipment.map(({ name }) => name) },
+    ...nutrition !== void 0 && {
+      nutrition: nutritionInformation(nutrition)
+    }
+  };
+  const data = {
+    ...written,
+    ...Object.fromEntries(
+      Object.entries(chunkD5CV3UF7_cjs.isRecord(extra) ? extra : {}).filter(
+        ([field, value]) => value !== void 0 && !chunkD5CV3UF7_cjs.hasOwn(written, field)
+      )
+    )
+  };
+  if (data.image === void 0) {
+    chunkD5CV3UF7_cjs.warning(
+      warnings,
+      "missing_field",
+      ["image"],
+      "Add an image. Google requires one for recipe results."
+    );
+  }
+  if (data.nutrition !== void 0 && data.recipeYield === void 0) {
+    chunkD5CV3UF7_cjs.warning(
+      warnings,
+      "missing_field",
+      ["recipeYield"],
+      "Add servings or a yield. Google requires one with nutrition, which is for one serving."
+    );
+  }
+  return { data, warnings };
+}
+function servingsText(servings) {
+  const amount = chunkD5CV3UF7_cjs.formatServings(servings, { fractions: false });
+  const word = servings.amount === 1 && servings.max === void 0 ? "serving" : "servings";
+  return [amount, `${amount} ${word}`];
+}
+function ingredientLine(item, scale, system) {
+  const { ingredient, origin } = item;
+  const { quantity, name, note } = chunkD5CV3UF7_cjs.formatIngredient(item);
+  const authored = ingredient.quantity ? [ingredient.quantity, ...ingredient.equivalents] : [];
+  const shown = origin === "authored" ? 0 : origin === "equivalent" ? 1 + ingredient.equivalents.findIndex((q) => chunkD5CV3UF7_cjs.isNative(q, system)) : -1;
+  const alternatives = authored.filter((_, i) => i !== shown).map((q) => chunkD5CV3UF7_cjs.formatQuantity(scale === 1 ? q : chunkD5CV3UF7_cjs.multiply(q, scale))).join("; ");
+  const inParentheses = alternatives && ` (${alternatives})`;
+  const head = quantity === void 0 ? name : item.quantity?.unit === void 0 ? `${quantity} ${name}${inParentheses}` : `${quantity}${inParentheses} ${name}`;
+  return plainSpaces(
+    `${head}${note ? `, ${note}` : ""}${ingredient.optional ? " (optional)" : ""}`
+  );
+}
+function duration(warnings, key, minutes) {
+  if (minutes === void 0) {
+    return {};
+  }
+  if (Number.isNaN(minutes) || minutes > Number.MAX_SAFE_INTEGER) {
+    chunkD5CV3UF7_cjs.warning(
+      warnings,
+      "invalid_duration",
+      ["times", key],
+      `Expected minutes such as 30, received ${chunkD5CV3UF7_cjs.describeValue(minutes)}${Number.isNaN(minutes) ? "" : ", which is too long"}. It is ignored.`
+    );
+    return {};
+  }
+  const seconds = Math.round(minutes * 60);
+  if (seconds <= 0) {
+    return {};
+  }
+  const parts = [
+    [Math.floor(seconds / 3600), "H"],
+    [Math.floor(seconds / 60) % 60, "M"],
+    [seconds % 60, "S"]
+  ];
+  return {
+    [`${key}Time`]: `PT${parts.map(([n, unit]) => n ? `${n}${unit}` : "").join("")}`
+  };
+}
+function nutritionInformation(nutrition) {
+  const information = {
+    "@type": "NutritionInformation"
+  };
+  for (const key of Object.keys(NUTRIENTS)) {
+    const value = nutrition[key];
+    if (value !== void 0) {
+      information[NUTRIENTS[key]] = typeof value === "string" ? value : `${chunkD5CV3UF7_cjs.round(value, 3)} ${chunkD5CV3UF7_cjs.NUTRIENT_UNITS[key]}`;
+    }
+  }
+  return information;
+}
+function plainSpaces(text2) {
+  return text2.replace(/\u00A0/g, " ");
+}
+
+exports.findRecipeJsonLd = findRecipeJsonLd;
+exports.fromJsonLd = fromJsonLd;
+exports.toJsonLd = toJsonLd;
+//# sourceMappingURL=schema-org.cjs.map
+//# sourceMappingURL=schema-org.cjs.map