@recipe-book/core 0.0.3 → 0.1.1

package/dist/schema-org.d.ts

@@ -0,0 +1,223 @@
+import { ParseResult, Recipe, System, RecipeIssue } from './index.js';
+
+/**
+ * Finds the schema.org Recipe nodes in a page's
+ * `<script type="application/ld+json">` tags, without a DOM. Pass one to
+ * `fromJsonLd`.
+ *
+ * Reads arrays and `@graph`, as Yoast and WP Recipe Maker write them, and the
+ * `mainEntity` of a node there, up to 32 levels deep, and matches a node whose
+ * `@type` is or includes `"Recipe"`. When that finds none, it also reads each
+ * `ItemList` in those places, as a roundup page lists its recipes, taking each
+ * Recipe in its `itemListElement`, or in a `ListItem`'s `item` there. A
+ * `ListItem` with only a `url` is skipped: fetch that page and call
+ * `findRecipeJsonLd` on it. A `mainEntity`, or an entry of a `mainEntity`
+ * array, that is neither a Recipe nor an `ItemList` is skipped with everything
+ * in it, and a Recipe anywhere else, such as inside another Recipe or in a list
+ * inside a `ListItem` or another list, isn't found.
+ *
+ * A tag whose JSON doesn't parse is retried with the raw line breaks and tabs
+ * inside its strings escaped, as real pages have them, and skipped if it still
+ * doesn't. A tag inside an HTML comment is skipped, and a `<!--` in an
+ * attribute value or in a `style` or `textarea` element is text, as in a
+ * browser. A quote starts an attribute value only right after `=`, so a stray
+ * one, as in `content="a 9" pan"`, doesn't hide later tags. A Recipe node with
+ * the `@id` of an earlier one is returned once, where the first appears. When
+ * the first holds only keywords, such as a `mainEntity` of
+ * `{ "@type": "Recipe", "@id": "#recipe" }`, the later node is returned in its
+ * place. An empty `@id` is no `@id`, so it merges nothing.
+ *
+ * In each Recipe node returned, an image that is an `@id` reference to a node
+ * at the top level of the JSON-LD, or reached from there through arrays and
+ * `@graph`, holds that node instead of the reference, an object that holds only
+ * that `@id`. That applies to the recipe's `image` and each step's `image` in
+ * `recipeInstructions`, and lets `fromJsonLd` read them. A reference to a node
+ * in any other field, such as an `Organization`'s `logo` or an `ImageObject` in
+ * a `WebPage`'s `mainEntity`, isn't followed. Other references, such as
+ * `author` and `mainEntityOfPage`, and references inside the node an image
+ * holds, stay as the page wrote them.
+ *
+ * @param html - The page's HTML, such as `await response.text()`.
+ * @returns The Recipe nodes it finds, in document order, or `[]` when there
+ * are none.
+ * @throws {RecipeBookError} `invalid_argument` when `html` isn't a string.
+ *
+ * @example
+ * const [node] = findRecipeJsonLd(await response.text())
+ * const result = fromJsonLd(node)
+ */
+declare function findRecipeJsonLd(html: string): Record<string, unknown>[];
+
+/**
+ * A schema.org Recipe as `toJsonLd` writes it: plain JSON when `extra` is, so
+ * a Server Component can render it into a `<script type="application/ld+json">`
+ * tag. Fields from the `extra` option sit alongside these with the values you
+ * passed, including a field core leaves out, such as an `image` URL for a
+ * recipe that has none.
+ */
+type SchemaOrgRecipe = {
+    '@context': 'https://schema.org';
+    '@type': 'Recipe';
+    name: string;
+    description?: string;
+    /** An http or https URL, or a relative one. */
+    image?: string;
+    /** `["4", "4 servings"]` for servings, then the yield, as in `"24 cookies"`. */
+    recipeYield?: string[];
+    /** ISO 8601, such as `"PT1H30M"`. */
+    prepTime?: string;
+    cookTime?: string;
+    totalTime?: string;
+    /** Ingredient lines, such as `"1 ½ cups (190 g) flour, sifted"`. */
+    recipeIngredient?: string[];
+    /** Steps, with each titled section that has steps as a `HowToSection`. */
+    recipeInstructions?: (SchemaOrgHowToStep | SchemaOrgHowToSection)[];
+    /** Equipment names. */
+    tool?: string[];
+    nutrition?: SchemaOrgNutritionInformation;
+    [field: string]: unknown;
+};
+/** A step in {@link SchemaOrgRecipe}. */
+type SchemaOrgHowToStep = {
+    '@type': 'HowToStep';
+    name?: string;
+    text: string;
+    image?: string;
+    /** The `url` option with the step's id, percent-encoded, as its fragment, as in `"https://example.com/pancakes#mix"`. */
+    url?: string;
+};
+/** A titled section of steps in {@link SchemaOrgRecipe}. */
+type SchemaOrgHowToSection = {
+    '@type': 'HowToSection';
+    name: string;
+    itemListElement: SchemaOrgHowToStep[];
+};
+/** Nutrition for one serving in {@link SchemaOrgRecipe}, as text with units, such as `"250 kcal"` or `"12 g"`. */
+type SchemaOrgNutritionInformation = {
+    '@type': 'NutritionInformation';
+    servingSize?: string;
+    calories?: string;
+    fatContent?: string;
+    saturatedFatContent?: string;
+    transFatContent?: string;
+    unsaturatedFatContent?: string;
+    carbohydrateContent?: string;
+    sugarContent?: string;
+    fiberContent?: string;
+    proteinContent?: string;
+    sodiumContent?: string;
+    cholesterolContent?: string;
+};
+/** The {@link SchemaOrgRecipe} fields `toJsonLd` writes from a recipe. */
+type Modelled = 'name' | 'description' | 'image' | 'recipeYield' | 'prepTime' | 'cookTime' | 'totalTime' | 'recipeIngredient' | 'recipeInstructions' | 'tool' | 'nutrition';
+/** Options for `toJsonLd`. */
+type ToJsonLdOptions = {
+    /** Writes the recipe at this many servings, as `resolveRecipe` scales it. Defaults to the recipe's own. */
+    servings?: number | undefined;
+    /** Writes quantities in this measurement system. Defaults to `recipe.system`, then `'metric'`. */
+    system?: System | undefined;
+    /** The recipe page's URL. Each step gets it as `url`, with the step's id, percent-encoded, as the fragment. */
+    url?: string | undefined;
+    /**
+     * schema.org fields the recipe doesn't model, such as `author`,
+     * `datePublished`, or `keywords`, written as you pass them. A field core
+     * writes from the recipe wins; `@context` and `@type` are always core's. A
+     * field that is `undefined` is left out, so `{ image: maybeImage }` adds an
+     * image only when there is one. A field core writes from a recipe takes the
+     * type {@link SchemaOrgRecipe} gives it here too, so an `image` is a URL.
+     * Pass the `extra` that `fromJsonLd` returned to write them back.
+     */
+    extra?: ({
+        [K in Modelled]?: SchemaOrgRecipe[K] | undefined;
+    } & Record<string, unknown>) | undefined;
+};
+/** What `toJsonLd` returns. */
+type ToJsonLdResult = {
+    data: SchemaOrgRecipe;
+    warnings: RecipeIssue[];
+};
+/**
+ * What `fromJsonLd` returns: a `ParseResult`, with `extra` on success and
+ * failure alike. `extra` holds the node's fields the recipe doesn't model.
+ */
+type FromJsonLdResult = ParseResult<Recipe> & {
+    extra: Record<string, unknown>;
+};
+
+/**
+ * Reads a schema.org Recipe from JSON-LD, as recipe sites publish it for
+ * search engines: a Recipe node, or an array, `@graph`, `mainEntity`, or
+ * `ItemList` that holds one, such as a node from `findRecipeJsonLd` or
+ * `JSON.parse` of a script tag. An `ItemList` is read only when no other
+ * Recipe is found, as in `findRecipeJsonLd`. Never throws for bad data; an
+ * error thrown by a getter or proxy in the input passes through.
+ *
+ * Every string has its tags removed, then its HTML entities decoded, so an
+ * encoded tag such as `&lt;b&gt;` stays as text. Ingredient lines are read
+ * with `parseIngredientLine`. Issue paths point into the JSON-LD, such as
+ * `recipeIngredient[3]`.
+ *
+ * Reading is forgiving. A value the recipe can't hold, such as a `data:`
+ * image or nutrition of "N/A", is left out with a warning that keeps its usual
+ * code and ends "It is ignored." A second Recipe node, a second number of
+ * servings, or a second yield is an `ignored_value` warning. The result fails
+ * only when there is no Recipe node, the recipe's name is missing or isn't
+ * text, or a problem remains that leaving a value out can't fix.
+ *
+ * @returns The recipe or the error, and `extra`: the node's fields the recipe
+ * doesn't model, such as `author` and `keywords`, as they were. A field that
+ * nests more than 32 levels deep, counted from the top of `input`, is left
+ * out, with a warning. Pass `extra` to `toJsonLd` to write them back. It is
+ * `{}` when no Recipe node is found.
+ *
+ * @example
+ * const result = fromJsonLd(node)
+ * if (!result.success) {
+ *   console.error(result.error.message)
+ *   // Recipe has 1 problem:
+ *   //   ✖ name  Add a name for the recipe.
+ *   // See https://recipe-book.siraj.page/errors/invalid_recipe
+ *   return
+ * }
+ * result.data.ingredients[0].items[0] // { id: 'flour', name: 'flour', quantity: { amount: 2, unit: 'cup' }, … }
+ * result.extra.author // { '@type': 'Person', name: 'Ada' }
+ */
+declare function fromJsonLd(input: unknown): FromJsonLdResult;
+
+/**
+ * Writes a recipe as schema.org Recipe JSON-LD, for search engines' recipe
+ * results. Writes it at its own servings and in `recipe.system`, else metric,
+ * unless the options say otherwise; invalid options fall back to these, as in
+ * `resolveRecipe`. Never throws for an unchanged recipe from `parseRecipe` or
+ * `fromJsonLd`.
+ *
+ * `data` is plain JSON when `extra` is. Write it into a
+ * `<script type="application/ld+json">` tag with `<` escaped as `\u003c`, so
+ * recipe text can't end the tag. An `image` passed in `extra` is a URL; for an
+ * `ImageObject` or several images, spread `data` into a new object with your
+ * own `image`.
+ *
+ * Ingredient lines read back with `parseIngredientLine`: a quantity's
+ * alternatives follow it in parentheses, as in `"1 ½ cups (190 g) flour,
+ * sifted"` and `"2 eggs (100 g)"`, and an optional ingredient ends
+ * `" (optional)"`. schema.org has no place for ingredient section titles, the
+ * recipe's notes, custom times, an ingredient's `url`, or equipment beyond its
+ * name, so they aren't written. Reading `data` back with `fromJsonLd` gives a
+ * similar recipe, not the same one.
+ *
+ * `warnings` names the fields Google requires for recipe results that `data`
+ * lacks, with paths that use the schema.org names: `image`, and `recipeYield`
+ * when there is nutrition. A time longer than `Number.MAX_SAFE_INTEGER`
+ * minutes is left out, as `fromJsonLd` leaves it out, and so is a `NaN` time,
+ * each with an `invalid_duration` warning at its path in the recipe, such as
+ * `['times', 'cook']`.
+ *
+ * @example
+ * const { data } = toJsonLd(recipe, { url: 'https://example.com/pancakes' })
+ * data.recipeYield // ['4', '4 servings']
+ * data.recipeIngredient // ['1 ½ cups (190 g) flour, sifted', '2 eggs', 'salt, to taste']
+ */
+declare function toJsonLd(recipe: Recipe, options?: ToJsonLdOptions): ToJsonLdResult;
+
+export { findRecipeJsonLd, fromJsonLd, toJsonLd };
+export type { FromJsonLdResult, SchemaOrgHowToSection, SchemaOrgHowToStep, SchemaOrgNutritionInformation, SchemaOrgRecipe, ToJsonLdOptions, ToJsonLdResult };

