ezmedicationinput 0.1.14 → 0.1.16

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");
@@ -186,6 +188,33 @@ const COUNT_CONNECTOR_WORDS = new Set([
     "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",
@@ -290,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++) {
@@ -580,6 +609,115 @@ function tryParseNumericCadence(internal, tokens, index) {
     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;
+}
 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"] },
@@ -622,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);
@@ -658,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;
     }
@@ -1244,6 +1383,9 @@ function mapIntervalUnit(token) {
     }
     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) {
@@ -1282,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)
@@ -1391,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);
@@ -1620,6 +1771,9 @@ function parseInternal(input, options) {
             }
         }
         // Numeric dose
+        if (tryParseCountBasedFrequency(internal, tokens, i, options)) {
+            continue;
+        }
         const rangeValue = parseNumericRange(token.lower);
         if (rangeValue) {
             if (!internal.doseRange) {
@@ -1739,6 +1893,51 @@ 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 = [];
+        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);
+            mark(internal.consumed, token);
+        }
+        if (reasonTokens.length > 0) {
+            const joined = reasonTokens.join(" ").trim();
+            if (joined) {
+                const sortedIndices = reasonIndices.sort((a, b) => a - b);
+                const range = computeTokenRange(internal.input, tokens, sortedIndices);
+                const sourceText = range ? internal.input.slice(range.start, range.end) : undefined;
+                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();
@@ -1746,6 +1945,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) {
@@ -1807,7 +2013,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(/^\{(.+)}$/);
@@ -1858,21 +2064,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).");
@@ -1883,6 +2074,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);
 }
@@ -2098,16 +2297,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
@@ -2115,11 +2319,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
     };
@@ -2165,6 +2373,415 @@ 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;
+}
+function collectAdditionalInstructions(internal, tokens) {
+    var _a, _b, _c, _d, _e, _f;
+    if (internal.additionalInstructions.length) {
+        return;
+    }
+    const leftover = tokens.filter((token) => !internal.consumed.has(token.index));
+    if (!leftover.length) {
+        return;
+    }
+    const punctuationOnly = /^[;:.,-]+$/;
+    const contentTokens = leftover.filter((token) => !punctuationOnly.test(token.original));
+    if (!contentTokens.length) {
+        return;
+    }
+    const leftoverIndices = leftover.map((token) => token.index).sort((a, b) => a - b);
+    const contiguous = leftoverIndices.every((index, i) => i === 0 || index === leftoverIndices[i - 1] + 1);
+    if (!contiguous) {
+        return;
+    }
+    const lastIndex = leftoverIndices[leftoverIndices.length - 1];
+    for (let i = lastIndex + 1; i < tokens.length; i++) {
+        const trailingToken = tokens[i];
+        if (!internal.consumed.has(trailingToken.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 range = 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 leftover) {
+            mark(internal.consumed, token);
+        }
+    }
+}
+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.
  */