ezmedicationinput 0.1.43 → 0.1.45

package/dist/suggest.js

@@ -1,907 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.suggestSig = suggestSig;
-const context_1 = require("./context");
-const maps_1 = require("./maps");
-const types_1 = require("./types");
-const DEFAULT_LIMIT = 10;
-const HOUSEHOLD_VOLUME_UNIT_SET = new Set(maps_1.HOUSEHOLD_VOLUME_UNITS.map((unit) => unit.trim().toLowerCase()));
-const ROUTE_TOKEN_BY_CODE = {
-    [types_1.RouteCode["Oral route"]]: "po",
-    [types_1.RouteCode["Respiratory tract route (qualifier value)"]]: "inh",
-    [types_1.RouteCode["Nasal route"]]: "in",
-    [types_1.RouteCode["Ophthalmic route"]]: "oph",
-    [types_1.RouteCode["Per rectum"]]: "pr",
-    [types_1.RouteCode["Transdermal route"]]: "transdermal",
-    [types_1.RouteCode["Topical route"]]: "topical",
-};
-const DEFAULT_UNIT_ROUTE_ORDER = [
-    { unit: "tab", routeCode: types_1.RouteCode["Oral route"] },
-    { unit: "cap", routeCode: types_1.RouteCode["Oral route"] },
-    { unit: "tsp", routeCode: types_1.RouteCode["Oral route"] },
-    { unit: "tbsp", routeCode: types_1.RouteCode["Oral route"] },
-    { unit: "mL", routeCode: types_1.RouteCode["Oral route"] },
-    { unit: "L", routeCode: types_1.RouteCode["Oral route"] },
-    { unit: "mcL", routeCode: types_1.RouteCode["Oral route"] },
-    { unit: "nL", routeCode: types_1.RouteCode["Oral route"] },
-    { unit: "mg", routeCode: types_1.RouteCode["Oral route"] },
-    { unit: "mcg", routeCode: types_1.RouteCode["Oral route"] },
-    { unit: "ng", routeCode: types_1.RouteCode["Oral route"] },
-    { unit: "g", routeCode: types_1.RouteCode["Topical route"] },
-    { unit: "kg", routeCode: types_1.RouteCode["Topical route"] },
-    { unit: "puff", routeCode: types_1.RouteCode["Respiratory tract route (qualifier value)"] },
-    { unit: "spray", routeCode: types_1.RouteCode["Nasal route"] },
-    { unit: "drop", routeCode: types_1.RouteCode["Ophthalmic route"] },
-    { unit: "suppository", routeCode: types_1.RouteCode["Per rectum"] },
-    { unit: "patch", routeCode: types_1.RouteCode["Transdermal route"] },
-];
-const ROUTE_TOKEN_BY_UNIT = (() => {
-    var _a, _b, _c;
-    const map = new Map();
-    const assign = (unit, token) => {
-        if (!unit || !token) {
-            return;
-        }
-        const normalizedUnit = normalizeKey(unit);
-        if (!normalizedUnit || map.has(normalizedUnit)) {
-            return;
-        }
-        map.set(normalizedUnit, normalizeSpacing(token));
-    };
-    for (const routeCodeKey in maps_1.DEFAULT_UNIT_BY_ROUTE) {
-        if (!Object.prototype.hasOwnProperty.call(maps_1.DEFAULT_UNIT_BY_ROUTE, routeCodeKey)) {
-            continue;
-        }
-        const routeCode = routeCodeKey;
-        const unit = maps_1.DEFAULT_UNIT_BY_ROUTE[routeCode];
-        if (!unit) {
-            continue;
-        }
-        const token = (_a = ROUTE_TOKEN_BY_CODE[routeCode]) !== null && _a !== void 0 ? _a : maps_1.ROUTE_TEXT[routeCode];
-        assign(unit, token);
-    }
-    for (const preference of DEFAULT_UNIT_ROUTE_ORDER) {
-        const token = (_c = (_b = preference.routeToken) !== null && _b !== void 0 ? _b : ROUTE_TOKEN_BY_CODE[preference.routeCode]) !== null && _c !== void 0 ? _c : maps_1.ROUTE_TEXT[preference.routeCode];
-        assign(preference.unit, token);
-    }
-    return map;
-})();
-const BASE_INTERVAL_CODES = Object.keys(maps_1.TIMING_ABBREVIATIONS)
-    .filter((token) => /^q\d+h$/.test(token))
-    .sort((a, b) => Number.parseInt(a.slice(1, -1), 10) - Number.parseInt(b.slice(1, -1), 10));
-const DEFAULT_INTERVAL_RANGES = ["q2-4h", "q4-6h", "q6-8h", "q8-12h"];
-const BASE_WHEN_TOKEN_CANDIDATES = [
-    "ac",
-    "pc",
-    "hs",
-    "am",
-    "pm",
-    "morn",
-    "morning",
-    "noon",
-    "afternoon",
-    "evening",
-    "night",
-    "bedtime",
-    "wake",
-    "waking",
-    "breakfast",
-    "lunch",
-    "dinner",
-    "stat",
-];
-const WHEN_TOKENS = BASE_WHEN_TOKEN_CANDIDATES.filter((token) => maps_1.EVENT_TIMING_TOKENS[token] !== undefined);
-const WHEN_COMBINATIONS = [
-    "am",
-    "morning",
-    "morn",
-    "noon",
-    "afternoon",
-    "pm",
-    "evening",
-    "night",
-    "hs",
-    "bedtime",
-].filter((token) => maps_1.EVENT_TIMING_TOKENS[token] !== undefined);
-const CORE_WHEN_TOKENS = ["pc", "ac", "hs"].filter((token) => maps_1.EVENT_TIMING_TOKENS[token] !== undefined);
-const FREQUENCY_CODES = ["qd", "od", "bid", "tid", "qid"].filter((token) => maps_1.TIMING_ABBREVIATIONS[token] !== undefined);
-const FREQUENCY_CODE_SUFFIXES = FREQUENCY_CODES.map((code) => ` ${code}`);
-const FREQ_TOKEN_BY_NUMBER = {};
-for (const [frequency, token] of [
-    [1, "qd"],
-    [2, "bid"],
-    [3, "tid"],
-    [4, "qid"],
-]) {
-    if (maps_1.TIMING_ABBREVIATIONS[token]) {
-        FREQ_TOKEN_BY_NUMBER[frequency] = token;
-    }
-}
-const FREQUENCY_NUMBERS = Object.keys(FREQ_TOKEN_BY_NUMBER)
-    .map((value) => Number.parseInt(value, 10))
-    .sort((a, b) => a - b);
-const DEFAULT_PRN_REASONS = [
-    "pain",
-    "nausea",
-    "itching",
-    "anxiety",
-    "sleep",
-    "cough",
-    "fever",
-    "spasm",
-    "constipation",
-    "dyspnea",
-];
-const DEFAULT_DOSE_COUNTS = ["1", "2"];
-const OPTIONAL_MATCH_TOKENS = new Set([
-    "to",
-    "into",
-    "in",
-    "on",
-    "onto",
-    "per",
-    "for",
-    "the",
-    "od",
-    "os",
-    "ou",
-]);
-const ROUTE_TOKEN_FRAGMENTS = new Set();
-for (const phrase of Object.keys(maps_1.DEFAULT_ROUTE_SYNONYMS)) {
-    for (const fragment of phrase.split(/\s+/)) {
-        const normalized = fragment.trim();
-        if (normalized) {
-            ROUTE_TOKEN_FRAGMENTS.add(normalized);
-        }
-    }
-}
-const SKIPPABLE_CANDIDATE_TOKENS = new Set([
-    ...Array.from(OPTIONAL_MATCH_TOKENS),
-    ...Array.from(ROUTE_TOKEN_FRAGMENTS),
-]);
-const UNIT_LOOKUP = (() => {
-    const canonicalByKey = new Map();
-    const variantsByCanonical = new Map();
-    const registerVariant = (canonical, variant) => {
-        const normalizedCanonical = normalizeKey(canonical);
-        if (!normalizedCanonical) {
-            return;
-        }
-        let variants = variantsByCanonical.get(normalizedCanonical);
-        if (!variants) {
-            variants = new Set();
-            variantsByCanonical.set(normalizedCanonical, variants);
-        }
-        variants.add(normalizeSpacing(canonical));
-        variants.add(normalizeSpacing(variant));
-    };
-    for (const token in maps_1.DEFAULT_UNIT_SYNONYMS) {
-        if (!Object.prototype.hasOwnProperty.call(maps_1.DEFAULT_UNIT_SYNONYMS, token)) {
-            continue;
-        }
-        const canonicalValue = maps_1.DEFAULT_UNIT_SYNONYMS[token];
-        const canonical = normalizeSpacing(canonicalValue);
-        registerVariant(canonical, canonical);
-        registerVariant(canonical, token);
-        canonicalByKey.set(normalizeKey(token), canonical);
-        canonicalByKey.set(normalizeKey(canonical), canonical);
-    }
-    return { canonicalByKey, variantsByCanonical };
-})();
-function resolveCanonicalUnit(unit) {
-    var _a;
-    if (!unit) {
-        return undefined;
-    }
-    const normalized = normalizeKey(unit);
-    if (!normalized) {
-        return undefined;
-    }
-    return (_a = UNIT_LOOKUP.canonicalByKey.get(normalized)) !== null && _a !== void 0 ? _a : normalizeSpacing(unit);
-}
-function normalizeKey(value) {
-    return value.trim().toLowerCase();
-}
-function normalizeSpacing(value) {
-    return value
-        .trim()
-        .replace(/\s+/g, " ");
-}
-function removeWhitespaceCharacters(value) {
-    for (let index = 0; index < value.length; index += 1) {
-        const code = value.charCodeAt(index);
-        if (code <= 32) {
-            const result = [];
-            for (let inner = 0; inner < value.length; inner += 1) {
-                const currentCode = value.charCodeAt(inner);
-                if (currentCode > 32) {
-                    result.push(value.charAt(inner));
-                }
-            }
-            return result.join("");
-        }
-    }
-    return value;
-}
-function removeDashes(value) {
-    if (value.indexOf("-") === -1) {
-        return value;
-    }
-    const result = [];
-    for (let index = 0; index < value.length; index += 1) {
-        const char = value.charAt(index);
-        if (char !== "-") {
-            result.push(char);
-        }
-    }
-    return result.join("");
-}
-const UNIT_VARIANT_CACHE = new Map();
-function getUnitVariants(unit) {
-    var _a;
-    const canonical = (_a = resolveCanonicalUnit(unit)) !== null && _a !== void 0 ? _a : normalizeSpacing(unit);
-    const normalizedCanonical = normalizeKey(canonical);
-    const cached = UNIT_VARIANT_CACHE.get(normalizedCanonical);
-    if (cached) {
-        return cached;
-    }
-    const variants = new Map();
-    const push = (candidate) => {
-        if (!candidate) {
-            return;
-        }
-        const normalizedCandidate = normalizeSpacing(candidate);
-        if (!normalizedCandidate) {
-            return;
-        }
-        const lower = normalizedCandidate.toLowerCase();
-        if (variants.has(lower)) {
-            return;
-        }
-        variants.set(lower, { value: normalizedCandidate, lower });
-    };
-    push(canonical);
-    push(unit);
-    const canonicalVariants = UNIT_LOOKUP.variantsByCanonical.get(normalizedCanonical);
-    if (canonicalVariants) {
-        for (const candidate of canonicalVariants) {
-            push(candidate);
-        }
-    }
-    const result = [...variants.values()];
-    UNIT_VARIANT_CACHE.set(normalizedCanonical, result);
-    return result;
-}
-function buildIntervalTokens(input) {
-    const intervals = new Set();
-    const add = (token) => {
-        if (!token) {
-            return;
-        }
-        const normalized = token.trim().toLowerCase();
-        if (!normalized) {
-            return;
-        }
-        intervals.add(normalized);
-    };
-    for (const token of BASE_INTERVAL_CODES) {
-        add(token);
-    }
-    for (const token of DEFAULT_INTERVAL_RANGES) {
-        add(token);
-    }
-    const normalizedInput = input.toLowerCase();
-    const rawTokens = normalizedInput.split(/[^a-z0-9-]+/g);
-    for (const rawToken of rawTokens) {
-        if (!rawToken) {
-            continue;
-        }
-        const match = rawToken.match(/^q(\d{1,2})(?:-(\d{1,2}))?(h?)$/);
-        if (!match) {
-            continue;
-        }
-        const first = Number.parseInt(match[1], 10);
-        const second = match[2] ? Number.parseInt(match[2], 10) : undefined;
-        if (Number.isNaN(first) || first <= 0 || first > 48) {
-            continue;
-        }
-        if (second !== undefined) {
-            if (Number.isNaN(second) || second < first || second > 48) {
-                continue;
-            }
-        }
-        const normalized = `q${first}${second ? `-${second}` : ""}h`;
-        add(normalized);
-    }
-    return [...intervals];
-}
-function buildWhenSequences() {
-    const sequences = [];
-    for (const token of WHEN_TOKENS) {
-        sequences.push([token]);
-    }
-    for (let i = 0; i < WHEN_COMBINATIONS.length; i++) {
-        const first = WHEN_COMBINATIONS[i];
-        for (let j = i + 1; j < WHEN_COMBINATIONS.length; j++) {
-            const second = WHEN_COMBINATIONS[j];
-            sequences.push([first, second]);
-        }
-    }
-    return sequences;
-}
-const PRECOMPUTED_WHEN_SEQUENCES = buildWhenSequences();
-const PRECOMPUTED_WHEN_SEQUENCE_SUFFIXES = PRECOMPUTED_WHEN_SEQUENCES.map((sequence) => ` ${sequence.join(" ")}`);
-function tokenizeLowercaseForMatching(value) {
-    return value
-        .split(/\s+/)
-        .map((token) => token.replace(/^[^a-z0-9-]+|[^a-z0-9-]+$/g, ""))
-        .filter((token) => token.length > 0)
-        .filter((token) => !OPTIONAL_MATCH_TOKENS.has(token));
-}
-function tokenizeForMatching(value) {
-    return tokenizeLowercaseForMatching(value.toLowerCase());
-}
-function canonicalizeLowercaseForMatching(value) {
-    return tokenizeLowercaseForMatching(value).join(" ");
-}
-function canonicalizeForMatching(value) {
-    return canonicalizeLowercaseForMatching(value.toLowerCase());
-}
-function buildTimeTokens(input) {
-    const tokens = new Set();
-    // Add common times
-    for (let i = 1; i <= 12; i++) {
-        tokens.add(`at ${i}:00 am`);
-        tokens.add(`at ${i}:00 pm`);
-    }
-    // Analyze input for specific time requests to provide more granular suggestions
-    const match = input.match(/(?:at|@)\s*(\d{1,2})(?::(\d{0,2}))?/i);
-    if (match) {
-        const h = parseInt(match[1], 10);
-        if (h >= 1 && h <= 12) {
-            const m = match[2] || "00";
-            if (m.length === 1) {
-                tokens.add(`at ${h}:${m}0 am`);
-                tokens.add(`at ${h}:${m}0 pm`);
-            }
-            else {
-                tokens.add(`at ${h}:${m} am`);
-                tokens.add(`at ${h}:${m} pm`);
-            }
-        }
-        else if (h > 12 && h < 24) {
-            // Input seems to be 24h, but we format as am/pm usually.
-            // Let's add the 24h format as well if that's what they are typing?
-            // Or convert to am/pm? Let's add both for robustness.
-            const m = match[2] || "00";
-            if (m.length === 1) {
-                tokens.add(`at ${h}:${m}0`);
-            }
-            else {
-                tokens.add(`at ${h}:${m}`);
-            }
-        }
-    }
-    return [...tokens];
-}
-function tokensMatch(prefixTokens, candidateTokens) {
-    if (prefixTokens.length === 0) {
-        return true;
-    }
-    let prefixIndex = 0;
-    for (const candidateToken of candidateTokens) {
-        if (prefixIndex >= prefixTokens.length) {
-            return true;
-        }
-        const prefixToken = prefixTokens[prefixIndex];
-        if (candidateToken.startsWith(prefixToken)) {
-            prefixIndex += 1;
-            if (prefixIndex >= prefixTokens.length) {
-                return true;
-            }
-            continue;
-        }
-        if (!SKIPPABLE_CANDIDATE_TOKENS.has(candidateToken)) {
-            return false;
-        }
-    }
-    return prefixIndex >= prefixTokens.length;
-}
-function buildUnitRoutePairs(contextUnit, options) {
-    var _a, _b;
-    const pairs = [];
-    const seen = new Set();
-    const addPair = (unit, routeOverride) => {
-        var _a;
-        const canonicalUnit = resolveCanonicalUnit(unit);
-        if (!canonicalUnit) {
-            return;
-        }
-        const normalizedUnit = normalizeKey(canonicalUnit);
-        if ((options === null || options === void 0 ? void 0 : options.allowHouseholdVolumeUnits) === false &&
-            HOUSEHOLD_VOLUME_UNIT_SET.has(normalizedUnit)) {
-            return;
-        }
-        const resolvedRoute = (_a = routeOverride !== null && routeOverride !== void 0 ? routeOverride : ROUTE_TOKEN_BY_UNIT.get(normalizedUnit)) !== null && _a !== void 0 ? _a : "po";
-        const cleanRoute = normalizeSpacing(resolvedRoute);
-        if (!cleanRoute) {
-            return;
-        }
-        const routeLower = cleanRoute.toLowerCase();
-        const key = `${normalizedUnit}::${routeLower}`;
-        if (seen.has(key)) {
-            return;
-        }
-        seen.add(key);
-        pairs.push({ unit: canonicalUnit, route: cleanRoute, routeLower });
-    };
-    addPair(contextUnit);
-    for (const preference of DEFAULT_UNIT_ROUTE_ORDER) {
-        const routeToken = (_b = (_a = preference.routeToken) !== null && _a !== void 0 ? _a : ROUTE_TOKEN_BY_CODE[preference.routeCode]) !== null && _b !== void 0 ? _b : maps_1.ROUTE_TEXT[preference.routeCode];
-        addPair(preference.unit, routeToken);
-    }
-    return pairs;
-}
-function buildPrnReasons(customReasons) {
-    const reasons = new Set();
-    const add = (reason) => {
-        if (!reason) {
-            return;
-        }
-        const normalized = normalizeSpacing(reason.toLowerCase());
-        if (!normalized) {
-            return;
-        }
-        reasons.add(normalized);
-    };
-    if (customReasons) {
-        for (const reason of customReasons) {
-            add(reason);
-        }
-    }
-    for (const reason of DEFAULT_PRN_REASONS) {
-        add(reason);
-    }
-    return [...reasons];
-}
-function extractDoseValuesFromInput(input) {
-    const matches = input.match(/\d+(?:\.\d+)?(?:\/\d+(?:\.\d+)?)?/g);
-    if (!matches) {
-        return [];
-    }
-    const values = new Set();
-    for (const match of matches) {
-        if (!match) {
-            continue;
-        }
-        values.add(match);
-    }
-    return [...values];
-}
-function buildDoseValues(input) {
-    const dynamicValues = extractDoseValuesFromInput(input);
-    const values = new Set();
-    for (const value of dynamicValues) {
-        values.add(value);
-    }
-    for (const value of DEFAULT_DOSE_COUNTS) {
-        values.add(value);
-    }
-    return [...values];
-}
-const CANDIDATE_FINGERPRINT_CACHE = new Map();
-function getCandidateFingerprint(candidateLower) {
-    let fingerprint = CANDIDATE_FINGERPRINT_CACHE.get(candidateLower);
-    if (!fingerprint) {
-        fingerprint = {};
-        CANDIDATE_FINGERPRINT_CACHE.set(candidateLower, fingerprint);
-    }
-    return fingerprint;
-}
-function generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, timeTokens, whenSequences, limit, matcher) {
-    const suggestions = [];
-    const seen = new Set();
-    const doseVariantMap = new Map();
-    for (const dose of doseValues) {
-        const normalized = normalizeSpacing(dose);
-        if (!normalized) {
-            continue;
-        }
-        const lower = normalized.toLowerCase();
-        if (!doseVariantMap.has(lower)) {
-            doseVariantMap.set(lower, { value: normalized, lower });
-        }
-    }
-    const doseVariants = [...doseVariantMap.values()];
-    const push = (value, lower) => {
-        if (!lower) {
-            return false;
-        }
-        if (seen.has(lower)) {
-            return false;
-        }
-        if (!matcher(value, lower)) {
-            return false;
-        }
-        seen.add(lower);
-        suggestions.push(value);
-        return suggestions.length >= limit;
-    };
-    const codeSuffixes = FREQUENCY_CODE_SUFFIXES;
-    const prnSuffixes = new Array(prnReasons.length);
-    for (let i = 0; i < prnReasons.length; i += 1) {
-        prnSuffixes[i] = ` prn ${prnReasons[i]}`;
-    }
-    const intervalSuffixes = new Array(intervalTokens.length);
-    for (let i = 0; i < intervalTokens.length; i += 1) {
-        intervalSuffixes[i] = ` ${intervalTokens[i]}`;
-    }
-    const whenSuffixes = whenSequences === PRECOMPUTED_WHEN_SEQUENCES
-        ? PRECOMPUTED_WHEN_SEQUENCE_SUFFIXES
-        : whenSequences.map((sequence) => ` ${sequence.join(" ")}`);
-    const timeSuffixes = timeTokens.map((token) => ` ${token}`);
-    for (let pairIndex = 0; pairIndex < pairs.length; pairIndex += 1) {
-        const pair = pairs[pairIndex];
-        const unitVariants = getUnitVariants(pair.unit);
-        const route = pair.route;
-        const routeLower = pair.routeLower;
-        const unitDoseVariants = new Array(unitVariants.length);
-        for (let unitIndex = 0; unitIndex < unitVariants.length; unitIndex += 1) {
-            const unitVariant = unitVariants[unitIndex];
-            const unitRouteValue = `${unitVariant.value} ${route}`;
-            const unitRouteLower = `${unitVariant.lower} ${routeLower}`;
-            const doseBases = new Array(doseVariants.length);
-            for (let doseIndex = 0; doseIndex < doseVariants.length; doseIndex += 1) {
-                const doseVariant = doseVariants[doseIndex];
-                doseBases[doseIndex] = {
-                    value: `${doseVariant.value} ${unitRouteValue}`,
-                    lower: `${doseVariant.lower} ${unitRouteLower}`,
-                };
-            }
-            unitDoseVariants[unitIndex] = doseBases;
-        }
-        for (let codeIndex = 0; codeIndex < codeSuffixes.length; codeIndex += 1) {
-            const codeSuffix = codeSuffixes[codeIndex];
-            for (let unitIndex = 0; unitIndex < unitDoseVariants.length; unitIndex += 1) {
-                const doseBases = unitDoseVariants[unitIndex];
-                for (let doseIndex = 0; doseIndex < doseBases.length; doseIndex += 1) {
-                    const base = doseBases[doseIndex];
-                    if (push(base.value + codeSuffix, base.lower + codeSuffix)) {
-                        return suggestions;
-                    }
-                }
-            }
-            if (push(route + codeSuffix, routeLower + codeSuffix)) {
-                return suggestions;
-            }
-        }
-        for (let intervalIndex = 0; intervalIndex < intervalSuffixes.length; intervalIndex += 1) {
-            const intervalSuffix = intervalSuffixes[intervalIndex];
-            for (let unitIndex = 0; unitIndex < unitDoseVariants.length; unitIndex += 1) {
-                const doseBases = unitDoseVariants[unitIndex];
-                for (let doseIndex = 0; doseIndex < doseBases.length; doseIndex += 1) {
-                    const base = doseBases[doseIndex];
-                    const baseIntervalValue = base.value + intervalSuffix;
-                    const baseIntervalLower = base.lower + intervalSuffix;
-                    if (push(baseIntervalValue, baseIntervalLower)) {
-                        return suggestions;
-                    }
-                    for (let reasonIndex = 0; reasonIndex < prnSuffixes.length; reasonIndex += 1) {
-                        const reasonSuffix = prnSuffixes[reasonIndex];
-                        if (push(baseIntervalValue + reasonSuffix, baseIntervalLower + reasonSuffix)) {
-                            return suggestions;
-                        }
-                    }
-                }
-            }
-            if (push(route + intervalSuffix, routeLower + intervalSuffix)) {
-                return suggestions;
-            }
-        }
-        for (let freqIndex = 0; freqIndex < FREQUENCY_NUMBERS.length; freqIndex += 1) {
-            const freq = FREQUENCY_NUMBERS[freqIndex];
-            const freqToken = FREQ_TOKEN_BY_NUMBER[freq];
-            if (!freqToken) {
-                continue;
-            }
-            const baseValue = `1x${freq} ${route}`;
-            const baseLower = `1x${freq} ${routeLower}`;
-            if (push(`${baseValue} ${freqToken}`, `${baseLower} ${freqToken}`)) {
-                return suggestions;
-            }
-            for (let whenIndex = 0; whenIndex < CORE_WHEN_TOKENS.length; whenIndex += 1) {
-                const whenToken = CORE_WHEN_TOKENS[whenIndex];
-                if (push(`${baseValue} ${whenToken}`, `${baseLower} ${whenToken}`)) {
-                    return suggestions;
-                }
-            }
-        }
-        for (let whenIndex = 0; whenIndex < whenSuffixes.length; whenIndex += 1) {
-            const whenSuffix = whenSuffixes[whenIndex];
-            for (let unitIndex = 0; unitIndex < unitDoseVariants.length; unitIndex += 1) {
-                const doseBases = unitDoseVariants[unitIndex];
-                for (let doseIndex = 0; doseIndex < doseBases.length; doseIndex += 1) {
-                    const base = doseBases[doseIndex];
-                    if (push(base.value + whenSuffix, base.lower + whenSuffix)) {
-                        return suggestions;
-                    }
-                }
-            }
-            if (push(route + whenSuffix, routeLower + whenSuffix)) {
-                return suggestions;
-            }
-        }
-        for (let timeIndex = 0; timeIndex < timeSuffixes.length; timeIndex += 1) {
-            const timeSuffix = timeSuffixes[timeIndex];
-            for (let unitIndex = 0; unitIndex < unitDoseVariants.length; unitIndex += 1) {
-                const doseBases = unitDoseVariants[unitIndex];
-                for (let doseIndex = 0; doseIndex < doseBases.length; doseIndex += 1) {
-                    const base = doseBases[doseIndex];
-                    if (push(base.value + timeSuffix, base.lower + timeSuffix)) {
-                        return suggestions;
-                    }
-                }
-            }
-            if (push(route + timeSuffix, routeLower + timeSuffix)) {
-                return suggestions;
-            }
-        }
-        for (let reasonIndex = 0; reasonIndex < prnSuffixes.length; reasonIndex += 1) {
-            const reasonSuffix = prnSuffixes[reasonIndex];
-            for (let unitIndex = 0; unitIndex < unitDoseVariants.length; unitIndex += 1) {
-                const doseBases = unitDoseVariants[unitIndex];
-                for (let doseIndex = 0; doseIndex < doseBases.length; doseIndex += 1) {
-                    const base = doseBases[doseIndex];
-                    if (push(base.value + reasonSuffix, base.lower + reasonSuffix)) {
-                        return suggestions;
-                    }
-                }
-            }
-            if (push(route + reasonSuffix, routeLower + reasonSuffix)) {
-                return suggestions;
-            }
-        }
-    }
-    return suggestions;
-}
-function matchesPrefix(_candidate, candidateLower, context) {
-    var _a, _b, _c, _d, _e, _f;
-    if (!context.raw) {
-        return true;
-    }
-    if (!context.hasCanonical && !context.hasTokens) {
-        return true;
-    }
-    if (candidateLower.startsWith(context.raw)) {
-        return true;
-    }
-    const fingerprint = getCandidateFingerprint(candidateLower);
-    if (context.requiresCompact) {
-        const compactCandidate = (_a = fingerprint.compact) !== null && _a !== void 0 ? _a : (fingerprint.compact = removeWhitespaceCharacters(candidateLower));
-        if (compactCandidate.startsWith(context.compact)) {
-            return true;
-        }
-    }
-    if (context.requiresNoDashes) {
-        const candidateNoDashes = (_b = fingerprint.noDashes) !== null && _b !== void 0 ? _b : (fingerprint.noDashes = removeDashes(candidateLower));
-        if (candidateNoDashes.startsWith(context.noDashes)) {
-            return true;
-        }
-    }
-    const getCandidateTokens = () => {
-        if (!fingerprint.tokens) {
-            fingerprint.tokens = tokenizeLowercaseForMatching(candidateLower);
-        }
-        return fingerprint.tokens;
-    };
-    if (context.hasCanonical) {
-        const canonicalCandidate = (_c = fingerprint.canonical) !== null && _c !== void 0 ? _c : (fingerprint.canonical = getCandidateTokens().join(" "));
-        if (canonicalCandidate.startsWith(context.canonical)) {
-            return true;
-        }
-        if (context.requiresCanonicalCompact) {
-            const canonicalCompact = (_d = fingerprint.canonicalCompact) !== null && _d !== void 0 ? _d : (fingerprint.canonicalCompact = removeWhitespaceCharacters(canonicalCandidate));
-            if (canonicalCompact.startsWith(context.canonicalCompact)) {
-                return true;
-            }
-        }
-        if (context.requiresCanonicalNoDashes) {
-            const canonicalNoDashes = (_e = fingerprint.canonicalNoDashes) !== null && _e !== void 0 ? _e : (fingerprint.canonicalNoDashes = removeDashes(canonicalCandidate));
-            if (canonicalNoDashes.startsWith(context.canonicalNoDashes)) {
-                return true;
-            }
-        }
-    }
-    if (context.hasTokens) {
-        const resolvedTokens = getCandidateTokens();
-        if (tokensMatch(context.tokens, resolvedTokens)) {
-            return true;
-        }
-        if (context.requiresTokenNoDashes) {
-            const candidateTokensNoDashes = (_f = fingerprint.tokensNoDashes) !== null && _f !== void 0 ? _f : (fingerprint.tokensNoDashes = resolvedTokens.map((token) => removeDashes(token)));
-            if (tokensMatch(context.tokensNoDashes, candidateTokensNoDashes)) {
-                return true;
-            }
-        }
-    }
-    else if (context.requiresTokenNoDashes) {
-        return true;
-    }
-    return false;
-}
-function collectMatchedCandidates(candidates, limit, matcher) {
-    const suggestions = [];
-    const seen = new Set();
-    for (const candidate of candidates) {
-        const value = normalizeSpacing(candidate);
-        if (!value) {
-            continue;
-        }
-        const lower = value.toLowerCase();
-        if (seen.has(lower)) {
-            continue;
-        }
-        if (!matcher(value, lower)) {
-            continue;
-        }
-        seen.add(lower);
-        suggestions.push(value);
-        if (suggestions.length >= limit) {
-            break;
-        }
-    }
-    return suggestions;
-}
-function buildMealDashCoreVariants(prefixCore) {
-    var _a;
-    if (!prefixCore.includes("-") || prefixCore.includes("--")) {
-        return [];
-    }
-    const slots = prefixCore.split("-");
-    if (slots.length < 2 || slots.length > 4) {
-        return [];
-    }
-    if (!/^[0-9]+(?:\.[0-9]+)?$/.test((_a = slots[0]) !== null && _a !== void 0 ? _a : "")) {
-        return [];
-    }
-    for (let i = 1; i < slots.length; i += 1) {
-        const slot = slots[i];
-        if (slot.length === 0) {
-            continue;
-        }
-        if (!/^[0-9]+(?:\.[0-9]+)?$/.test(slot)) {
-            return [];
-        }
-    }
-    const variants = [];
-    const seen = new Set();
-    const addVariant = (value) => {
-        if (!seen.has(value)) {
-            seen.add(value);
-            variants.push(value);
-        }
-    };
-    const first = slots[0];
-    const fillBase = (targetLength) => {
-        const values = new Array(targetLength).fill("0");
-        values[0] = first;
-        for (let i = 1; i < targetLength; i += 1) {
-            if (i < slots.length && slots[i] !== "") {
-                values[i] = slots[i];
-            }
-        }
-        return values;
-    };
-    const base3 = fillBase(3);
-    const missingThird = slots.length < 3 || slots[2] === "";
-    if (missingThird && (slots.length === 1 || slots[1] === "" || slots[1] === "0")) {
-        const mirror = [...base3];
-        mirror[2] = first;
-        addVariant(mirror.join("-"));
-    }
-    addVariant(base3.join("-"));
-    const base4 = fillBase(4);
-    const missingFourth = slots.length < 4 || slots[3] === "";
-    if (missingFourth &&
-        (slots.length === 1 ||
-            slots[1] === "" ||
-            (slots[1] === "0" && (slots.length < 3 || slots[2] === "" || slots[2] === "0")))) {
-        const mirror = [...base4];
-        mirror[3] = first;
-        addVariant(mirror.join("-"));
-    }
-    addVariant(base4.join("-"));
-    return variants;
-}
-function suggestMealDashSyntax(prefix, limit, matcher) {
-    if (!prefix.includes("-")) {
-        return undefined;
-    }
-    const match = prefix.match(/^(\d+(?:-\d*){0,3})(?:\s+(ac|pc))?$/);
-    if (!match) {
-        return undefined;
-    }
-    const core = match[1];
-    const relation = match[2];
-    const coreVariants = buildMealDashCoreVariants(core);
-    if (coreVariants.length === 0) {
-        return undefined;
-    }
-    const suffixes = relation ? [` ${relation}`] : ["", " ac", " pc"];
-    const candidates = [];
-    for (const variant of coreVariants) {
-        for (const suffix of suffixes) {
-            candidates.push(`${variant}${suffix}`);
-        }
-    }
-    return collectMatchedCandidates(candidates, limit, matcher);
-}
-function suggestCompactOralMealTiming(prefix, limit, matcher) {
-    var _a, _b;
-    const match = prefix.match(/^(\d+(?:\.\d+)?)\s*(?:po\s*(c|ac|pc)|po(c|ac|pc))$/);
-    if (!match) {
-        return undefined;
-    }
-    const dose = normalizeSpacing(match[1]);
-    const timing = ((_b = (_a = match[2]) !== null && _a !== void 0 ? _a : match[3]) !== null && _b !== void 0 ? _b : "").toLowerCase();
-    const orderedTimings = timing === "c"
-        ? ["c", "ac", "pc"]
-        : timing === "ac"
-            ? ["ac", "c", "pc"]
-            : timing === "pc"
-                ? ["pc", "c", "ac"]
-                : ["c", "ac", "pc"];
-    const candidates = orderedTimings.map((token) => `${dose} po ${token}`);
-    return collectMatchedCandidates(candidates, limit, matcher);
-}
-function suggestSig(input, options) {
-    var _a, _b;
-    const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : DEFAULT_LIMIT;
-    if (limit <= 0) {
-        return [];
-    }
-    const prefix = normalizeSpacing(input.toLowerCase());
-    const prefixCompact = prefix.replace(/\s+/g, "");
-    const prefixNoDashes = prefix.replace(/-/g, "");
-    const prefixTokens = tokenizeLowercaseForMatching(prefix);
-    const prefixCanonical = prefixTokens.join(" ");
-    const prefixCanonicalCompact = prefixCanonical.replace(/\s+/g, "");
-    const prefixCanonicalNoDashes = prefixCanonical.replace(/-/g, "");
-    const prefixTokensNoDashes = prefixTokens.map((token) => token.replace(/-/g, ""));
-    const prefixContext = {
-        raw: prefix,
-        compact: prefixCompact,
-        noDashes: prefixNoDashes,
-        canonical: prefixCanonical,
-        canonicalCompact: prefixCanonicalCompact,
-        canonicalNoDashes: prefixCanonicalNoDashes,
-        tokens: prefixTokens,
-        tokensNoDashes: prefixTokensNoDashes,
-        hasCanonical: prefixCanonical.length > 0,
-        hasTokens: prefixTokens.length > 0,
-        requiresCompact: prefixCompact !== prefix,
-        requiresNoDashes: prefixNoDashes !== prefix,
-        requiresCanonicalCompact: prefixCanonicalCompact !== prefixCanonical,
-        requiresCanonicalNoDashes: prefixCanonicalNoDashes !== prefixCanonical,
-        requiresTokenNoDashes: prefixTokens.some((token, index) => token !== prefixTokensNoDashes[index]),
-    };
-    const contextUnit = (0, context_1.inferUnitFromContext)((_b = options === null || options === void 0 ? void 0 : options.context) !== null && _b !== void 0 ? _b : undefined);
-    const pairs = buildUnitRoutePairs(contextUnit, options);
-    const doseValues = buildDoseValues(input);
-    const prnReasons = buildPrnReasons(options === null || options === void 0 ? void 0 : options.prnReasons);
-    const intervalTokens = buildIntervalTokens(input);
-    const timeTokens = buildTimeTokens(input);
-    const whenSequences = PRECOMPUTED_WHEN_SEQUENCES;
-    const matcher = (candidate, candidateLower) => matchesPrefix(candidate, candidateLower, prefixContext);
-    const compactOralSuggestions = suggestCompactOralMealTiming(prefix, limit, matcher);
-    if (compactOralSuggestions && compactOralSuggestions.length > 0) {
-        return compactOralSuggestions;
-    }
-    if (options === null || options === void 0 ? void 0 : options.enableMealDashSyntax) {
-        const mealDashSuggestions = suggestMealDashSyntax(prefix, limit, matcher);
-        if (mealDashSuggestions && mealDashSuggestions.length > 0) {
-            return mealDashSuggestions;
-        }
-    }
-    return generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, timeTokens, whenSequences, limit, matcher);
-}