package/dist/schema-org.js

@@ -0,0 +1,10 @@
+// src/schema-org/index.ts
+import { findRecipeJsonLd } from "./schema-org/find.js";
+import { fromJsonLd } from "./schema-org/from-json-ld.js";
+import { toJsonLd } from "./schema-org/to-json-ld.js";
+export {
+  findRecipeJsonLd,
+  fromJsonLd,
+  toJsonLd
+};
+//# sourceMappingURL=schema-org.js.map

package/dist/schema-org.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema-org/index.ts"],"sourcesContent":["export { findRecipeJsonLd } from './find'\nexport { fromJsonLd } from './from-json-ld'\nexport { toJsonLd } from './to-json-ld'\nexport type {\n  FromJsonLdResult,\n  SchemaOrgHowToSection,\n  SchemaOrgHowToStep,\n  SchemaOrgNutritionInformation,\n  SchemaOrgRecipe,\n  ToJsonLdOptions,\n  ToJsonLdResult,\n} from './types'\n"],"mappings":";AAAA,SAAS,wBAAwB;AACjC,SAAS,kBAAkB;AAC3B,SAAS,gBAAgB;","names":[]}

package/dist/steps/segment.js

@@ -0,0 +1,45 @@
+// src/steps/segment.ts
+import { describeValue, RecipeBookError } from "../errors.js";
+import { matchTemperature } from "./temperature.js";
+function segmentStepText(text, options) {
+  if (typeof text !== "string") {
+    throw new RecipeBookError(
+      "invalid_argument",
+      `segmentStepText: text must be a string, received ${describeValue(text)}.`
+    );
+  }
+  const assumed = options?.assumeTemperatureUnit;
+  if (assumed !== void 0 && assumed !== "C" && assumed !== "F") {
+    throw new RecipeBookError(
+      "invalid_argument",
+      `segmentStepText: assumeTemperatureUnit must be "C" or "F", received ${describeValue(assumed)}.`
+    );
+  }
+  const segments = [];
+  const digits = /\d+/g;
+  let done = 0;
+  for (let found = digits.exec(text); found; found = digits.exec(text)) {
+    const match = matchTemperature(text, found.index, done, assumed);
+    if (!match) {
+      continue;
+    }
+    if (match.start > done) {
+      segments.push({ type: "text", text: text.slice(done, match.start) });
+    }
+    segments.push({
+      type: "temperature",
+      text: text.slice(match.start, match.end),
+      ...match.reading,
+      alternatives: match.alternatives
+    });
+    done = digits.lastIndex = match.end;
+  }
+  if (done < text.length) {
+    segments.push({ type: "text", text: text.slice(done) });
+  }
+  return segments;
+}
+export {
+  segmentStepText
+};
+//# sourceMappingURL=segment.js.map

