ezmedicationinput 0.1.0 → 0.1.2

package/dist/parser.js

@@ -1,7 +1,13 @@
-import { DAY_OF_WEEK_TOKENS, DEFAULT_ROUTE_SYNONYMS, DEFAULT_UNIT_SYNONYMS, EVENT_TIMING_TOKENS, MEAL_KEYWORDS, ROUTE_TEXT, TIMING_ABBREVIATIONS, WORD_FREQUENCIES } from "./maps";
-import { inferUnitFromContext } from "./context";
-import { checkDiscouraged } from "./safety";
-import { EventTiming, FhirPeriodUnit, RouteCode } from "./types";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = tokenize;
+exports.parseInternal = parseInternal;
+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 BODY_SITE_HINTS = new Set([
     "left",
     "right",
@@ -31,75 +37,491 @@ const BODY_SITE_HINTS = new Set([
     "upper",
     "lower",
     "forearm",
-    "back"
+    "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",
+    "rectum",
+    "rectal",
+    "anus",
+    "perineum"
+]);
+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 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": EventTiming["Early Morning"],
-    "late morning": EventTiming["Late Morning"],
-    "early afternoon": EventTiming["Early Afternoon"],
-    "late afternoon": EventTiming["Late Afternoon"],
-    "early evening": EventTiming["Early Evening"],
-    "late evening": EventTiming["Late Evening"],
-    "after sleep": EventTiming["After Sleep"],
-    "upon waking": EventTiming.Wake
+    "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"],
+    "upon waking": types_1.EventTiming.Wake
 };
 // 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([
-    EventTiming["Before Breakfast"],
-    EventTiming["Before Lunch"],
-    EventTiming["Before Dinner"],
-    EventTiming["After Breakfast"],
-    EventTiming["After Lunch"],
-    EventTiming["After Dinner"],
-    EventTiming.Breakfast,
-    EventTiming.Lunch,
-    EventTiming.Dinner
+    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: RouteCode["Ophthalmic route"] },
-    re: { site: "right eye", route: RouteCode["Ophthalmic route"] },
-    os: { site: "left eye", route: RouteCode["Ophthalmic route"] },
-    le: { site: "left eye", route: RouteCode["Ophthalmic route"] },
-    ou: { site: "both eyes", route: RouteCode["Ophthalmic route"] },
-    be: { site: "both eyes", route: RouteCode["Ophthalmic route"] },
+    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: RouteCode["Intravitreal route (qualifier value)"]
+        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
     },
     vos: {
         site: "left eye",
-        route: RouteCode["Intravitreal route (qualifier value)"]
+        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
     },
     ivtod: {
         site: "right eye",
-        route: RouteCode["Intravitreal route (qualifier value)"]
+        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
     },
     ivtre: {
         site: "right eye",
-        route: RouteCode["Intravitreal route (qualifier value)"]
+        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
     },
     ivtos: {
         site: "left eye",
-        route: RouteCode["Intravitreal route (qualifier value)"]
+        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
     },
     ivtle: {
         site: "left eye",
-        route: RouteCode["Intravitreal route (qualifier value)"]
+        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
     },
     ivtou: {
         site: "both eyes",
-        route: RouteCode["Intravitreal route (qualifier value)"]
+        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
     },
     ivtbe: {
         site: "both eyes",
-        route: RouteCode["Intravitreal route (qualifier value)"]
+        route: types_1.RouteCode["Intravitreal route (qualifier value)"]
     }
 };
