ezmedicationinput 0.1.39 → 0.1.41

package/dist/index.js

@@ -58,6 +58,15 @@ Object.defineProperty(exports, "DEFAULT_BODY_SITE_SNOMED_SOURCE", { enumerable:
 Object.defineProperty(exports, "DEFAULT_ROUTE_SYNONYMS", { enumerable: true, get: function () { return maps_1.DEFAULT_ROUTE_SYNONYMS; } });
 Object.defineProperty(exports, "DEFAULT_UNIT_BY_ROUTE", { enumerable: true, get: function () { return maps_1.DEFAULT_UNIT_BY_ROUTE; } });
 Object.defineProperty(exports, "KNOWN_DOSAGE_FORMS_TO_DOSE", { enumerable: true, get: function () { return maps_1.KNOWN_DOSAGE_FORMS_TO_DOSE; } });
+const REPEAT_NON_ANCHOR_KEYS = [
+    "count",
+    "frequency",
+    "frequencyMax",
+    "period",
+    "periodMax",
+    "periodUnit",
+    "offset"
+];
 function parseMealDashValues(token) {
     if (!/^[0-9]+(?:\.[0-9]+)?(?:-[0-9]+(?:\.[0-9]+)?){2,3}$/.test(token)) {
         return undefined;
@@ -155,6 +164,189 @@ function toSegmentMeta(segments) {
         range: { start: segment.start, end: segment.end }
     }));
 }
+/**
+ * Deep equality helper for plain JSON-like parser output objects.
+ *
+ * @param left Left-side value.
+ * @param right Right-side value.
+ * @returns `true` when both values are structurally equal.
+ */
+function deepEqual(left, right) {
+    if (left === right) {
+        return true;
+    }
+    if (left === null || right === null) {
+        return left === right;
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right)) {
+            return false;
+        }
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let i = 0; i < left.length; i += 1) {
+            if (!deepEqual(left[i], right[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (typeof left !== "object" || typeof right !== "object") {
+        return false;
+    }
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord).filter((key) => leftRecord[key] !== undefined);
+    const rightKeys = Object.keys(rightRecord).filter((key) => rightRecord[key] !== undefined);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    for (const key of leftKeys) {
+        if (!Object.prototype.hasOwnProperty.call(rightRecord, key)) {
+            return false;
+        }
+        if (!deepEqual(leftRecord[key], rightRecord[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Compares two string arrays as sets.
+ *
+ * @param left Left array.
+ * @param right Right array.
+ * @returns `true` when both arrays contain the same unique values.
+ */
+function sameStringSet(left, right) {
+    const a = left !== null && left !== void 0 ? left : [];
+    const b = right !== null && right !== void 0 ? right : [];
+    if (a.length !== b.length) {
+        return false;
+    }
+    const set = new Set(a);
+    if (set.size !== b.length) {
+        return false;
+    }
+    for (const value of b) {
+        if (!set.has(value)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Determines whether a repeat block only uses merge-safe anchor fields.
+ *
+ * @param repeat FHIR timing repeat payload.
+ * @returns `true` when repeat contains only `when`/`timeOfDay`/`dayOfWeek`.
+ */
+function isMergeableAnchorRepeat(repeat) {
+    if (!repeat) {
+        return true;
+    }
+    for (const key of REPEAT_NON_ANCHOR_KEYS) {
+        if (repeat[key] !== undefined) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Checks whether two parsed items can be merged without changing semantics.
+ *
+ * @param base Existing merged item candidate.
+ * @param next Incoming parsed item.
+ * @returns `true` when both items differ only by merge-safe timing anchors.
+ */
+function canMergeTimingOnly(base, next) {
+    const baseTiming = base.fhir.timing;
+    const nextTiming = next.fhir.timing;
+    const baseRepeat = baseTiming === null || baseTiming === void 0 ? void 0 : baseTiming.repeat;
+    const nextRepeat = nextTiming === null || nextTiming === void 0 ? void 0 : nextTiming.repeat;
+    if (!baseRepeat || !nextRepeat) {
+        return false;
+    }
+    if (!isMergeableAnchorRepeat(baseRepeat) || !isMergeableAnchorRepeat(nextRepeat)) {
+        return false;
+    }
+    if (!sameStringSet(baseRepeat.dayOfWeek, nextRepeat.dayOfWeek)) {
+        return false;
+    }
+    if (!deepEqual(baseTiming === null || baseTiming === void 0 ? void 0 : baseTiming.code, nextTiming === null || nextTiming === void 0 ? void 0 : nextTiming.code)) {
+        return false;
+    }
+    if (!deepEqual(baseTiming === null || baseTiming === void 0 ? void 0 : baseTiming.event, nextTiming === null || nextTiming === void 0 ? void 0 : nextTiming.event)) {
+        return false;
+    }
+    return (deepEqual(base.fhir.doseAndRate, next.fhir.doseAndRate) &&
+        deepEqual(base.fhir.route, next.fhir.route) &&
+        deepEqual(base.fhir.site, next.fhir.site) &&
+        deepEqual(base.fhir.additionalInstruction, next.fhir.additionalInstruction) &&
+        deepEqual(base.fhir.asNeededBoolean, next.fhir.asNeededBoolean) &&
+        deepEqual(base.fhir.asNeededFor, next.fhir.asNeededFor));
+}
+/**
+ * Returns a stable unique list preserving first-seen order.
+ *
+ * @param values Input values.
+ * @returns Deduplicated values in insertion order.
+ */
+function uniqueStrings(values) {
+    const seen = new Set();
+    const output = [];
+    for (const value of values) {
+        if (!seen.has(value)) {
+            seen.add(value);
+            output.push(value);
+        }
+    }
+    return output;
+}
+/**
+ * Merges two parse results that are known to be timing-compatible.
+ *
+ * @param base Existing merged result.
+ * @param next Next result to fold into `base`.
+ * @param options Parse options used to render localized text.
+ * @returns New merged parse result.
+ */
+function mergeParseResults(base, next, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+    const baseRepeat = (_b = (_a = base.fhir.timing) === null || _a === void 0 ? void 0 : _a.repeat) !== null && _b !== void 0 ? _b : {};
+    const nextRepeat = (_d = (_c = next.fhir.timing) === null || _c === void 0 ? void 0 : _c.repeat) !== null && _d !== void 0 ? _d : {};
+    const mergedWhen = uniqueStrings([...((_e = baseRepeat.when) !== null && _e !== void 0 ? _e : []), ...((_f = nextRepeat.when) !== null && _f !== void 0 ? _f : [])]);
+    const mergedTimeOfDay = uniqueStrings([...((_g = baseRepeat.timeOfDay) !== null && _g !== void 0 ? _g : []), ...((_h = nextRepeat.timeOfDay) !== null && _h !== void 0 ? _h : [])]).sort();
+    const mergedRepeat = Object.assign(Object.assign(Object.assign(Object.assign({}, baseRepeat), (nextRepeat.dayOfWeek ? { dayOfWeek: nextRepeat.dayOfWeek } : {})), (mergedWhen.length ? { when: mergedWhen } : {})), (mergedTimeOfDay.length ? { timeOfDay: mergedTimeOfDay } : {}));
+    const mergedFhir = Object.assign(Object.assign({}, base.fhir), { timing: Object.assign(Object.assign({}, ((_j = base.fhir.timing) !== null && _j !== void 0 ? _j : {})), { repeat: mergedRepeat }) });
+    const shortText = formatSig(mergedFhir, "short", options);
+    const longText = formatSig(mergedFhir, "long", options);
+    mergedFhir.text = longText;
+    return {
+        fhir: mergedFhir,
+        shortText,
+        longText,
+        warnings: uniqueStrings([...((_k = base.warnings) !== null && _k !== void 0 ? _k : []), ...((_l = next.warnings) !== null && _l !== void 0 ? _l : [])]),
+        meta: Object.assign(Object.assign({}, base.meta), { consumedTokens: uniqueStrings([...((_m = base.meta.consumedTokens) !== null && _m !== void 0 ? _m : []), ...((_o = next.meta.consumedTokens) !== null && _o !== void 0 ? _o : [])]), leftoverText: uniqueStrings([base.meta.leftoverText, next.meta.leftoverText].filter((value) => !!value)).join(" ").trim() || undefined, siteLookups: [...((_p = base.meta.siteLookups) !== null && _p !== void 0 ? _p : []), ...((_q = next.meta.siteLookups) !== null && _q !== void 0 ? _q : [])], prnReasonLookups: [...((_r = base.meta.prnReasonLookups) !== null && _r !== void 0 ? _r : []), ...((_s = next.meta.prnReasonLookups) !== null && _s !== void 0 ? _s : [])] })
+    };
+}
+/**
+ * Appends a parsed segment result to the batch, reusing the current item when
+ * timing-only expansion can be represented as a single dosage element.
+ *
+ * @param items Accumulated batch items.
+ * @param next Newly parsed segment result.
+ * @param options Parse options used to format merged text.
+ */
+function appendParseResult(items, next, options) {
+    const previous = items[items.length - 1];
+    if (previous && canMergeTimingOnly(previous, next)) {
+        items[items.length - 1] = mergeParseResults(previous, next, options);
+        return;
+    }
+    items.push(next);
+}
 function parseSig(input, options) {
     const segments = expandMealDashSegments((0, segment_1.splitSigSegments)(input), options);
     const carry = {};
@@ -166,7 +358,7 @@ function parseSig(input, options) {
         (0, parser_1.applySiteCoding)(internal, options);
         const result = buildParseResult(internal, options);
         rebaseParseResult(result, input, segment.start);
-        results.push(result);
+        appendParseResult(results, result, options);
         updateCarryForward(carry, internal);
     }
     const legacy = resolveLegacyParseResult(results, input, options);
@@ -232,7 +424,7 @@ function parseSigAsync(input, options) {
             yield (0, parser_1.applySiteCodingAsync)(internal, options);
             const result = buildParseResult(internal, options);
             rebaseParseResult(result, input, segment.start);
-            results.push(result);
+            appendParseResult(results, result, options);
             updateCarryForward(carry, internal);
         }
         const legacy = resolveLegacyParseResult(results, input, options);

package/dist/maps.js

@@ -548,6 +548,13 @@ function addMetricUnitSynonyms(map) {
 }
 exports.HOUSEHOLD_VOLUME_UNITS = ["tsp", "tbsp"];
 const STATIC_UNIT_SYNONYMS = {
+    u: "U",
+    unit: "U",
+    units: "U",
+    iu: "IU",
+    "i.u": "IU",
+    "i.u.": "IU",
+    ius: "IU",
     tab: "tab",
     tabs: "tab",
     tablet: "tab",
@@ -745,18 +752,43 @@ exports.DISCOURAGED_TOKENS = {
 exports.DAY_OF_WEEK_TOKENS = {
     monday: types_1.FhirDayOfWeek.Monday,
     mon: types_1.FhirDayOfWeek.Monday,
+    mond: types_1.FhirDayOfWeek.Monday,
     tuesday: types_1.FhirDayOfWeek.Tuesday,
     tue: types_1.FhirDayOfWeek.Tuesday,
+    tues: types_1.FhirDayOfWeek.Tuesday,
     wednesday: types_1.FhirDayOfWeek.Wednesday,
     wed: types_1.FhirDayOfWeek.Wednesday,
+    weds: types_1.FhirDayOfWeek.Wednesday,
     thursday: types_1.FhirDayOfWeek.Thursday,
     thu: types_1.FhirDayOfWeek.Thursday,
+    thur: types_1.FhirDayOfWeek.Thursday,
+    thurs: types_1.FhirDayOfWeek.Thursday,
     friday: types_1.FhirDayOfWeek.Friday,
     fri: types_1.FhirDayOfWeek.Friday,
     saturday: types_1.FhirDayOfWeek.Saturday,
     sat: types_1.FhirDayOfWeek.Saturday,
     sunday: types_1.FhirDayOfWeek.Sunday,
-    sun: types_1.FhirDayOfWeek.Sunday
+    sun: types_1.FhirDayOfWeek.Sunday,
+    จ: types_1.FhirDayOfWeek.Monday,
+    จัน: types_1.FhirDayOfWeek.Monday,
+    จันทร์: types_1.FhirDayOfWeek.Monday,
+    อ: types_1.FhirDayOfWeek.Tuesday,
+    อัง: types_1.FhirDayOfWeek.Tuesday,
+    อังคาร: types_1.FhirDayOfWeek.Tuesday,
+    พ: types_1.FhirDayOfWeek.Wednesday,
+    พุธ: types_1.FhirDayOfWeek.Wednesday,
+    พฤ: types_1.FhirDayOfWeek.Thursday,
+    พฤหัส: types_1.FhirDayOfWeek.Thursday,
+    พฤหัสบดี: types_1.FhirDayOfWeek.Thursday,
+    ศ: types_1.FhirDayOfWeek.Friday,
+    ศุก: types_1.FhirDayOfWeek.Friday,
+    ศุกร์: types_1.FhirDayOfWeek.Friday,
+    ส: types_1.FhirDayOfWeek.Saturday,
+    เสา: types_1.FhirDayOfWeek.Saturday,
+    เสาร์: types_1.FhirDayOfWeek.Saturday,
+    อา: types_1.FhirDayOfWeek.Sunday,
+    อาท: types_1.FhirDayOfWeek.Sunday,
+    อาทิตย์: types_1.FhirDayOfWeek.Sunday
 };
 exports.WORD_FREQUENCIES = {
     daily: { frequency: 1, periodUnit: types_1.FhirPeriodUnit.Day },

package/dist/parser.js

@@ -195,6 +195,11 @@ const COMBO_EVENT_TIMINGS = {
     "before sleep": types_1.EventTiming["Before Sleep"],
     "upon waking": types_1.EventTiming.Wake
 };
+const DAY_RANGE_PART_PATTERN = Object.keys(maps_1.DAY_OF_WEEK_TOKENS)
+    .sort((a, b) => b.length - a.length)
+    .map((token) => token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+    .join("|");
+const DAY_RANGE_SPACED_HYPHEN_REGEX = new RegExp(`(^|\\s)(${DAY_RANGE_PART_PATTERN})\\s*-\\s*(${DAY_RANGE_PART_PATTERN})(?=\\s|$)`, "giu");
 const MEAL_CONTEXT_CONNECTORS = new Set(["and", "or", "&", "+", "plus"]);
 const COUNT_KEYWORDS = new Set([
     "time",
@@ -965,6 +970,7 @@ const SITE_UNIT_ROUTE_HINTS = [
 function tokenize(input) {
     const separators = /[(),;]/g;
     let normalized = input.trim().replace(separators, " ");
+    normalized = normalized.replace(DAY_RANGE_SPACED_HYPHEN_REGEX, (_match, prefix, start, end) => `${prefix}${start}-${end}`);
     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) => {
@@ -1585,6 +1591,154 @@ function isTimingAnchorOrPrefix(tokens, index, prnReasonStart) {
         (isAtPrefixToken(lower) || lower === "on" || lower === "with") ||
         /^\d/.test(lower));
 }
+const DAY_SEQUENCE = [
+    types_1.FhirDayOfWeek.Monday,
+    types_1.FhirDayOfWeek.Tuesday,
+    types_1.FhirDayOfWeek.Wednesday,
+    types_1.FhirDayOfWeek.Thursday,
+    types_1.FhirDayOfWeek.Friday,
+    types_1.FhirDayOfWeek.Saturday,
+    types_1.FhirDayOfWeek.Sunday
+];
+const DAY_GROUP_TOKENS = {
+    weekend: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
+    weekends: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
+    wknd: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
+    weekdays: [
+        types_1.FhirDayOfWeek.Monday,
+        types_1.FhirDayOfWeek.Tuesday,
+        types_1.FhirDayOfWeek.Wednesday,
+        types_1.FhirDayOfWeek.Thursday,
+        types_1.FhirDayOfWeek.Friday
+    ],
+    weekday: [
+        types_1.FhirDayOfWeek.Monday,
+        types_1.FhirDayOfWeek.Tuesday,
+        types_1.FhirDayOfWeek.Wednesday,
+        types_1.FhirDayOfWeek.Thursday,
+        types_1.FhirDayOfWeek.Friday
+    ],
+    workday: [
+        types_1.FhirDayOfWeek.Monday,
+        types_1.FhirDayOfWeek.Tuesday,
+        types_1.FhirDayOfWeek.Wednesday,
+        types_1.FhirDayOfWeek.Thursday,
+        types_1.FhirDayOfWeek.Friday
+    ],
+    workdays: [
+        types_1.FhirDayOfWeek.Monday,
+        types_1.FhirDayOfWeek.Tuesday,
+        types_1.FhirDayOfWeek.Wednesday,
+        types_1.FhirDayOfWeek.Thursday,
+        types_1.FhirDayOfWeek.Friday
+    ],
+    วันธรรมดา: [
+        types_1.FhirDayOfWeek.Monday,
+        types_1.FhirDayOfWeek.Tuesday,
+        types_1.FhirDayOfWeek.Wednesday,
+        types_1.FhirDayOfWeek.Thursday,
+        types_1.FhirDayOfWeek.Friday
+    ],
+    วันทำงาน: [
+        types_1.FhirDayOfWeek.Monday,
+        types_1.FhirDayOfWeek.Tuesday,
+        types_1.FhirDayOfWeek.Wednesday,
+        types_1.FhirDayOfWeek.Thursday,
+        types_1.FhirDayOfWeek.Friday
+    ],
+    วันหยุด: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
+    สุดสัปดาห์: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
+    เสาร์อาทิตย์: [types_1.FhirDayOfWeek.Saturday, types_1.FhirDayOfWeek.Sunday],
+    จันทร์ถึงศุกร์: [
+        types_1.FhirDayOfWeek.Monday,
+        types_1.FhirDayOfWeek.Tuesday,
+        types_1.FhirDayOfWeek.Wednesday,
+        types_1.FhirDayOfWeek.Thursday,
+        types_1.FhirDayOfWeek.Friday
+    ]
+};
+const DAY_RANGE_CONNECTOR_TOKENS = new Set(["-", "to", "through", "thru", "ถึง", "จนถึง"]);
+function addDayOfWeek(internal, day) {
+    if (!(0, array_1.arrayIncludes)(internal.dayOfWeek, day)) {
+        internal.dayOfWeek.push(day);
+    }
+}
+function addDayOfWeekList(internal, days) {
+    for (const day of days) {
+        addDayOfWeek(internal, day);
+    }
+}
+function expandDayRange(start, end) {
+    const startIndex = DAY_SEQUENCE.indexOf(start);
+    const endIndex = DAY_SEQUENCE.indexOf(end);
+    if (startIndex < 0 || endIndex < 0) {
+        return [start, end];
+    }
+    if (startIndex <= endIndex) {
+        return DAY_SEQUENCE.slice(startIndex, endIndex + 1);
+    }
+    return [...DAY_SEQUENCE.slice(startIndex), ...DAY_SEQUENCE.slice(0, endIndex + 1)];
+}
+function resolveDayTokenDays(tokenLower) {
+    const normalized = tokenLower.replace(/[.,;:]/g, "");
+    const direct = maps_1.DAY_OF_WEEK_TOKENS[normalized];
+    if (direct) {
+        return [direct];
+    }
+    const grouped = DAY_GROUP_TOKENS[normalized];
+    if (grouped) {
+        return grouped.slice();
+    }
+    const rangeMatch = normalized.match(/^([^-–—~]+)[-–—~]([^-–—~]+)$/);
+    if (rangeMatch) {
+        const start = maps_1.DAY_OF_WEEK_TOKENS[rangeMatch[1]];
+        const end = maps_1.DAY_OF_WEEK_TOKENS[rangeMatch[2]];
+        if (start && end) {
+            return expandDayRange(start, end);
+        }
+    }
+    const compactConnectorRange = normalized.match(/^(.+?)(ถึง|จนถึง|to|through|thru)(.+)$/u);
+    if (compactConnectorRange) {
+        const start = maps_1.DAY_OF_WEEK_TOKENS[compactConnectorRange[1]];
+        const end = maps_1.DAY_OF_WEEK_TOKENS[compactConnectorRange[3]];
+        if (start && end) {
+            return expandDayRange(start, end);
+        }
+    }
+    return undefined;
+}
+function tryConsumeDayRangeTokens(internal, tokens, index) {
+    const startToken = tokens[index];
+    if (!startToken || internal.consumed.has(startToken.index)) {
+        return 0;
+    }
+    const startDays = resolveDayTokenDays(normalizeTokenLower(startToken));
+    if (!startDays || startDays.length !== 1) {
+        return 0;
+    }
+    const connectorToken = tokens[index + 1];
+    const endToken = tokens[index + 2];
+    if (!connectorToken ||
+        !endToken ||
+        internal.consumed.has(connectorToken.index) ||
+        internal.consumed.has(endToken.index)) {
+        return 0;
+    }
+    const connector = normalizeTokenLower(connectorToken);
+    if (!DAY_RANGE_CONNECTOR_TOKENS.has(connector)) {
+        return 0;
+    }
+    const endDays = resolveDayTokenDays(normalizeTokenLower(endToken));
+    if (!endDays || endDays.length !== 1) {
+        return 0;
+    }
+    const expanded = expandDayRange(startDays[0], endDays[0]);
+    addDayOfWeekList(internal, expanded);
+    mark(internal.consumed, startToken);
+    mark(internal.consumed, connectorToken);
+    mark(internal.consumed, endToken);
+    return 3;
+}
 function parseAnchorSequence(internal, tokens, index, prefixCode) {
     var _a;
     const token = tokens[index];
@@ -1594,16 +1748,20 @@ function parseAnchorSequence(internal, tokens, index, prefixCode) {
         if (internal.consumed.has(nextToken.index)) {
             continue;
         }
-        const lower = nextToken.lower;
+        const lower = normalizeTokenLower(nextToken);
         if (MEAL_CONTEXT_CONNECTORS.has(lower) || lower === ",") {
             mark(internal.consumed, nextToken);
             continue;
         }
-        const day = maps_1.DAY_OF_WEEK_TOKENS[lower];
-        if (day) {
-            if (!(0, array_1.arrayIncludes)(internal.dayOfWeek, day)) {
-                internal.dayOfWeek.push(day);
-            }
+        const rangeConsumed = tryConsumeDayRangeTokens(internal, tokens, lookahead);
+        if (rangeConsumed > 0) {
+            converted++;
+            lookahead += rangeConsumed - 1;
+            continue;
+        }
+        const days = resolveDayTokenDays(lower);
+        if (days) {
+            addDayOfWeekList(internal, days);
             mark(internal.consumed, nextToken);
             converted++;
             continue;
@@ -1748,6 +1906,70 @@ function applyCountLimit(internal, value) {
     internal.count = rounded;
     return true;
 }
+const DOSE_SCALE_MULTIPLIERS = {
+    k: 1000,
+    thousand: 1000,
+    m: 1000000,
+    mn: 1000000,
+    mio: 1000000,
+    million: 1000000,
+    b: 1000000000,
+    bn: 1000000000,
+    billion: 1000000000
+};
+function resolveUnitTokenAt(tokens, index, consumed, options) {
+    const token = tokens[index];
+    if (!token || consumed.has(token.index)) {
+        return undefined;
+    }
+    const normalized = normalizeTokenLower(token);
+    const direct = normalizeUnit(normalized, options);
+    if (direct) {
+        return { unit: direct, consumedIndices: [index] };
+    }
+    if (normalized === "international") {
+        const nextToken = tokens[index + 1];
+        if (!nextToken || consumed.has(nextToken.index)) {
+            return undefined;
+        }
+        const nextNormalized = normalizeTokenLower(nextToken);
+        if (nextNormalized === "unit" ||
+            nextNormalized === "units" ||
+            nextNormalized === "u" ||
+            nextNormalized === "iu" ||
+            nextNormalized === "ius") {
+            return { unit: "IU", consumedIndices: [index, index + 1] };
+        }
+    }
+    return undefined;
+}
+function resolveNumericDoseUnit(tokens, numberIndex, value, consumed, options) {
+    const directUnit = resolveUnitTokenAt(tokens, numberIndex + 1, consumed, options);
+    if (directUnit) {
+        return {
+            doseValue: value,
+            unit: directUnit.unit,
+            consumedIndices: directUnit.consumedIndices
+        };
+    }
+    const scaleToken = tokens[numberIndex + 1];
+    if (!scaleToken || consumed.has(scaleToken.index)) {
+        return { doseValue: value, consumedIndices: [] };
+    }
+    const multiplier = DOSE_SCALE_MULTIPLIERS[normalizeTokenLower(scaleToken)];
+    if (!multiplier) {
+        return { doseValue: value, consumedIndices: [] };
+    }
+    const scaledUnit = resolveUnitTokenAt(tokens, numberIndex + 2, consumed, options);
+    if (!scaledUnit) {
+        return { doseValue: value, consumedIndices: [] };
+    }
+    return {
+        doseValue: value * multiplier,
+        unit: scaledUnit.unit,
+        consumedIndices: [numberIndex + 1, ...scaledUnit.consumedIndices]
+    };
+}
 function parseInternal(input, options) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     const tokens = tokenize(input);
@@ -2063,11 +2285,13 @@ function parseInternal(input, options) {
             }
         }
         // Day of week
-        const day = maps_1.DAY_OF_WEEK_TOKENS[token.lower];
-        if (day) {
-            if (!(0, array_1.arrayIncludes)(internal.dayOfWeek, day)) {
-                internal.dayOfWeek.push(day);
-            }
+        const rangeConsumed = tryConsumeDayRangeTokens(internal, tokens, i);
+        if (rangeConsumed > 0) {
+            continue;
+        }
+        const days = resolveDayTokenDays(normalizeTokenLower(token));
+        if (days) {
+            addDayOfWeekList(internal, days);
             mark(internal.consumed, token);
             continue;
         }
@@ -2210,29 +2434,27 @@ function parseInternal(input, options) {
                 internal.doseRange = rangeValue;
             }
             mark(internal.consumed, token);
-            const unitToken = tokens[i + 1];
-            if (unitToken && !internal.consumed.has(unitToken.index)) {
-                const unit = normalizeUnit(unitToken.lower, options);
-                if (unit) {
-                    internal.unit = unit;
-                    mark(internal.consumed, unitToken);
+            const resolvedUnit = resolveUnitTokenAt(tokens, i + 1, internal.consumed, options);
+            if (resolvedUnit) {
+                internal.unit = resolvedUnit.unit;
+                for (const consumedIndex of resolvedUnit.consumedIndices) {
+                    mark(internal.consumed, tokens[consumedIndex]);
                 }
             }
             continue;
         }
         if (/^[0-9]+(?:\.[0-9]+)?$/.test(token.lower)) {
             const value = parseFloat(token.original);
+            const resolvedDose = resolveNumericDoseUnit(tokens, i, value, internal.consumed, options);
             if (internal.dose === undefined) {
-                internal.dose = value;
+                internal.dose = resolvedDose.doseValue;
             }
             mark(internal.consumed, token);
-            const unitToken = tokens[i + 1];
-            if (unitToken && !internal.consumed.has(unitToken.index)) {
-                const unit = normalizeUnit(unitToken.lower, options);
-                if (unit) {
-                    internal.unit = unit;
-                    mark(internal.consumed, unitToken);
-                }
+            if (resolvedDose.unit) {
+                internal.unit = resolvedDose.unit;
+            }
+            for (const consumedIndex of resolvedDose.consumedIndices) {
+                mark(internal.consumed, tokens[consumedIndex]);
             }
             continue;
         }

package/package.json

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