package/dist/steps/segment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/steps/segment.ts"],"sourcesContent":["import { describeValue, RecipeBookError } from '../errors'\nimport type { Temperature, TemperatureUnit } from '../units/temperature'\nimport { matchTemperature } from './temperature'\n\n/** A temperature read from step text, and whether it is for a fan oven. */\nexport type TemperatureReading = {\n  temperature: Temperature\n  /**\n   * True when the text marks it for a fan or convection oven, as in \"170C\n   * fan\". A marker after a segment's closing parenthesis, as in \"170°C (about\n   * 340°F) fan\", marks every reading in the segment. An unmarked reading in\n   * parentheses that restates a marked one, in the other unit and within 10 °C,\n   * is marked too, as in \"170°C fan (about 340°F)\". In \"160°C fan (350°F)\",\n   * 350 °F is 177 °C, so it isn't. Otherwise, a marker with other words between\n   * it and the reading, as in \"325°F for convection\", isn't read.\n   */\n  fan: boolean\n}\n\n/** Step text with nothing recognized in it. */\nexport type TextSegment = { type: 'text'; text: string }\n\n/**\n * A temperature in step text. When the author already wrote the setting more\n * than one way, as in \"400 degrees F (200 degrees C)\" or \"190C/170C fan/gas 5\",\n * the whole run is one segment: the first reading is `temperature`, the others\n * are `alternatives`, and `text` keeps any gas mark uninterpreted. Readings\n * with the same `fan` value are one setting in both units, within 10 °C of\n * each other, so no two share a unit and a `fan` value.\n */\nexport type TemperatureSegment = TemperatureReading & {\n  type: 'temperature'\n  /** The text exactly as authored, such as `'350°F'` or `'200C/180C fan forced'`. */\n  text: string\n  /** The other readings in this segment, in authored order. Often empty. */\n  alternatives: TemperatureReading[]\n}\n\n/**\n * A piece of step text. Recognizes temperatures in 0.1; durations and other\n * kinds may be added in minor releases, so handle unknown `type`s as text.\n */\nexport type StepSegment = TextSegment | TemperatureSegment\n\n/** Options for {@link segmentStepText}. */\nexport type SegmentStepTextOptions = {\n  /**\n   * Scale for a temperature written with a degree sign or the word \"degree\" or\n   * \"degrees\" but no scale, such as \"Bake at 350 degrees\", \"Bake in a\n   * 350-degree oven.\" or \"Preheat oven to 350°.\" Default: none, so those stay\n   * text. A number with no degree sign or word, as in \"Preheat oven to 350.\",\n   * stays text even with a scale. With one, such a temperature counts only\n   * after a word such as \"at\" or \"to\", before \"oven\", or when a reading in the\n   * other unit restates it, as in \"350° (175°C)\", so \"rotate the pan 180\n   * degrees\" stays text.\n   */\n  assumeTemperatureUnit?: TemperatureUnit | undefined\n}\n\n/**\n * Splits step text into plain text and the temperatures in it. Joining every\n * segment's `text` gives back the input exactly.\n *\n * @throws {RecipeBookError} `invalid_argument` for text that isn't a string or an unknown `assumeTemperatureUnit`.\n *\n * @example\n * segmentStepText('Bake at 350°F for 20 minutes.')\n * // [\n * //   { type: 'text', text: 'Bake at ' },\n * //   { type: 'temperature', text: '350°F', temperature: { value: 350, unit: 'F' }, fan: false, alternatives: [] },\n * //   { type: 'text', text: ' for 20 minutes.' },\n * // ]\n */\nexport function segmentStepText(\n  text: string,\n  options?: SegmentStepTextOptions,\n): StepSegment[] {\n  if (typeof text !== 'string') {\n    throw new RecipeBookError(\n      'invalid_argument',\n      `segmentStepText: text must be a string, received ${describeValue(text)}.`,\n    )\n  }\n\n  const assumed = options?.assumeTemperatureUnit\n  if (assumed !== undefined && assumed !== 'C' && assumed !== 'F') {\n    throw new RecipeBookError(\n      'invalid_argument',\n      `segmentStepText: assumeTemperatureUnit must be \"C\" or \"F\", received ${describeValue(assumed)}.`,\n    )\n  }\n\n  const segments: StepSegment[] = []\n  const digits = /\\d+/g\n  let done = 0\n  for (let found = digits.exec(text); found; found = digits.exec(text)) {\n    const match = matchTemperature(text, found.index, done, assumed)\n    if (!match) {\n      continue\n    }\n\n    if (match.start > done) {\n      segments.push({ type: 'text', text: text.slice(done, match.start) })\n    }\n\n    segments.push({\n      type: 'temperature',\n      text: text.slice(match.start, match.end),\n      ...match.reading,\n      alternatives: match.alternatives,\n    })\n    done = digits.lastIndex = match.end\n  }\n\n  if (done < text.length) {\n    segments.push({ type: 'text', text: text.slice(done) })\n  }\n\n  return segments\n}\n"],"mappings":";AAAA,SAAS,eAAe,uBAAuB;AAE/C,SAAS,wBAAwB;AAuE1B,SAAS,gBACd,MACA,SACe;AACf,MAAI,OAAO,SAAS,UAAU;AAC5B,UAAM,IAAI;AAAA,MACR;AAAA,MACA,oDAAoD,cAAc,IAAI,CAAC;AAAA,IACzE;AAAA,EACF;AAEA,QAAM,UAAU,SAAS;AACzB,MAAI,YAAY,UAAa,YAAY,OAAO,YAAY,KAAK;AAC/D,UAAM,IAAI;AAAA,MACR;AAAA,MACA,uEAAuE,cAAc,OAAO,CAAC;AAAA,IAC/F;AAAA,EACF;AAEA,QAAM,WAA0B,CAAC;AACjC,QAAM,SAAS;AACf,MAAI,OAAO;AACX,WAAS,QAAQ,OAAO,KAAK,IAAI,GAAG,OAAO,QAAQ,OAAO,KAAK,IAAI,GAAG;AACpE,UAAM,QAAQ,iBAAiB,MAAM,MAAM,OAAO,MAAM,OAAO;AAC/D,QAAI,CAAC,OAAO;AACV;AAAA,IACF;AAEA,QAAI,MAAM,QAAQ,MAAM;AACtB,eAAS,KAAK,EAAE,MAAM,QAAQ,MAAM,KAAK,MAAM,MAAM,MAAM,KAAK,EAAE,CAAC;AAAA,IACrE;AAEA,aAAS,KAAK;AAAA,MACZ,MAAM;AAAA,MACN,MAAM,KAAK,MAAM,MAAM,OAAO,MAAM,GAAG;AAAA,MACvC,GAAG,MAAM;AAAA,MACT,cAAc,MAAM;AAAA,IACtB,CAAC;AACD,WAAO,OAAO,YAAY,MAAM;AAAA,EAClC;AAEA,MAAI,OAAO,KAAK,QAAQ;AACtB,aAAS,KAAK,EAAE,MAAM,QAAQ,MAAM,KAAK,MAAM,IAAI,EAAE,CAAC;AAAA,EACxD;AAEA,SAAO;AACT;","names":[]}

