ezmedicationinput 0.1.6 → 0.1.8

package/README.md

@@ -110,6 +110,8 @@ When `when` is populated, `timeOfDay` is intentionally omitted to stay within HL
 
 Routes always include SNOMED CT codings. Every code from the SNOMED Route of Administration value set is represented so you can confidently pass parsed results into downstream FHIR services that expect coded routes.
 
+You can specify the number of times (total count) the medication is supposed to be used by ending with `for {number} times`, `x {number} doses`, or simply `x {number}`
+
 ### Advanced parsing options
 
 `parseSig` accepts a `ParseOptions` object. Highlights:

package/dist/fhir.js

@@ -17,6 +17,10 @@ function toFhir(internal) {
         repeat.frequency = internal.frequency;
         hasRepeat = true;
     }
+    if (internal.count !== undefined) {
+        repeat.count = internal.count;
+        hasRepeat = true;
+    }
     if (internal.frequencyMax !== undefined) {
         repeat.frequencyMax = internal.frequencyMax;
         hasRepeat = true;
@@ -112,7 +116,7 @@ function toFhir(internal) {
     return dosage;
 }
 function internalFromFhir(dosage) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5;
     const internal = {
         input: (_a = dosage.text) !== null && _a !== void 0 ? _a : "",
         tokens: [],
@@ -125,18 +129,19 @@ function internalFromFhir(dosage) {
             : [],
         warnings: [],
         timingCode: (_j = (_h = (_g = (_f = dosage.timing) === null || _f === void 0 ? void 0 : _f.code) === null || _g === void 0 ? void 0 : _g.coding) === null || _h === void 0 ? void 0 : _h[0]) === null || _j === void 0 ? void 0 : _j.code,
-        frequency: (_l = (_k = dosage.timing) === null || _k === void 0 ? void 0 : _k.repeat) === null || _l === void 0 ? void 0 : _l.frequency,
-        frequencyMax: (_o = (_m = dosage.timing) === null || _m === void 0 ? void 0 : _m.repeat) === null || _o === void 0 ? void 0 : _o.frequencyMax,
-        period: (_q = (_p = dosage.timing) === null || _p === void 0 ? void 0 : _p.repeat) === null || _q === void 0 ? void 0 : _q.period,
-        periodMax: (_s = (_r = dosage.timing) === null || _r === void 0 ? void 0 : _r.repeat) === null || _s === void 0 ? void 0 : _s.periodMax,
-        periodUnit: (_u = (_t = dosage.timing) === null || _t === void 0 ? void 0 : _t.repeat) === null || _u === void 0 ? void 0 : _u.periodUnit,
-        routeText: (_v = dosage.route) === null || _v === void 0 ? void 0 : _v.text,
-        siteText: (_w = dosage.site) === null || _w === void 0 ? void 0 : _w.text,
+        count: (_l = (_k = dosage.timing) === null || _k === void 0 ? void 0 : _k.repeat) === null || _l === void 0 ? void 0 : _l.count,
+        frequency: (_o = (_m = dosage.timing) === null || _m === void 0 ? void 0 : _m.repeat) === null || _o === void 0 ? void 0 : _o.frequency,
+        frequencyMax: (_q = (_p = dosage.timing) === null || _p === void 0 ? void 0 : _p.repeat) === null || _q === void 0 ? void 0 : _q.frequencyMax,
+        period: (_s = (_r = dosage.timing) === null || _r === void 0 ? void 0 : _r.repeat) === null || _s === void 0 ? void 0 : _s.period,
+        periodMax: (_u = (_t = dosage.timing) === null || _t === void 0 ? void 0 : _t.repeat) === null || _u === void 0 ? void 0 : _u.periodMax,
+        periodUnit: (_w = (_v = dosage.timing) === null || _v === void 0 ? void 0 : _v.repeat) === null || _w === void 0 ? void 0 : _w.periodUnit,
+        routeText: (_x = dosage.route) === null || _x === void 0 ? void 0 : _x.text,
+        siteText: (_y = dosage.site) === null || _y === void 0 ? void 0 : _y.text,
         asNeeded: dosage.asNeededBoolean,
-        asNeededReason: (_y = (_x = dosage.asNeededFor) === null || _x === void 0 ? void 0 : _x[0]) === null || _y === void 0 ? void 0 : _y.text,
+        asNeededReason: (_0 = (_z = dosage.asNeededFor) === null || _z === void 0 ? void 0 : _z[0]) === null || _0 === void 0 ? void 0 : _0.text,
         siteTokenIndices: new Set()
     };
-    const routeCoding = (_0 = (_z = dosage.route) === null || _z === void 0 ? void 0 : _z.coding) === null || _0 === void 0 ? void 0 : _0.find((code) => code.system === SNOMED_SYSTEM);
+    const routeCoding = (_2 = (_1 = dosage.route) === null || _1 === void 0 ? void 0 : _1.coding) === null || _2 === void 0 ? void 0 : _2.find((code) => code.system === SNOMED_SYSTEM);
     if (routeCoding === null || routeCoding === void 0 ? void 0 : routeCoding.code) {
         // Translate SNOMED codings back into the simplified enum for round-trip fidelity.
         const mapped = maps_1.ROUTE_BY_SNOMED[routeCoding.code];
@@ -145,13 +150,13 @@ function internalFromFhir(dosage) {
             internal.routeText = maps_1.ROUTE_TEXT[mapped];
         }
     }
-    const doseAndRate = (_1 = dosage.doseAndRate) === null || _1 === void 0 ? void 0 : _1[0];
+    const doseAndRate = (_3 = dosage.doseAndRate) === null || _3 === void 0 ? void 0 : _3[0];
     if (doseAndRate === null || doseAndRate === void 0 ? void 0 : doseAndRate.doseRange) {
         const { low, high } = doseAndRate.doseRange;
         if ((low === null || low === void 0 ? void 0 : low.value) !== undefined && (high === null || high === void 0 ? void 0 : high.value) !== undefined) {
             internal.doseRange = { low: low.value, high: high.value };
         }
-        internal.unit = (_3 = (_2 = low === null || low === void 0 ? void 0 : low.unit) !== null && _2 !== void 0 ? _2 : high === null || high === void 0 ? void 0 : high.unit) !== null && _3 !== void 0 ? _3 : internal.unit;
+        internal.unit = (_5 = (_4 = low === null || low === void 0 ? void 0 : low.unit) !== null && _4 !== void 0 ? _4 : high === null || high === void 0 ? void 0 : high.unit) !== null && _5 !== void 0 ? _5 : internal.unit;
     }
     else if (doseAndRate === null || doseAndRate === void 0 ? void 0 : doseAndRate.doseQuantity) {
         const dose = doseAndRate.doseQuantity;

package/dist/format.js

@@ -548,6 +548,9 @@ function formatShort(internal) {
             .map((d) => d.charAt(0).toUpperCase() + d.slice(1, 3))
             .join(","));
     }
+    if (internal.count !== undefined) {
+        parts.push(`x${stripTrailingZero(internal.count)}`);
+    }
     if (internal.asNeeded) {
         if (internal.asNeededReason) {
             parts.push(`PRN ${internal.asNeededReason}`);
@@ -568,6 +571,9 @@ function formatLong(internal) {
     const eventParts = collectWhenPhrases(internal);
     const timing = combineFrequencyAndEvents(frequencyPart, eventParts);
     const dayPart = describeDayOfWeek(internal);
+    const countPart = internal.count
+        ? `for ${stripTrailingZero(internal.count)} ${internal.count === 1 ? "dose" : "doses"}`
+        : undefined;
     const asNeededPart = internal.asNeeded
         ? internal.asNeededReason
             ? `as needed for ${internal.asNeededReason}`
@@ -586,6 +592,9 @@ function formatLong(internal) {
     if (dayPart) {
         segments.push(dayPart);
     }
+    if (countPart) {
+        segments.push(countPart);
+    }
     if (asNeededPart) {
         segments.push(asNeededPart);
     }

package/dist/internal-types.d.ts

@@ -16,6 +16,7 @@ export interface ParsedSigInternal {
     unit?: string;
     routeCode?: RouteCode;
     routeText?: string;
+    count?: number;
     frequency?: number;
     frequencyMax?: number;
     period?: number;

package/dist/parser.js

@@ -111,6 +111,58 @@ const COMBO_EVENT_TIMINGS = {
     "upon waking": types_1.EventTiming.Wake
 };
 const MEAL_CONTEXT_CONNECTORS = new Set(["and", "or", "&", "+", "plus"]);
+const COUNT_KEYWORDS = new Set([
+    "time",
+    "times",
+    "dose",
+    "doses",
+    "application",
+    "applications",
+    "use",
+    "uses"
+]);
+const COUNT_CONNECTOR_WORDS = new Set([
+    "a",
+    "an",
+    "the",
+    "total",
+    "of",
+    "up",
+    "to",
+    "no",
+    "more",
+    "than",
+    "max",
+    "maximum",
+    "additional",
+    "extra"
+]);
+const ROUTE_DESCRIPTOR_FILLER_WORDS = new Set([
+    "per",
+    "by",
+    "via",
+    "the",
+    "a",
+    "an"
+]);
+function normalizeRouteDescriptorPhrase(phrase) {
+    return phrase
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((word) => word.length > 0 && !ROUTE_DESCRIPTOR_FILLER_WORDS.has(word))
+        .join(" ");
+}
+const DEFAULT_ROUTE_DESCRIPTOR_SYNONYMS = (() => {
+    const map = new Map();
+    for (const [phrase, synonym] of (0, object_1.objectEntries)(maps_1.DEFAULT_ROUTE_SYNONYMS)) {
+        const normalized = normalizeRouteDescriptorPhrase(phrase);
+        if (normalized && !map.has(normalized)) {
+            map.set(normalized, synonym);
+        }
+    }
+    return map;
+})();
 // Tracking explicit breakfast/lunch/dinner markers lets the meal-expansion
 // logic bail early when the clinician already specified precise events.
 const SPECIFIC_MEAL_TIMINGS = new Set([
@@ -1093,6 +1145,20 @@ function parseNumericRange(token) {
     }
     return { low, high };
 }
+function applyCountLimit(internal, value) {
+    if (value === undefined || !Number.isFinite(value) || value <= 0) {
+        return false;
+    }
+    if (internal.count !== undefined) {
+        return false;
+    }
+    const rounded = Math.round(value);
+    if (rounded <= 0) {
+        return false;
+    }
+    internal.count = rounded;
+    return true;
+}
 function parseInternal(input, options) {
     var _a, _b, _c, _d, _e, _f;
     const tokens = tokenize(input);
@@ -1112,6 +1178,11 @@ function parseInternal(input, options) {
             value
         ]))
         : undefined;
+    const customRouteDescriptorMap = customRouteMap
+        ? new Map(Array.from(customRouteMap.entries())
+            .map(([key, value]) => [normalizeRouteDescriptorPhrase(key), value])
+            .filter(([normalized]) => normalized.length > 0))
+        : undefined;
     if (tokens.length === 0) {
         return internal;
     }
@@ -1155,6 +1226,50 @@ function parseInternal(input, options) {
             mark(internal.consumed, token);
         }
     }
+    const applyRouteDescriptor = (code, text) => {
+        if (internal.routeCode && internal.routeCode !== code) {
+            return false;
+        }
+        setRoute(internal, code, text);
+        return true;
+    };
+    const maybeApplyRouteDescriptor = (phrase) => {
+        if (!phrase) {
+            return false;
+        }
+        const normalized = phrase.trim().toLowerCase();
+        if (!normalized) {
+            return false;
+        }
+        const customCode = customRouteMap === null || customRouteMap === void 0 ? void 0 : customRouteMap.get(normalized);
+        if (customCode) {
+            if (applyRouteDescriptor(customCode)) {
+                return true;
+            }
+        }
+        const synonym = maps_1.DEFAULT_ROUTE_SYNONYMS[normalized];
+        if (synonym) {
+            if (applyRouteDescriptor(synonym.code, synonym.text)) {
+                return true;
+            }
+        }
+        const normalizedDescriptor = normalizeRouteDescriptorPhrase(normalized);
+        if (normalizedDescriptor && normalizedDescriptor !== normalized) {
+            const customDescriptorCode = customRouteDescriptorMap === null || customRouteDescriptorMap === void 0 ? void 0 : customRouteDescriptorMap.get(normalizedDescriptor);
+            if (customDescriptorCode) {
+                if (applyRouteDescriptor(customDescriptorCode)) {
+                    return true;
+                }
+            }
+            const fallbackSynonym = DEFAULT_ROUTE_DESCRIPTOR_SYNONYMS.get(normalizedDescriptor);
+            if (fallbackSynonym) {
+                if (applyRouteDescriptor(fallbackSynonym.code, fallbackSynonym.text)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
     // Process tokens sequentially
     const tryRouteSynonym = (startIndex) => {
         const maxSpan = Math.min(24, tokens.length - startIndex);
@@ -1275,6 +1390,122 @@ function parseInternal(input, options) {
             mark(internal.consumed, token);
             continue;
         }
+        if (internal.count === undefined) {
+            const countMatch = token.lower.match(/^[x*]([0-9]+(?:\.[0-9]+)?)$/);
+            if (countMatch) {
+                if (applyCountLimit(internal, parseFloat(countMatch[1]))) {
+                    mark(internal.consumed, token);
+                    const nextToken = tokens[i + 1];
+                    if (nextToken && COUNT_KEYWORDS.has(nextToken.lower)) {
+                        mark(internal.consumed, nextToken);
+                    }
+                    continue;
+                }
+            }
+            if (token.lower === "x" || token.lower === "*") {
+                const numericToken = tokens[i + 1];
+                if (numericToken &&
+                    !internal.consumed.has(numericToken.index) &&
+                    /^[0-9]+(?:\.[0-9]+)?$/.test(numericToken.lower) &&
+                    applyCountLimit(internal, parseFloat(numericToken.original))) {
+                    mark(internal.consumed, token);
+                    mark(internal.consumed, numericToken);
+                    const afterToken = tokens[i + 2];
+                    if (afterToken && COUNT_KEYWORDS.has(afterToken.lower)) {
+                        mark(internal.consumed, afterToken);
+                    }
+                    continue;
+                }
+            }
+            if (token.lower === "for") {
+                const skipConnectors = (startIndex, bucket) => {
+                    let cursor = startIndex;
+                    while (cursor < tokens.length) {
+                        const candidate = tokens[cursor];
+                        if (!candidate) {
+                            break;
+                        }
+                        if (internal.consumed.has(candidate.index)) {
+                            cursor += 1;
+                            continue;
+                        }
+                        if (!COUNT_CONNECTOR_WORDS.has(candidate.lower)) {
+                            break;
+                        }
+                        bucket.push(candidate);
+                        cursor += 1;
+                    }
+                    return cursor;
+                };
+                const preConnectors = [];
+                let lookaheadIndex = skipConnectors(i + 1, preConnectors);
+                const numericToken = tokens[lookaheadIndex];
+                if (numericToken &&
+                    !internal.consumed.has(numericToken.index) &&
+                    /^[0-9]+(?:\.[0-9]+)?$/.test(numericToken.lower)) {
+                    const postConnectors = [];
+                    lookaheadIndex = skipConnectors(lookaheadIndex + 1, postConnectors);
+                    const keywordToken = tokens[lookaheadIndex];
+                    if (keywordToken &&
+                        !internal.consumed.has(keywordToken.index) &&
+                        COUNT_KEYWORDS.has(keywordToken.lower) &&
+                        applyCountLimit(internal, parseFloat(numericToken.original))) {
+                        mark(internal.consumed, token);
+                        for (const connector of preConnectors) {
+                            mark(internal.consumed, connector);
+                        }
+                        mark(internal.consumed, numericToken);
+                        for (const connector of postConnectors) {
+                            mark(internal.consumed, connector);
+                        }
+                        mark(internal.consumed, keywordToken);
+                        continue;
+                    }
+                }
+            }
+            if (COUNT_KEYWORDS.has(token.lower)) {
+                const partsToMark = [token];
+                let value;
+                const prevToken = tokens[i - 1];
+                if (prevToken && !internal.consumed.has(prevToken.index)) {
+                    const prevLower = prevToken.lower;
+                    const suffixMatch = prevLower.match(/^([0-9]+(?:\.[0-9]+)?)[x*]$/);
+                    const prefixMatch = prevLower.match(/^[x*]([0-9]+(?:\.[0-9]+)?)$/);
+                    if (suffixMatch) {
+                        value = parseFloat(suffixMatch[1]);
+                        partsToMark.push(prevToken);
+                    }
+                    else if (prefixMatch) {
+                        value = parseFloat(prefixMatch[1]);
+                        partsToMark.push(prevToken);
+                    }
+                    else if (/^[0-9]+(?:\.[0-9]+)?$/.test(prevLower)) {
+                        const maybeX = tokens[i - 2];
+                        if (maybeX &&
+                            !internal.consumed.has(maybeX.index) &&
+                            (maybeX.lower === "x" || maybeX.lower === "*")) {
+                            value = parseFloat(prevToken.original);
+                            partsToMark.push(maybeX, prevToken);
+                        }
+                    }
+                }
+                if (value === undefined) {
+                    const nextToken = tokens[i + 1];
+                    if (nextToken &&
+                        !internal.consumed.has(nextToken.index) &&
+                        /^[0-9]+(?:\.[0-9]+)?$/.test(nextToken.lower)) {
+                        value = parseFloat(nextToken.original);
+                        partsToMark.push(nextToken);
+                    }
+                }
+                if (applyCountLimit(internal, value)) {
+                    for (const part of partsToMark) {
+                        mark(internal.consumed, part);
+                    }
+                    continue;
+                }
+            }
+        }
         // Numeric dose
         const rangeValue = parseNumericRange(token.lower);
         if (rangeValue) {
@@ -1416,7 +1647,9 @@ function parseInternal(input, options) {
                     break;
                 }
                 const lower = token.lower;
-                if (SITE_CONNECTORS.has(lower) || BODY_SITE_HINTS.has(lower)) {
+                if (SITE_CONNECTORS.has(lower) ||
+                    BODY_SITE_HINTS.has(lower) ||
+                    ROUTE_DESCRIPTOR_FILLER_WORDS.has(lower)) {
                     indicesToInclude.add(token.index);
                     prev -= 1;
                     continue;
@@ -1430,7 +1663,9 @@ function parseInternal(input, options) {
                     break;
                 }
                 const lower = token.lower;
-                if (SITE_CONNECTORS.has(lower) || BODY_SITE_HINTS.has(lower)) {
+                if (SITE_CONNECTORS.has(lower) ||
+                    BODY_SITE_HINTS.has(lower) ||
+                    ROUTE_DESCRIPTOR_FILLER_WORDS.has(lower)) {
                     indicesToInclude.add(token.index);
                     next += 1;
                     continue;
@@ -1456,9 +1691,17 @@ function parseInternal(input, options) {
             .join(" ")
             .trim();
         if (normalizedSite) {
-            internal.siteText = normalizedSite;
-            if (!internal.siteSource) {
-                internal.siteSource = "text";
+            const normalizedLower = normalizedSite.toLowerCase();
+            const strippedDescriptor = normalizeRouteDescriptorPhrase(normalizedLower);
+            const siteWords = normalizedLower.split(/\s+/).filter((word) => word.length > 0);
+            const hasNonSiteWords = siteWords.some((word) => !BODY_SITE_HINTS.has(word));
+            const shouldAttemptRouteDescriptor = strippedDescriptor !== normalizedLower || hasNonSiteWords || strippedDescriptor === "mouth";
+            const appliedRouteDescriptor = shouldAttemptRouteDescriptor && maybeApplyRouteDescriptor(normalizedSite);
+            if (!appliedRouteDescriptor) {
+                internal.siteText = normalizedSite;
+                if (!internal.siteSource) {
+                    internal.siteSource = "text";
+                }
             }
         }
     }

package/dist/schedule.js

@@ -495,6 +495,12 @@ function nextDueDoses(dosage, options) {
     if (!timing || !repeat) {
         return [];
     }
+    const rawCount = repeat.count;
+    const normalizedCount = rawCount === undefined ? undefined : Math.max(0, Math.floor(rawCount));
+    if (normalizedCount === 0) {
+        return [];
+    }
+    const effectiveLimit = normalizedCount !== undefined ? Math.min(limit, normalizedCount) : limit;
     const results = [];
     const seen = new Set();
     const dayFilter = new Set(((_g = repeat.dayOfWeek) !== null && _g !== void 0 ? _g : []).map((day) => day.toLowerCase()));
@@ -519,17 +525,22 @@ function nextDueDoses(dosage, options) {
             const immediateSource = orderedAt !== null && orderedAt !== void 0 ? orderedAt : from;
             if (!orderedAt || orderedAt >= from) {
                 const instantIso = formatZonedIso(immediateSource, timeZone);
-                results.push(instantIso);
-                seen.add(instantIso);
+                if (!seen.has(instantIso)) {
+                    seen.add(instantIso);
+                    results.push(instantIso);
+                }
             }
         }
+        if (results.length >= effectiveLimit) {
+            return results.slice(0, effectiveLimit);
+        }
         if (expanded.length === 0) {
-            return results.slice(0, limit);
+            return results.slice(0, effectiveLimit);
         }
         let currentDay = startOfLocalDay(from, timeZone);
         let iterations = 0;
-        const maxIterations = limit * 31;
-        while (results.length < limit && iterations < maxIterations) {
+        const maxIterations = effectiveLimit * 31;
+        while (results.length < effectiveLimit && iterations < maxIterations) {
             const weekday = getLocalWeekday(currentDay, timeZone);
             if (!enforceDayFilter || dayFilter.has(weekday)) {
                 for (const entry of expanded) {
@@ -550,16 +561,19 @@ function nextDueDoses(dosage, options) {
                     if (!seen.has(iso)) {
                         seen.add(iso);
                         results.push(iso);
-                        if (results.length === limit) {
+                        if (results.length === effectiveLimit) {
                             break;
                         }
                     }
                 }
             }
+            if (results.length >= effectiveLimit) {
+                break;
+            }
             currentDay = addLocalDays(currentDay, 1, timeZone);
             iterations += 1;
         }
-        return results.slice(0, limit);
+        return results.slice(0, effectiveLimit);
     }
     const treatAsInterval = !!repeat.period &&
         !!repeat.periodUnit &&
@@ -569,7 +583,7 @@ function nextDueDoses(dosage, options) {
     if (treatAsInterval) {
         // True interval schedules advance from the order start in fixed units. The
         // timing.code remains advisory so we only rely on the period/unit fields.
-        const candidates = generateIntervalSeries(baseTime, from, limit, repeat, timeZone, dayFilter, enforceDayFilter, orderedAt);
+        const candidates = generateIntervalSeries(baseTime, from, effectiveLimit, repeat, timeZone, dayFilter, enforceDayFilter, orderedAt);
         return candidates;
     }
     if (repeat.frequency && repeat.period && repeat.periodUnit) {
@@ -582,8 +596,8 @@ function nextDueDoses(dosage, options) {
         }
         let currentDay = startOfLocalDay(from, timeZone);
         let iterations = 0;
-        const maxIterations = limit * 31;
-        while (results.length < limit && iterations < maxIterations) {
+        const maxIterations = effectiveLimit * 31;
+        while (results.length < effectiveLimit && iterations < maxIterations) {
             const weekday = getLocalWeekday(currentDay, timeZone);
             if (!enforceDayFilter || dayFilter.has(weekday)) {
                 for (const clock of clocks) {
@@ -601,7 +615,7 @@ function nextDueDoses(dosage, options) {
                     if (!seen.has(iso)) {
                         seen.add(iso);
                         results.push(iso);
-                        if (results.length === limit) {
+                        if (results.length === effectiveLimit) {
                             break;
                         }
                     }
@@ -610,7 +624,7 @@ function nextDueDoses(dosage, options) {
             currentDay = addLocalDays(currentDay, 1, timeZone);
             iterations += 1;
         }
-        return results.slice(0, limit);
+        return results.slice(0, effectiveLimit);
     }
     return [];
 }
@@ -618,7 +632,7 @@ function nextDueDoses(dosage, options) {
  * Generates an interval-based series by stepping forward from the base time
  * until the requested number of timestamps have been produced.
  */
-function generateIntervalSeries(baseTime, from, limit, repeat, timeZone, dayFilter, enforceDayFilter, orderedAt) {
+function generateIntervalSeries(baseTime, from, effectiveLimit, repeat, timeZone, dayFilter, enforceDayFilter, orderedAt) {
     const increment = createIntervalStepper(repeat, timeZone);
     if (!increment) {
         return [];
@@ -627,7 +641,7 @@ function generateIntervalSeries(baseTime, from, limit, repeat, timeZone, dayFilt
     const seen = new Set();
     let current = baseTime;
     let guard = 0;
-    const maxIterations = limit * 1000;
+    const maxIterations = effectiveLimit * 1000;
     while (current < from && guard < maxIterations) {
         const next = increment(current);
         if (!next || next.getTime() === current.getTime()) {
@@ -636,7 +650,7 @@ function generateIntervalSeries(baseTime, from, limit, repeat, timeZone, dayFilt
         current = next;
         guard += 1;
     }
-    while (results.length < limit && guard < maxIterations) {
+    while (results.length < effectiveLimit && guard < maxIterations) {
         const weekday = getLocalWeekday(current, timeZone);
         if (!enforceDayFilter || dayFilter.has(weekday)) {
             if (current < from) {
@@ -671,7 +685,7 @@ function generateIntervalSeries(baseTime, from, limit, repeat, timeZone, dayFilt
         current = next;
         guard += 1;
     }
-    return results.slice(0, limit);
+    return results.slice(0, effectiveLimit);
 }
 /**
  * Builds a function that advances a Date according to repeat.period/unit.

package/dist/suggest.js

@@ -105,6 +105,7 @@ const WHEN_COMBINATIONS = [
 ].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"],
@@ -235,10 +236,15 @@ function removeDashes(value) {
     }
     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) {
@@ -262,7 +268,9 @@ function getUnitVariants(unit) {
             push(candidate);
         }
     }
-    return [...variants.values()];
+    const result = [...variants.values()];
+    UNIT_VARIANT_CACHE.set(normalizedCanonical, result);
+    return result;
 }
 function buildIntervalTokens(input) {
     const intervals = new Set();
@@ -322,6 +330,7 @@ function buildWhenSequences() {
     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+/)
@@ -481,117 +490,121 @@ function generateCandidateDirections(pairs, doseValues, prnReasons, intervalToke
         suggestions.push(value);
         return suggestions.length >= limit;
     };
-    for (const pair of pairs) {
+    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(" ")}`);
+    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;
-        for (const code of FREQUENCY_CODES) {
-            const codeSuffix = ` ${code}`;
-            for (const unitVariant of unitVariants) {
-                const unitRoute = `${unitVariant.value} ${route}`;
-                const unitRouteLower = `${unitVariant.lower} ${routeLower}`;
-                for (const doseVariant of doseVariants) {
-                    const candidate = `${doseVariant.value} ${unitRoute}${codeSuffix}`;
-                    const candidateLower = `${doseVariant.lower} ${unitRouteLower}${codeSuffix}`;
-                    if (push(candidate, candidateLower)) {
+        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;
                     }
                 }
             }
-            const candidate = `${route}${codeSuffix}`;
-            const candidateLower = `${routeLower}${codeSuffix}`;
-            if (push(candidate, candidateLower)) {
+            if (push(route + codeSuffix, routeLower + codeSuffix)) {
                 return suggestions;
             }
         }
-        for (const interval of intervalTokens) {
-            const intervalSuffix = ` ${interval}`;
-            for (const unitVariant of unitVariants) {
-                const unitRoute = `${unitVariant.value} ${route}`;
-                const unitRouteLower = `${unitVariant.lower} ${routeLower}`;
-                for (const doseVariant of doseVariants) {
-                    const base = `${doseVariant.value} ${unitRoute}`;
-                    const baseLower = `${doseVariant.lower} ${unitRouteLower}`;
-                    const intervalCandidate = `${base}${intervalSuffix}`;
-                    const intervalCandidateLower = `${baseLower}${intervalSuffix}`;
-                    if (push(intervalCandidate, intervalCandidateLower)) {
+        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 (const reason of prnReasons) {
-                        const reasonSuffix = `${intervalSuffix} prn ${reason}`;
-                        const reasonCandidate = `${base}${reasonSuffix}`;
-                        const reasonCandidateLower = `${baseLower}${reasonSuffix}`;
-                        if (push(reasonCandidate, reasonCandidateLower)) {
+                    for (let reasonIndex = 0; reasonIndex < prnSuffixes.length; reasonIndex += 1) {
+                        const reasonSuffix = prnSuffixes[reasonIndex];
+                        if (push(baseIntervalValue + reasonSuffix, baseIntervalLower + reasonSuffix)) {
                             return suggestions;
                         }
                     }
                 }
             }
-            const candidate = `${route}${intervalSuffix}`;
-            const candidateLower = `${routeLower}${intervalSuffix}`;
-            if (push(candidate, candidateLower)) {
+            if (push(route + intervalSuffix, routeLower + intervalSuffix)) {
                 return suggestions;
             }
         }
-        for (const freq of FREQUENCY_NUMBERS) {
+        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 base = `1x${freq} ${route}`;
+            const baseValue = `1x${freq} ${route}`;
             const baseLower = `1x${freq} ${routeLower}`;
-            const freqCandidate = `${base} ${freqToken}`;
-            const freqCandidateLower = `${baseLower} ${freqToken}`;
-            if (push(freqCandidate, freqCandidateLower)) {
+            if (push(`${baseValue} ${freqToken}`, `${baseLower} ${freqToken}`)) {
                 return suggestions;
             }
-            for (const when of CORE_WHEN_TOKENS) {
-                const whenCandidate = `${base} ${when}`;
-                const whenCandidateLower = `${baseLower} ${when}`;
-                if (push(whenCandidate, whenCandidateLower)) {
+            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 (const whenSequence of whenSequences) {
-            const suffix = ` ${whenSequence.join(" ")}`;
-            for (const unitVariant of unitVariants) {
-                const unitRoute = `${unitVariant.value} ${route}`;
-                const unitRouteLower = `${unitVariant.lower} ${routeLower}`;
-                for (const doseVariant of doseVariants) {
-                    const base = `${doseVariant.value} ${unitRoute}`;
-                    const baseLower = `${doseVariant.lower} ${unitRouteLower}`;
-                    const candidate = `${base}${suffix}`;
-                    const candidateLower = `${baseLower}${suffix}`;
-                    if (push(candidate, candidateLower)) {
+        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;
                     }
                 }
             }
-            const candidate = `${route}${suffix}`;
-            const candidateLower = `${routeLower}${suffix}`;
-            if (push(candidate, candidateLower)) {
+            if (push(route + whenSuffix, routeLower + whenSuffix)) {
                 return suggestions;
             }
         }
-        for (const reason of prnReasons) {
-            const reasonSuffix = ` prn ${reason}`;
-            for (const unitVariant of unitVariants) {
-                const unitRoute = `${unitVariant.value} ${route}`;
-                const unitRouteLower = `${unitVariant.lower} ${routeLower}`;
-                for (const doseVariant of doseVariants) {
-                    const base = `${doseVariant.value} ${unitRoute}`;
-                    const baseLower = `${doseVariant.lower} ${unitRouteLower}`;
-                    const candidate = `${base}${reasonSuffix}`;
-                    const candidateLower = `${baseLower}${reasonSuffix}`;
-                    if (push(candidate, candidateLower)) {
+        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;
                     }
                 }
             }
-            const candidate = `${route}${reasonSuffix}`;
-            const candidateLower = `${routeLower}${reasonSuffix}`;
-            if (push(candidate, candidateLower)) {
+            if (push(route + reasonSuffix, routeLower + reasonSuffix)) {
                 return suggestions;
             }
         }

package/dist/types.d.ts

@@ -241,6 +241,7 @@ export declare enum FhirDayOfWeek {
     Sunday = "sun"
 }
 export interface FhirTimingRepeat {
+    count?: number;
     frequency?: number;
     frequencyMax?: number;
     period?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ezmedicationinput",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Parse concise medication sigs into FHIR R5 Dosage JSON",
   "type": "module",
   "main": "dist/index.js",