ezmedicationinput 0.1.43 → 0.1.45

package/dist/parser.js

@@ -1,4007 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tokenize = tokenize;
-exports.findUnparsedTokenGroups = findUnparsedTokenGroups;
-exports.parseInternal = parseInternal;
-exports.applyPrnReasonCoding = applyPrnReasonCoding;
-exports.applyPrnReasonCodingAsync = applyPrnReasonCodingAsync;
-exports.applySiteCoding = applySiteCoding;
-exports.applySiteCodingAsync = applySiteCodingAsync;
-const maps_1 = require("./maps");
-const context_1 = require("./context");
-const safety_1 = require("./safety");
-const types_1 = require("./types");
-const object_1 = require("./utils/object");
-const array_1 = require("./utils/array");
-const SNOMED_SYSTEM = "http://snomed.info/sct";
-function buildCustomSiteHints(map) {
-    if (!map) {
-        return undefined;
-    }
-    const hints = new Set();
-    const addPhraseHints = (phrase) => {
-        if (!phrase) {
-            return;
-        }
-        const normalized = (0, maps_1.normalizeBodySiteKey)(phrase);
-        if (!normalized) {
-            return;
-        }
-        for (const part of normalized.split(" ")) {
-            if (part) {
-                hints.add(part);
-            }
-        }
-    };
-    for (const [key, definition] of (0, object_1.objectEntries)(map)) {
-        addPhraseHints(key);
-        if (definition.aliases) {
-            for (const alias of definition.aliases) {
-                addPhraseHints(alias);
-            }
-        }
-    }
-    return hints;
-}
-function isBodySiteHint(word, customSiteHints) {
-    var _a;
-    return BODY_SITE_HINTS.has(word) || ((_a = customSiteHints === null || customSiteHints === void 0 ? void 0 : customSiteHints.has(word)) !== null && _a !== void 0 ? _a : false);
-}
-const BODY_SITE_HINTS = new Set([
-    "left",
-    "right",
-    "bilateral",
-    "arm",
-    "arms",
-    "leg",
-    "legs",
-    "thigh",
-    "thighs",
-    "shoulder",
-    "shoulders",
-    "hand",
-    "hands",
-    "foot",
-    "feet",
-    "eye",
-    "eyes",
-    "ear",
-    "ears",
-    "nostril",
-    "nostrils",
-    "abdomen",
-    "belly",
-    "cheek",
-    "cheeks",
-    "upper",
-    "lower",
-    "forearm",
-    "back",
-    "mouth",
-    "tongue",
-    "tongues",
-    "cheek",
-    "cheeks",
-    "gum",
-    "gums",
-    "tooth",
-    "teeth",
-    "nose",
-    "nares",
-    "hair",
-    "skin",
-    "scalp",
-    "face",
-    "forehead",
-    "chin",
-    "neck",
-    "buttock",
-    "buttocks",
-    "gluteal",
-    "glute",
-    "muscle",
-    "muscles",
-    "vein",
-    "veins",
-    "vagina",
-    "vaginal",
-    "penis",
-    "penile",
-    "rectum",
-    "rectal",
-    "anus",
-    "perineum",
-    "temple",
-    "temples"
-]);
-const SITE_CONNECTORS = new Set(["to", "in", "into", "on", "onto", "at"]);
-const SITE_FILLER_WORDS = new Set([
-    "the",
-    "a",
-    "an",
-    "your",
-    "his",
-    "her",
-    "their",
-    "my"
-]);
-const HOUSEHOLD_VOLUME_UNIT_SET = new Set(maps_1.HOUSEHOLD_VOLUME_UNITS.map((unit) => unit.toLowerCase()));
-const DISCRETE_UNIT_SET = new Set([
-    "tab",
-    "tabs",
-    "tablet",
-    "tablets",
-    "cap",
-    "caps",
-    "capsule",
-    "capsules",
-    "puff",
-    "puffs",
-    "spray",
-    "sprays",
-    "drop",
-    "drops",
-    "patch",
-    "patches",
-    "suppository",
-    "suppositories",
-    "implant",
-    "implants",
-    "piece",
-    "pieces",
-    "stick",
-    "sticks",
-    "pessary",
-    "pessaries",
-    "lozenge",
-    "lozenges"
-]);
-const OCULAR_DIRECTION_WORDS = new Set([
-    "left",
-    "right",
-    "both",
-    "either",
-    "each",
-    "bilateral"
-]);
-const OCULAR_SITE_WORDS = new Set([
-    "eye",
-    "eyes",
-    "eyelid",
-    "eyelids",
-    "ocular",
-    "ophthalmic",
-    "oculus"
-]);
-const COMBO_EVENT_TIMINGS = {
-    "early morning": types_1.EventTiming["Early Morning"],
-    "late morning": types_1.EventTiming["Late Morning"],
-    "early afternoon": types_1.EventTiming["Early Afternoon"],
-    "late afternoon": types_1.EventTiming["Late Afternoon"],
-    "early evening": types_1.EventTiming["Early Evening"],
-    "late evening": types_1.EventTiming["Late Evening"],
-    "after sleep": types_1.EventTiming["After Sleep"],
-    "before bed": types_1.EventTiming["Before Sleep"],
-    "before bedtime": types_1.EventTiming["Before Sleep"],
-    "before sleep": types_1.EventTiming["Before Sleep"],
-    "upon waking": types_1.EventTiming.Wake
-};
-const DAY_RANGE_PART_PATTERN = Object.keys(maps_1.DAY_OF_WEEK_TOKENS)
-    .sort((a, b) => b.length - a.length)
-    .map((token) => token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
-    .join("|");
-const DAY_RANGE_SPACED_HYPHEN_REGEX = new RegExp(`(^|\\s)(${DAY_RANGE_PART_PATTERN})\\s*-\\s*(${DAY_RANGE_PART_PATTERN})(?=\\s|$)`, "giu");
-const MEAL_CONTEXT_CONNECTORS = new Set(["and", "or", "&", "+", "plus"]);
-const COUNT_KEYWORDS = new Set([
-    "time",
-    "times",
-    "dose",
-    "doses",
-    "application",
-    "applications",
-    "use",
-    "uses"
-]);
-const COUNT_CONNECTOR_WORDS = new Set([
-    "a",
-    "an",
-    "the",
-    "total",
-    "of",
-    "up",
-    "to",
-    "no",
-    "more",
-    "than",
-    "max",
-    "maximum",
-    "additional",
-    "extra"
-]);
-const FREQUENCY_SIMPLE_WORDS = {
-    once: 1,
-    twice: 2,
-    thrice: 3
-};
-const FREQUENCY_NUMBER_WORDS = {
-    one: 1,
-    two: 2,
-    three: 3,
-    four: 4,
-    five: 5,
-    six: 6,
-    seven: 7,
-    eight: 8,
-    nine: 9,
-    ten: 10,
-    eleven: 11,
-    twelve: 12
-};
-const FREQUENCY_TIMES_WORDS = new Set(["time", "times", "x"]);
-const FREQUENCY_CONNECTOR_WORDS = new Set(["per", "a", "an", "each", "every"]);
-const FREQUENCY_ADVERB_UNITS = {
-    daily: types_1.FhirPeriodUnit.Day,
-    weekly: types_1.FhirPeriodUnit.Week,
-    monthly: types_1.FhirPeriodUnit.Month,
-    hourly: types_1.FhirPeriodUnit.Hour
-};
-const ROUTE_DESCRIPTOR_FILLER_WORDS = new Set([
-    "per",
-    "by",
-    "via",
-    "the",
-    "a",
-    "an"
-]);
-function normalizeRouteDescriptorPhrase(phrase) {
-    return phrase
-        .trim()
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((word) => word.length > 0 && !ROUTE_DESCRIPTOR_FILLER_WORDS.has(word))
-        .join(" ");
-}
-const DEFAULT_ROUTE_DESCRIPTOR_SYNONYMS = (() => {
-    const map = new Map();
-    for (const [phrase, synonym] of (0, object_1.objectEntries)(maps_1.DEFAULT_ROUTE_SYNONYMS)) {
-        const normalized = normalizeRouteDescriptorPhrase(phrase);
-        if (normalized && !map.has(normalized)) {
-            map.set(normalized, synonym);
-        }
-    }
-    return map;
-})();
-// Tracking explicit breakfast/lunch/dinner markers lets the meal-expansion
-// logic bail early when the clinician already specified precise events.
-const SPECIFIC_MEAL_TIMINGS = new Set([
-    types_1.EventTiming["Before Breakfast"],
-    types_1.EventTiming["Before Lunch"],
-    types_1.EventTiming["Before Dinner"],
-    types_1.EventTiming["After Breakfast"],
-    types_1.EventTiming["After Lunch"],
-    types_1.EventTiming["After Dinner"],
-    types_1.EventTiming.Breakfast,
-    types_1.EventTiming.Lunch,
-    types_1.EventTiming.Dinner
-]);
-// Ocular shorthand tokens commonly used in ophthalmic sigs.
-const EYE_SITE_TOKENS = {
-    od: { site: "right eye", route: types_1.RouteCode["Ophthalmic route"] },
-    re: { site: "right eye", route: types_1.RouteCode["Ophthalmic route"] },
-    os: { site: "left eye", route: types_1.RouteCode["Ophthalmic route"] },
-    le: { site: "left eye", route: types_1.RouteCode["Ophthalmic route"] },
-    ou: { site: "both eyes", route: types_1.RouteCode["Ophthalmic route"] },
-    be: { site: "both eyes", route: types_1.RouteCode["Ophthalmic route"] },
-    vod: {
-        site: "right eye",
-        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
-    },
-    vos: {
-        site: "left eye",
-        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
-    },
-    ivtod: {
-        site: "right eye",
-        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
-    },
-    ivtre: {
-        site: "right eye",
-        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
-    },
-    ivtos: {
-        site: "left eye",
-        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
-    },
-    ivtle: {
-        site: "left eye",
-        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
-    },
-    ivtou: {
-        site: "both eyes",
-        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
-    },
-    ivtbe: {
-        site: "both eyes",
-        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
-    }
-};
-const OPHTHALMIC_ROUTE_CODES = new Set([
-    types_1.RouteCode["Ophthalmic route"],
-    types_1.RouteCode["Ocular route (qualifier value)"],
-    types_1.RouteCode["Intravitreal route (qualifier value)"]
-]);
-const OPHTHALMIC_CONTEXT_TOKENS = new Set([
-    "drop",
-    "drops",
-    "gtt",
-    "gtts",
-    "eye",
-    "eyes",
-    "eyelid",
-    "eyelids",
-    "ocular",
-    "ophthalmic",
-    "ophth",
-    "oculus",
-    "os",
-    "ou",
-    "re",
-    "le",
-    "be"
-]);
-function normalizeTokenLower(token) {
-    return token.lower.replace(/[.{};]/g, "");
-}
-function hasOphthalmicContextHint(tokens, index) {
-    for (let offset = -3; offset <= 3; offset++) {
-        if (offset === 0) {
-            continue;
-        }
-        const neighbor = tokens[index + offset];
-        if (!neighbor) {
-            continue;
-        }
-        const normalized = normalizeTokenLower(neighbor);
-        if (OPHTHALMIC_CONTEXT_TOKENS.has(normalized) || normalized.includes("eye")) {
-            return true;
-        }
-    }
-    return false;
-}
-function shouldInterpretOdAsOnceDaily(internal, tokens, index, treatAsSite) {
-    var _a;
-    if (treatAsSite) {
-        return false;
-    }
-    const hasCadenceAssigned = internal.frequency !== undefined ||
-        internal.frequencyMax !== undefined ||
-        internal.period !== undefined ||
-        internal.periodMax !== undefined ||
-        internal.timingCode !== undefined;
-    const hasPriorSiteContext = hasBodySiteContextBefore(internal, tokens, index);
-    const hasUpcomingSiteContext = hasBodySiteContextAfter(internal, tokens, index);
-    const previous = tokens[index - 1];
-    const previousNormalized = previous ? normalizeTokenLower(previous) : undefined;
-    const previousIsOd = previousNormalized === "od";
-    const previousConsumed = previousIsOd && internal.consumed.has(previous.index);
-    const previousOdProvidedSite = previousConsumed && /eye/i.test((_a = internal.siteText) !== null && _a !== void 0 ? _a : "");
-    if (previousOdProvidedSite) {
-        return true;
-    }
-    const previousEyeToken = previousNormalized && previousNormalized !== "od"
-        ? EYE_SITE_TOKENS[previousNormalized]
-        : undefined;
-    if (previousEyeToken && internal.consumed.has(previous.index)) {
-        return true;
-    }
-    if (previousNormalized === "od" &&
-        internal.siteSource === "abbreviation" &&
-        internal.siteText &&
-        /eye/i.test(internal.siteText)) {
-        return true;
-    }
-    if (hasPriorSiteContext || hasUpcomingSiteContext) {
-        return !hasCadenceAssigned;
-    }
-    if (hasCadenceAssigned) {
-        return false;
-    }
-    if (internal.routeCode && !OPHTHALMIC_ROUTE_CODES.has(internal.routeCode)) {
-        return true;
-    }
-    if (internal.unit && internal.unit !== "drop") {
-        return true;
-    }
-    if (internal.siteText && !/eye/i.test(internal.siteText)) {
-        return true;
-    }
-    const hasNonOdToken = tokens.some((token, tokenIndex) => {
-        if (tokenIndex === index) {
-            return false;
-        }
-        return normalizeTokenLower(token) !== "od";
-    });
-    if (!hasNonOdToken) {
-        return false;
-    }
-    const ophthalmicContext = hasOphthalmicContextHint(tokens, index) ||
-        (internal.routeCode !== undefined && OPHTHALMIC_ROUTE_CODES.has(internal.routeCode)) ||
-        (internal.siteText !== undefined && /eye/i.test(internal.siteText));
-    if (ophthalmicContext && hasSpelledOcularSiteBefore(tokens, index)) {
-        return true;
-    }
-    return !ophthalmicContext;
-}
-function hasBodySiteContextBefore(internal, tokens, index) {
-    const currentToken = tokens[index];
-    const currentTokenIndex = currentToken ? currentToken.index : index;
-    if (internal.siteText) {
-        return true;
-    }
-    for (const tokenIndex of internal.siteTokenIndices) {
-        if (tokenIndex < currentTokenIndex) {
-            return true;
-        }
-    }
-    for (let i = 0; i < index; i++) {
-        const token = tokens[i];
-        if (!token) {
-            continue;
-        }
-        if (internal.consumed.has(token.index)) {
-            if (internal.siteTokenIndices.has(token.index) && token.index < currentTokenIndex) {
-                return true;
-            }
-            continue;
-        }
-        const normalized = normalizeTokenLower(token);
-        if (isBodySiteHint(normalized, internal.customSiteHints)) {
-            return true;
-        }
-        if (EYE_SITE_TOKENS[normalized]) {
-            return true;
-        }
-    }
-    return false;
-}
-function hasBodySiteContextAfter(internal, tokens, index) {
-    const currentToken = tokens[index];
-    const currentTokenIndex = currentToken ? currentToken.index : index;
-    for (const tokenIndex of internal.siteTokenIndices) {
-        if (tokenIndex > currentTokenIndex) {
-            return true;
-        }
-    }
-    let seenConnector = false;
-    for (let i = index + 1; i < tokens.length; i++) {
-        const token = tokens[i];
-        if (!token) {
-            continue;
-        }
-        if (internal.consumed.has(token.index)) {
-            if (internal.siteTokenIndices.has(token.index) && token.index > currentTokenIndex) {
-                return true;
-            }
-            continue;
-        }
-        const normalized = normalizeTokenLower(token);
-        if (SITE_CONNECTORS.has(normalized)) {
-            seenConnector = true;
-            continue;
-        }
-        if (SITE_FILLER_WORDS.has(normalized)) {
-            continue;
-        }
-        if (isBodySiteHint(normalized, internal.customSiteHints)) {
-            return true;
-        }
-        if (seenConnector) {
-            break;
-        }
-        if (!seenConnector) {
-            break;
-        }
-    }
-    return false;
-}
-function hasSpelledOcularSiteBefore(tokens, index) {
-    let hasOcularWord = false;
-    let hasDirectionalCue = false;
-    for (let i = 0; i < index; i++) {
-        const token = tokens[i];
-        if (!token) {
-            continue;
-        }
-        const normalized = normalizeTokenLower(token);
-        if (SITE_CONNECTORS.has(normalized) || OCULAR_DIRECTION_WORDS.has(normalized)) {
-            hasDirectionalCue = true;
-        }
-        if (OCULAR_SITE_WORDS.has(normalized) || normalized.includes("eye")) {
-            hasOcularWord = true;
-        }
-        if (hasDirectionalCue && hasOcularWord) {
-            return true;
-        }
-    }
-    return false;
-}
-function shouldTreatEyeTokenAsSite(internal, tokens, index, context) {
-    var _a;
-    const currentToken = tokens[index];
-    const normalizedSelf = normalizeTokenLower(currentToken);
-    const eyeMeta = EYE_SITE_TOKENS[normalizedSelf];
-    const contextRoute = (0, context_1.inferRouteFromContext)(context !== null && context !== void 0 ? context : undefined);
-    if (internal.routeCode && !OPHTHALMIC_ROUTE_CODES.has(internal.routeCode)) {
-        return false;
-    }
-    if (contextRoute && !OPHTHALMIC_ROUTE_CODES.has(contextRoute)) {
-        return false;
-    }
-    if (internal.siteText) {
-        return false;
-    }
-    if (internal.siteSource === "abbreviation") {
-        return false;
-    }
-    const dosageForm = (_a = context === null || context === void 0 ? void 0 : context.dosageForm) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-    const contextImpliesOphthalmic = contextRoute
-        ? OPHTHALMIC_ROUTE_CODES.has(contextRoute)
-        : Boolean(dosageForm && /(eye|ophth|ocular|intravit)/i.test(dosageForm));
-    const eyeRouteImpliesOphthalmic = (eyeMeta === null || eyeMeta === void 0 ? void 0 : eyeMeta.route) === types_1.RouteCode["Intravitreal route (qualifier value)"];
-    const ophthalmicContext = hasOphthalmicContextHint(tokens, index) ||
-        (internal.routeCode !== undefined && OPHTHALMIC_ROUTE_CODES.has(internal.routeCode)) ||
-        contextImpliesOphthalmic ||
-        eyeRouteImpliesOphthalmic;
-    if (hasBodySiteContextAfter(internal, tokens, index)) {
-        return false;
-    }
-    if (!ophthalmicContext) {
-        const hasOtherActiveTokens = tokens.some((token, tokenIndex) => tokenIndex !== index && !internal.consumed.has(token.index));
-        const onlyEyeTokens = tokens.every((token, tokenIndex) => {
-            if (tokenIndex === index || internal.consumed.has(token.index)) {
-                return true;
-            }
-            return normalizeTokenLower(token) === "od";
-        });
-        if (!hasOtherActiveTokens) {
-            return internal.unit === undefined && internal.routeCode === undefined;
-        }
-        if (onlyEyeTokens) {
-            return true;
-        }
-        return false;
-    }
-    for (let i = 0; i < index; i++) {
-        const candidate = tokens[i];
-        if (internal.consumed.has(candidate.index)) {
-            continue;
-        }
-        const normalized = normalizeTokenLower(candidate);
-        if (SITE_CONNECTORS.has(normalized)) {
-            continue;
-        }
-        if (isBodySiteHint(normalized, internal.customSiteHints)) {
-            return false;
-        }
-        if (EYE_SITE_TOKENS[normalized]) {
-            return false;
-        }
-        if (maps_1.DEFAULT_ROUTE_SYNONYMS[normalized]) {
-            return false;
-        }
-    }
-    return true;
-}
-function tryParseNumericCadence(internal, tokens, index) {
-    const token = tokens[index];
-    if (!/^[0-9]+(?:\.[0-9]+)?$/.test(token.lower)) {
-        return false;
-    }
-    if (internal.frequency !== undefined ||
-        internal.frequencyMax !== undefined ||
-        internal.period !== undefined ||
-        internal.periodMax !== undefined) {
-        return false;
-    }
-    let nextIndex = index + 1;
-    const connectors = [];
-    while (true) {
-        const connector = tokens[nextIndex];
-        if (!connector || internal.consumed.has(connector.index)) {
-            break;
-        }
-        const normalized = normalizeTokenLower(connector);
-        if (normalized === "per" || normalized === "a" || normalized === "each" || normalized === "every") {
-            connectors.push(connector);
-            nextIndex += 1;
-            continue;
-        }
-        break;
-    }
-    if (!connectors.length) {
-        return false;
-    }
-    const unitToken = tokens[nextIndex];
-    if (!unitToken || internal.consumed.has(unitToken.index)) {
-        return false;
-    }
-    const unitCode = mapIntervalUnit(normalizeTokenLower(unitToken));
-    if (!unitCode) {
-        return false;
-    }
-    const value = parseFloat(token.original);
-    if (!Number.isFinite(value)) {
-        return false;
-    }
-    internal.frequency = value;
-    internal.period = 1;
-    internal.periodUnit = unitCode;
-    if (value === 1 && unitCode === types_1.FhirPeriodUnit.Day && !internal.timingCode) {
-        internal.timingCode = "QD";
-    }
-    mark(internal.consumed, token);
-    for (const connector of connectors) {
-        mark(internal.consumed, connector);
-    }
-    mark(internal.consumed, unitToken);
-    return true;
-}
-function tryParseCountBasedFrequency(internal, tokens, index, options) {
-    const token = tokens[index];
-    if (internal.consumed.has(token.index)) {
-        return false;
-    }
-    if (internal.frequency !== undefined ||
-        internal.frequencyMax !== undefined ||
-        internal.period !== undefined ||
-        internal.periodMax !== undefined) {
-        return false;
-    }
-    const normalized = normalizeTokenLower(token);
-    let value;
-    let requiresPeriod = true;
-    let requiresCue = true;
-    if (/^[0-9]+(?:\.[0-9]+)?$/.test(normalized)) {
-        value = parseFloat(token.original);
-    }
-    else {
-        const simple = FREQUENCY_SIMPLE_WORDS[normalized];
-        if (simple !== undefined) {
-            value = simple;
-            requiresPeriod = false;
-            requiresCue = false;
-        }
-        else {
-            const wordValue = FREQUENCY_NUMBER_WORDS[normalized];
-            if (wordValue === undefined) {
-                return false;
-            }
-            value = wordValue;
-        }
-    }
-    if (!Number.isFinite(value) || value === undefined || value <= 0) {
-        return false;
-    }
-    const nextToken = tokens[index + 1];
-    if (nextToken &&
-        !internal.consumed.has(nextToken.index) &&
-        normalizeUnit(normalizeTokenLower(nextToken), options)) {
-        return false;
-    }
-    const partsToConsume = [];
-    let nextIndex = index + 1;
-    let periodUnit;
-    let sawCue = !requiresCue;
-    let sawTimesWord = false;
-    let sawConnectorWord = false;
-    while (true) {
-        const candidate = tokens[nextIndex];
-        if (!candidate || internal.consumed.has(candidate.index)) {
-            break;
-        }
-        const lower = normalizeTokenLower(candidate);
-        if (FREQUENCY_TIMES_WORDS.has(lower)) {
-            partsToConsume.push(candidate);
-            sawCue = true;
-            sawTimesWord = true;
-            nextIndex += 1;
-            continue;
-        }
-        if (FREQUENCY_CONNECTOR_WORDS.has(lower)) {
-            partsToConsume.push(candidate);
-            sawCue = true;
-            sawConnectorWord = true;
-            nextIndex += 1;
-            continue;
-        }
-        const adverbUnit = mapFrequencyAdverb(lower);
-        if (adverbUnit) {
-            periodUnit = adverbUnit;
-            partsToConsume.push(candidate);
-            break;
-        }
-        const mappedUnit = mapIntervalUnit(lower);
-        if (mappedUnit) {
-            periodUnit = mappedUnit;
-            partsToConsume.push(candidate);
-            break;
-        }
-        break;
-    }
-    if (!periodUnit) {
-        if (requiresPeriod) {
-            return false;
-        }
-        periodUnit = types_1.FhirPeriodUnit.Day;
-    }
-    if (requiresCue && !sawCue) {
-        return false;
-    }
-    internal.frequency = value;
-    internal.period = 1;
-    internal.periodUnit = periodUnit;
-    if (value === 1 && periodUnit === types_1.FhirPeriodUnit.Day && !internal.timingCode) {
-        internal.timingCode = "QD";
-    }
-    let consumeCurrentToken = true;
-    if (value === 1 && !sawConnectorWord && sawTimesWord && periodUnit !== types_1.FhirPeriodUnit.Day) {
-        consumeCurrentToken = false;
-    }
-    if (consumeCurrentToken) {
-        mark(internal.consumed, token);
-    }
-    for (const part of partsToConsume) {
-        mark(internal.consumed, part);
-    }
-    return consumeCurrentToken;
-}
-function parseTimeToFhir(timeStr) {
-    const clean = timeStr.toLowerCase().trim();
-    // Match 9:00, 9.00, 9:00am, 9pm, 9 am, 9
-    const match = clean.match(/^(\d{1,2})[:.](\d{2})\s*(am|pm)?$/) ||
-        clean.match(/^(\d{1,2})\s*(am|pm)$/) ||
-        clean.match(/^(\d{1,2})$/);
-    if (!match)
-        return undefined;
-    let hour = parseInt(match[1], 10);
-    let minute = 0;
-    let ampm;
-    if (match[2] && !isNaN(parseInt(match[2], 10))) {
-        minute = parseInt(match[2], 10);
-        ampm = match[3];
-    }
-    else {
-        ampm = match[2];
-    }
-    if (ampm === "pm" && hour < 12)
-        hour += 12;
-    if (ampm === "am" && hour === 12)
-        hour = 0;
-    if (hour < 0 || hour > 23 || minute < 0 || minute > 59)
-        return undefined;
-    const h = hour < 10 ? `0${hour}` : `${hour}`;
-    const m = minute < 10 ? `0${minute}` : `${minute}`;
-    return `${h}:${m}:00`;
-}
-function extractAttachedAtTimeToken(lower) {
-    if (lower.length <= 1) {
-        return undefined;
-    }
-    if (lower.charAt(0) === "@") {
-        const candidate = lower.slice(1);
-        return parseTimeToFhir(candidate) ? candidate : undefined;
-    }
-    if (lower.startsWith("at") && lower.length > 2 && /^\d/.test(lower.charAt(2))) {
-        const candidate = lower.slice(2);
-        return parseTimeToFhir(candidate) ? candidate : undefined;
-    }
-    return undefined;
-}
-function isAtPrefixToken(lower) {
-    return lower === "@" || lower === "at" || extractAttachedAtTimeToken(lower) !== undefined;
-}
-function tryParseTimeBasedSchedule(internal, tokens, index) {
-    const token = tokens[index];
-    if (internal.consumed.has(token.index))
-        return false;
-    const attachedAtTime = extractAttachedAtTimeToken(token.lower);
-    const isAtPrefix = isAtPrefixToken(token.lower);
-    if (!isAtPrefix && !/^\d/.test(token.lower))
-        return false;
-    let nextIndex = index;
-    const times = [];
-    const consumedIndices = [];
-    const timeTokens = [];
-    if (token.lower === "@" || token.lower === "at") {
-        consumedIndices.push(index);
-        nextIndex++;
-    }
-    else if (attachedAtTime) {
-        let timeStr = attachedAtTime;
-        const lookaheadIndices = [];
-        if (!timeStr.includes("am") && !timeStr.includes("pm")) {
-            const ampmToken = tokens[index + 1];
-            if (ampmToken &&
-                !internal.consumed.has(ampmToken.index) &&
-                (ampmToken.lower === "am" || ampmToken.lower === "pm")) {
-                timeStr += ampmToken.lower;
-                lookaheadIndices.push(index + 1);
-            }
-        }
-        const compactTime = parseTimeToFhir(timeStr);
-        if (!compactTime) {
-            return false;
-        }
-        times.push(compactTime);
-        timeTokens.push(timeStr);
-        consumedIndices.push(index);
-        for (const idx of lookaheadIndices) {
-            consumedIndices.push(idx);
-        }
-        nextIndex = index + 1 + lookaheadIndices.length;
-    }
-    while (nextIndex < tokens.length) {
-        const nextToken = tokens[nextIndex];
-        if (!nextToken || internal.consumed.has(nextToken.index))
-            break;
-        if ((nextToken.lower === "," || nextToken.lower === "and") && times.length > 0) {
-            const peekToken = tokens[nextIndex + 1];
-            if (peekToken && !internal.consumed.has(peekToken.index)) {
-                let peekStr = peekToken.lower;
-                const ampmToken = tokens[nextIndex + 2];
-                if (ampmToken &&
-                    !internal.consumed.has(ampmToken.index) &&
-                    (ampmToken.lower === "am" || ampmToken.lower === "pm")) {
-                    peekStr += ampmToken.lower;
-                }
-                if (parseTimeToFhir(peekStr)) {
-                    consumedIndices.push(nextIndex);
-                    nextIndex++;
-                    continue;
-                }
-            }
-        }
-        let timeStr = nextToken.lower;
-        let lookaheadIndices = [];
-        // Look ahead for am/pm if current token is just a number or doesn't have am/pm
-        if (!timeStr.includes("am") && !timeStr.includes("pm")) {
-            const nextNext = tokens[nextIndex + 1];
-            if (nextNext && !internal.consumed.has(nextNext.index) && (nextNext.lower === "am" || nextNext.lower === "pm")) {
-                timeStr += nextNext.lower;
-                lookaheadIndices.push(nextIndex + 1);
-            }
-        }
-        const time = parseTimeToFhir(timeStr);
-        if (time) {
-            times.push(time);
-            timeTokens.push(timeStr);
-            consumedIndices.push(nextIndex);
-            for (const idx of lookaheadIndices) {
-                consumedIndices.push(idx);
-            }
-            nextIndex += 1 + lookaheadIndices.length;
-            // Support comma or space separated times
-            const separatorToken = tokens[nextIndex];
-            // Check if there is another time after the separator
-            if (separatorToken && (separatorToken.lower === "," || separatorToken.lower === "and")) {
-                // Peek for next time
-                let peekIndex = nextIndex + 1;
-                let peekToken = tokens[peekIndex];
-                if (peekToken) {
-                    let peekStr = peekToken.lower;
-                    let peekNext = tokens[peekIndex + 1];
-                    if (peekNext && !internal.consumed.has(peekNext.index) && (peekNext.lower === "am" || peekNext.lower === "pm")) {
-                        peekStr += peekNext.lower;
-                    }
-                    if (parseTimeToFhir(peekStr)) {
-                        consumedIndices.push(nextIndex);
-                        nextIndex++;
-                        continue;
-                    }
-                }
-            }
-            continue;
-        }
-        break;
-    }
-    if (times.length > 0) {
-        if (!isAtPrefix) {
-            const hasClearTimeFormat = timeTokens.some((t) => t.includes(":") || t.includes("am") || t.includes("pm"));
-            if (!hasClearTimeFormat) {
-                return false;
-            }
-        }
-        internal.timeOfDay = internal.timeOfDay || [];
-        for (const time of times) {
-            if (!(0, array_1.arrayIncludes)(internal.timeOfDay, time)) {
-                internal.timeOfDay.push(time);
-            }
-        }
-        for (const idx of consumedIndices) {
-            mark(internal.consumed, tokens[idx]);
-        }
-        return true;
-    }
-    return false;
-}
-const SITE_UNIT_ROUTE_HINTS = [
-    { pattern: /\beye(s)?\b/i, route: types_1.RouteCode["Ophthalmic route"] },
-    { pattern: /\beyelid(s)?\b/i, route: types_1.RouteCode["Ophthalmic route"] },
-    { pattern: /\bintravitreal\b/i, route: types_1.RouteCode["Intravitreal route (qualifier value)"] },
-    { pattern: /\bear(s)?\b/i, route: types_1.RouteCode["Otic route"] },
-    { pattern: /\bnostril(s)?\b/i, route: types_1.RouteCode["Nasal route"] },
-    { pattern: /\bnares?\b/i, route: types_1.RouteCode["Nasal route"] },
-    { pattern: /\bnose\b/i, route: types_1.RouteCode["Nasal route"] },
-    { pattern: /\bmouth\b/i, route: types_1.RouteCode["Oral route"] },
-    { pattern: /\boral\b/i, route: types_1.RouteCode["Oral route"] },
-    { pattern: /\bunder (the )?tongue\b/i, route: types_1.RouteCode["Sublingual route"] },
-    { pattern: /\btongue\b/i, route: types_1.RouteCode["Sublingual route"] },
-    { pattern: /\bcheek(s)?\b/i, route: types_1.RouteCode["Buccal route"] },
-    { pattern: /\blung(s)?\b/i, route: types_1.RouteCode["Respiratory tract route (qualifier value)"] },
-    { pattern: /\brespiratory tract\b/i, route: types_1.RouteCode["Respiratory tract route (qualifier value)"] },
-    { pattern: /\bskin\b/i, route: types_1.RouteCode["Topical route"] },
-    { pattern: /\bscalp\b/i, route: types_1.RouteCode["Topical route"] },
-    { pattern: /\bface\b/i, route: types_1.RouteCode["Topical route"] },
-    { pattern: /\bhand(s)?\b/i, route: types_1.RouteCode["Topical route"] },
-    { pattern: /(\bfoot\b|\bfeet\b)/i, route: types_1.RouteCode["Topical route"] },
-    { pattern: /\belbow(s)?\b/i, route: types_1.RouteCode["Topical route"] },
-    { pattern: /\bknee(s)?\b/i, route: types_1.RouteCode["Topical route"] },
-    { pattern: /\bleg(s)?\b/i, route: types_1.RouteCode["Topical route"] },
-    { pattern: /\barm(s)?\b/i, route: types_1.RouteCode["Topical route"] },
-    { pattern: /\bpatch(es)?\b/i, route: types_1.RouteCode["Transdermal route"] },
-    { pattern: /\babdomen\b/i, route: types_1.RouteCode["Subcutaneous route"] },
-    { pattern: /\bbelly\b/i, route: types_1.RouteCode["Subcutaneous route"] },
-    { pattern: /\bstomach\b/i, route: types_1.RouteCode["Subcutaneous route"] },
-    { pattern: /\bthigh(s)?\b/i, route: types_1.RouteCode["Subcutaneous route"] },
-    { pattern: /\bupper arm\b/i, route: types_1.RouteCode["Subcutaneous route"] },
-    { pattern: /\bbuttock(s)?\b/i, route: types_1.RouteCode["Intramuscular route"] },
-    { pattern: /\bglute(al)?\b/i, route: types_1.RouteCode["Intramuscular route"] },
-    { pattern: /\bdeltoid\b/i, route: types_1.RouteCode["Intramuscular route"] },
-    { pattern: /\bmuscle(s)?\b/i, route: types_1.RouteCode["Intramuscular route"] },
-    { pattern: /\bvein(s)?\b/i, route: types_1.RouteCode["Intravenous route"] },
-    { pattern: /\brectum\b/i, route: types_1.RouteCode["Per rectum"] },
-    { pattern: /\banus\b/i, route: types_1.RouteCode["Per rectum"] },
-    { pattern: /\brectal\b/i, route: types_1.RouteCode["Per rectum"] },
-    { pattern: /\bvagina\b/i, route: types_1.RouteCode["Per vagina"] },
-    { pattern: /\bvaginal\b/i, route: types_1.RouteCode["Per vagina"] }
-];
-function tokenize(input) {
-    const separators = /[(),;]/g;
-    let normalized = input.trim().replace(separators, " ");
-    normalized = normalized.replace(DAY_RANGE_SPACED_HYPHEN_REGEX, (_match, prefix, start, end) => `${prefix}${start}-${end}`);
-    normalized = normalized.replace(/\s-\s/g, " ; ");
-    normalized = normalized.replace(/(\d+(?:\.\d+)?)\s*\/\s*(d|day|days|wk|w|week|weeks|mo|month|months|hr|hrs|hour|hours|h|min|mins|minute|minutes)\b/gi, (_match, value, unit) => `${value} per ${unit}`);
-    normalized = normalized.replace(/(\d+)\s*\/\s*(\d+)/g, (match, num, den) => {
-        const numerator = parseFloat(num);
-        const denominator = parseFloat(den);
-        if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator === 0) {
-            return match;
-        }
-        const value = numerator / denominator;
-        return value.toString();
-    });
-    normalized = normalized.replace(/(\d+(?:\.\d+)?[x*])([A-Za-z]+)/g, "$1 $2");
-    normalized = normalized.replace(/(\d+(?:\.\d+)?)\s*-\s*(\d+(?:\.\d+)?)/g, "$1-$2");
-    normalized = normalized.replace(/(\d+(?:\.\d+)?)(tab|tabs|tablet|tablets|cap|caps|capsule|capsules|mg|mcg|ml|g|drops|drop|puff|puffs|spray|sprays|patch|patches)/gi, "$1 $2");
-    normalized = normalized.replace(/[\\/]/g, " ");
-    const rawTokens = normalized
-        .split(/\s+/)
-        .map((t) => t.trim())
-        .filter((t) => t.length > 0 && t !== "." && t !== "-");
-    const tokens = [];
-    for (let i = 0; i < rawTokens.length; i++) {
-        const raw = rawTokens[i];
-        const parts = splitToken(raw);
-        for (const part of parts) {
-            if (!part)
-                continue;
-            tokens.push({ original: part, lower: part.toLowerCase(), index: tokens.length });
-        }
-    }
-    return tokens;
-}
-/**
- * Locates the span of the detected site tokens within the caller's original
- * input so downstream consumers can highlight or replace the exact substring.
- */
-function computeTokenRange(input, tokens, indices) {
-    if (!indices.length) {
-        return undefined;
-    }
-    const lowerInput = input.toLowerCase();
-    let searchStart = 0;
-    let rangeStart;
-    let rangeEnd;
-    for (const tokenIndex of indices) {
-        const token = tokens[tokenIndex];
-        if (!token) {
-            continue;
-        }
-        const segment = token.original.trim();
-        if (!segment) {
-            continue;
-        }
-        const lowerSegment = segment.toLowerCase();
-        const foundIndex = lowerInput.indexOf(lowerSegment, searchStart);
-        if (foundIndex === -1) {
-            return undefined;
-        }
-        const segmentEnd = foundIndex + lowerSegment.length;
-        if (rangeStart === undefined) {
-            rangeStart = foundIndex;
-        }
-        rangeEnd = segmentEnd;
-        searchStart = segmentEnd;
-    }
-    if (rangeStart === undefined || rangeEnd === undefined) {
-        return undefined;
-    }
-    return { start: rangeStart, end: rangeEnd };
-}
-/**
- * Prefers highlighting the sanitized site text when it can be located directly
- * in the original input; otherwise falls back to the broader token-derived
- * range.
- */
-function refineSiteRange(input, sanitized, tokenRange) {
-    if (!input) {
-        return tokenRange;
-    }
-    const trimmed = sanitized.trim();
-    if (!trimmed) {
-        return tokenRange;
-    }
-    const lowerInput = input.toLowerCase();
-    const lowerSanitized = trimmed.toLowerCase();
-    let startIndex = tokenRange ? lowerInput.indexOf(lowerSanitized, tokenRange.start) : -1;
-    if (startIndex === -1) {
-        startIndex = lowerInput.indexOf(lowerSanitized);
-    }
-    if (startIndex === -1) {
-        return tokenRange;
-    }
-    return { start: startIndex, end: startIndex + lowerSanitized.length };
-}
-function findUnparsedTokenGroups(internal) {
-    const leftoverTokens = internal.tokens
-        .filter((token) => !internal.consumed.has(token.index))
-        .sort((a, b) => a.index - b.index);
-    if (leftoverTokens.length === 0) {
-        return [];
-    }
-    const groups = [];
-    let currentGroup = [];
-    let previousIndex;
-    let minimumStart = 0;
-    const locateRange = (tokensToLocate, initial) => {
-        const lowerInput = internal.input.toLowerCase();
-        let searchStart = minimumStart;
-        let rangeStart;
-        let rangeEnd;
-        for (const token of tokensToLocate) {
-            const segment = token.original.trim();
-            if (!segment) {
-                continue;
-            }
-            const lowerSegment = segment.toLowerCase();
-            const foundIndex = lowerInput.indexOf(lowerSegment, searchStart);
-            if (foundIndex === -1) {
-                return initial;
-            }
-            if (rangeStart === undefined) {
-                rangeStart = foundIndex;
-            }
-            const segmentEnd = foundIndex + lowerSegment.length;
-            rangeEnd = rangeEnd === undefined ? segmentEnd : Math.max(rangeEnd, segmentEnd);
-            searchStart = segmentEnd;
-        }
-        if (rangeStart === undefined || rangeEnd === undefined) {
-            return initial;
-        }
-        return { start: rangeStart, end: rangeEnd };
-    };
-    const flush = () => {
-        if (!currentGroup.length) {
-            return;
-        }
-        const indices = currentGroup.map((token) => token.index);
-        const initialRange = computeTokenRange(internal.input, internal.tokens, indices);
-        const range = locateRange(currentGroup, initialRange);
-        groups.push({ tokens: currentGroup, range });
-        if (range) {
-            minimumStart = Math.max(minimumStart, range.end);
-        }
-        currentGroup = [];
-        previousIndex = undefined;
-    };
-    for (const token of leftoverTokens) {
-        if (previousIndex !== undefined && token.index !== previousIndex + 1) {
-            flush();
-        }
-        currentGroup.push(token);
-        previousIndex = token.index;
-    }
-    flush();
-    return groups;
-}
-function splitToken(token) {
-    if (/^[0-9]+(?:\.[0-9]+)?$/.test(token)) {
-        return [token];
-    }
-    const compactPoMeal = token.match(/^(po)(ac|pc|c)$/i);
-    if (compactPoMeal) {
-        const [, po, meal] = compactPoMeal;
-        return [po, meal];
-    }
-    if (/^[A-Za-z]+$/.test(token)) {
-        return [token];
-    }
-    const qRange = token.match(/^q([0-9]+(?:\.[0-9]+)?)-([0-9]+(?:\.[0-9]+)?)([A-Za-z]+)$/i);
-    if (qRange) {
-        const [, low, high, unit] = qRange;
-        return [token.charAt(0), `${low}-${high}`, unit];
-    }
-    const match = token.match(/^([0-9]+(?:\.[0-9]+)?)([A-Za-z]+)$/);
-    if (match) {
-        const [, num, unit] = match;
-        const compactPoMealUnit = unit.match(/^(po)(ac|pc|c)$/i);
-        if (compactPoMealUnit) {
-            const [, po, meal] = compactPoMealUnit;
-            return [num, po, meal];
-        }
-        if (!/^x\d+/i.test(unit) && !/^q\d+/i.test(unit)) {
-            return [num, unit];
-        }
-    }
-    return [token];
-}
-function mark(consumed, token) {
-    consumed.add(token.index);
-}
-function addWhen(target, code) {
-    if (!(0, array_1.arrayIncludes)(target, code)) {
-        target.push(code);
-    }
-}
-// Removing is slightly more work than adding because a clinician might repeat
-// the same token; trimming them all keeps downstream assertions tidy.
-function removeWhen(target, code) {
-    let index = target.indexOf(code);
-    while (index !== -1) {
-        target.splice(index, 1);
-        index = target.indexOf(code);
-    }
-}
-const DEFAULT_EVENT_TIMING_WEIGHTS = {
-    [types_1.EventTiming.Immediate]: 0,
-    [types_1.EventTiming.Wake]: 6 * 3600,
-    [types_1.EventTiming["After Sleep"]]: 6 * 3600 + 15 * 60,
-    [types_1.EventTiming["Early Morning"]]: 7 * 3600,
-    [types_1.EventTiming["Before Meal"]]: 7 * 3600 + 30 * 60,
-    [types_1.EventTiming["Before Breakfast"]]: 7 * 3600 + 45 * 60,
-    [types_1.EventTiming.Morning]: 8 * 3600,
-    [types_1.EventTiming.Breakfast]: 8 * 3600 + 15 * 60,
-    [types_1.EventTiming.Meal]: 8 * 3600 + 30 * 60,
-    [types_1.EventTiming["After Breakfast"]]: 9 * 3600,
-    [types_1.EventTiming["After Meal"]]: 9 * 3600 + 15 * 60,
-    [types_1.EventTiming["Late Morning"]]: 10 * 3600 + 30 * 60,
-    [types_1.EventTiming["Before Lunch"]]: 11 * 3600 + 45 * 60,
-    [types_1.EventTiming.Noon]: 12 * 3600,
-    [types_1.EventTiming.Lunch]: 12 * 3600 + 15 * 60,
-    [types_1.EventTiming["After Lunch"]]: 12 * 3600 + 45 * 60,
-    [types_1.EventTiming["Early Afternoon"]]: 13 * 3600 + 30 * 60,
-    [types_1.EventTiming.Afternoon]: 15 * 3600,
-    [types_1.EventTiming["Late Afternoon"]]: 16 * 3600 + 30 * 60,
-    [types_1.EventTiming["Before Dinner"]]: 17 * 3600 + 30 * 60,
-    [types_1.EventTiming.Dinner]: 18 * 3600,
-    [types_1.EventTiming["After Dinner"]]: 19 * 3600,
-    [types_1.EventTiming["Early Evening"]]: 19 * 3600 + 30 * 60,
-    [types_1.EventTiming.Evening]: 20 * 3600,
-    [types_1.EventTiming["Late Evening"]]: 21 * 3600,
-    [types_1.EventTiming.Night]: 22 * 3600,
-    [types_1.EventTiming["Before Sleep"]]: 22 * 3600 + 30 * 60,
-};
-function parseClockToSeconds(clock) {
-    const match = clock.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/);
-    if (!match) {
-        return undefined;
-    }
-    const hour = Number(match[1]);
-    const minute = Number(match[2]);
-    const second = match[3] ? Number(match[3]) : 0;
-    if (!Number.isFinite(hour) ||
-        !Number.isFinite(minute) ||
-        !Number.isFinite(second) ||
-        hour < 0 ||
-        hour > 23 ||
-        minute < 0 ||
-        minute > 59 ||
-        second < 0 ||
-        second > 59) {
-        return undefined;
-    }
-    return hour * 3600 + minute * 60 + second;
-}
-function computeWhenWeight(code, options) {
-    var _a, _b;
-    const clock = (_a = options === null || options === void 0 ? void 0 : options.eventClock) === null || _a === void 0 ? void 0 : _a[code];
-    if (clock) {
-        const seconds = parseClockToSeconds(clock);
-        if (seconds !== undefined) {
-            return seconds;
-        }
-    }
-    return (_b = DEFAULT_EVENT_TIMING_WEIGHTS[code]) !== null && _b !== void 0 ? _b : 10000;
-}
-function sortWhenValues(internal, options) {
-    if (internal.when.length < 2) {
-        return;
-    }
-    const weighted = internal.when.map((code, index) => ({
-        code,
-        weight: computeWhenWeight(code, options),
-        index,
-    }));
-    weighted.sort((a, b) => {
-        if (a.weight !== b.weight) {
-            return a.weight - b.weight;
-        }
-        return a.index - b.index;
-    });
-    internal.when.splice(0, internal.when.length, ...weighted.map((entry) => entry.code));
-}
-// Translate the requested expansion context into the appropriate sequence of
-// EventTiming values (e.g., AC -> ACM/ACD/ACV) for the detected frequency.
-function computeMealExpansions(base, frequency, pairPreference) {
-    if (frequency < 1 || frequency > 4) {
-        return undefined;
-    }
-    const bedtime = types_1.EventTiming["Before Sleep"];
-    const beforePair = pairPreference === "breakfast+lunch"
-        ? [types_1.EventTiming["Before Breakfast"], types_1.EventTiming["Before Lunch"]]
-        : [types_1.EventTiming["Before Breakfast"], types_1.EventTiming["Before Dinner"]];
-    const afterPair = pairPreference === "breakfast+lunch"
-        ? [types_1.EventTiming["After Breakfast"], types_1.EventTiming["After Lunch"]]
-        : [types_1.EventTiming["After Breakfast"], types_1.EventTiming["After Dinner"]];
-    const withPair = pairPreference === "breakfast+lunch"
-        ? [types_1.EventTiming.Breakfast, types_1.EventTiming.Lunch]
-        : [types_1.EventTiming.Breakfast, types_1.EventTiming.Dinner];
-    if (base === "before") {
-        if (frequency === 1)
-            return [types_1.EventTiming["Before Breakfast"]];
-        if (frequency === 2)
-            return beforePair;
-        if (frequency === 3) {
-            return [
-                types_1.EventTiming["Before Breakfast"],
-                types_1.EventTiming["Before Lunch"],
-                types_1.EventTiming["Before Dinner"]
-            ];
-        }
-        return [
-            types_1.EventTiming["Before Breakfast"],
-            types_1.EventTiming["Before Lunch"],
-            types_1.EventTiming["Before Dinner"],
-            bedtime
-        ];
-    }
-    if (base === "after") {
-        if (frequency === 1)
-            return [types_1.EventTiming["After Breakfast"]];
-        if (frequency === 2)
-            return afterPair;
-        if (frequency === 3) {
-            return [
-                types_1.EventTiming["After Breakfast"],
-                types_1.EventTiming["After Lunch"],
-                types_1.EventTiming["After Dinner"]
-            ];
-        }
-        return [
-            types_1.EventTiming["After Breakfast"],
-            types_1.EventTiming["After Lunch"],
-            types_1.EventTiming["After Dinner"],
-            bedtime
-        ];
-    }
-    // base === "with"
-    if (frequency === 1)
-        return [types_1.EventTiming.Breakfast];
-    if (frequency === 2)
-        return withPair;
-    if (frequency === 3) {
-        return [types_1.EventTiming.Breakfast, types_1.EventTiming.Lunch, types_1.EventTiming.Dinner];
-    }
-    return [types_1.EventTiming.Breakfast, types_1.EventTiming.Lunch, types_1.EventTiming.Dinner, bedtime];
-}
-function reconcileMealTimingSpecificity(internal) {
-    if (!internal.when.length) {
-        return;
-    }
-    const convertSpecifics = (base, mappings) => {
-        if (!(0, array_1.arrayIncludes)(internal.when, base)) {
-            return;
-        }
-        let replaced = false;
-        for (const [general, specific] of mappings) {
-            if ((0, array_1.arrayIncludes)(internal.when, general)) {
-                removeWhen(internal.when, general);
-                addWhen(internal.when, specific);
-                replaced = true;
-            }
-        }
-        if (replaced) {
-            removeWhen(internal.when, base);
-        }
-    };
-    convertSpecifics(types_1.EventTiming["Before Meal"], [
-        [types_1.EventTiming.Breakfast, types_1.EventTiming["Before Breakfast"]],
-        [types_1.EventTiming.Lunch, types_1.EventTiming["Before Lunch"]],
-        [types_1.EventTiming.Dinner, types_1.EventTiming["Before Dinner"]],
-    ]);
-    convertSpecifics(types_1.EventTiming["After Meal"], [
-        [types_1.EventTiming.Breakfast, types_1.EventTiming["After Breakfast"]],
-        [types_1.EventTiming.Lunch, types_1.EventTiming["After Lunch"]],
-        [types_1.EventTiming.Dinner, types_1.EventTiming["After Dinner"]],
-    ]);
-}
-// Optionally replace generic meal tokens with concrete breakfast/lunch/dinner
-// EventTiming codes when the cadence or explicit meal abbreviations make the
-// intent obvious.
-function expandMealTimings(internal, options) {
-    var _a, _b, _c;
-    const allowSmartExpansion = (options === null || options === void 0 ? void 0 : options.smartMealExpansion) === true;
-    if (!allowSmartExpansion) {
-        return;
-    }
-    if (internal.when.some((code) => SPECIFIC_MEAL_TIMINGS.has(code))) {
-        return;
-    }
-    const frequency = internal.frequency;
-    if (!frequency || frequency < 1 || frequency > 4) {
-        return;
-    }
-    const needsDefaultExpansion = internal.when.length === 0 && frequency >= 2;
-    const hasBeforeMeal = (0, array_1.arrayIncludes)(internal.when, types_1.EventTiming["Before Meal"]);
-    const hasAfterMeal = (0, array_1.arrayIncludes)(internal.when, types_1.EventTiming["After Meal"]);
-    const hasWithMeal = (0, array_1.arrayIncludes)(internal.when, types_1.EventTiming.Meal);
-    const hasGeneralMealToken = hasBeforeMeal || hasAfterMeal || hasWithMeal;
-    if (!hasGeneralMealToken && !needsDefaultExpansion) {
-        return;
-    }
-    if (internal.period !== undefined &&
-        internal.periodUnit !== undefined &&
-        (internal.periodUnit !== types_1.FhirPeriodUnit.Day || internal.period !== 1)) {
-        return;
-    }
-    if (internal.period !== undefined &&
-        internal.periodUnit === undefined &&
-        internal.period !== 1) {
-        return;
-    }
-    if (internal.periodUnit && internal.periodUnit !== types_1.FhirPeriodUnit.Day) {
-        return;
-    }
-    if (internal.frequencyMax !== undefined || internal.periodMax !== undefined) {
-        return;
-    }
-    const pairPreference = (_a = options === null || options === void 0 ? void 0 : options.twoPerDayPair) !== null && _a !== void 0 ? _a : "breakfast+dinner";
-    const replacements = [];
-    const addReplacement = (general, base, removeGeneral) => {
-        const specifics = computeMealExpansions(base, frequency, pairPreference);
-        if (specifics) {
-            replacements.push({ general, specifics, removeGeneral });
-        }
-    };
-    if (hasBeforeMeal) {
-        addReplacement(types_1.EventTiming["Before Meal"], "before", true);
-    }
-    if (hasAfterMeal) {
-        addReplacement(types_1.EventTiming["After Meal"], "after", true);
-    }
-    if (hasWithMeal) {
-        addReplacement(types_1.EventTiming.Meal, "with", true);
-    }
-    if (needsDefaultExpansion) {
-        const relation = (_c = (_b = options === null || options === void 0 ? void 0 : options.context) === null || _b === void 0 ? void 0 : _b.mealRelation) !== null && _c !== void 0 ? _c : types_1.EventTiming.Meal;
-        const base = relation === types_1.EventTiming["Before Meal"]
-            ? "before"
-            : relation === types_1.EventTiming["After Meal"]
-                ? "after"
-                : "with";
-        addReplacement(relation, base, false);
-    }
-    for (const { general, specifics, removeGeneral } of replacements) {
-        if (removeGeneral) {
-            removeWhen(internal.when, general);
-        }
-        for (const specific of specifics) {
-            addWhen(internal.when, specific);
-        }
-    }
-}
-function setRoute(internal, code, text) {
-    internal.routeCode = code;
-    internal.routeText = text !== null && text !== void 0 ? text : maps_1.ROUTE_TEXT[code];
-}
-/**
- * Convert hour-based values into minutes when fractional quantities appear so
- * the resulting FHIR repeat payloads avoid unwieldy decimals.
- */
-function normalizePeriodValue(value, unit) {
-    if (unit === types_1.FhirPeriodUnit.Hour && (!Number.isInteger(value) || value < 1)) {
-        return { value: Math.round(value * 60 * 1000) / 1000, unit: types_1.FhirPeriodUnit.Minute };
-    }
-    return { value, unit };
-}
-/**
- * Ensure ranges expressed in hours remain consistent when fractional values
- * demand conversion into minutes.
- */
-function normalizePeriodRange(low, high, unit) {
-    if (unit === types_1.FhirPeriodUnit.Hour && (!Number.isInteger(low) || !Number.isInteger(high) || low < 1 || high < 1)) {
-        return {
-            low: Math.round(low * 60 * 1000) / 1000,
-            high: Math.round(high * 60 * 1000) / 1000,
-            unit: types_1.FhirPeriodUnit.Minute
-        };
-    }
-    return { low, high, unit };
-}
-function periodUnitSuffix(unit) {
-    switch (unit) {
-        case types_1.FhirPeriodUnit.Minute:
-            return "min";
-        case types_1.FhirPeriodUnit.Hour:
-            return "h";
-        case types_1.FhirPeriodUnit.Day:
-            return "d";
-        case types_1.FhirPeriodUnit.Week:
-            return "wk";
-        case types_1.FhirPeriodUnit.Month:
-            return "mo";
-        case types_1.FhirPeriodUnit.Year:
-            return "a";
-        default:
-            return undefined;
-    }
-}
-function maybeAssignTimingCode(internal, value, unit) {
-    const suffix = periodUnitSuffix(unit);
-    if (!suffix) {
-        return;
-    }
-    const key = `q${value}${suffix}`;
-    const descriptor = maps_1.TIMING_ABBREVIATIONS[key];
-    if ((descriptor === null || descriptor === void 0 ? void 0 : descriptor.code) && !internal.timingCode) {
-        internal.timingCode = descriptor.code;
-    }
-}
-/**
- * Apply the chosen period/unit pair and infer helpful timing codes when the
- * period clearly represents common cadences (daily/weekly/monthly).
- */
-function applyPeriod(internal, period, unit) {
-    var _a, _b, _c;
-    const normalized = normalizePeriodValue(period, unit);
-    internal.period = normalized.value;
-    internal.periodUnit = normalized.unit;
-    maybeAssignTimingCode(internal, normalized.value, normalized.unit);
-    if (normalized.unit === types_1.FhirPeriodUnit.Day && normalized.value === 1) {
-        internal.frequency = (_a = internal.frequency) !== null && _a !== void 0 ? _a : 1;
-    }
-    if (normalized.unit === types_1.FhirPeriodUnit.Week && normalized.value === 1) {
-        internal.timingCode = (_b = internal.timingCode) !== null && _b !== void 0 ? _b : "WK";
-    }
-    if (normalized.unit === types_1.FhirPeriodUnit.Month && normalized.value === 1) {
-        internal.timingCode = (_c = internal.timingCode) !== null && _c !== void 0 ? _c : "MO";
-    }
-}
-/**
- * Parse compact q-interval tokens like q30min, q0.5h, or q1w, optionally using
- * the following token as the unit if the compact token only carries the value.
- */
-function tryParseCompactQ(internal, tokens, index) {
-    const token = tokens[index];
-    const lower = token.lower;
-    const compact = lower.match(/^q([0-9]+(?:\.[0-9]+)?)([a-z]+)$/);
-    if (compact) {
-        const value = parseFloat(compact[1]);
-        const unitCode = mapIntervalUnit(compact[2]);
-        if (Number.isFinite(value) && unitCode) {
-            applyPeriod(internal, value, unitCode);
-            mark(internal.consumed, token);
-            return true;
-        }
-    }
-    const valueOnly = lower.match(/^q([0-9]+(?:\.[0-9]+)?)$/);
-    if (valueOnly) {
-        const unitToken = tokens[index + 1];
-        if (!unitToken || internal.consumed.has(unitToken.index)) {
-            return false;
-        }
-        const unitCode = mapIntervalUnit(unitToken.lower);
-        if (!unitCode) {
-            return false;
-        }
-        const value = parseFloat(valueOnly[1]);
-        if (!Number.isFinite(value)) {
-            return false;
-        }
-        applyPeriod(internal, value, unitCode);
-        mark(internal.consumed, token);
-        mark(internal.consumed, unitToken);
-        return true;
-    }
-    return false;
-}
-function applyFrequencyDescriptor(internal, token, descriptor, options) {
-    if (descriptor.discouraged) {
-        const check = (0, safety_1.checkDiscouraged)(token.original, options);
-        if (check.warning) {
-            internal.warnings.push(check.warning);
-        }
-    }
-    if (descriptor.code) {
-        internal.timingCode = descriptor.code;
-    }
-    if (descriptor.frequency !== undefined) {
-        internal.frequency = descriptor.frequency;
-    }
-    if (descriptor.frequencyMax !== undefined) {
-        internal.frequencyMax = descriptor.frequencyMax;
-    }
-    if (descriptor.period !== undefined) {
-        internal.period = descriptor.period;
-    }
-    if (descriptor.periodMax !== undefined) {
-        internal.periodMax = descriptor.periodMax;
-    }
-    if (descriptor.periodUnit) {
-        internal.periodUnit = descriptor.periodUnit;
-    }
-    if (descriptor.when) {
-        for (const w of descriptor.when) {
-            addWhen(internal.when, w);
-        }
-    }
-    mark(internal.consumed, token);
-}
-function applyWhenToken(internal, token, code) {
-    addWhen(internal.when, code);
-    mark(internal.consumed, token);
-}
-function isTimingAnchorOrPrefix(tokens, index, prnReasonStart) {
-    const token = tokens[index];
-    if (!token)
-        return false;
-    // Cautious handling of "sleep" in PRN zone
-    if (prnReasonStart !== undefined && index >= prnReasonStart && token.lower === "sleep") {
-        return false;
-    }
-    const lower = token.lower;
-    const nextToken = tokens[index + 1];
-    const comboKey = nextToken ? `${lower} ${nextToken.lower}` : undefined;
-    return Boolean(maps_1.EVENT_TIMING_TOKENS[lower] ||
-        maps_1.TIMING_ABBREVIATIONS[lower] ||
-        (comboKey && COMBO_EVENT_TIMINGS[comboKey]) ||
-        (lower === "pc" || lower === "ac" || lower === "after" || lower === "before") ||
-        (isAtPrefixToken(lower) || lower === "on" || lower === "with") ||
-        /^\d/.test(lower));
-}
-const DAY_SEQUENCE = [
-    types_1.FhirDayOfWeek.Monday,
-    types_1.FhirDayOfWeek.Tuesday,
-    types_1.FhirDayOfWeek.Wednesday,
-    types_1.FhirDayOfWeek.Thursday,
-    types_1.FhirDayOfWeek.Friday,
-    types_1.FhirDayOfWeek.Saturday,
-    types_1.FhirDayOfWeek.Sunday
-];
-const DAY_GROUP_TOKENS = {
-    weekend: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
-    weekends: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
-    wknd: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
-    weekdays: [
-        types_1.FhirDayOfWeek.Monday,
-        types_1.FhirDayOfWeek.Tuesday,
-        types_1.FhirDayOfWeek.Wednesday,
-        types_1.FhirDayOfWeek.Thursday,
-        types_1.FhirDayOfWeek.Friday
-    ],
-    weekday: [
-        types_1.FhirDayOfWeek.Monday,
-        types_1.FhirDayOfWeek.Tuesday,
-        types_1.FhirDayOfWeek.Wednesday,
-        types_1.FhirDayOfWeek.Thursday,
-        types_1.FhirDayOfWeek.Friday
-    ],
-    workday: [
-        types_1.FhirDayOfWeek.Monday,
-        types_1.FhirDayOfWeek.Tuesday,
-        types_1.FhirDayOfWeek.Wednesday,
-        types_1.FhirDayOfWeek.Thursday,
-        types_1.FhirDayOfWeek.Friday
-    ],
-    workdays: [
-        types_1.FhirDayOfWeek.Monday,
-        types_1.FhirDayOfWeek.Tuesday,
-        types_1.FhirDayOfWeek.Wednesday,
-        types_1.FhirDayOfWeek.Thursday,
-        types_1.FhirDayOfWeek.Friday
-    ],
-    วันธรรมดา: [
-        types_1.FhirDayOfWeek.Monday,
-        types_1.FhirDayOfWeek.Tuesday,
-        types_1.FhirDayOfWeek.Wednesday,
-        types_1.FhirDayOfWeek.Thursday,
-        types_1.FhirDayOfWeek.Friday
-    ],
-    วันทำงาน: [
-        types_1.FhirDayOfWeek.Monday,
-        types_1.FhirDayOfWeek.Tuesday,
-        types_1.FhirDayOfWeek.Wednesday,
-        types_1.FhirDayOfWeek.Thursday,
-        types_1.FhirDayOfWeek.Friday
-    ],
-    วันหยุด: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
-    สุดสัปดาห์: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
-    เสาร์อาทิตย์: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
-    จันทร์ถึงศุกร์: [
-        types_1.FhirDayOfWeek.Monday,
-        types_1.FhirDayOfWeek.Tuesday,
-        types_1.FhirDayOfWeek.Wednesday,
-        types_1.FhirDayOfWeek.Thursday,
-        types_1.FhirDayOfWeek.Friday
-    ]
-};
-const DAY_RANGE_CONNECTOR_TOKENS = new Set(["-", "to", "through", "thru", "ถึง", "จนถึง"]);
-function addDayOfWeek(internal, day) {
-    if (!(0, array_1.arrayIncludes)(internal.dayOfWeek, day)) {
-        internal.dayOfWeek.push(day);
-    }
-}
-function addDayOfWeekList(internal, days) {
-    for (const day of days) {
-        addDayOfWeek(internal, day);
-    }
-}
-function expandDayRange(start, end) {
-    const startIndex = DAY_SEQUENCE.indexOf(start);
-    const endIndex = DAY_SEQUENCE.indexOf(end);
-    if (startIndex < 0 || endIndex < 0) {
-        return [start, end];
-    }
-    if (startIndex <= endIndex) {
-        return DAY_SEQUENCE.slice(startIndex, endIndex + 1);
-    }
-    return [...DAY_SEQUENCE.slice(startIndex), ...DAY_SEQUENCE.slice(0, endIndex + 1)];
-}
-function resolveDayTokenDays(tokenLower) {
-    const normalized = tokenLower.replace(/[.,;:]/g, "");
-    const direct = maps_1.DAY_OF_WEEK_TOKENS[normalized];
-    if (direct) {
-        return [direct];
-    }
-    const grouped = DAY_GROUP_TOKENS[normalized];
-    if (grouped) {
-        return grouped.slice();
-    }
-    const rangeMatch = normalized.match(/^([^-–—~]+)[-–—~]([^-–—~]+)$/);
-    if (rangeMatch) {
-        const start = maps_1.DAY_OF_WEEK_TOKENS[rangeMatch[1]];
-        const end = maps_1.DAY_OF_WEEK_TOKENS[rangeMatch[2]];
-        if (start && end) {
-            return expandDayRange(start, end);
-        }
-    }
-    const compactConnectorRange = normalized.match(/^(.+?)(ถึง|จนถึง|to|through|thru)(.+)$/u);
-    if (compactConnectorRange) {
-        const start = maps_1.DAY_OF_WEEK_TOKENS[compactConnectorRange[1]];
-        const end = maps_1.DAY_OF_WEEK_TOKENS[compactConnectorRange[3]];
-        if (start && end) {
-            return expandDayRange(start, end);
-        }
-    }
-    return undefined;
-}
-function tryConsumeDayRangeTokens(internal, tokens, index) {
-    const startToken = tokens[index];
-    if (!startToken || internal.consumed.has(startToken.index)) {
-        return 0;
-    }
-    const startDays = resolveDayTokenDays(normalizeTokenLower(startToken));
-    if (!startDays || startDays.length !== 1) {
-        return 0;
-    }
-    const connectorToken = tokens[index + 1];
-    const endToken = tokens[index + 2];
-    if (!connectorToken ||
-        !endToken ||
-        internal.consumed.has(connectorToken.index) ||
-        internal.consumed.has(endToken.index)) {
-        return 0;
-    }
-    const connector = normalizeTokenLower(connectorToken);
-    if (!DAY_RANGE_CONNECTOR_TOKENS.has(connector)) {
-        return 0;
-    }
-    const endDays = resolveDayTokenDays(normalizeTokenLower(endToken));
-    if (!endDays || endDays.length !== 1) {
-        return 0;
-    }
-    const expanded = expandDayRange(startDays[0], endDays[0]);
-    addDayOfWeekList(internal, expanded);
-    mark(internal.consumed, startToken);
-    mark(internal.consumed, connectorToken);
-    mark(internal.consumed, endToken);
-    return 3;
-}
-function parseAnchorSequence(internal, tokens, index, prefixCode) {
-    var _a;
-    const token = tokens[index];
-    let converted = 0;
-    for (let lookahead = index + 1; lookahead < tokens.length; lookahead++) {
-        const nextToken = tokens[lookahead];
-        if (internal.consumed.has(nextToken.index)) {
-            continue;
-        }
-        const lower = normalizeTokenLower(nextToken);
-        if (MEAL_CONTEXT_CONNECTORS.has(lower) || lower === ",") {
-            mark(internal.consumed, nextToken);
-            continue;
-        }
-        const rangeConsumed = tryConsumeDayRangeTokens(internal, tokens, lookahead);
-        if (rangeConsumed > 0) {
-            converted++;
-            lookahead += rangeConsumed - 1;
-            continue;
-        }
-        const days = resolveDayTokenDays(lower);
-        if (days) {
-            addDayOfWeekList(internal, days);
-            mark(internal.consumed, nextToken);
-            converted++;
-            continue;
-        }
-        const meal = maps_1.MEAL_KEYWORDS[lower];
-        if (meal) {
-            const whenCode = prefixCode === types_1.EventTiming["After Meal"]
-                ? meal.pc
-                : prefixCode === types_1.EventTiming["Before Meal"]
-                    ? meal.ac
-                    : ((_a = maps_1.EVENT_TIMING_TOKENS[lower]) !== null && _a !== void 0 ? _a : meal.pc); // fallback to general or conservative default
-            addWhen(internal.when, whenCode);
-            mark(internal.consumed, nextToken);
-            converted++;
-            continue;
-        }
-        const whenCode = maps_1.EVENT_TIMING_TOKENS[lower];
-        if (whenCode) {
-            if (prefixCode && !meal) {
-                // if we have pc/ac, we only want to follow it with explicit meals
-                // to avoid over-consuming anchors that should be separate (like 'pc hs')
-                break;
-            }
-            addWhen(internal.when, whenCode);
-            mark(internal.consumed, nextToken);
-            converted++;
-            continue;
-        }
-        break;
-    }
-    if (converted > 0) {
-        mark(internal.consumed, token);
-        return true;
-    }
-    if (prefixCode) {
-        applyWhenToken(internal, token, prefixCode);
-        return true;
-    }
-    return false;
-}
-function parseSeparatedInterval(internal, tokens, index, options) {
-    const token = tokens[index];
-    const next = tokens[index + 1];
-    if (!next || internal.consumed.has(next.index)) {
-        return false;
-    }
-    const after = tokens[index + 2];
-    const lowerNext = next.lower;
-    const range = parseNumericRange(lowerNext);
-    if (range) {
-        const unitToken = after;
-        if (!unitToken) {
-            return false;
-        }
-        const unitCode = mapIntervalUnit(unitToken.lower);
-        if (!unitCode) {
-            return false;
-        }
-        const normalized = normalizePeriodRange(range.low, range.high, unitCode);
-        internal.period = normalized.low;
-        internal.periodMax = normalized.high;
-        internal.periodUnit = normalized.unit;
-        mark(internal.consumed, token);
-        mark(internal.consumed, next);
-        mark(internal.consumed, unitToken);
-        return true;
-    }
-    const isNumber = /^[0-9]+(?:\.[0-9]+)?$/.test(lowerNext);
-    if (!isNumber) {
-        const unitCode = mapIntervalUnit(lowerNext);
-        if (unitCode) {
-            mark(internal.consumed, token);
-            mark(internal.consumed, next);
-            applyPeriod(internal, 1, unitCode);
-            return true;
-        }
-        return false;
-    }
-    const unitToken = after;
-    if (!unitToken) {
-        return false;
-    }
-    const unitCode = mapIntervalUnit(unitToken.lower);
-    if (!unitCode) {
-        return false;
-    }
-    const value = parseFloat(next.original);
-    applyPeriod(internal, value, unitCode);
-    mark(internal.consumed, token);
-    mark(internal.consumed, next);
-    mark(internal.consumed, unitToken);
-    return true;
-}
-function mapIntervalUnit(token) {
-    if (token === "min" ||
-        token === "mins" ||
-        token === "minute" ||
-        token === "minutes" ||
-        token === "m") {
-        return types_1.FhirPeriodUnit.Minute;
-    }
-    if (token === "h" || token === "hr" || token === "hrs" || token === "hour" || token === "hours") {
-        return types_1.FhirPeriodUnit.Hour;
-    }
-    if (token === "d" || token === "day" || token === "days") {
-        return types_1.FhirPeriodUnit.Day;
-    }
-    if (token === "wk" || token === "w" || token === "week" || token === "weeks") {
-        return types_1.FhirPeriodUnit.Week;
-    }
-    if (token === "mo" || token === "month" || token === "months") {
-        return types_1.FhirPeriodUnit.Month;
-    }
-    return undefined;
-}
-function mapFrequencyAdverb(token) {
-    return FREQUENCY_ADVERB_UNITS[token];
-}
-function parseNumericRange(token) {
-    const rangeMatch = token.match(/^([0-9]+(?:\.[0-9]+)?)-([0-9]+(?:\.[0-9]+)?)$/);
-    if (!rangeMatch) {
-        return undefined;
-    }
-    const low = parseFloat(rangeMatch[1]);
-    const high = parseFloat(rangeMatch[2]);
-    if (!Number.isFinite(low) || !Number.isFinite(high)) {
-        return undefined;
-    }
-    return { low, high };
-}
-function applyCountLimit(internal, value) {
-    if (value === undefined || !Number.isFinite(value) || value <= 0) {
-        return false;
-    }
-    if (internal.count !== undefined) {
-        return false;
-    }
-    const rounded = Math.round(value);
-    if (rounded <= 0) {
-        return false;
-    }
-    internal.count = rounded;
-    return true;
-}
-const DOSE_SCALE_MULTIPLIERS = {
-    k: 1000,
-    thousand: 1000,
-    m: 1000000,
-    mn: 1000000,
-    mio: 1000000,
-    million: 1000000,
-    b: 1000000000,
-    bn: 1000000000,
-    billion: 1000000000
-};
-function resolveUnitTokenAt(tokens, index, consumed, options) {
-    const token = tokens[index];
-    if (!token || consumed.has(token.index)) {
-        return undefined;
-    }
-    const normalized = normalizeTokenLower(token);
-    const direct = normalizeUnit(normalized, options);
-    if (direct) {
-        return { unit: direct, consumedIndices: [index] };
-    }
-    if (normalized === "international") {
-        const nextToken = tokens[index + 1];
-        if (!nextToken || consumed.has(nextToken.index)) {
-            return undefined;
-        }
-        const nextNormalized = normalizeTokenLower(nextToken);
-        if (nextNormalized === "unit" ||
-            nextNormalized === "units" ||
-            nextNormalized === "u" ||
-            nextNormalized === "iu" ||
-            nextNormalized === "ius") {
-            return { unit: "IU", consumedIndices: [index, index + 1] };
-        }
-    }
-    return undefined;
-}
-function resolveNumericDoseUnit(tokens, numberIndex, value, consumed, options) {
-    const directUnit = resolveUnitTokenAt(tokens, numberIndex + 1, consumed, options);
-    if (directUnit) {
-        return {
-            doseValue: value,
-            unit: directUnit.unit,
-            consumedIndices: directUnit.consumedIndices
-        };
-    }
-    const scaleToken = tokens[numberIndex + 1];
-    if (!scaleToken || consumed.has(scaleToken.index)) {
-        return { doseValue: value, consumedIndices: [] };
-    }
-    const multiplier = DOSE_SCALE_MULTIPLIERS[normalizeTokenLower(scaleToken)];
-    if (!multiplier) {
-        return { doseValue: value, consumedIndices: [] };
-    }
-    const scaledUnit = resolveUnitTokenAt(tokens, numberIndex + 2, consumed, options);
-    if (!scaledUnit) {
-        return { doseValue: value, consumedIndices: [] };
-    }
-    return {
-        doseValue: value * multiplier,
-        unit: scaledUnit.unit,
-        consumedIndices: [numberIndex + 1, ...scaledUnit.consumedIndices]
-    };
-}
-function parseInternal(input, options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    const tokens = tokenize(input);
-    const internal = {
-        input,
-        tokens,
-        consumed: new Set(),
-        dayOfWeek: [],
-        when: [],
-        warnings: [],
-        siteTokenIndices: new Set(),
-        siteLookups: [],
-        customSiteHints: buildCustomSiteHints(options === null || options === void 0 ? void 0 : options.siteCodeMap),
-        prnReasonLookups: [],
-        additionalInstructions: []
-    };
-    const context = (_a = options === null || options === void 0 ? void 0 : options.context) !== null && _a !== void 0 ? _a : undefined;
-    const customRouteMap = (options === null || options === void 0 ? void 0 : options.routeMap)
-        ? new Map((0, object_1.objectEntries)(options.routeMap).map(([key, value]) => [
-            key.toLowerCase(),
-            value
-        ]))
-        : undefined;
-    const customRouteDescriptorMap = customRouteMap
-        ? new Map(Array.from(customRouteMap.entries())
-            .map(([key, value]) => [normalizeRouteDescriptorPhrase(key), value])
-            .filter(([normalized]) => normalized.length > 0))
-        : undefined;
-    if (tokens.length === 0) {
-        return internal;
-    }
-    // PRN detection
-    let prnReasonStart;
-    const prnSiteSuffixIndices = new Set();
-    for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
-        if (token.lower === "prn") {
-            internal.asNeeded = true;
-            mark(internal.consumed, token);
-            let reasonIndex = i + 1;
-            if (((_b = tokens[reasonIndex]) === null || _b === void 0 ? void 0 : _b.lower) === "for") {
-                mark(internal.consumed, tokens[reasonIndex]);
-                reasonIndex += 1;
-            }
-            prnReasonStart = reasonIndex;
-            break;
-        }
-        if (token.lower === "as" && ((_c = tokens[i + 1]) === null || _c === void 0 ? void 0 : _c.lower) === "needed") {
-            internal.asNeeded = true;
-            mark(internal.consumed, token);
-            mark(internal.consumed, tokens[i + 1]);
-            let reasonIndex = i + 2;
-            if (((_d = tokens[reasonIndex]) === null || _d === void 0 ? void 0 : _d.lower) === "for") {
-                mark(internal.consumed, tokens[reasonIndex]);
-                reasonIndex += 1;
-            }
-            prnReasonStart = reasonIndex;
-            break;
-        }
-    }
-    // Multiplicative tokens like 1x3
-    for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
-        if (internal.consumed.has(token.index))
-            continue;
-        const combined = token.lower.match(/^([0-9]+(?:\.[0-9]+)?)[x*]([0-9]+(?:\.[0-9]+)?)$/);
-        if (combined) {
-            const dose = parseFloat(combined[1]);
-            const freq = parseFloat(combined[2]);
-            if (internal.dose === undefined) {
-                internal.dose = dose;
-            }
-            internal.frequency = freq;
-            internal.period = 1;
-            internal.periodUnit = types_1.FhirPeriodUnit.Day;
-            mark(internal.consumed, token);
-            continue;
-        }
-        const hasNumericDoseBefore = () => {
-            for (let j = i - 1; j >= 0; j--) {
-                const prev = tokens[j];
-                if (!prev) {
-                    continue;
-                }
-                if (internal.consumed.has(prev.index)) {
-                    continue;
-                }
-                if (/^[0-9]+(?:\.[0-9]+)?$/.test(prev.lower)) {
-                    return true;
-                }
-                if (normalizeUnit(prev.lower, options)) {
-                    continue;
-                }
-                break;
-            }
-            return false;
-        };
-        if (internal.frequency === undefined && hasNumericDoseBefore()) {
-            const prefix = token.lower.match(/^[x*]([0-9]+(?:\.[0-9]+)?)$/);
-            if (prefix) {
-                const freq = parseFloat(prefix[1]);
-                if (Number.isFinite(freq)) {
-                    internal.frequency = freq;
-                    internal.period = 1;
-                    internal.periodUnit = types_1.FhirPeriodUnit.Day;
-                    mark(internal.consumed, token);
-                    continue;
-                }
-            }
-            if (token.lower === "x" || token.lower === "*") {
-                const next = tokens[i + 1];
-                if (next &&
-                    !internal.consumed.has(next.index) &&
-                    /^[0-9]+(?:\.[0-9]+)?$/.test(next.lower)) {
-                    const freq = parseFloat(next.original);
-                    if (Number.isFinite(freq)) {
-                        internal.frequency = freq;
-                        internal.period = 1;
-                        internal.periodUnit = types_1.FhirPeriodUnit.Day;
-                        mark(internal.consumed, token);
-                        mark(internal.consumed, next);
-                        continue;
-                    }
-                }
-            }
-        }
-    }
-    const applyRouteDescriptor = (code, text) => {
-        if (internal.routeCode && internal.routeCode !== code) {
-            return false;
-        }
-        setRoute(internal, code, text);
-        return true;
-    };
-    const maybeApplyRouteDescriptor = (phrase) => {
-        if (!phrase) {
-            return false;
-        }
-        const normalized = phrase.trim().toLowerCase();
-        if (!normalized) {
-            return false;
-        }
-        const customCode = customRouteMap === null || customRouteMap === void 0 ? void 0 : customRouteMap.get(normalized);
-        if (customCode) {
-            if (applyRouteDescriptor(customCode)) {
-                return true;
-            }
-        }
-        const synonym = maps_1.DEFAULT_ROUTE_SYNONYMS[normalized];
-        if (synonym) {
-            if (applyRouteDescriptor(synonym.code, synonym.text)) {
-                return true;
-            }
-        }
-        const normalizedDescriptor = normalizeRouteDescriptorPhrase(normalized);
-        if (normalizedDescriptor && normalizedDescriptor !== normalized) {
-            const customDescriptorCode = customRouteDescriptorMap === null || customRouteDescriptorMap === void 0 ? void 0 : customRouteDescriptorMap.get(normalizedDescriptor);
-            if (customDescriptorCode) {
-                if (applyRouteDescriptor(customDescriptorCode)) {
-                    return true;
-                }
-            }
-            const fallbackSynonym = DEFAULT_ROUTE_DESCRIPTOR_SYNONYMS.get(normalizedDescriptor);
-            if (fallbackSynonym) {
-                if (applyRouteDescriptor(fallbackSynonym.code, fallbackSynonym.text)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    };
-    // Process tokens sequentially
-    const tryRouteSynonym = (startIndex) => {
-        if (prnReasonStart !== undefined && startIndex >= prnReasonStart) {
-            return false;
-        }
-        const maxSpan = Math.min(24, tokens.length - startIndex);
-        for (let span = maxSpan; span >= 1; span--) {
-            const slice = tokens.slice(startIndex, startIndex + span);
-            if (slice.some((part) => internal.consumed.has(part.index))) {
-                continue;
-            }
-            const normalizedParts = slice.filter((part) => !/^[;:(),]+$/.test(part.lower));
-            const phrase = normalizedParts.map((part) => part.lower).join(" ");
-            const customCode = customRouteMap === null || customRouteMap === void 0 ? void 0 : customRouteMap.get(phrase);
-            const synonym = customCode
-                ? { code: customCode, text: maps_1.ROUTE_TEXT[customCode] }
-                : maps_1.DEFAULT_ROUTE_SYNONYMS[phrase];
-            if (synonym) {
-                if (phrase === "in" && slice.length === 1) {
-                    if (internal.routeCode) {
-                        continue;
-                    }
-                    const prevToken = tokens[startIndex - 1];
-                    if (prevToken && !internal.consumed.has(prevToken.index)) {
-                        continue;
-                    }
-                }
-                setRoute(internal, synonym.code, synonym.text);
-                for (const part of slice) {
-                    mark(internal.consumed, part);
-                    if (isBodySiteHint(part.lower, internal.customSiteHints)) {
-                        internal.siteTokenIndices.add(part.index);
-                    }
-                }
-                return true;
-            }
-        }
-        return false;
-    };
-    for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
-        if (internal.consumed.has(token.index)) {
-            continue;
-        }
-        const normalizedLower = normalizeTokenLower(token);
-        if (token.lower === "bld" || token.lower === "b-l-d") {
-            const check = (0, safety_1.checkDiscouraged)(token.original, options);
-            if (check.warning) {
-                internal.warnings.push(check.warning);
-            }
-            applyWhenToken(internal, token, types_1.EventTiming.Meal);
-            continue;
-        }
-        if (token.lower === "q" || token.lower === "every" || token.lower === "each") {
-            if (parseSeparatedInterval(internal, tokens, i, options)) {
-                continue;
-            }
-        }
-        if (tryParseTimeBasedSchedule(internal, tokens, i)) {
-            continue;
-        }
-        if (tryParseNumericCadence(internal, tokens, i)) {
-            continue;
-        }
-        const eyeSite = EYE_SITE_TOKENS[normalizedLower];
-        const treatEyeTokenAsSite = eyeSite
-            ? shouldTreatEyeTokenAsSite(internal, tokens, i, context)
-            : false;
-        if (normalizedLower === "od") {
-            const descriptor = maps_1.TIMING_ABBREVIATIONS.od;
-            if (descriptor &&
-                shouldInterpretOdAsOnceDaily(internal, tokens, i, treatEyeTokenAsSite)) {
-                applyFrequencyDescriptor(internal, token, descriptor, options);
-                continue;
-            }
-        }
-        // Frequency abbreviation map
-        const freqDescriptor = normalizedLower === "od"
-            ? undefined
-            : (_e = maps_1.TIMING_ABBREVIATIONS[token.lower]) !== null && _e !== void 0 ? _e : maps_1.TIMING_ABBREVIATIONS[normalizedLower];
-        if (freqDescriptor) {
-            applyFrequencyDescriptor(internal, token, freqDescriptor, options);
-            continue;
-        }
-        if (tryParseCompactQ(internal, tokens, i)) {
-            continue;
-        }
-        // Skip connectors if they are followed by recognized timing tokens or prefixes
-        if (MEAL_CONTEXT_CONNECTORS.has(token.lower) || token.lower === ",") {
-            if (isTimingAnchorOrPrefix(tokens, i + 1, prnReasonStart)) {
-                mark(internal.consumed, token);
-                continue;
-            }
-        }
-        // Event timing tokens
-        const nextToken = tokens[i + 1];
-        if (nextToken && !internal.consumed.has(nextToken.index)) {
-            const lowerNext = nextToken.lower;
-            const combo = `${token.lower} ${lowerNext}`;
-            const comboWhen = (_f = COMBO_EVENT_TIMINGS[combo]) !== null && _f !== void 0 ? _f : maps_1.EVENT_TIMING_TOKENS[combo];
-            if (comboWhen) {
-                applyWhenToken(internal, token, comboWhen);
-                mark(internal.consumed, nextToken);
-                continue;
-            }
-        }
-        if (token.lower === "pc" || token.lower === "ac" || token.lower === "after" || token.lower === "before") {
-            parseAnchorSequence(internal, tokens, i, (token.lower === "pc" || token.lower === "after")
-                ? types_1.EventTiming["After Meal"]
-                : types_1.EventTiming["Before Meal"]);
-            continue;
-        }
-        if (isAtPrefixToken(token.lower) || token.lower === "on" || token.lower === "with") {
-            if (tryParseTimeBasedSchedule(internal, tokens, i)) {
-                continue;
-            }
-            if (parseAnchorSequence(internal, tokens, i)) {
-                continue;
-            }
-            // If none of the above consume it, and it's a known anchor prefix, mark it
-            // but only if it's not "with" which might be part of other phrases later.
-            if (token.lower !== "with") {
-                mark(internal.consumed, token);
-                continue;
-            }
-        }
-        const customWhen = (_g = options === null || options === void 0 ? void 0 : options.whenMap) === null || _g === void 0 ? void 0 : _g[token.lower];
-        if (customWhen) {
-            applyWhenToken(internal, token, customWhen);
-            continue;
-        }
-        const whenCode = maps_1.EVENT_TIMING_TOKENS[token.lower];
-        if (whenCode) {
-            // If we are in the PRN zone, be cautious about common reason words like "sleep"
-            // unless they were already handled by combo/anchor logic (which happens above).
-            if (prnReasonStart !== undefined && i >= prnReasonStart && token.lower === "sleep") {
-                // Leave for PRN reason
-            }
-            else {
-                applyWhenToken(internal, token, whenCode);
-                continue;
-            }
-        }
-        // Day of week
-        const rangeConsumed = tryConsumeDayRangeTokens(internal, tokens, i);
-        if (rangeConsumed > 0) {
-            continue;
-        }
-        const days = resolveDayTokenDays(normalizeTokenLower(token));
-        if (days) {
-            addDayOfWeekList(internal, days);
-            mark(internal.consumed, token);
-            continue;
-        }
-        // Units following numbers handled later
-        if (tryRouteSynonym(i)) {
-            continue;
-        }
-        if (eyeSite && treatEyeTokenAsSite) {
-            internal.siteText = eyeSite.site;
-            internal.siteSource = "abbreviation";
-            if (eyeSite.route && !internal.routeCode) {
-                setRoute(internal, eyeSite.route);
-            }
-            mark(internal.consumed, token);
-            continue;
-        }
-        if (internal.count === undefined) {
-            const countMatch = token.lower.match(/^[x*]([0-9]+(?:\.[0-9]+)?)$/);
-            if (countMatch) {
-                if (applyCountLimit(internal, parseFloat(countMatch[1]))) {
-                    mark(internal.consumed, token);
-                    const nextToken = tokens[i + 1];
-                    if (nextToken && COUNT_KEYWORDS.has(nextToken.lower)) {
-                        mark(internal.consumed, nextToken);
-                    }
-                    continue;
-                }
-            }
-            if (token.lower === "x" || token.lower === "*") {
-                const numericToken = tokens[i + 1];
-                if (numericToken &&
-                    !internal.consumed.has(numericToken.index) &&
-                    /^[0-9]+(?:\.[0-9]+)?$/.test(numericToken.lower) &&
-                    applyCountLimit(internal, parseFloat(numericToken.original))) {
-                    mark(internal.consumed, token);
-                    mark(internal.consumed, numericToken);
-                    const afterToken = tokens[i + 2];
-                    if (afterToken && COUNT_KEYWORDS.has(afterToken.lower)) {
-                        mark(internal.consumed, afterToken);
-                    }
-                    continue;
-                }
-            }
-            if (token.lower === "for") {
-                const skipConnectors = (startIndex, bucket) => {
-                    let cursor = startIndex;
-                    while (cursor < tokens.length) {
-                        const candidate = tokens[cursor];
-                        if (!candidate) {
-                            break;
-                        }
-                        if (internal.consumed.has(candidate.index)) {
-                            cursor += 1;
-                            continue;
-                        }
-                        if (!COUNT_CONNECTOR_WORDS.has(candidate.lower)) {
-                            break;
-                        }
-                        bucket.push(candidate);
-                        cursor += 1;
-                    }
-                    return cursor;
-                };
-                const preConnectors = [];
-                let lookaheadIndex = skipConnectors(i + 1, preConnectors);
-                const numericToken = tokens[lookaheadIndex];
-                if (numericToken &&
-                    !internal.consumed.has(numericToken.index) &&
-                    /^[0-9]+(?:\.[0-9]+)?$/.test(numericToken.lower)) {
-                    const postConnectors = [];
-                    lookaheadIndex = skipConnectors(lookaheadIndex + 1, postConnectors);
-                    const keywordToken = tokens[lookaheadIndex];
-                    if (keywordToken &&
-                        !internal.consumed.has(keywordToken.index) &&
-                        COUNT_KEYWORDS.has(keywordToken.lower) &&
-                        applyCountLimit(internal, parseFloat(numericToken.original))) {
-                        mark(internal.consumed, token);
-                        for (const connector of preConnectors) {
-                            mark(internal.consumed, connector);
-                        }
-                        mark(internal.consumed, numericToken);
-                        for (const connector of postConnectors) {
-                            mark(internal.consumed, connector);
-                        }
-                        mark(internal.consumed, keywordToken);
-                        continue;
-                    }
-                }
-            }
-            if (COUNT_KEYWORDS.has(token.lower)) {
-                const partsToMark = [token];
-                let value;
-                const prevToken = tokens[i - 1];
-                if (prevToken && !internal.consumed.has(prevToken.index)) {
-                    const prevLower = prevToken.lower;
-                    const suffixMatch = prevLower.match(/^([0-9]+(?:\.[0-9]+)?)[x*]$/);
-                    const prefixMatch = prevLower.match(/^[x*]([0-9]+(?:\.[0-9]+)?)$/);
-                    if (suffixMatch) {
-                        value = parseFloat(suffixMatch[1]);
-                        partsToMark.push(prevToken);
-                    }
-                    else if (prefixMatch) {
-                        value = parseFloat(prefixMatch[1]);
-                        partsToMark.push(prevToken);
-                    }
-                    else if (/^[0-9]+(?:\.[0-9]+)?$/.test(prevLower)) {
-                        const maybeX = tokens[i - 2];
-                        if (maybeX &&
-                            !internal.consumed.has(maybeX.index) &&
-                            (maybeX.lower === "x" || maybeX.lower === "*")) {
-                            value = parseFloat(prevToken.original);
-                            partsToMark.push(maybeX, prevToken);
-                        }
-                    }
-                }
-                if (value === undefined) {
-                    const nextToken = tokens[i + 1];
-                    if (nextToken &&
-                        !internal.consumed.has(nextToken.index) &&
-                        /^[0-9]+(?:\.[0-9]+)?$/.test(nextToken.lower)) {
-                        value = parseFloat(nextToken.original);
-                        partsToMark.push(nextToken);
-                    }
-                }
-                if (applyCountLimit(internal, value)) {
-                    for (const part of partsToMark) {
-                        mark(internal.consumed, part);
-                    }
-                    continue;
-                }
-            }
-        }
-        // Numeric dose
-        if (tryParseCountBasedFrequency(internal, tokens, i, options)) {
-            continue;
-        }
-        const rangeValue = parseNumericRange(token.lower);
-        if (rangeValue) {
-            if (!internal.doseRange) {
-                internal.doseRange = rangeValue;
-            }
-            mark(internal.consumed, token);
-            const resolvedUnit = resolveUnitTokenAt(tokens, i + 1, internal.consumed, options);
-            if (resolvedUnit) {
-                internal.unit = resolvedUnit.unit;
-                for (const consumedIndex of resolvedUnit.consumedIndices) {
-                    mark(internal.consumed, tokens[consumedIndex]);
-                }
-            }
-            continue;
-        }
-        if (/^[0-9]+(?:\.[0-9]+)?$/.test(token.lower)) {
-            const value = parseFloat(token.original);
-            const resolvedDose = resolveNumericDoseUnit(tokens, i, value, internal.consumed, options);
-            if (internal.dose === undefined) {
-                internal.dose = resolvedDose.doseValue;
-            }
-            mark(internal.consumed, token);
-            if (resolvedDose.unit) {
-                internal.unit = resolvedDose.unit;
-            }
-            for (const consumedIndex of resolvedDose.consumedIndices) {
-                mark(internal.consumed, tokens[consumedIndex]);
-            }
-            continue;
-        }
-        // Patterns like 1x or 2x
-        const timesMatch = token.lower.match(/^([0-9]+(?:\.[0-9]+)?)[x*]$/);
-        if (timesMatch) {
-            const val = parseFloat(timesMatch[1]);
-            if (internal.dose === undefined) {
-                internal.dose = val;
-            }
-            mark(internal.consumed, token);
-            continue;
-        }
-        // Words for frequency
-        const wordFreq = maps_1.WORD_FREQUENCIES[token.lower];
-        if (wordFreq) {
-            internal.frequency = wordFreq.frequency;
-            internal.period = 1;
-            internal.periodUnit = wordFreq.periodUnit;
-            mark(internal.consumed, token);
-            continue;
-        }
-        // Skip generic connectors
-        if (token.lower === "per" || token.lower === "a" || token.lower === "every" || token.lower === "each") {
-            mark(internal.consumed, token);
-            continue;
-        }
-    }
-    // Units from trailing tokens if still undefined
-    if (internal.unit === undefined) {
-        for (const token of tokens) {
-            if (internal.consumed.has(token.index))
-                continue;
-            const unit = normalizeUnit(token.lower, options);
-            if (unit) {
-                internal.unit = unit;
-                mark(internal.consumed, token);
-                break;
-            }
-        }
-    }
-    if (internal.unit === undefined) {
-        internal.unit = enforceHouseholdUnitPolicy((0, context_1.inferUnitFromContext)(context), options);
-    }
-    if (internal.unit === undefined) {
-        const fallbackUnit = enforceHouseholdUnitPolicy(inferUnitFromRouteHints(internal), options);
-        if (fallbackUnit) {
-            internal.unit = fallbackUnit;
-        }
-    }
-    if ((options === null || options === void 0 ? void 0 : options.assumeSingleDiscreteDose) &&
-        internal.dose === undefined &&
-        internal.doseRange === undefined &&
-        internal.unit !== undefined &&
-        isDiscreteUnit(internal.unit)) {
-        internal.dose = 1;
-    }
-    // Frequency defaults when timing code implies it
-    if (internal.frequency === undefined &&
-        internal.period === undefined &&
-        internal.timingCode) {
-        const descriptor = maps_1.TIMING_ABBREVIATIONS[internal.timingCode.toLowerCase()];
-        if (descriptor) {
-            if (descriptor.frequency !== undefined) {
-                internal.frequency = descriptor.frequency;
-            }
-            if (descriptor.period !== undefined) {
-                internal.period = descriptor.period;
-            }
-            if (descriptor.periodUnit) {
-                internal.periodUnit = descriptor.periodUnit;
-            }
-            if (descriptor.when) {
-                for (const w of descriptor.when) {
-                    addWhen(internal.when, w);
-                }
-            }
-        }
-    }
-    if (!internal.timingCode &&
-        internal.frequency !== undefined &&
-        internal.periodUnit === types_1.FhirPeriodUnit.Day &&
-        (internal.period === undefined || internal.period === 1)) {
-        if (internal.frequency === 2) {
-            internal.timingCode = "BID";
-        }
-        else if (internal.frequency === 3) {
-            internal.timingCode = "TID";
-        }
-        else if (internal.frequency === 4) {
-            internal.timingCode = "QID";
-        }
-    }
-    reconcileMealTimingSpecificity(internal);
-    // Expand generic meal markers into specific EventTiming codes when asked to.
-    expandMealTimings(internal, options);
-    sortWhenValues(internal, options);
-    // PRN reason text
-    if (internal.asNeeded && prnReasonStart !== undefined) {
-        const reasonTokens = [];
-        const reasonIndices = [];
-        const reasonObjects = [];
-        const PRN_RECLAIMABLE_CONNECTORS = new Set(["at", "to", "in", "into", "on", "onto"]);
-        for (let i = prnReasonStart; i < tokens.length; i++) {
-            const token = tokens[i];
-            if (internal.consumed.has(token.index)) {
-                // We only allow reclaiming certain generic connectors if they were used
-                // as standalone markers (like 'at' or 'to') and not if they were clearly
-                // part of a frequency/period instruction (which would be skipped here
-                // if they were consumed by those specific logic paths).
-                if (!PRN_RECLAIMABLE_CONNECTORS.has(token.lower)) {
-                    continue;
-                }
-                // If it is a reclaimable connector, we can pull it back into the reason
-                // if it helps form a coherent phrase like 'irritation at rectum'.
-            }
-            // If we haven't started collecting the reason yet, we should skip introductory
-            // connectors to avoid phrases like "as needed for if pain".
-            const PRN_INTRODUCTIONS = new Set(["for", "if", "when", "upon", "due", "to"]);
-            if (reasonTokens.length === 0 && PRN_INTRODUCTIONS.has(token.lower)) {
-                // Special handling for "due to" - if we skipped "due", we should also skip "to"
-                if (token.lower === "due") {
-                    const next = tokens[i + 1];
-                    if (next && next.lower === "to") {
-                        mark(internal.consumed, token);
-                        mark(internal.consumed, next);
-                        i++; // skip next token in loop
-                        continue;
-                    }
-                }
-                mark(internal.consumed, token);
-                continue;
-            }
-            reasonTokens.push(token.original);
-            reasonIndices.push(token.index);
-            reasonObjects.push(token);
-            mark(internal.consumed, token);
-        }
-        if (reasonTokens.length > 0) {
-            let sortedIndices = reasonIndices.slice().sort((a, b) => a - b);
-            let range = computeTokenRange(internal.input, tokens, sortedIndices);
-            let sourceText = range ? internal.input.slice(range.start, range.end) : undefined;
-            if (sourceText) {
-                const cutoff = determinePrnReasonCutoff(reasonObjects, sourceText);
-                if (cutoff !== undefined) {
-                    for (let i = cutoff; i < reasonObjects.length; i++) {
-                        internal.consumed.delete(reasonObjects[i].index);
-                    }
-                    reasonObjects.splice(cutoff);
-                    reasonTokens.splice(cutoff);
-                    reasonIndices.splice(cutoff);
-                    while (reasonTokens.length > 0) {
-                        const lastToken = reasonTokens[reasonTokens.length - 1];
-                        if (!lastToken || /^[;:.,-]+$/.test(lastToken.trim())) {
-                            const removedObject = reasonObjects.pop();
-                            if (removedObject) {
-                                internal.consumed.delete(removedObject.index);
-                            }
-                            reasonTokens.pop();
-                            const removedIndex = reasonIndices.pop();
-                            if (removedIndex !== undefined) {
-                                internal.consumed.delete(removedIndex);
-                            }
-                            continue;
-                        }
-                        break;
-                    }
-                    if (reasonTokens.length > 0) {
-                        sortedIndices = reasonIndices.slice().sort((a, b) => a - b);
-                        range = computeTokenRange(internal.input, tokens, sortedIndices);
-                        sourceText = range ? internal.input.slice(range.start, range.end) : undefined;
-                    }
-                    else {
-                        range = undefined;
-                        sourceText = undefined;
-                    }
-                }
-            }
-            let canonicalPrefix;
-            if (reasonTokens.length > 0) {
-                const suffixInfo = findTrailingPrnSiteSuffix(reasonObjects, internal, options);
-                if ((_h = suffixInfo === null || suffixInfo === void 0 ? void 0 : suffixInfo.tokens) === null || _h === void 0 ? void 0 : _h.length) {
-                    for (const token of suffixInfo.tokens) {
-                        prnSiteSuffixIndices.add(token.index);
-                    }
-                }
-                if (suffixInfo && suffixInfo.startIndex > 0) {
-                    const prefixTokens = reasonObjects
-                        .slice(0, suffixInfo.startIndex)
-                        .map((token) => token.original)
-                        .join(" ")
-                        .replace(/\s+/g, " ")
-                        .trim();
-                    if (prefixTokens) {
-                        canonicalPrefix = prefixTokens.replace(/[{}]/g, " ").replace(/\s+/g, " ").trim();
-                    }
-                }
-            }
-            if (reasonTokens.length > 0) {
-                const joined = reasonTokens.join(" ").trim();
-                if (joined) {
-                    let sanitized = joined.replace(/\s+/g, " ").trim();
-                    let isProbe = false;
-                    const probeMatch = sanitized.match(/^\{(.+)}$/);
-                    if (probeMatch) {
-                        isProbe = true;
-                        sanitized = probeMatch[1];
-                    }
-                    sanitized = sanitized.replace(/[{}]/g, " ").replace(/\s+/g, " ").trim();
-                    const text = sanitized || joined;
-                    internal.asNeededReason = text;
-                    const normalized = text.toLowerCase();
-                    const canonicalSource = canonicalPrefix || sanitized || text;
-                    const canonical = canonicalSource
-                        ? (0, maps_1.normalizePrnReasonKey)(canonicalSource)
-                        : (0, maps_1.normalizePrnReasonKey)(text);
-                    internal.prnReasonLookupRequest = {
-                        originalText: joined,
-                        text,
-                        normalized,
-                        canonical: canonical !== null && canonical !== void 0 ? canonical : "",
-                        isProbe,
-                        inputText: internal.input,
-                        sourceText,
-                        range
-                    };
-                }
-            }
-        }
-    }
-    collectAdditionalInstructions(internal, tokens);
-    // Determine site text from leftover tokens (excluding PRN reason tokens)
-    const leftoverTokens = tokens.filter((t) => !internal.consumed.has(t.index));
-    const siteCandidateIndices = new Set();
-    const leftoverSiteIndices = new Set();
-    for (const token of leftoverTokens) {
-        if (prnSiteSuffixIndices.has(token.index)) {
-            continue;
-        }
-        const normalized = normalizeTokenLower(token);
-        if (isBodySiteHint(normalized, internal.customSiteHints)) {
-            siteCandidateIndices.add(token.index);
-            leftoverSiteIndices.add(token.index);
-            continue;
-        }
-        if (SITE_CONNECTORS.has(normalized)) {
-            const next = tokens[token.index + 1];
-            if (next && !internal.consumed.has(next.index) && !prnSiteSuffixIndices.has(next.index)) {
-                siteCandidateIndices.add(next.index);
-            }
-        }
-    }
-    if (leftoverSiteIndices.size === 0) {
-        for (const idx of internal.siteTokenIndices) {
-            if (prnSiteSuffixIndices.has(idx)) {
-                continue;
-            }
-            siteCandidateIndices.add(idx);
-        }
-    }
-    if (siteCandidateIndices.size > 0) {
-        const indicesToInclude = new Set(siteCandidateIndices);
-        for (const idx of siteCandidateIndices) {
-            let prev = idx - 1;
-            while (prev >= 0) {
-                const token = tokens[prev];
-                if (!token) {
-                    break;
-                }
-                const lower = normalizeTokenLower(token);
-                if (SITE_CONNECTORS.has(lower) ||
-                    isBodySiteHint(lower, internal.customSiteHints) ||
-                    ROUTE_DESCRIPTOR_FILLER_WORDS.has(lower)) {
-                    indicesToInclude.add(token.index);
-                    prev -= 1;
-                    continue;
-                }
-                break;
-            }
-            let next = idx + 1;
-            while (next < tokens.length) {
-                const token = tokens[next];
-                if (!token) {
-                    break;
-                }
-                const lower = normalizeTokenLower(token);
-                if (SITE_CONNECTORS.has(lower) ||
-                    isBodySiteHint(lower, internal.customSiteHints) ||
-                    ROUTE_DESCRIPTOR_FILLER_WORDS.has(lower)) {
-                    indicesToInclude.add(token.index);
-                    next += 1;
-                    continue;
-                }
-                break;
-            }
-        }
-        const sortedIndices = Array.from(indicesToInclude).sort((a, b) => a - b);
-        const displayWords = [];
-        for (const index of sortedIndices) {
-            const token = tokens[index];
-            if (!token) {
-                continue;
-            }
-            const lower = normalizeTokenLower(token);
-            const trimmed = token.original.trim();
-            const isBraceToken = trimmed.length > 0 && /^[{}]+$/.test(trimmed);
-            if (!isBraceToken && !SITE_CONNECTORS.has(lower) && !SITE_FILLER_WORDS.has(lower)) {
-                displayWords.push(token.original);
-            }
-            mark(internal.consumed, token);
-        }
-        const normalizedSite = displayWords
-            .filter((word) => !SITE_CONNECTORS.has(word.trim().toLowerCase()))
-            .join(" ")
-            .trim();
-        if (normalizedSite) {
-            const tokenRange = computeTokenRange(internal.input, tokens, sortedIndices);
-            let sanitized = normalizedSite;
-            let isProbe = false;
-            const probeMatch = sanitized.match(/^\{(.+)}$/);
-            if (probeMatch) {
-                // `{site}` placeholders flag interactive lookups so consumers can prompt
-                // for a coded selection even when the parser cannot resolve the entry.
-                isProbe = true;
-                sanitized = probeMatch[1];
-            }
-            // Remove stray braces and normalize whitespace so lookups and downstream
-            // displays operate on a clean phrase.
-            sanitized = sanitized.replace(/[{}]/g, " ").replace(/\s+/g, " ").trim();
-            const range = refineSiteRange(internal.input, sanitized, tokenRange);
-            const sourceText = range ? internal.input.slice(range.start, range.end) : undefined;
-            const displayText = normalizeSiteDisplayText(sanitized, options === null || options === void 0 ? void 0 : options.siteCodeMap);
-            const displayLower = displayText.toLowerCase();
-            const canonical = displayText ? (0, maps_1.normalizeBodySiteKey)(displayText) : "";
-            internal.siteLookupRequest = {
-                originalText: normalizedSite,
-                text: displayText,
-                normalized: displayLower,
-                canonical,
-                isProbe,
-                inputText: internal.input,
-                sourceText,
-                range
-            };
-            if (displayText) {
-                const normalizedLower = sanitized.toLowerCase();
-                const strippedDescriptor = normalizeRouteDescriptorPhrase(normalizedLower);
-                const siteWords = displayLower.split(/\s+/).filter((word) => word.length > 0);
-                const hasNonSiteWords = siteWords.some((word) => !isBodySiteHint(word, internal.customSiteHints));
-                const shouldAttemptRouteDescriptor = strippedDescriptor !== normalizedLower || hasNonSiteWords || strippedDescriptor === "mouth";
-                const appliedRouteDescriptor = shouldAttemptRouteDescriptor && maybeApplyRouteDescriptor(sanitized);
-                if (!appliedRouteDescriptor) {
-                    // Preserve the clean site text for FHIR output and resolver context
-                    // whenever we keep the original phrase.
-                    internal.siteText = displayText;
-                    if (!internal.siteSource) {
-                        internal.siteSource = "text";
-                    }
-                }
-            }
-        }
-    }
-    if (!internal.routeCode && internal.siteText) {
-        for (const { pattern, route } of SITE_UNIT_ROUTE_HINTS) {
-            if (pattern.test(internal.siteText)) {
-                setRoute(internal, route);
-                break;
-            }
-        }
-    }
-    if (internal.routeCode === types_1.RouteCode["Intravitreal route (qualifier value)"] &&
-        (!internal.siteText || !/eye/i.test(internal.siteText))) {
-        internal.warnings.push("Intravitreal administrations require an eye site (e.g., OD/OS/OU).");
-    }
-    return internal;
-}
-/**
- * Resolves parsed site text against SNOMED dictionaries and synchronous
- * callbacks, applying the best match to the in-progress parse result.
- */
-function applyPrnReasonCoding(internal, options) {
-    runPrnReasonResolutionSync(internal, options);
-}
-function applyPrnReasonCodingAsync(internal, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield runPrnReasonResolutionAsync(internal, options);
-    });
-}
-function applySiteCoding(internal, options) {
-    runSiteCodingResolutionSync(internal, options);
-}
-/**
- * Asynchronous counterpart to {@link applySiteCoding} that awaits resolver and
- * suggestion callbacks so remote terminology services can be used.
- */
-function applySiteCodingAsync(internal, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield runSiteCodingResolutionAsync(internal, options);
-    });
-}
-/**
- * Attempts to resolve site codings using built-in dictionaries followed by any
- * provided synchronous resolvers. Suggestions are collected when resolution
- * fails or a `{probe}` placeholder requested an interactive lookup.
- */
-function runSiteCodingResolutionSync(internal, options) {
-    internal.siteLookups = [];
-    const request = internal.siteLookupRequest;
-    if (!request) {
-        return;
-    }
-    const canonical = request.canonical;
-    const selection = pickSiteSelection(options === null || options === void 0 ? void 0 : options.siteCodeSelections, request);
-    const customDefinition = lookupBodySiteDefinition(options === null || options === void 0 ? void 0 : options.siteCodeMap, canonical);
-    let resolution = selection !== null && selection !== void 0 ? selection : customDefinition;
-    if (!resolution) {
-        // Allow synchronous resolver callbacks to claim the site.
-        for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.siteCodeResolvers)) {
-            const result = resolver(request);
-            if (isPromise(result)) {
-                throw new Error("Site code resolver returned a Promise; use parseSigAsync for asynchronous site resolution.");
-            }
-            if (result) {
-                resolution = result;
-                break;
-            }
-        }
-    }
-    const defaultDefinition = canonical ? maps_1.DEFAULT_BODY_SITE_SNOMED[canonical] : undefined;
-    if (!resolution && defaultDefinition) {
-        // Fall back to bundled SNOMED lookups when no overrides claim the site.
-        resolution = defaultDefinition;
-    }
-    if (resolution) {
-        applySiteDefinition(internal, resolution);
-    }
-    else {
-        internal.siteCoding = undefined;
-    }
-    const needsSuggestions = request.isProbe || !resolution;
-    if (!needsSuggestions) {
-        return;
-    }
-    const suggestionMap = new Map();
-    if (selection) {
-        addSuggestionToMap(suggestionMap, definitionToSuggestion(selection));
-    }
-    if (customDefinition) {
-        addSuggestionToMap(suggestionMap, definitionToSuggestion(customDefinition));
-    }
-    if (defaultDefinition) {
-        addSuggestionToMap(suggestionMap, definitionToSuggestion(defaultDefinition));
-    }
-    for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.siteCodeSuggestionResolvers)) {
-        // Aggregates resolver suggestions while guarding against accidental async
-        // usage, mirroring the behavior of site resolvers.
-        const result = resolver(request);
-        if (isPromise(result)) {
-            throw new Error("Site code suggestion resolver returned a Promise; use parseSigAsync for asynchronous site suggestions.");
-        }
-        collectSuggestionResult(suggestionMap, result);
-    }
-    const suggestions = Array.from(suggestionMap.values());
-    if (suggestions.length || request.isProbe) {
-        internal.siteLookups.push({ request, suggestions });
-    }
-}
-/**
- * Async version of {@link runSiteCodingResolutionSync} that awaits resolver
- * results and suggestion providers, enabling remote terminology services.
- */
-function runSiteCodingResolutionAsync(internal, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        internal.siteLookups = [];
-        const request = internal.siteLookupRequest;
-        if (!request) {
-            return;
-        }
-        const canonical = request.canonical;
-        const selection = pickSiteSelection(options === null || options === void 0 ? void 0 : options.siteCodeSelections, request);
-        const customDefinition = lookupBodySiteDefinition(options === null || options === void 0 ? void 0 : options.siteCodeMap, canonical);
-        let resolution = selection !== null && selection !== void 0 ? selection : customDefinition;
-        if (!resolution) {
-            // Await asynchronous resolver callbacks (e.g., HTTP terminology services).
-            for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.siteCodeResolvers)) {
-                const result = yield resolver(request);
-                if (result) {
-                    resolution = result;
-                    break;
-                }
-            }
-        }
-        const defaultDefinition = canonical ? maps_1.DEFAULT_BODY_SITE_SNOMED[canonical] : undefined;
-        if (!resolution && defaultDefinition) {
-            resolution = defaultDefinition;
-        }
-        if (resolution) {
-            applySiteDefinition(internal, resolution);
-        }
-        else {
-            internal.siteCoding = undefined;
-        }
-        const needsSuggestions = request.isProbe || !resolution;
-        if (!needsSuggestions) {
-            return;
-        }
-        const suggestionMap = new Map();
-        if (selection) {
-            addSuggestionToMap(suggestionMap, definitionToSuggestion(selection));
-        }
-        if (customDefinition) {
-            addSuggestionToMap(suggestionMap, definitionToSuggestion(customDefinition));
-        }
-        if (defaultDefinition) {
-            addSuggestionToMap(suggestionMap, definitionToSuggestion(defaultDefinition));
-        }
-        for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.siteCodeSuggestionResolvers)) {
-            // Async suggestion providers are awaited, allowing UI workflows to fetch
-            // candidate codes on demand.
-            const result = yield resolver(request);
-            collectSuggestionResult(suggestionMap, result);
-        }
-        const suggestions = Array.from(suggestionMap.values());
-        if (suggestions.length || request.isProbe) {
-            internal.siteLookups.push({ request, suggestions });
-        }
-    });
-}
-/**
- * Looks up a body-site definition in a caller-provided map, honoring both
- * direct keys and entries that normalize to the same canonical phrase.
- */
-function lookupBodySiteDefinition(map, canonical) {
-    if (!map) {
-        return undefined;
-    }
-    const direct = map[canonical];
-    if (direct) {
-        return direct;
-    }
-    for (const [key, definition] of (0, object_1.objectEntries)(map)) {
-        if ((0, maps_1.normalizeBodySiteKey)(key) === canonical) {
-            return definition;
-        }
-        if (definition.aliases) {
-            for (const alias of definition.aliases) {
-                if ((0, maps_1.normalizeBodySiteKey)(alias) === canonical) {
-                    return definition;
-                }
-            }
-        }
-    }
-    return undefined;
-}
-function pickSiteSelection(selections, request) {
-    if (!selections) {
-        return undefined;
-    }
-    const canonical = request.canonical;
-    const normalizedText = (0, maps_1.normalizeBodySiteKey)(request.text);
-    const requestRange = request.range;
-    for (const selection of toArray(selections)) {
-        if (!selection) {
-            continue;
-        }
-        let matched = false;
-        if (selection.range) {
-            if (!requestRange) {
-                continue;
-            }
-            if (selection.range.start !== requestRange.start ||
-                selection.range.end !== requestRange.end) {
-                continue;
-            }
-            matched = true;
-        }
-        if (selection.canonical) {
-            if ((0, maps_1.normalizeBodySiteKey)(selection.canonical) !== canonical) {
-                continue;
-            }
-            matched = true;
-        }
-        else if (selection.text) {
-            const normalizedSelection = (0, maps_1.normalizeBodySiteKey)(selection.text);
-            if (normalizedSelection !== canonical && normalizedSelection !== normalizedText) {
-                continue;
-            }
-            matched = true;
-        }
-        if (!selection.range && !selection.canonical && !selection.text) {
-            continue;
-        }
-        if (matched) {
-            return selection.resolution;
-        }
-    }
-    return undefined;
-}
-/**
- * Applies the selected body-site definition onto the parser state, defaulting
- * the coding system to SNOMED CT when the definition omits one.
- */
-function applySiteDefinition(internal, definition) {
-    var _a, _b;
-    const coding = definition.coding;
-    internal.siteCoding = (coding === null || coding === void 0 ? void 0 : coding.code)
-        ? {
-            code: coding.code,
-            display: coding.display,
-            system: (_a = coding.system) !== null && _a !== void 0 ? _a : SNOMED_SYSTEM
-        }
-        : undefined;
-    if (definition.text) {
-        internal.siteText = definition.text;
-    }
-    else if (!internal.siteText && ((_b = internal.siteLookupRequest) === null || _b === void 0 ? void 0 : _b.text)) {
-        internal.siteText = internal.siteLookupRequest.text;
-    }
-}
-/**
- * Converts a body-site definition into a suggestion payload so all suggestion
- * sources share consistent structure.
- */
-function definitionToSuggestion(definition) {
-    var _a;
-    const coding = definition.coding;
-    if (!(coding === null || coding === void 0 ? void 0 : coding.code)) {
-        return undefined;
-    }
-    return {
-        coding: {
-            code: coding.code,
-            display: coding.display,
-            system: (_a = coding.system) !== null && _a !== void 0 ? _a : SNOMED_SYSTEM
-        },
-        text: definition.text
-    };
-}
-/**
- * Inserts a suggestion into a deduplicated map keyed by system and code.
- */
-function addSuggestionToMap(map, suggestion) {
-    var _a, _b;
-    if (!suggestion) {
-        return;
-    }
-    const coding = suggestion.coding;
-    if (!(coding === null || coding === void 0 ? void 0 : coding.code)) {
-        return;
-    }
-    const key = `${(_a = coding.system) !== null && _a !== void 0 ? _a : SNOMED_SYSTEM}|${coding.code}`;
-    if (!map.has(key)) {
-        map.set(key, {
-            coding: {
-                code: coding.code,
-                display: coding.display,
-                system: (_b = coding.system) !== null && _b !== void 0 ? _b : SNOMED_SYSTEM
-            },
-            text: suggestion.text
-        });
-    }
-}
-/**
- * Normalizes resolver outputs into a consistent array before merging them into
- * the suggestion map.
- */
-function collectSuggestionResult(map, result) {
-    if (!result) {
-        return;
-    }
-    const suggestions = Array.isArray(result)
-        ? result
-        : typeof result === "object" && "suggestions" in result
-            ? result.suggestions
-            : [result];
-    for (const suggestion of suggestions) {
-        addSuggestionToMap(map, suggestion);
-    }
-}
-function findAdditionalInstructionDefinition(text, canonical) {
-    if (!canonical) {
-        return undefined;
-    }
-    for (const entry of maps_1.DEFAULT_ADDITIONAL_INSTRUCTION_ENTRIES) {
-        if (!entry.canonical) {
-            continue;
-        }
-        // Check for exact canonical match first
-        if (entry.canonical === canonical) {
-            return entry.definition;
-        }
-        // Avoid broad includes checks (like "with" matching "with meal") 
-        // to prevent leakage of common connectors into additional instructions.
-        for (const term of entry.terms) {
-            const normalizedTerm = (0, maps_1.normalizeAdditionalInstructionKey)(term);
-            if (!normalizedTerm) {
-                continue;
-            }
-            if (canonical.includes(normalizedTerm) || normalizedTerm.includes(canonical)) {
-                return entry.definition;
-            }
-        }
-    }
-    return undefined;
-}
-const BODY_SITE_ADJECTIVE_SUFFIXES = [
-    "al",
-    "ial",
-    "ual",
-    "ic",
-    "ous",
-    "ive",
-    "ary",
-    "ory",
-    "atic",
-    "etic",
-    "ular",
-    "otic",
-    "ile",
-    "eal",
-    "inal",
-    "aneal",
-    "enal"
-];
-const DEFAULT_SITE_SYNONYM_KEYS = (() => {
-    const map = new Map();
-    for (const [key, definition] of (0, object_1.objectEntries)(maps_1.DEFAULT_BODY_SITE_SNOMED)) {
-        if (!definition) {
-            continue;
-        }
-        const normalized = key.trim();
-        if (!normalized) {
-            continue;
-        }
-        const existing = map.get(definition);
-        if (existing) {
-            if (existing.indexOf(normalized) === -1) {
-                existing.push(normalized);
-            }
-        }
-        else {
-            map.set(definition, [normalized]);
-        }
-    }
-    return map;
-})();
-function normalizeSiteDisplayText(text, customSiteMap) {
-    var _a;
-    const trimmed = text.trim();
-    if (!trimmed) {
-        return trimmed;
-    }
-    const canonicalInput = (0, maps_1.normalizeBodySiteKey)(trimmed);
-    if (!canonicalInput) {
-        return trimmed;
-    }
-    const resolvePreferred = (canonical) => {
-        var _a;
-        const definition = (_a = lookupBodySiteDefinition(customSiteMap, canonical)) !== null && _a !== void 0 ? _a : maps_1.DEFAULT_BODY_SITE_SNOMED[canonical];
-        if (!definition) {
-            return undefined;
-        }
-        const preferred = pickPreferredBodySitePhrase(canonical, definition, customSiteMap);
-        const textValue = preferred !== null && preferred !== void 0 ? preferred : canonical;
-        const normalized = (0, maps_1.normalizeBodySiteKey)(textValue);
-        if (!normalized) {
-            return undefined;
-        }
-        return { text: textValue, canonical: normalized };
-    };
-    if (isAdjectivalSitePhrase(canonicalInput)) {
-        const direct = resolvePreferred(canonicalInput);
-        return (_a = direct === null || direct === void 0 ? void 0 : direct.text) !== null && _a !== void 0 ? _a : trimmed;
-    }
-    const words = canonicalInput.split(/\s+/).filter((word) => word.length > 0);
-    for (let i = 1; i < words.length; i++) {
-        const prefix = words.slice(0, i);
-        if (!prefix.every((word) => isAdjectivalSitePhrase(word))) {
-            continue;
-        }
-        const candidateCanonical = words.slice(i).join(" ");
-        if (!candidateCanonical) {
-            continue;
-        }
-        const candidatePreferred = resolvePreferred(candidateCanonical);
-        if (!candidatePreferred) {
-            continue;
-        }
-        const prefixMatches = prefix.every((word) => {
-            const normalizedPrefix = resolvePreferred(word);
-            return (normalizedPrefix !== undefined &&
-                normalizedPrefix.canonical === candidatePreferred.canonical);
-        });
-        if (!prefixMatches) {
-            continue;
-        }
-        return candidatePreferred.text;
-    }
-    return trimmed;
-}
-function pickPreferredBodySitePhrase(canonical, definition, customSiteMap) {
-    const synonyms = new Set();
-    synonyms.add(canonical);
-    if (definition.aliases) {
-        for (const alias of definition.aliases) {
-            const normalizedAlias = (0, maps_1.normalizeBodySiteKey)(alias);
-            if (normalizedAlias) {
-                synonyms.add(normalizedAlias);
-            }
-        }
-    }
-    const defaultSynonyms = DEFAULT_SITE_SYNONYM_KEYS.get(definition);
-    if (defaultSynonyms) {
-        for (const synonym of defaultSynonyms) {
-            synonyms.add(synonym);
-        }
-    }
-    if (customSiteMap) {
-        for (const [key, candidate] of (0, object_1.objectEntries)(customSiteMap)) {
-            if (!candidate) {
-                continue;
-            }
-            if (candidate === definition) {
-                const normalizedKey = (0, maps_1.normalizeBodySiteKey)(key);
-                if (normalizedKey) {
-                    synonyms.add(normalizedKey);
-                }
-                if (candidate.aliases) {
-                    for (const alias of candidate.aliases) {
-                        const normalizedAlias = (0, maps_1.normalizeBodySiteKey)(alias);
-                        if (normalizedAlias) {
-                            synonyms.add(normalizedAlias);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    const candidates = Array.from(synonyms).filter((phrase) => phrase && !isAdjectivalSitePhrase(phrase));
-    if (!candidates.length) {
-        return undefined;
-    }
-    candidates.sort((a, b) => scoreBodySitePhrase(b) - scoreBodySitePhrase(a));
-    const best = candidates[0];
-    if (!best) {
-        return undefined;
-    }
-    if ((0, maps_1.normalizeBodySiteKey)(best) === canonical) {
-        return undefined;
-    }
-    return best;
-}
-function scoreBodySitePhrase(phrase) {
-    const lower = phrase.toLowerCase();
-    const words = lower.split(/\s+/).filter((part) => part.length > 0);
-    let score = 0;
-    if (!/(structure|region|entire|proper|body)/.test(lower)) {
-        score += 3;
-    }
-    if (!lower.includes(" of ")) {
-        score += 1;
-    }
-    if (words.length <= 2) {
-        score += 1;
-    }
-    if (words.length === 1) {
-        score += 0.5;
-    }
-    score -= words.length * 0.2;
-    score -= lower.length * 0.01;
-    return score;
-}
-function isAdjectivalSitePhrase(phrase) {
-    const normalized = phrase.trim().toLowerCase();
-    if (!normalized) {
-        return false;
-    }
-    const words = normalized.split(/\s+/).filter((word) => word.length > 0);
-    if (words.length !== 1) {
-        return false;
-    }
-    const last = words[words.length - 1];
-    if (last.length <= 3) {
-        return false;
-    }
-    return BODY_SITE_ADJECTIVE_SUFFIXES.some((suffix) => last.endsWith(suffix));
-}
-function collectAdditionalInstructions(internal, tokens) {
-    var _a, _b, _c, _d, _e, _f;
-    if (internal.additionalInstructions.length) {
-        return;
-    }
-    const punctuationOnly = /^[;:.,-]+$/;
-    const trailing = [];
-    let expectedIndex;
-    for (let cursor = tokens.length - 1; cursor >= 0; cursor--) {
-        const token = tokens[cursor];
-        if (!token) {
-            continue;
-        }
-        if (internal.consumed.has(token.index)) {
-            if (trailing.length > 0) {
-                break;
-            }
-            continue;
-        }
-        if (expectedIndex !== undefined && token.index !== expectedIndex - 1) {
-            break;
-        }
-        trailing.unshift(token);
-        expectedIndex = token.index;
-    }
-    if (!trailing.length) {
-        return;
-    }
-    const contentTokens = trailing.filter((token) => !punctuationOnly.test(token.original));
-    if (!contentTokens.length) {
-        return;
-    }
-    const trailingIndices = trailing.map((token) => token.index).sort((a, b) => a - b);
-    const lastIndex = trailingIndices[trailingIndices.length - 1];
-    for (let i = lastIndex + 1; i < tokens.length; i++) {
-        const nextToken = tokens[i];
-        if (!nextToken) {
-            continue;
-        }
-        if (!internal.consumed.has(nextToken.index)) {
-            return;
-        }
-    }
-    const joined = contentTokens
-        .map((token) => token.original)
-        .join(" ")
-        .replace(/\s+/g, " ")
-        .trim();
-    if (!joined) {
-        return;
-    }
-    const contentIndices = contentTokens.map((token) => token.index).sort((a, b) => a - b);
-    const lowerInput = internal.input.toLowerCase();
-    let trailingRange;
-    let searchEnd = lowerInput.length;
-    let rangeStart;
-    let rangeEnd;
-    for (let i = contentTokens.length - 1; i >= 0; i--) {
-        const fragment = contentTokens[i].original.trim();
-        if (!fragment) {
-            continue;
-        }
-        const lowerFragment = fragment.toLowerCase();
-        const foundIndex = lowerInput.lastIndexOf(lowerFragment, searchEnd - 1);
-        if (foundIndex === -1) {
-            rangeStart = undefined;
-            rangeEnd = undefined;
-            break;
-        }
-        rangeStart = foundIndex;
-        if (rangeEnd === undefined) {
-            rangeEnd = foundIndex + lowerFragment.length;
-        }
-        searchEnd = foundIndex;
-    }
-    if (rangeStart !== undefined && rangeEnd !== undefined) {
-        trailingRange = { start: rangeStart, end: rangeEnd };
-    }
-    const range = trailingRange !== null && trailingRange !== void 0 ? trailingRange : computeTokenRange(internal.input, tokens, contentIndices);
-    let separatorDetected = false;
-    if (range) {
-        for (let cursor = range.start - 1; cursor >= 0; cursor--) {
-            const ch = internal.input[cursor];
-            if (ch === "\n" || ch === "\r") {
-                separatorDetected = true;
-                break;
-            }
-            if (/\s/.test(ch)) {
-                continue;
-            }
-            if (/-|;|:|\.|\,/.test(ch)) {
-                separatorDetected = true;
-            }
-            break;
-        }
-    }
-    const sourceText = range
-        ? internal.input.slice(range.start, range.end)
-        : joined;
-    const normalized = sourceText
-        .replace(/\s*[-:]+\s*/g, "; ")
-        .replace(/\s*(?:\r?\n)+\s*/g, "; ")
-        .replace(/\s+/g, " ");
-    const segments = normalized
-        .split(/(?:;|\.)/)
-        .map((segment) => segment.trim())
-        .filter((segment) => segment.length > 0);
-    // If no punctuation was detected, we only collect if at least one segment matches a known definition.
-    // This avoids capturing random trailing text as instructions unless it's codified.
-    if (!separatorDetected && !/[-;:.]/.test(sourceText)) {
-        const hasKnownDefinition = segments.some((phrase) => {
-            const canonical = (0, maps_1.normalizeAdditionalInstructionKey)(phrase);
-            return (maps_1.DEFAULT_ADDITIONAL_INSTRUCTION_DEFINITIONS[canonical] ||
-                findAdditionalInstructionDefinition(phrase, canonical));
-        });
-        if (!hasKnownDefinition) {
-            return;
-        }
-    }
-    const phrases = segments.length ? segments : [joined];
-    const seen = new Set();
-    const instructions = [];
-    for (const phrase of phrases) {
-        const canonical = (0, maps_1.normalizeAdditionalInstructionKey)(phrase);
-        const definition = (_a = maps_1.DEFAULT_ADDITIONAL_INSTRUCTION_DEFINITIONS[canonical]) !== null && _a !== void 0 ? _a : findAdditionalInstructionDefinition(phrase, canonical);
-        const key = ((_b = definition === null || definition === void 0 ? void 0 : definition.coding) === null || _b === void 0 ? void 0 : _b.code)
-            ? `code:${(_c = definition.coding.system) !== null && _c !== void 0 ? _c : SNOMED_SYSTEM}|${definition.coding.code}`
-            : canonical
-                ? `text:${canonical}`
-                : phrase.toLowerCase();
-        if (key && seen.has(key)) {
-            continue;
-        }
-        seen.add(key);
-        if (definition) {
-            instructions.push({
-                text: (_d = definition.text) !== null && _d !== void 0 ? _d : phrase,
-                coding: ((_e = definition.coding) === null || _e === void 0 ? void 0 : _e.code)
-                    ? {
-                        code: definition.coding.code,
-                        display: definition.coding.display,
-                        system: (_f = definition.coding.system) !== null && _f !== void 0 ? _f : SNOMED_SYSTEM,
-                        i18n: definition.i18n
-                    }
-                    : undefined
-            });
-        }
-        else if (!MEAL_CONTEXT_CONNECTORS.has(phrase.toLowerCase())) {
-            instructions.push({ text: phrase });
-        }
-    }
-    if (instructions.length) {
-        internal.additionalInstructions = instructions;
-        for (const token of trailing) {
-            mark(internal.consumed, token);
-        }
-    }
-}
-function determinePrnReasonCutoff(tokens, sourceText) {
-    const separatorIndex = findPrnReasonSeparator(sourceText);
-    if (separatorIndex === undefined) {
-        return undefined;
-    }
-    const lowerSource = sourceText.toLowerCase();
-    let searchOffset = 0;
-    for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
-        const fragment = token.original.trim();
-        if (!fragment) {
-            continue;
-        }
-        const lowerFragment = fragment.toLowerCase();
-        const position = lowerSource.indexOf(lowerFragment, searchOffset);
-        if (position === -1) {
-            continue;
-        }
-        const end = position + lowerFragment.length;
-        searchOffset = end;
-        if (position >= separatorIndex) {
-            return i;
-        }
-    }
-    return undefined;
-}
-function findPrnReasonSeparator(sourceText) {
-    var _a;
-    for (let i = 0; i < sourceText.length; i++) {
-        const ch = sourceText[i];
-        if (ch === "\n" || ch === "\r") {
-            if (sourceText.slice(i + 1).trim().length > 0) {
-                return i;
-            }
-            continue;
-        }
-        if (ch === ";") {
-            if (sourceText.slice(i + 1).trim().length > 0) {
-                return i;
-            }
-            continue;
-        }
-        if (ch === "-") {
-            const prev = sourceText[i - 1];
-            const next = sourceText[i + 1];
-            const hasWhitespaceAround = (!prev || /\s/.test(prev)) && (!next || /\s/.test(next));
-            if (hasWhitespaceAround && sourceText.slice(i + 1).trim().length > 0) {
-                return i;
-            }
-            continue;
-        }
-        if (ch === ":" || ch === ".") {
-            const rest = sourceText.slice(i + 1);
-            if (!rest.trim().length) {
-                continue;
-            }
-            const nextChar = rest.replace(/^\s+/, "")[0];
-            if (!nextChar) {
-                continue;
-            }
-            if (ch === "." &&
-                /[0-9]/.test((_a = sourceText[i - 1]) !== null && _a !== void 0 ? _a : "") &&
-                /[0-9]/.test(nextChar)) {
-                continue;
-            }
-            return i;
-        }
-    }
-    return undefined;
-}
-function findTrailingPrnSiteSuffix(tokens, internal, options) {
-    var _a;
-    let suffixStart;
-    let hasSiteHint = false;
-    let hasConnector = false;
-    for (let i = tokens.length - 1; i >= 0; i--) {
-        const token = tokens[i];
-        const lower = normalizeTokenLower(token);
-        if (!lower) {
-            if (suffixStart !== undefined && token.original.trim()) {
-                break;
-            }
-            continue;
-        }
-        if (isBodySiteHint(lower, internal.customSiteHints)) {
-            hasSiteHint = true;
-            suffixStart = i;
-            continue;
-        }
-        if (suffixStart !== undefined) {
-            if (SITE_CONNECTORS.has(lower)) {
-                hasConnector = true;
-                suffixStart = i;
-                continue;
-            }
-            if (SITE_FILLER_WORDS.has(lower) || ROUTE_DESCRIPTOR_FILLER_WORDS.has(lower)) {
-                suffixStart = i;
-                continue;
-            }
-        }
-        if (suffixStart !== undefined) {
-            break;
-        }
-    }
-    if (!hasSiteHint || !hasConnector || suffixStart === undefined || suffixStart === 0) {
-        return undefined;
-    }
-    const suffixTokens = tokens.slice(suffixStart);
-    const siteWords = [];
-    const siteHintTokens = [];
-    for (const token of suffixTokens) {
-        const trimmed = token.original.trim();
-        if (!trimmed) {
-            continue;
-        }
-        const lower = normalizeTokenLower(token);
-        if (SITE_CONNECTORS.has(lower) ||
-            SITE_FILLER_WORDS.has(lower) ||
-            ROUTE_DESCRIPTOR_FILLER_WORDS.has(lower)) {
-            continue;
-        }
-        siteHintTokens.push(token);
-        siteWords.push(trimmed);
-    }
-    if (!siteWords.length) {
-        return undefined;
-    }
-    const sitePhrase = siteWords.join(" ");
-    const canonical = (0, maps_1.normalizeBodySiteKey)(sitePhrase);
-    if (!canonical) {
-        return undefined;
-    }
-    const definition = (_a = lookupBodySiteDefinition(options === null || options === void 0 ? void 0 : options.siteCodeMap, canonical)) !== null && _a !== void 0 ? _a : maps_1.DEFAULT_BODY_SITE_SNOMED[canonical];
-    if (!definition) {
-        return undefined;
-    }
-    return {
-        tokens: siteHintTokens,
-        startIndex: suffixStart
-    };
-}
-function lookupPrnReasonDefinition(map, canonical) {
-    if (!map) {
-        return undefined;
-    }
-    const direct = map[canonical];
-    if (direct) {
-        return direct;
-    }
-    for (const [key, definition] of (0, object_1.objectEntries)(map)) {
-        if ((0, maps_1.normalizePrnReasonKey)(key) === canonical) {
-            return definition;
-        }
-        if (definition.aliases) {
-            for (const alias of definition.aliases) {
-                if ((0, maps_1.normalizePrnReasonKey)(alias) === canonical) {
-                    return definition;
-                }
-            }
-        }
-    }
-    return undefined;
-}
-function pickPrnReasonSelection(selections, request) {
-    if (!selections) {
-        return undefined;
-    }
-    const canonical = request.canonical;
-    const normalizedText = (0, maps_1.normalizePrnReasonKey)(request.text);
-    const requestRange = request.range;
-    for (const selection of toArray(selections)) {
-        if (!selection) {
-            continue;
-        }
-        let matched = false;
-        if (selection.range) {
-            if (!requestRange) {
-                continue;
-            }
-            if (selection.range.start !== requestRange.start ||
-                selection.range.end !== requestRange.end) {
-                continue;
-            }
-            matched = true;
-        }
-        if (selection.canonical) {
-            if ((0, maps_1.normalizePrnReasonKey)(selection.canonical) !== canonical) {
-                continue;
-            }
-            matched = true;
-        }
-        else if (selection.text) {
-            const normalizedSelection = (0, maps_1.normalizePrnReasonKey)(selection.text);
-            if (normalizedSelection !== canonical && normalizedSelection !== normalizedText) {
-                continue;
-            }
-            matched = true;
-        }
-        if (!selection.range && !selection.canonical && !selection.text) {
-            continue;
-        }
-        if (matched) {
-            return selection.resolution;
-        }
-    }
-    return undefined;
-}
-function applyPrnReasonDefinition(internal, definition) {
-    var _a;
-    const coding = definition.coding;
-    internal.asNeededReasonCoding = (coding === null || coding === void 0 ? void 0 : coding.code)
-        ? {
-            code: coding.code,
-            display: coding.display,
-            system: (_a = coding.system) !== null && _a !== void 0 ? _a : SNOMED_SYSTEM,
-            i18n: definition.i18n
-        }
-        : undefined;
-    if (definition.text && !internal.asNeededReason) {
-        internal.asNeededReason = definition.text;
-    }
-}
-function definitionToPrnSuggestion(definition) {
-    var _a, _b, _c, _d;
-    return {
-        coding: ((_a = definition.coding) === null || _a === void 0 ? void 0 : _a.code)
-            ? {
-                code: definition.coding.code,
-                display: definition.coding.display,
-                system: (_b = definition.coding.system) !== null && _b !== void 0 ? _b : SNOMED_SYSTEM
-            }
-            : undefined,
-        text: (_c = definition.text) !== null && _c !== void 0 ? _c : (_d = definition.coding) === null || _d === void 0 ? void 0 : _d.display
-    };
-}
-function addReasonSuggestionToMap(map, suggestion) {
-    var _a;
-    if (!suggestion) {
-        return;
-    }
-    const coding = suggestion.coding;
-    const key = (coding === null || coding === void 0 ? void 0 : coding.code)
-        ? `${(_a = coding.system) !== null && _a !== void 0 ? _a : SNOMED_SYSTEM}|${coding.code}`
-        : suggestion.text
-            ? `text:${suggestion.text.toLowerCase()}`
-            : undefined;
-    if (!key || map.has(key)) {
-        return;
-    }
-    map.set(key, suggestion);
-}
-function collectReasonSuggestionResult(map, result) {
-    if (!result) {
-        return;
-    }
-    const suggestions = Array.isArray(result)
-        ? result
-        : typeof result === "object" && "suggestions" in result
-            ? result.suggestions
-            : [result];
-    for (const suggestion of suggestions) {
-        addReasonSuggestionToMap(map, suggestion);
-    }
-}
-function collectDefaultPrnReasonDefinitions(request) {
-    const canonical = request.canonical;
-    const normalized = request.normalized;
-    const seen = new Set();
-    for (const entry of maps_1.DEFAULT_PRN_REASON_ENTRIES) {
-        if (!entry.canonical) {
-            continue;
-        }
-        if (entry.canonical === canonical) {
-            seen.add(entry.definition);
-            continue;
-        }
-        if (canonical && (entry.canonical.includes(canonical) || canonical.includes(entry.canonical))) {
-            seen.add(entry.definition);
-            continue;
-        }
-        for (const term of entry.terms) {
-            const normalizedTerm = (0, maps_1.normalizePrnReasonKey)(term);
-            if (!normalizedTerm) {
-                continue;
-            }
-            if (canonical && canonical.includes(normalizedTerm)) {
-                seen.add(entry.definition);
-                break;
-            }
-            if (normalized.includes(normalizedTerm)) {
-                seen.add(entry.definition);
-                break;
-            }
-        }
-    }
-    if (!seen.size) {
-        for (const entry of maps_1.DEFAULT_PRN_REASON_ENTRIES) {
-            seen.add(entry.definition);
-        }
-    }
-    return Array.from(seen);
-}
-function runPrnReasonResolutionSync(internal, options) {
-    internal.prnReasonLookups = [];
-    const request = internal.prnReasonLookupRequest;
-    if (!request) {
-        return;
-    }
-    const canonical = request.canonical;
-    const selection = pickPrnReasonSelection(options === null || options === void 0 ? void 0 : options.prnReasonSelections, request);
-    const customDefinition = lookupPrnReasonDefinition(options === null || options === void 0 ? void 0 : options.prnReasonMap, canonical);
-    let resolution = selection !== null && selection !== void 0 ? selection : customDefinition;
-    if (!resolution) {
-        for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.prnReasonResolvers)) {
-            const result = resolver(request);
-            if (isPromise(result)) {
-                throw new Error("PRN reason resolver returned a Promise; use parseSigAsync for asynchronous PRN reason resolution.");
-            }
-            if (result) {
-                resolution = result;
-                break;
-            }
-        }
-    }
-    const defaultDefinition = canonical ? maps_1.DEFAULT_PRN_REASON_DEFINITIONS[canonical] : undefined;
-    if (!resolution && defaultDefinition) {
-        resolution = defaultDefinition;
-    }
-    if (resolution) {
-        applyPrnReasonDefinition(internal, resolution);
-    }
-    else {
-        internal.asNeededReasonCoding = undefined;
-    }
-    const needsSuggestions = request.isProbe || !resolution;
-    if (!needsSuggestions) {
-        return;
-    }
-    const suggestionMap = new Map();
-    if (selection) {
-        addReasonSuggestionToMap(suggestionMap, definitionToPrnSuggestion(selection));
-    }
-    if (customDefinition) {
-        addReasonSuggestionToMap(suggestionMap, definitionToPrnSuggestion(customDefinition));
-    }
-    if (defaultDefinition) {
-        addReasonSuggestionToMap(suggestionMap, definitionToPrnSuggestion(defaultDefinition));
-    }
-    for (const definition of collectDefaultPrnReasonDefinitions(request)) {
-        addReasonSuggestionToMap(suggestionMap, definitionToPrnSuggestion(definition));
-    }
-    for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.prnReasonSuggestionResolvers)) {
-        const result = resolver(request);
-        if (isPromise(result)) {
-            throw new Error("PRN reason suggestion resolver returned a Promise; use parseSigAsync for asynchronous PRN reason suggestions.");
-        }
-        collectReasonSuggestionResult(suggestionMap, result);
-    }
-    const suggestions = Array.from(suggestionMap.values());
-    if (suggestions.length || request.isProbe) {
-        internal.prnReasonLookups.push({ request, suggestions });
-    }
-}
-function runPrnReasonResolutionAsync(internal, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        internal.prnReasonLookups = [];
-        const request = internal.prnReasonLookupRequest;
-        if (!request) {
-            return;
-        }
-        const canonical = request.canonical;
-        const selection = pickPrnReasonSelection(options === null || options === void 0 ? void 0 : options.prnReasonSelections, request);
-        const customDefinition = lookupPrnReasonDefinition(options === null || options === void 0 ? void 0 : options.prnReasonMap, canonical);
-        let resolution = selection !== null && selection !== void 0 ? selection : customDefinition;
-        if (!resolution) {
-            for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.prnReasonResolvers)) {
-                const result = yield resolver(request);
-                if (result) {
-                    resolution = result;
-                    break;
-                }
-            }
-        }
-        const defaultDefinition = canonical ? maps_1.DEFAULT_PRN_REASON_DEFINITIONS[canonical] : undefined;
-        if (!resolution && defaultDefinition) {
-            resolution = defaultDefinition;
-        }
-        if (resolution) {
-            applyPrnReasonDefinition(internal, resolution);
-        }
-        else {
-            internal.asNeededReasonCoding = undefined;
-        }
-        const needsSuggestions = request.isProbe || !resolution;
-        if (!needsSuggestions) {
-            return;
-        }
-        const suggestionMap = new Map();
-        if (selection) {
-            addReasonSuggestionToMap(suggestionMap, definitionToPrnSuggestion(selection));
-        }
-        if (customDefinition) {
-            addReasonSuggestionToMap(suggestionMap, definitionToPrnSuggestion(customDefinition));
-        }
-        if (defaultDefinition) {
-            addReasonSuggestionToMap(suggestionMap, definitionToPrnSuggestion(defaultDefinition));
-        }
-        for (const definition of collectDefaultPrnReasonDefinitions(request)) {
-            addReasonSuggestionToMap(suggestionMap, definitionToPrnSuggestion(definition));
-        }
-        for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.prnReasonSuggestionResolvers)) {
-            const result = yield resolver(request);
-            collectReasonSuggestionResult(suggestionMap, result);
-        }
-        const suggestions = Array.from(suggestionMap.values());
-        if (suggestions.length || request.isProbe) {
-            internal.prnReasonLookups.push({ request, suggestions });
-        }
-    });
-}
-/**
- * Wraps scalar or array configuration into an array to simplify iteration.
- */
-function toArray(value) {
-    if (!value) {
-        return [];
-    }
-    return Array.isArray(value) ? value : [value];
-}
-/**
- * Detects thenables without relying on `instanceof Promise`, which can break
- * across execution contexts.
- */
-function isPromise(value) {
-    return !!value && typeof value.then === "function";
-}
-function normalizeUnit(token, options) {
-    var _a;
-    const override = enforceHouseholdUnitPolicy((_a = options === null || options === void 0 ? void 0 : options.unitMap) === null || _a === void 0 ? void 0 : _a[token], options);
-    if (override) {
-        return override;
-    }
-    const defaultUnit = enforceHouseholdUnitPolicy(maps_1.DEFAULT_UNIT_SYNONYMS[token], options);
-    if (defaultUnit) {
-        return defaultUnit;
-    }
-    return undefined;
-}
-function enforceHouseholdUnitPolicy(unit, options) {
-    if (unit &&
-        (options === null || options === void 0 ? void 0 : options.allowHouseholdVolumeUnits) === false &&
-        HOUSEHOLD_VOLUME_UNIT_SET.has(unit.toLowerCase())) {
-        return undefined;
-    }
-    return unit;
-}
-function isDiscreteUnit(unit) {
-    if (!unit) {
-        return false;
-    }
-    return DISCRETE_UNIT_SET.has(unit.trim().toLowerCase());
-}
-function inferUnitFromRouteHints(internal) {
-    if (internal.routeCode) {
-        const unit = maps_1.DEFAULT_UNIT_BY_ROUTE[internal.routeCode];
-        if (unit) {
-            return unit;
-        }
-    }
-    if (internal.routeText) {
-        const normalized = internal.routeText.trim().toLowerCase();
-        const synonym = maps_1.DEFAULT_ROUTE_SYNONYMS[normalized];
-        if (synonym) {
-            const unit = maps_1.DEFAULT_UNIT_BY_ROUTE[synonym.code];
-            if (unit) {
-                return unit;
-            }
-        }
-    }
-    if (internal.siteText) {
-        const unit = inferUnitFromSiteText(internal.siteText);
-        if (unit) {
-            return unit;
-        }
-    }
-    return undefined;
-}
-function inferUnitFromSiteText(siteText) {
-    for (const { pattern, route } of SITE_UNIT_ROUTE_HINTS) {
-        if (pattern.test(siteText)) {
-            const unit = maps_1.DEFAULT_UNIT_BY_ROUTE[route];
-            if (unit) {
-                return unit;
-            }
-        }
-    }
-    return undefined;
-}