package/dist/steps/temperature.js

@@ -0,0 +1,174 @@
+// src/steps/temperature.ts
+var LOOKBACK = 24;
+var MAX_ITEMS = 6;
+var NUMBER = /(\d{1,4})(\.\d{1,2})?(?![.,]?\d)/y;
+var DEGREES = /(?:-|\s{0,3})(?:([℃℉])|(?:[°º˚]|degrees?(?!(?!ι)[\p{sc=Latin}\p{sc=Cyrillic}\p{M}\d_]))(?:\s{0,3}(?:(cel[cs]ius|centigrade|fahrenheit|[cfс])(?!(?![ºªι])[\p{sc=Latin}\p{sc=Cyrillic}\p{M}\d_])|\(([cf])\)))?)/iuy;
+var SCALE = /(\s{0,3})(cel[cs]ius|centigrade|fahrenheit|[cf])(?!(?![ºªι])[\p{sc=Latin}\p{sc=Cyrillic}\p{M}\d_])(?:°|\s{1,3}degrees?(?!(?!ι)[\p{sc=Latin}\p{sc=Cyrillic}\p{M}\d_]))?/iuy;
+var FAN_AFTER = /(?:\s{1,3}|-)(?:(?:fan|convection)(?:[- ](?:forced|assisted|oven))?|umluft|hei(?:ß|ss)luft)(?!(?!ι)[\p{sc=Latin}\p{sc=Cyrillic}\p{M}\d_])/iuy;
+var FAN_GROUP = /\s{0,3}\(\s{0,2}(?:(?:fan|convection)(?:[- ](?:forced|assisted|oven))?|umluft|hei(?:ß|ss)luft)\s{0,2}\)/iy;
+var FAN_BEFORE = /(?:(?:fan|convection)(?:[- ](?:forced|assisted|oven))?|umluft|hei(?:ß|ss)luft)\s{1,3}/iy;
+var FAN_PREFIX = /(?:^|ι|[^\p{sc=Latin}\p{sc=Cyrillic}\p{M}\d_])((?:(?:fan|convection)(?:[- ](?:forced|assisted|oven))?|umluft|hei(?:ß|ss)luft)\s{1,3})$/iu;
+var GAS = /(?:gas(?:\s{1,3}mark)?|mark)\s{0,3}(?:\d{1,2}(?:[-/\u2013]\d{1,2})?|[¼½¾])(?!(?!ι)[\p{sc=Latin}\p{sc=Cyrillic}\p{M}\d_])/iuy;
+var SEPARATOR = /\s{0,3}(?:(?:,?\s{0,3}or(?=\s)|[-/,\u2013\u2014])\s{0,3})?/iy;
+var OPEN = /\s{0,3}\(\s{0,2}(?:(?:about|around|roughly|approx(?:imately|\.)?|ca\.|i\.e\.,?|or)\s{1,3}|[~≈]\s{0,2})?/iy;
+var CLOSE = /\s{0,2}\)/y;
+var OVEN_STEP = 10;
+var SHARED = /\d\s{0,3}(?:(?:[°º˚]|degrees?)\s{0,3}\(|(?:[°º˚]|degrees?)?\s{0,3}(?:[-\u2010-\u2015~/&]|to|and|or))\s{0,3}$/i;
+var GAS_ALTERNATIVE = /(?:gas|mark)\s{0,3}\d{1,2}\s{0,3}(?:\/|or)\s{0,3}$/i;
+var RANGE_AFTER = /\s{0,3}(?:[-\u2010-\u2015~/&]|to|and|or)\s{0,3}-?\d/iy;
+var NOT_A_READING = /\d[.,:]$|(?:^|ι|[^\p{sc=Latin}\p{sc=Cyrillic}\p{M}\d_])by\s{1,3}(?:(?:about|around|roughly|approximately|another|an?|further|additional|extra)\s{1,3}){0,3}$/iu;
+var SETTING = /(?:^|ι|[^\p{sc=Latin}\p{sc=Cyrillic}\p{M}\d_])(?:at|to|of|be|is|until|oven|bake|roast|reads?|reach(?:es)?|registers?|hits?)\s{1,3}(?:(?:about|around|roughly|approximately)\s{1,3})?$/iu;
+var OVEN_AFTER = /\s{1,3}oven(?!(?!ι)[\p{sc=Latin}\p{sc=Cyrillic}\p{M}\d_])/iuy;
+var SIGN = /[-\u2212]/;
+var SIGN_BEFORE = /[\s(]/;
+var LETTER = /[a-z]/i;
+function matchTemperature(text, digit, floor, assumed) {
+  const negative = digit > floor && SIGN.test(text[digit - 1] ?? "") && SIGN_BEFORE.test(text.charAt(digit - 2) || " ");
+  const start = negative ? digit - 1 : digit;
+  const before = text.slice(Math.max(floor, start - LOOKBACK), start);
+  if (LETTER.test(text.charAt(start - 1)) || NOT_A_READING.test(before) || SHARED.test(before) && !GAS_ALTERNATIVE.test(before)) {
+    return void 0;
+  }
+  const first = readingAt(text, digit);
+  if (!first) {
+    return void 0;
+  }
+  const prefix = FAN_PREFIX.exec(before)?.[1];
+  const unit = first.unit ?? assumed;
+  if (!unit || !first.unit && exec(RANGE_AFTER, text, first.end)) {
+    return void 0;
+  }
+  const reading = {
+    temperature: {
+      value: negative && first.value ? -first.value : first.value,
+      unit
+    },
+    fan: Boolean(prefix) || first.fan
+  };
+  const run = { readings: [reading], gas: false };
+  let end = extend(text, first.end, run);
+  if (first.cued && run.readings.length < 2 && !(prefix || SETTING.test(before) || exec(OVEN_AFTER, text, first.end))) {
+    return void 0;
+  }
+  const fanEnd = text[end - 1] === ")" && !run.readings.some(({ fan }) => fan) ? at(FAN_AFTER, text, end) : void 0;
+  if (fanEnd !== void 0) {
+    end = fanEnd;
+    for (const item of run.readings) {
+      item.fan = true;
+    }
+  }
+  return {
+    start: prefix ? start - prefix.length : start,
+    end,
+    reading,
+    alternatives: run.readings.slice(1)
+  };
+}
+function extend(text, end, run, grouped) {
+  let owner;
+  for (let count = 1; count < MAX_ITEMS; count++) {
+    run.clash = false;
+    let group;
+    if (!grouped) {
+      const { readings, gas } = run;
+      const { length } = readings;
+      const first = itemAt(text, at(OPEN, text, end), run);
+      group = first === void 0 ? void 0 : at(CLOSE, text, extend(text, first, run, true));
+      if (group !== void 0) {
+        const fanOwner = readings[length - 1];
+        for (const item of readings.slice(length)) {
+          const { unit } = item.temperature;
+          if (fanOwner?.fan && near(item.temperature, fanOwner.temperature) && !readings.some(
+            (other) => other.fan && other.temperature.unit === unit
+          )) {
+            item.fan = true;
+          }
+        }
+      } else {
+        readings.length = length;
+        run.gas = gas;
+      }
+    }
+    if (run.clash && owner) {
+      run.readings.length = owner[1];
+      return owner[0];
+    }
+    const size = run.readings.length;
+    const next = group ?? itemAt(text, at(SEPARATOR, text, end), run);
+    if (next === void 0) {
+      break;
+    }
+    owner = run.readings.length > size ? [end, size] : void 0;
+    end = next;
+  }
+  return end;
+}
+function itemAt(text, index, run) {
+  if (index === void 0) {
+    return void 0;
+  }
+  const reading = readingAt(text, index);
+  if (reading?.unit) {
+    const { value, unit, fan } = reading;
+    const temperature = { value, unit };
+    if (run.readings.some(
+      (item) => item.fan === fan && (item.temperature.unit === unit || !near(item.temperature, temperature))
+    )) {
+      run.clash = true;
+      return void 0;
+    }
+    run.readings.push({ temperature, fan });
+    return reading.end;
+  }
+  const end = run.gas ? void 0 : at(GAS, text, index);
+  if (end !== void 0) {
+    run.gas = true;
+  }
+  return end;
+}
+function readingAt(text, index) {
+  const marked = at(FAN_BEFORE, text, index);
+  const number = exec(NUMBER, text, marked ?? index);
+  if (!number) {
+    return void 0;
+  }
+  const [digits, integer = "", fraction] = number;
+  const after = number.index + digits.length;
+  let scale = exec(DEGREES, text, after);
+  let name = scale && (scale[1] ?? scale[2] ?? scale[3]);
+  let cups = false;
+  if (!scale) {
+    scale = exec(SCALE, text, after);
+    name = scale?.[2];
+    cups = name === "c" || name === "C" && Boolean(scale?.[1]);
+    if (!scale || name?.length === 1 && (fraction || integer.length < (cups || name === "f" ? 3 : 2))) {
+      return void 0;
+    }
+  }
+  const end = scale.index + scale[0].length;
+  const fanEnd = at(FAN_AFTER, text, end) ?? at(FAN_GROUP, text, end);
+  return {
+    value: Number(digits),
+    unit: name ? /^[cс℃]/i.test(name) ? "C" : "F" : void 0,
+    fan: marked !== void 0 || fanEnd !== void 0,
+    cued: !name || cups,
+    end: fanEnd ?? end
+  };
+}
+function near(a, b) {
+  return Math.abs(celsius(a) - celsius(b)) <= OVEN_STEP;
+}
+function celsius({ value, unit }) {
+  return unit === "C" ? value : (value - 32) / 1.8;
+}
+function exec(pattern, text, index) {
+  pattern.lastIndex = index;
+  return pattern.exec(text);
+}
+function at(pattern, text, index) {
+  return exec(pattern, text, index) ? pattern.lastIndex : void 0;
+}
+export {
+  matchTemperature
+};
+//# sourceMappingURL=temperature.js.map

package/dist/steps/temperature.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/steps/temperature.ts"],"sourcesContent":["import type { Temperature, TemperatureUnit } from '../units/temperature'\nimport type { TemperatureReading } from './segment'\n\ntype TemperatureMatch = {\n  start: number\n  end: number\n  reading: TemperatureReading\n  alternatives: TemperatureReading[]\n}\n\ntype Reading = {\n  value: number\n  unit: TemperatureUnit | undefined\n  fan: boolean\n  /** True when it counts only after a word such as \"at\", as \"350°\" and \"180 C\" do. */\n  cued: boolean\n  end: number\n}\n\n/**\n * The readings in a run, first included, and whether a gas mark was among\n * them. Readings for the same kind of oven are one setting written in both\n * units, so \"350°F or 375°F\" and \"350°F or 200°C\" are separate settings.\n * `clash` is set when a reading was turned away for that reason.\n */\ntype Run = { readings: TemperatureReading[]; gas: boolean; clash?: boolean }\n\n// Every quantifier is bounded, lookbehind reads at most LOOKBACK characters,\n// and a run holds at most MAX_ITEMS items, so each call does constant work and\n// a scan stays linear in the text length.\nconst LOOKBACK = 24\nconst MAX_ITEMS = 6\n\n// The lookahead never changes a reading, since no scale starts with a digit,\n// \".\" or \",\". It's there for speed: it turns a longer number away before\n// DEGREES and SCALE are tried.\nconst NUMBER = /(\\d{1,4})(\\.\\d{1,2})?(?![.,]?\\d)/y\n// Every word boundary in this file except LETTER, below, treats a Latin or\n// Cyrillic letter, a combining mark, a digit, or \"_\" as continuing a word,\n// since those scripts write the units and separate words with spaces:\n// \"200 fèves\" isn't 200 °F. Chinese, Japanese, and Korean attach words and\n// particles straight to a number or unit, as in \"45°C/113°F的温水\" and\n// \"180°C에서\", so their letters end a word. So do Greek letters, since Greek\n// writes the unit in its own letters: \"180°Cγια\" is missing a space. So does\n// U+0345, a combining mark that only sits on a Greek vowel. Under \"/iu\" the\n// Greek iotas fold onto it and match \"\\p{M}\", so each of these boundaries\n// lets \"ι\" end a word explicitly. \"º\" and \"ª\" end a unit letter too, as in\n// \"180Cº\". The unit may be a Cyrillic \"С\", as in \"180 °С\".\nconst DEGREES =\n  /(?:-|\\s{0,3})(?:([℃℉])|(?:[°º˚]|degrees?(?!(?!ι)[\\p{sc=Latin}\\p{sc=Cyrillic}\\p{M}\\d_]))(?:\\s{0,3}(?:(cel[cs]ius|centigrade|fahrenheit|[cfс])(?!(?![ºªι])[\\p{sc=Latin}\\p{sc=Cyrillic}\\p{M}\\d_])|\\(([cf])\\)))?)/iuy\nconst SCALE =\n  /(\\s{0,3})(cel[cs]ius|centigrade|fahrenheit|[cf])(?!(?![ºªι])[\\p{sc=Latin}\\p{sc=Cyrillic}\\p{M}\\d_])(?:°|\\s{1,3}degrees?(?!(?!ι)[\\p{sc=Latin}\\p{sc=Cyrillic}\\p{M}\\d_]))?/iuy\nconst FAN_AFTER =\n  /(?:\\s{1,3}|-)(?:(?:fan|convection)(?:[- ](?:forced|assisted|oven))?|umluft|hei(?:ß|ss)luft)(?!(?!ι)[\\p{sc=Latin}\\p{sc=Cyrillic}\\p{M}\\d_])/iuy\nconst FAN_GROUP =\n  /\\s{0,3}\\(\\s{0,2}(?:(?:fan|convection)(?:[- ](?:forced|assisted|oven))?|umluft|hei(?:ß|ss)luft)\\s{0,2}\\)/iy\nconst FAN_BEFORE =\n  /(?:(?:fan|convection)(?:[- ](?:forced|assisted|oven))?|umluft|hei(?:ß|ss)luft)\\s{1,3}/iy\nconst FAN_PREFIX =\n  /(?:^|ι|[^\\p{sc=Latin}\\p{sc=Cyrillic}\\p{M}\\d_])((?:(?:fan|convection)(?:[- ](?:forced|assisted|oven))?|umluft|hei(?:ß|ss)luft)\\s{1,3})$/iu\nconst GAS =\n  /(?:gas(?:\\s{1,3}mark)?|mark)\\s{0,3}(?:\\d{1,2}(?:[-/\\u2013]\\d{1,2})?|[¼½¾])(?!(?!ι)[\\p{sc=Latin}\\p{sc=Cyrillic}\\p{M}\\d_])/iuy\nconst SEPARATOR = /\\s{0,3}(?:(?:,?\\s{0,3}or(?=\\s)|[-/,\\u2013\\u2014])\\s{0,3})?/iy\n// A parenthesis may hedge what it restates, as in \"350°F (about 180°C)\".\nconst OPEN =\n  /\\s{0,3}\\(\\s{0,2}(?:(?:about|around|roughly|approx(?:imately|\\.)?|ca\\.|i\\.e\\.,?|or)\\s{1,3}|[~≈]\\s{0,2})?/iy\nconst CLOSE = /\\s{0,2}\\)/y\n// Readings this close are one setting written in both units: 170°C is 338°F,\n// and recipes round it to 325°F or 350°F.\nconst OVEN_STEP = 10\n\n// A number that takes its scale from a later one, as 350 does in \"350–375°F\",\n// \"350 to 375 degrees F\", and \"350° (175°C)\". The later one stays text too,\n// so a converter never rewrites one end of a range.\nconst SHARED =\n  /\\d\\s{0,3}(?:(?:[°º˚]|degrees?)\\s{0,3}\\(|(?:[°º˚]|degrees?)?\\s{0,3}(?:[-\\u2010-\\u2015~/&]|to|and|or))\\s{0,3}$/i\n// A gas mark before \"/\" or \"or\" has its own scale, so the 200C in\n// \"gas 6/200C\" and \"gas mark 6 or 200C\" is read. Other joiners can start a\n// range, as in \"gas 4–5\" and \"gas mark 4 to 5\", so SHARED still applies.\nconst GAS_ALTERNATIVE = /(?:gas|mark)\\s{0,3}\\d{1,2}\\s{0,3}(?:\\/|or)\\s{0,3}$/i\nconst RANGE_AFTER = /\\s{0,3}(?:[-\\u2010-\\u2015~/&]|to|and|or)\\s{0,3}-?\\d/iy\n// A number that continues another, as in \"1.5\" and \"10:30\", isn't a reading,\n// and \"Reduce the heat by 20°F\" is a difference; converting it is wrong.\nconst NOT_A_READING =\n  /\\d[.,:]$|(?:^|ι|[^\\p{sc=Latin}\\p{sc=Cyrillic}\\p{M}\\d_])by\\s{1,3}(?:(?:about|around|roughly|approximately|another|an?|further|additional|extra)\\s{1,3}){0,3}$/iu\n// Words that make a bare \"350°\" or \"350 degrees\" an oven setting rather than\n// an angle, as in \"rotate the pan 180 degrees\", and \"180 C\" a temperature\n// rather than cups, as in \"add 100 c sugar\".\nconst SETTING =\n  /(?:^|ι|[^\\p{sc=Latin}\\p{sc=Cyrillic}\\p{M}\\d_])(?:at|to|of|be|is|until|oven|bake|roast|reads?|reach(?:es)?|registers?|hits?)\\s{1,3}(?:(?:about|around|roughly|approximately)\\s{1,3})?$/iu\nconst OVEN_AFTER =\n  /\\s{1,3}oven(?!(?!ι)[\\p{sc=Latin}\\p{sc=Cyrillic}\\p{M}\\d_])/iuy\n\nconst SIGN = /[-\\u2212]/\nconst SIGN_BEFORE = /[\\s(]/\n// ASCII only: Chinese puts numbers right after words, as in \"预热至200°C\".\nconst LETTER = /[a-z]/i\n\n/**\n * Matches a temperature, or a run of readings that state one setting several\n * ways, whose first number starts at `digit`. Text before `floor` belongs to\n * an earlier segment and is never included.\n */\nexport function matchTemperature(\n  text: string,\n  digit: number,\n  floor: number,\n  assumed: TemperatureUnit | undefined,\n): TemperatureMatch | undefined {\n  // Past the start of the text, `charAt` gives '' where an index would read a\n  // key set on `Object.prototype`.\n  const negative =\n    digit > floor &&\n    SIGN.test(text[digit - 1] ?? '') &&\n    SIGN_BEFORE.test(text.charAt(digit - 2) || ' ')\n  const start = negative ? digit - 1 : digit\n  const before = text.slice(Math.max(floor, start - LOOKBACK), start)\n  if (\n    LETTER.test(text.charAt(start - 1)) ||\n    NOT_A_READING.test(before) ||\n    (SHARED.test(before) && !GAS_ALTERNATIVE.test(before))\n  ) {\n    return undefined\n  }\n\n  const first = readingAt(text, digit)\n  if (!first) {\n    return undefined\n  }\n\n  const prefix = FAN_PREFIX.exec(before)?.[1]\n  const unit = first.unit ?? assumed\n  if (!unit || (!first.unit && exec(RANGE_AFTER, text, first.end))) {\n    return undefined\n  }\n\n  const reading: TemperatureReading = {\n    temperature: {\n      value: negative && first.value ? -first.value : first.value,\n      unit,\n    },\n    fan: Boolean(prefix) || first.fan,\n  }\n  const run: Run = { readings: [reading], gas: false }\n  let end = extend(text, first.end, run)\n  // A reading that needs a cue word is a temperature without one when the\n  // author restated it, as in \"Oven: 180 C (350 F).\"\n  if (\n    first.cued &&\n    run.readings.length < 2 &&\n    !(prefix || SETTING.test(before) || exec(OVEN_AFTER, text, first.end))\n  ) {\n    return undefined\n  }\n  // A marker after a pair, as in \"170°C (340°F) Fan\", is for the whole pair.\n  const fanEnd =\n    text[end - 1] === ')' && !run.readings.some(({ fan }) => fan)\n      ? at(FAN_AFTER, text, end)\n      : undefined\n  if (fanEnd !== undefined) {\n    end = fanEnd\n    for (const item of run.readings) {\n      item.fan = true\n    }\n  }\n\n  return {\n    start: prefix ? start - prefix.length : start,\n    end,\n    reading,\n    alternatives: run.readings.slice(1),\n  }\n}\n\n/**\n * Adds the items that follow `end` to `run`, such as \"/170C fan\" or\n * \"(200 degrees C)\", and returns where they stop. Groups don't nest.\n */\nfunction extend(text: string, end: number, run: Run, grouped?: true): number {\n  // Where the last reading after a joiner starts, and the run's size before it.\n  let owner: [number, number] | undefined\n  for (let count = 1; count < MAX_ITEMS; count++) {\n    run.clash = false\n    let group: number | undefined\n    if (!grouped) {\n      const { readings, gas } = run\n      const { length } = readings\n      const first = itemAt(text, at(OPEN, text, end), run)\n      group =\n        first === undefined\n          ? undefined\n          : at(CLOSE, text, extend(text, first, run, true))\n      if (group !== undefined) {\n        // An unmarked reading that restates a fan reading, as 340°F does in\n        // \"170°C fan (340°F)\", is for a fan oven too.\n        const fanOwner = readings[length - 1]\n        for (const item of readings.slice(length)) {\n          const { unit } = item.temperature\n          if (\n            fanOwner?.fan &&\n            near(item.temperature, fanOwner.temperature) &&\n            !readings.some(\n              (other) => other.fan && other.temperature.unit === unit,\n            )\n          ) {\n            item.fan = true\n          }\n        }\n      } else {\n        readings.length = length\n        run.gas = gas\n      }\n    }\n    // A parenthesis that clashes with the run restates the reading before it,\n    // which is a setting of its own, as in \"190°C (375°F) or 170°C fan\n    // (340°F)\", so the run ends before that reading.\n    if (run.clash && owner) {\n      run.readings.length = owner[1]\n      return owner[0]\n    }\n    const size = run.readings.length\n    const next = group ?? itemAt(text, at(SEPARATOR, text, end), run)\n    if (next === undefined) {\n      break\n    }\n    owner = run.readings.length > size ? [end, size] : undefined\n    end = next\n  }\n  return end\n}\n\n/**\n * A reading with its scale that restates the run's reading for the same kind\n * of oven in the other unit, or is the first for its kind, or a gas mark when\n * the run has none yet.\n */\nfunction itemAt(\n  text: string,\n  index: number | undefined,\n  run: Run,\n): number | undefined {\n  if (index === undefined) {\n    return undefined\n  }\n\n  const reading = readingAt(text, index)\n  if (reading?.unit) {\n    const { value, unit, fan } = reading\n    const temperature = { value, unit }\n    if (\n      run.readings.some(\n        (item) =>\n          item.fan === fan &&\n          (item.temperature.unit === unit ||\n            !near(item.temperature, temperature)),\n      )\n    ) {\n      run.clash = true\n      return undefined\n    }\n    run.readings.push({ temperature, fan })\n    return reading.end\n  }\n\n  const end = run.gas ? undefined : at(GAS, text, index)\n  if (end !== undefined) {\n    run.gas = true\n  }\n  return end\n}\n\n/**\n * Reads one temperature: an optional fan marker, a number, then a scale, a\n * degree sign, or the word \"degree\" or \"degrees\". `unit` is undefined when\n * only a degree sign or word says it is a temperature.\n */\nfunction readingAt(text: string, index: number): Reading | undefined {\n  const marked = at(FAN_BEFORE, text, index)\n  const number = exec(NUMBER, text, marked ?? index)\n  if (!number) {\n    return undefined\n  }\n\n  const [digits, integer = '', fraction] = number\n  const after = number.index + digits.length\n  let scale = exec(DEGREES, text, after)\n  let name = scale && (scale[1] ?? scale[2] ?? scale[3])\n  let cups = false\n  if (!scale) {\n    scale = exec(SCALE, text, after)\n    name = scale?.[2]\n    // A lone letter needs two digits, as in \"180C\" and \"350 F\". A C that could\n    // be cups needs three digits and, to start a run, a word such as \"to\"\n    // before it, so \"2C\", \"12 C bowl\", and \"add 100 c sugar\" stay text.\n    cups = name === 'c' || (name === 'C' && Boolean(scale?.[1]))\n    if (\n      !scale ||\n      (name?.length === 1 &&\n        (fraction || integer.length < (cups || name === 'f' ? 3 : 2)))\n    ) {\n      return undefined\n    }\n  }\n\n  const end = scale.index + scale[0].length\n  const fanEnd = at(FAN_AFTER, text, end) ?? at(FAN_GROUP, text, end)\n\n  return {\n    value: Number(digits),\n    unit: name ? (/^[cс℃]/i.test(name) ? 'C' : 'F') : undefined,\n    fan: marked !== undefined || fanEnd !== undefined,\n    cued: !name || cups,\n    end: fanEnd ?? end,\n  }\n}\n\nfunction near(a: Temperature, b: Temperature): boolean {\n  return Math.abs(celsius(a) - celsius(b)) <= OVEN_STEP\n}\n\nfunction celsius({ value, unit }: Temperature): number {\n  return unit === 'C' ? value : (value - 32) / 1.8\n}\n\nfunction exec(\n  pattern: RegExp,\n  text: string,\n  index: number,\n): RegExpExecArray | null {\n  pattern.lastIndex = index\n  return pattern.exec(text)\n}\n\n/** Where sticky `pattern` ends when it matches at `index`. */\nfunction at(pattern: RegExp, text: string, index: number): number | undefined {\n  return exec(pattern, text, index) ? pattern.lastIndex : undefined\n}\n"],"mappings":"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","names":[]}

package/dist/suggest.js

@@ -0,0 +1,50 @@
+// 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];
+}
+export {
+  closestMatch
+};
+//# sourceMappingURL=suggest.js.map

package/dist/suggest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/suggest.ts"],"sourcesContent":["/**\n * The candidate closest to misspelled text, for \"did you mean\" hints. Case is\n * ignored. Text under 3 characters must match apart from case; text under 6\n * allows one edit, and longer text allows two. Ties go to the candidate nearest\n * in length, then to the earliest.\n */\nexport function closestMatch<Candidate extends string>(\n  text: string,\n  candidates: Iterable<Candidate>,\n): Candidate | undefined {\n  const input = text.trim().toLowerCase()\n  const maxDistance = input.length < 3 ? 0 : input.length < 6 ? 1 : 2\n\n  let best: Candidate | undefined\n  let bestDistance = Infinity\n  let bestGap = 0\n\n  for (const candidate of candidates) {\n    const lengthGap = Math.abs(candidate.length - input.length)\n    if (lengthGap > maxDistance) {\n      continue\n    }\n\n    const distance = editDistance(input, candidate.toLowerCase())\n\n    if (\n      distance <= maxDistance &&\n      (distance < bestDistance ||\n        (distance === bestDistance && lengthGap < bestGap))\n    ) {\n      best = candidate\n      bestDistance = distance\n      bestGap = lengthGap\n    }\n  }\n\n  return best\n}\n\n/**\n * Optimal string alignment distance: insertions, deletions, substitutions, and\n * adjacent swaps. A swap costs half an edit, so for \"tbps\" the swap to \"tbsp\"\n * outranks the substitution to \"tsps\".\n */\nfunction editDistance(a: string, b: string): number {\n  let twoAbove: number[] = []\n  let above = [0]\n  for (let j = 1; j <= b.length; j++) {\n    above[j] = j\n  }\n\n  for (let i = 1; i <= a.length; i++) {\n    const row = [i]\n    for (let j = 1; j <= b.length; j++) {\n      const cost = a[i - 1] === b[j - 1] ? 0 : 1\n      let distance = Math.min(\n        above[j]! + 1,\n        row[j - 1]! + 1,\n        above[j - 1]! + cost,\n      )\n\n      if (a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {\n        distance = Math.min(distance, twoAbove[j - 2]! + 0.5)\n      }\n\n      row[j] = distance\n    }\n    twoAbove = above\n    above = row\n  }\n\n  return above[b.length]!\n}\n"],"mappings":";AAMO,SAAS,aACd,MACA,YACuB;AACvB,QAAM,QAAQ,KAAK,KAAK,EAAE,YAAY;AACtC,QAAM,cAAc,MAAM,SAAS,IAAI,IAAI,MAAM,SAAS,IAAI,IAAI;AAElE,MAAI;AACJ,MAAI,eAAe;AACnB,MAAI,UAAU;AAEd,aAAW,aAAa,YAAY;AAClC,UAAM,YAAY,KAAK,IAAI,UAAU,SAAS,MAAM,MAAM;AAC1D,QAAI,YAAY,aAAa;AAC3B;AAAA,IACF;AAEA,UAAM,WAAW,aAAa,OAAO,UAAU,YAAY,CAAC;AAE5D,QACE,YAAY,gBACX,WAAW,gBACT,aAAa,gBAAgB,YAAY,UAC5C;AACA,aAAO;AACP,qBAAe;AACf,gBAAU;AAAA,IACZ;AAAA,EACF;AAEA,SAAO;AACT;AAOA,SAAS,aAAa,GAAW,GAAmB;AAClD,MAAI,WAAqB,CAAC;AAC1B,MAAI,QAAQ,CAAC,CAAC;AACd,WAAS,IAAI,GAAG,KAAK,EAAE,QAAQ,KAAK;AAClC,UAAM,CAAC,IAAI;AAAA,EACb;AAEA,WAAS,IAAI,GAAG,KAAK,EAAE,QAAQ,KAAK;AAClC,UAAM,MAAM,CAAC,CAAC;AACd,aAAS,IAAI,GAAG,KAAK,EAAE,QAAQ,KAAK;AAClC,YAAM,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,IAAI;AACzC,UAAI,WAAW,KAAK;AAAA,QAClB,MAAM,CAAC,IAAK;AAAA,QACZ,IAAI,IAAI,CAAC,IAAK;AAAA,QACd,MAAM,IAAI,CAAC,IAAK;AAAA,MAClB;AAEA,UAAI,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG;AAClD,mBAAW,KAAK,IAAI,UAAU,SAAS,IAAI,CAAC,IAAK,GAAG;AAAA,MACtD;AAEA,UAAI,CAAC,IAAI;AAAA,IACX;AACA,eAAW;AACX,YAAQ;AAAA,EACV;AAEA,SAAO,MAAM,EAAE,MAAM;AACvB;","names":[]}