ezmedicationinput 0.1.15 → 0.1.17

package/dist/parser.js

@@ -11,6 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tokenize = tokenize;
 exports.parseInternal = parseInternal;
+exports.applyPrnReasonCoding = applyPrnReasonCoding;
+exports.applyPrnReasonCodingAsync = applyPrnReasonCodingAsync;
 exports.applySiteCoding = applySiteCoding;
 exports.applySiteCodingAsync = applySiteCodingAsync;
 const maps_1 = require("./maps");
@@ -317,7 +319,7 @@ const OPHTHALMIC_CONTEXT_TOKENS = new Set([
     "be"
 ]);
 function normalizeTokenLower(token) {
-    return token.lower.replace(/[.{}]/g, "");
+    return token.lower.replace(/[.{};]/g, "");
 }
 function hasOphthalmicContextHint(tokens, index) {
     for (let offset = -3; offset <= 3; offset++) {
@@ -758,8 +760,9 @@ const SITE_UNIT_ROUTE_HINTS = [
     { pattern: /\bvaginal\b/i, route: types_1.RouteCode["Per vagina"] }
 ];
 function tokenize(input) {
-    const separators = /[(),]/g;
+    const separators = /[(),;]/g;
     let normalized = input.trim().replace(separators, " ");
+    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);
@@ -794,7 +797,7 @@ function tokenize(input) {
  * 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 computeSiteTextRange(input, tokens, indices) {
+function computeTokenRange(input, tokens, indices) {
     if (!indices.length) {
         return undefined;
     }
@@ -1421,7 +1424,9 @@ function parseInternal(input, options) {
         warnings: [],
         siteTokenIndices: new Set(),
         siteLookups: [],
-        customSiteHints: buildCustomSiteHints(options === null || options === void 0 ? void 0 : options.siteCodeMap)
+        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)
@@ -1530,12 +1535,19 @@ function parseInternal(input, options) {
             if (slice.some((part) => internal.consumed.has(part.index))) {
                 continue;
             }
-            const phrase = slice.map((part) => part.lower).join(" ");
+            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) {
+                    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);
@@ -1881,6 +1893,93 @@ function parseInternal(input, options) {
     // 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 = [];
+        for (let i = prnReasonStart; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (internal.consumed.has(token.index)) {
+                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;
+                    }
+                }
+            }
+            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 canonical = sanitized
+                        ? (0, maps_1.normalizePrnReasonKey)(sanitized)
+                        : (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();
@@ -1888,6 +1987,13 @@ function parseInternal(input, options) {
         const normalized = normalizeTokenLower(token);
         if (isBodySiteHint(normalized, internal.customSiteHints)) {
             siteCandidateIndices.add(token.index);
+            continue;
+        }
+        if (SITE_CONNECTORS.has(normalized)) {
+            const next = tokens[token.index + 1];
+            if (next && !internal.consumed.has(next.index)) {
+                siteCandidateIndices.add(next.index);
+            }
         }
     }
     for (const idx of internal.siteTokenIndices) {
@@ -1949,7 +2055,7 @@ function parseInternal(input, options) {
             .join(" ")
             .trim();
         if (normalizedSite) {
-            const tokenRange = computeSiteTextRange(internal.input, tokens, sortedIndices);
+            const tokenRange = computeTokenRange(internal.input, tokens, sortedIndices);
             let sanitized = normalizedSite;
             let isProbe = false;
             const probeMatch = sanitized.match(/^\{(.+)}$/);
@@ -1964,27 +2070,30 @@ function parseInternal(input, options) {
             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: sanitized,
-                normalized: sanitized.toLowerCase(),
-                canonical: sanitized ? (0, maps_1.normalizeBodySiteKey)(sanitized) : "",
+                text: displayText,
+                normalized: displayLower,
+                canonical,
                 isProbe,
                 inputText: internal.input,
                 sourceText,
                 range
             };
-            if (sanitized) {
+            if (displayText) {
                 const normalizedLower = sanitized.toLowerCase();
                 const strippedDescriptor = normalizeRouteDescriptorPhrase(normalizedLower);
-                const siteWords = normalizedLower.split(/\s+/).filter((word) => word.length > 0);
+                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 = sanitized;
+                    internal.siteText = displayText;
                     if (!internal.siteSource) {
                         internal.siteSource = "text";
                     }
@@ -2000,21 +2109,6 @@ function parseInternal(input, options) {
             }
         }
     }
-    // PRN reason text
-    if (internal.asNeeded && prnReasonStart !== undefined) {
-        const reasonTokens = [];
-        for (let i = prnReasonStart; i < tokens.length; i++) {
-            const token = tokens[i];
-            if (internal.consumed.has(token.index)) {
-                continue;
-            }
-            reasonTokens.push(token.original);
-            mark(internal.consumed, token);
-        }
-        if (reasonTokens.length > 0) {
-            internal.asNeededReason = reasonTokens.join(" ");
-        }
-    }
     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).");
@@ -2025,6 +2119,14 @@ function parseInternal(input, options) {
  * 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);
 }
@@ -2240,16 +2342,21 @@ function pickSiteSelection(selections, request) {
  * the coding system to SNOMED CT when the definition omits one.
  */
 function applySiteDefinition(internal, definition) {
-    var _a;
+    var _a, _b;
     const coding = definition.coding;
-    internal.siteCoding = {
-        code: coding.code,
-        display: coding.display,
-        system: (_a = coding.system) !== null && _a !== void 0 ? _a : SNOMED_SYSTEM
-    };
+    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
@@ -2257,11 +2364,15 @@ function applySiteDefinition(internal, definition) {
  */
 function definitionToSuggestion(definition) {
     var _a;
+    const coding = definition.coding;
+    if (!(coding === null || coding === void 0 ? void 0 : coding.code)) {
+        return undefined;
+    }
     return {
         coding: {
-            code: definition.coding.code,
-            display: definition.coding.display,
-            system: (_a = definition.coding.system) !== null && _a !== void 0 ? _a : SNOMED_SYSTEM
+            code: coding.code,
+            display: coding.display,
+            system: (_a = coding.system) !== null && _a !== void 0 ? _a : SNOMED_SYSTEM
         },
         text: definition.text
     };
@@ -2307,6 +2418,676 @@ function collectSuggestionResult(map, result) {
         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;
+        }
+        if (entry.canonical === canonical) {
+            return entry.definition;
+        }
+        if (canonical.includes(entry.canonical) || entry.canonical.includes(canonical)) {
+            return entry.definition;
+        }
+        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 || !isAdjectivalSitePhrase(canonicalInput)) {
+        return trimmed;
+    }
+    const definition = (_a = lookupBodySiteDefinition(customSiteMap, canonicalInput)) !== null && _a !== void 0 ? _a : maps_1.DEFAULT_BODY_SITE_SNOMED[canonicalInput];
+    if (!definition) {
+        return trimmed;
+    }
+    const preferred = pickPreferredBodySitePhrase(canonicalInput, definition, customSiteMap);
+    if (!preferred) {
+        return trimmed;
+    }
+    return preferred;
+}
+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;
+    if (!separatorDetected && !/[-;:.]/.test(sourceText)) {
+        return;
+    }
+    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);
+    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
+                    }
+                    : undefined
+            });
+        }
+        else {
+            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 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
+        }
+        : 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.
  */