-export function tokenize(input) {
+const OPHTHALMIC_ROUTE_CODES = new Set([
+    types_1.RouteCode["Ophthalmic route"],
+    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 (BODY_SITE_HINTS.has(normalized)) {
+            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 (BODY_SITE_HINTS.has(normalized)) {
+            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];
+    if (internal.routeCode && !OPHTHALMIC_ROUTE_CODES.has(internal.routeCode)) {
+        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 = 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 (BODY_SITE_HINTS.has(normalized)) {
+            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;
+}
+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(/(\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);
@@ -154,7 +576,7 @@ function mark(consumed, token) {
     consumed.add(token.index);
 }
 function addWhen(target, code) {
-    if (!target.includes(code)) {
+    if (!(0, array_1.arrayIncludes)(target, code)) {
         target.push(code);
     }
 }
@@ -173,68 +595,69 @@ function computeMealExpansions(base, frequency, pairPreference) {
     if (frequency < 1 || frequency > 4) {
         return undefined;
     }
-    const bedtime = EventTiming["Before Sleep"];
+    const bedtime = types_1.EventTiming["Before Sleep"];
     const beforePair = pairPreference === "breakfast+lunch"
-        ? [EventTiming["Before Breakfast"], EventTiming["Before Lunch"]]
-        : [EventTiming["Before Breakfast"], EventTiming["Before Dinner"]];
+        ? [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"
-        ? [EventTiming["After Breakfast"], EventTiming["After Lunch"]]
-        : [EventTiming["After Breakfast"], EventTiming["After Dinner"]];
+        ? [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"
-        ? [EventTiming.Breakfast, EventTiming.Lunch]
-        : [EventTiming.Breakfast, EventTiming.Dinner];
+        ? [types_1.EventTiming.Breakfast, types_1.EventTiming.Lunch]
+        : [types_1.EventTiming.Breakfast, types_1.EventTiming.Dinner];
     if (base === "before") {
         if (frequency === 1)
-            return [EventTiming["Before Breakfast"]];
+            return [types_1.EventTiming["Before Breakfast"]];
         if (frequency === 2)
             return beforePair;
         if (frequency === 3) {
             return [
-                EventTiming["Before Breakfast"],
-                EventTiming["Before Lunch"],
-                EventTiming["Before Dinner"]
+                types_1.EventTiming["Before Breakfast"],
+                types_1.EventTiming["Before Lunch"],
+                types_1.EventTiming["Before Dinner"]
             ];
         }
         return [
-            EventTiming["Before Breakfast"],
-            EventTiming["Before Lunch"],
-            EventTiming["Before Dinner"],
+            types_1.EventTiming["Before Breakfast"],
+            types_1.EventTiming["Before Lunch"],
+            types_1.EventTiming["Before Dinner"],
             bedtime
         ];
     }
     if (base === "after") {
         if (frequency === 1)
-            return [EventTiming["After Breakfast"]];
+            return [types_1.EventTiming["After Breakfast"]];
         if (frequency === 2)
             return afterPair;
         if (frequency === 3) {
             return [
-                EventTiming["After Breakfast"],
-                EventTiming["After Lunch"],
-                EventTiming["After Dinner"]
+                types_1.EventTiming["After Breakfast"],
+                types_1.EventTiming["After Lunch"],
+                types_1.EventTiming["After Dinner"]
             ];
         }
         return [
-            EventTiming["After Breakfast"],
-            EventTiming["After Lunch"],
-            EventTiming["After Dinner"],
+            types_1.EventTiming["After Breakfast"],
+            types_1.EventTiming["After Lunch"],
+            types_1.EventTiming["After Dinner"],
             bedtime
         ];
     }
     // base === "with"
     if (frequency === 1)
-        return [EventTiming.Breakfast];
+        return [types_1.EventTiming.Breakfast];
     if (frequency === 2)
         return withPair;
     if (frequency === 3) {
-        return [EventTiming.Breakfast, EventTiming.Lunch, EventTiming.Dinner];
+        return [types_1.EventTiming.Breakfast, types_1.EventTiming.Lunch, types_1.EventTiming.Dinner];
     }
-    return [EventTiming.Breakfast, EventTiming.Lunch, EventTiming.Dinner, bedtime];
+    return [types_1.EventTiming.Breakfast, types_1.EventTiming.Lunch, types_1.EventTiming.Dinner, bedtime];
 }
 // Optionally replace generic meal tokens with concrete breakfast/lunch/dinner
 // EventTiming codes when the cadence makes the intent obvious.
 function expandMealTimings(internal, options) {
-    if (!options?.smartMealExpansion) {
+    var _a;
+    if (!(options === null || options === void 0 ? void 0 : options.smartMealExpansion)) {
         return;
     }
     if (!internal.when.length) {
@@ -249,7 +672,7 @@ function expandMealTimings(internal, options) {
     }
     if (internal.period !== undefined &&
         internal.periodUnit !== undefined &&
-        (internal.periodUnit !== FhirPeriodUnit.Day || internal.period !== 1)) {
+        (internal.periodUnit !== types_1.FhirPeriodUnit.Day || internal.period !== 1)) {
         return;
     }
     if (internal.period !== undefined &&
@@ -257,30 +680,30 @@ function expandMealTimings(internal, options) {
         internal.period !== 1) {
         return;
     }
-    if (internal.periodUnit && internal.periodUnit !== FhirPeriodUnit.Day) {
+    if (internal.periodUnit && internal.periodUnit !== types_1.FhirPeriodUnit.Day) {
         return;
     }
     if (internal.frequencyMax !== undefined || internal.periodMax !== undefined) {
         return;
     }
-    const pairPreference = options.twoPerDayPair ?? "breakfast+dinner";
+    const pairPreference = (_a = options.twoPerDayPair) !== null && _a !== void 0 ? _a : "breakfast+dinner";
     const replacements = [];
-    if (internal.when.includes(EventTiming["Before Meal"])) {
+    if ((0, array_1.arrayIncludes)(internal.when, types_1.EventTiming["Before Meal"])) {
         const specifics = computeMealExpansions("before", frequency, pairPreference);
         if (specifics) {
-            replacements.push({ general: EventTiming["Before Meal"], specifics });
+            replacements.push({ general: types_1.EventTiming["Before Meal"], specifics });
         }
     }
-    if (internal.when.includes(EventTiming["After Meal"])) {
+    if ((0, array_1.arrayIncludes)(internal.when, types_1.EventTiming["After Meal"])) {
         const specifics = computeMealExpansions("after", frequency, pairPreference);
         if (specifics) {
-            replacements.push({ general: EventTiming["After Meal"], specifics });
+            replacements.push({ general: types_1.EventTiming["After Meal"], specifics });
         }
     }
-    if (internal.when.includes(EventTiming.Meal)) {
+    if ((0, array_1.arrayIncludes)(internal.when, types_1.EventTiming.Meal)) {
         const specifics = computeMealExpansions("with", frequency, pairPreference);
         if (specifics) {
-            replacements.push({ general: EventTiming.Meal, specifics });
+            replacements.push({ general: types_1.EventTiming.Meal, specifics });
         }
     }
     for (const { general, specifics } of replacements) {
@@ -292,15 +715,15 @@ function expandMealTimings(internal, options) {
 }
 function setRoute(internal, code, text) {
     internal.routeCode = code;
-    internal.routeText = text ?? ROUTE_TEXT[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 === FhirPeriodUnit.Hour && (!Number.isInteger(value) || value < 1)) {
-        return { value: Math.round(value * 60 * 1000) / 1000, unit: FhirPeriodUnit.Minute };
+    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 };
 }
@@ -309,28 +732,28 @@ function normalizePeriodValue(value, unit) {
  * demand conversion into minutes.
  */
 function normalizePeriodRange(low, high, unit) {
-    if (unit === FhirPeriodUnit.Hour && (!Number.isInteger(low) || !Number.isInteger(high) || low < 1 || high < 1)) {
+    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: FhirPeriodUnit.Minute
+            unit: types_1.FhirPeriodUnit.Minute
         };
     }
     return { low, high, unit };
 }
 function periodUnitSuffix(unit) {
     switch (unit) {
-        case FhirPeriodUnit.Minute:
+        case types_1.FhirPeriodUnit.Minute:
             return "min";
-        case FhirPeriodUnit.Hour:
+        case types_1.FhirPeriodUnit.Hour:
             return "h";
-        case FhirPeriodUnit.Day:
+        case types_1.FhirPeriodUnit.Day:
             return "d";
-        case FhirPeriodUnit.Week:
+        case types_1.FhirPeriodUnit.Week:
             return "wk";
-        case FhirPeriodUnit.Month:
+        case types_1.FhirPeriodUnit.Month:
             return "mo";
-        case FhirPeriodUnit.Year:
+        case types_1.FhirPeriodUnit.Year:
             return "a";
         default:
             return undefined;
@@ -342,8 +765,8 @@ function maybeAssignTimingCode(internal, value, unit) {
         return;
     }
     const key = `q${value}${suffix}`;
-    const descriptor = TIMING_ABBREVIATIONS[key];
-    if (descriptor?.code && !internal.timingCode) {
+    const descriptor = maps_1.TIMING_ABBREVIATIONS[key];
+    if ((descriptor === null || descriptor === void 0 ? void 0 : descriptor.code) && !internal.timingCode) {
         internal.timingCode = descriptor.code;
     }
 }
@@ -352,18 +775,19 @@ function maybeAssignTimingCode(internal, value, unit) {
  * 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 === FhirPeriodUnit.Day && normalized.value === 1) {
-        internal.frequency = internal.frequency ?? 1;
+    if (normalized.unit === types_1.FhirPeriodUnit.Day && normalized.value === 1) {
+        internal.frequency = (_a = internal.frequency) !== null && _a !== void 0 ? _a : 1;
     }
-    if (normalized.unit === FhirPeriodUnit.Week && normalized.value === 1) {
-        internal.timingCode = internal.timingCode ?? "WK";
+    if (normalized.unit === types_1.FhirPeriodUnit.Week && normalized.value === 1) {
+        internal.timingCode = (_b = internal.timingCode) !== null && _b !== void 0 ? _b : "WK";
     }
-    if (normalized.unit === FhirPeriodUnit.Month && normalized.value === 1) {
-        internal.timingCode = internal.timingCode ?? "MO";
+    if (normalized.unit === types_1.FhirPeriodUnit.Month && normalized.value === 1) {
+        internal.timingCode = (_c = internal.timingCode) !== null && _c !== void 0 ? _c : "MO";
     }
 }
 /**
@@ -406,7 +830,7 @@ function tryParseCompactQ(internal, tokens, index) {
 }
 function applyFrequencyDescriptor(internal, token, descriptor, options) {
     if (descriptor.discouraged) {
-        const check = checkDiscouraged(token.original, options);
+        const check = (0, safety_1.checkDiscouraged)(token.original, options);
         if (check.warning) {
             internal.warnings.push(check.warning);
         }
@@ -447,11 +871,11 @@ function parseMealContext(internal, tokens, index, code) {
         applyWhenToken(internal, token, code);
         return;
     }
-    const meal = MEAL_KEYWORDS[next.lower];
+    const meal = maps_1.MEAL_KEYWORDS[next.lower];
     if (meal) {
-        const whenCode = code === EventTiming["After Meal"]
+        const whenCode = code === types_1.EventTiming["After Meal"]
             ? meal.pc
-            : code === EventTiming["Before Meal"]
+            : code === types_1.EventTiming["Before Meal"]
                 ? meal.ac
                 : code;
         applyWhenToken(internal, token, whenCode);
@@ -519,19 +943,19 @@ function mapIntervalUnit(token) {
         token === "minute" ||
         token === "minutes" ||
         token === "m") {
-        return FhirPeriodUnit.Minute;
+        return types_1.FhirPeriodUnit.Minute;
     }
     if (token === "h" || token === "hr" || token === "hrs" || token === "hour" || token === "hours") {
-        return FhirPeriodUnit.Hour;
+        return types_1.FhirPeriodUnit.Hour;
     }
     if (token === "d" || token === "day" || token === "days") {
-        return FhirPeriodUnit.Day;
+        return types_1.FhirPeriodUnit.Day;
     }
     if (token === "wk" || token === "w" || token === "week" || token === "weeks") {
-        return FhirPeriodUnit.Week;
+        return types_1.FhirPeriodUnit.Week;
     }
     if (token === "mo" || token === "month" || token === "months") {
-        return FhirPeriodUnit.Month;
+        return types_1.FhirPeriodUnit.Month;
     }
     return undefined;
 }
@@ -547,7 +971,8 @@ function parseNumericRange(token) {
     }
     return { low, high };
 }
-export function parseInternal(input, options) {
+function parseInternal(input, options) {
+    var _a, _b, _c, _d, _e, _f;
     const tokens = tokenize(input);
     const internal = {
         input,
@@ -555,11 +980,12 @@ export function parseInternal(input, options) {
         consumed: new Set(),
         dayOfWeek: [],
         when: [],
-        warnings: []
+        warnings: [],
+        siteTokenIndices: new Set()
     };
-    const context = options?.context ?? undefined;
-    const customRouteMap = options?.routeMap
-        ? new Map(Object.entries(options.routeMap).map(([key, value]) => [
+    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
         ]))
@@ -577,12 +1003,12 @@ export function parseInternal(input, options) {
             prnReasonStart = i + 1;
             break;
         }
-        if (token.lower === "as" && tokens[i + 1]?.lower === "needed") {
+        if (token.lower === "as" && ((_b = tokens[i + 1]) === null || _b === void 0 ? void 0 : _b.lower) === "needed") {
             internal.asNeeded = true;
             mark(internal.consumed, token);
             mark(internal.consumed, tokens[i + 1]);
             let reasonIndex = i + 2;
-            if (tokens[reasonIndex]?.lower === "for") {
+            if (((_c = tokens[reasonIndex]) === null || _c === void 0 ? void 0 : _c.lower) === "for") {
                 mark(internal.consumed, tokens[reasonIndex]);
                 reasonIndex += 1;
             }
@@ -603,27 +1029,30 @@ export function parseInternal(input, options) {
             }
             internal.frequency = freq;
             internal.period = 1;
-            internal.periodUnit = FhirPeriodUnit.Day;
+            internal.periodUnit = types_1.FhirPeriodUnit.Day;
             mark(internal.consumed, token);
         }
     }
     // Process tokens sequentially
     const tryRouteSynonym = (startIndex) => {
-        const maxSpan = Math.min(5, tokens.length - startIndex);
+        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 phrase = slice.map((part) => part.lower).join(" ");
-            const customCode = customRouteMap?.get(phrase);
+            const customCode = customRouteMap === null || customRouteMap === void 0 ? void 0 : customRouteMap.get(phrase);
             const synonym = customCode
-                ? { code: customCode, text: ROUTE_TEXT[customCode] }
-                : DEFAULT_ROUTE_SYNONYMS[phrase];
+                ? { code: customCode, text: maps_1.ROUTE_TEXT[customCode] }
+                : maps_1.DEFAULT_ROUTE_SYNONYMS[phrase];
             if (synonym) {
                 setRoute(internal, synonym.code, synonym.text);
                 for (const part of slice) {
                     mark(internal.consumed, part);
+                    if (BODY_SITE_HINTS.has(part.lower)) {
+                        internal.siteTokenIndices.add(part.index);
+                    }
                 }
                 return true;
             }
@@ -635,12 +1064,13 @@ export function parseInternal(input, options) {
         if (internal.consumed.has(token.index)) {
             continue;
         }
+        const normalizedLower = normalizeTokenLower(token);
         if (token.lower === "bld" || token.lower === "b-l-d") {
-            const check = checkDiscouraged(token.original, options);
+            const check = (0, safety_1.checkDiscouraged)(token.original, options);
             if (check.warning) {
                 internal.warnings.push(check.warning);
             }
-            applyWhenToken(internal, token, EventTiming.Meal);
+            applyWhenToken(internal, token, types_1.EventTiming.Meal);
             continue;
         }
         if (token.lower === "q") {
@@ -648,8 +1078,25 @@ export function parseInternal(input, options) {
                 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 = TIMING_ABBREVIATIONS[token.lower];
+        const freqDescriptor = normalizedLower === "od"
+            ? undefined
+            : (_d = maps_1.TIMING_ABBREVIATIONS[token.lower]) !== null && _d !== void 0 ? _d : maps_1.TIMING_ABBREVIATIONS[normalizedLower];
         if (freqDescriptor) {
             applyFrequencyDescriptor(internal, token, freqDescriptor, options);
             continue;
@@ -660,34 +1107,34 @@ export function parseInternal(input, options) {
         // Event timing tokens
         if (token.lower === "pc" || token.lower === "ac") {
             parseMealContext(internal, tokens, i, token.lower === "pc"
-                ? EventTiming["After Meal"]
-                : EventTiming["Before Meal"]);
+                ? types_1.EventTiming["After Meal"]
+                : types_1.EventTiming["Before Meal"]);
             continue;
         }
         const nextToken = tokens[i + 1];
         if (nextToken && !internal.consumed.has(nextToken.index)) {
             const combo = `${token.lower} ${nextToken.lower}`;
-            const comboWhen = COMBO_EVENT_TIMINGS[combo] ?? EVENT_TIMING_TOKENS[combo];
+            const comboWhen = (_e = COMBO_EVENT_TIMINGS[combo]) !== null && _e !== void 0 ? _e : maps_1.EVENT_TIMING_TOKENS[combo];
             if (comboWhen) {
                 applyWhenToken(internal, token, comboWhen);
                 mark(internal.consumed, nextToken);
                 continue;
             }
         }
-        const customWhen = options?.whenMap?.[token.lower];
+        const customWhen = (_f = options === null || options === void 0 ? void 0 : options.whenMap) === null || _f === void 0 ? void 0 : _f[token.lower];
         if (customWhen) {
             applyWhenToken(internal, token, customWhen);
             continue;
         }
-        const whenCode = EVENT_TIMING_TOKENS[token.lower];
+        const whenCode = maps_1.EVENT_TIMING_TOKENS[token.lower];
         if (whenCode) {
             applyWhenToken(internal, token, whenCode);
             continue;
         }
         // Day of week
-        const day = DAY_OF_WEEK_TOKENS[token.lower];
+        const day = maps_1.DAY_OF_WEEK_TOKENS[token.lower];
         if (day) {
-            if (!internal.dayOfWeek.includes(day)) {
+            if (!(0, array_1.arrayIncludes)(internal.dayOfWeek, day)) {
                 internal.dayOfWeek.push(day);
             }
             mark(internal.consumed, token);
@@ -697,9 +1144,9 @@ export function parseInternal(input, options) {
         if (tryRouteSynonym(i)) {
             continue;
         }
-        const eyeSite = EYE_SITE_TOKENS[token.lower];
-        if (eyeSite) {
+        if (eyeSite && treatEyeTokenAsSite) {
             internal.siteText = eyeSite.site;
+            internal.siteSource = "abbreviation";
             if (eyeSite.route && !internal.routeCode) {
                 setRoute(internal, eyeSite.route);
             }
@@ -750,7 +1197,7 @@ export function parseInternal(input, options) {
             continue;
         }
         // Words for frequency
-        const wordFreq = WORD_FREQUENCIES[token.lower];
+        const wordFreq = maps_1.WORD_FREQUENCIES[token.lower];
         if (wordFreq) {
             internal.frequency = wordFreq.frequency;
             internal.period = 1;
@@ -759,7 +1206,7 @@ export function parseInternal(input, options) {
             continue;
         }
         // Skip generic connectors
-        if (token.lower === "per" || token.lower === "a" || token.lower === "every") {
+        if (token.lower === "per" || token.lower === "a" || token.lower === "every" || token.lower === "each") {
             mark(internal.consumed, token);
             continue;
         }
@@ -778,13 +1225,19 @@ export function parseInternal(input, options) {
         }
     }
     if (internal.unit === undefined) {
-        internal.unit = inferUnitFromContext(context);
+        internal.unit = (0, context_1.inferUnitFromContext)(context);
+    }
+    if (internal.unit === undefined) {
+        const fallbackUnit = inferUnitFromRouteHints(internal);
+        if (fallbackUnit) {
+            internal.unit = fallbackUnit;
+        }
     }
     // Frequency defaults when timing code implies it
     if (internal.frequency === undefined &&
         internal.period === undefined &&
         internal.timingCode) {
-        const descriptor = TIMING_ABBREVIATIONS[internal.timingCode.toLowerCase()];
+        const descriptor = maps_1.TIMING_ABBREVIATIONS[internal.timingCode.toLowerCase()];
         if (descriptor) {
             if (descriptor.frequency !== undefined) {
                 internal.frequency = descriptor.frequency;
@@ -804,7 +1257,7 @@ export function parseInternal(input, options) {
     }
     if (!internal.timingCode &&
         internal.frequency !== undefined &&
-        internal.periodUnit === FhirPeriodUnit.Day &&
+        internal.periodUnit === types_1.FhirPeriodUnit.Day &&
         (internal.period === undefined || internal.period === 1)) {
         if (internal.frequency === 2) {
             internal.timingCode = "BID";
@@ -820,19 +1273,76 @@ export function parseInternal(input, options) {
     expandMealTimings(internal, options);
     // Determine site text from leftover tokens (excluding PRN reason tokens)
     const leftoverTokens = tokens.filter((t) => !internal.consumed.has(t.index));
-    if (leftoverTokens.length > 0) {
-        const siteCandidates = leftoverTokens.filter((t) => BODY_SITE_HINTS.has(t.lower));
-        if (siteCandidates.length > 0) {
-            const indices = new Set(siteCandidates.map((t) => t.index));
-            const words = [];
-            for (const token of leftoverTokens) {
-                if (indices.has(token.index) || BODY_SITE_HINTS.has(token.lower)) {
-                    words.push(token.original);
-                    mark(internal.consumed, token);
+    const siteCandidateIndices = new Set();
+    for (const token of leftoverTokens) {
+        if (BODY_SITE_HINTS.has(token.lower)) {
+            siteCandidateIndices.add(token.index);
+        }
+    }
+    for (const idx of internal.siteTokenIndices) {
+        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 = token.lower;
+                if (SITE_CONNECTORS.has(lower) || BODY_SITE_HINTS.has(lower)) {
+                    indicesToInclude.add(token.index);
+                    prev -= 1;
+                    continue;
                 }
+                break;
             }
-            if (words.length > 0) {
-                internal.siteText = words.join(" ");
+            let next = idx + 1;
+            while (next < tokens.length) {
+                const token = tokens[next];
+                if (!token) {
+                    break;
+                }
+                const lower = token.lower;
+                if (SITE_CONNECTORS.has(lower) || BODY_SITE_HINTS.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 = token.lower;
+            if (!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) {
+            internal.siteText = normalizedSite;
+            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;
             }
         }
     }
@@ -851,20 +1361,57 @@ export function parseInternal(input, options) {
             internal.asNeededReason = reasonTokens.join(" ");
         }
     }
-    if (internal.routeCode === RouteCode["Intravitreal route (qualifier value)"] &&
+    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;
 }
 function normalizeUnit(token, options) {
-    const override = options?.unitMap?.[token];
+    var _a;
+    const override = (_a = options === null || options === void 0 ? void 0 : options.unitMap) === null || _a === void 0 ? void 0 : _a[token];
     if (override) {
         return override;
     }
-    const defaultUnit = DEFAULT_UNIT_SYNONYMS[token];
+    const defaultUnit = maps_1.DEFAULT_UNIT_SYNONYMS[token];
     if (defaultUnit) {
         return defaultUnit;
     }
     return undefined;
 }
+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;
+}