ezmedicationinput 0.1.0

package/README.md

@@ -0,0 +1,153 @@
+# ezmedicationinput
+
+`ezmedicationinput` parses concise clinician shorthand medication instructions and produces [FHIR R5 Dosage](https://hl7.org/fhir/dosage.html) JSON. It is designed for use in lightweight medication-entry experiences and ships with batteries-included normalization for common Thai/English sig abbreviations.
+
+## Features
+
+- Converts shorthand strings (e.g. `1x3 po pc`, `500 mg po q6h prn pain`) into FHIR-compliant dosage JSON.
+- Emits timing abbreviations (`timing.code`) and repeat structures simultaneously where possible.
+- Maps meal/time blocks to the correct `Timing.repeat.when` **EventTiming** codes and can auto-expand AC/PC/C into specific meals.
+- Outputs SNOMED CT route codings (while providing friendly text) and round-trips known SNOMED routes back into the parser.
+- Understands ocular and intravitreal shorthand (OD/OS/OU, LE/RE/BE, IVT*, VOD/VOS, etc.) and warns when intravitreal instructions omit an eye side.
+- Parses fractional/ minute-based intervals (`q0.5h`, `q30 min`, `q1/4hr`) plus dose and timing ranges.
+- Supports extensible dictionaries for routes, units, frequency shorthands, and event timing tokens.
+- Applies medication context to infer default units when they are omitted.
+- Surfaces warnings when discouraged tokens (`QD`, `QOD`, `BLD`) are used and optionally rejects them.
+- Generates upcoming administration timestamps from FHIR dosage data via `nextDueDoses` using configurable clinic clocks.
+
+## Installation
+
+```bash
+npm install ezmedicationinput
+```
+
+## Usage
+
+```ts
+import { parseSig } from "ezmedicationinput";
+
+const result = parseSig("1x3 po pc", { context: { dosageForm: "tab" } });
+console.log(result.fhir);
+```
+
+Example output:
+
+```json
+{
+  "text": "1 tablet by mouth three times daily after meals",
+  "timing": {
+    "code": { "coding": [{ "code": "TID" }], "text": "TID" },
+    "repeat": {
+      "frequency": 3,
+      "period": 1,
+      "periodUnit": "d",
+      "when": ["PC"]
+    }
+  },
+  "route": { "text": "by mouth" },
+  "doseAndRate": [{ "doseQuantity": { "value": 1, "unit": "tab" } }]
+}
+```
+
+## Dictionaries
+
+The library exposes default dictionaries in `maps.ts` for routes, units, frequencies (Timing abbreviations + repeat defaults), and event timing tokens. You can extend or override them via the `ParseOptions` argument.
+
+Key EventTiming mappings include:
+
+| Token(s)        | EventTiming |
+|-----------------|-------------|
+| `ac`            | `AC`
+| `pc`            | `PC`
+| `wm`, `with meals` | `C`
+| `pc breakfast`  | `PCM`
+| `pc lunch`      | `PCD`
+| `pc dinner`     | `PCV`
+| `am`, `morning` | `MORN`
+| `noon`          | `NOON`
+| `pm`, `evening` | `EVE`
+| `night`         | `NIGHT`
+| `hs`, `bedtime` | `HS`
+
+When `when` is populated, `timeOfDay` is intentionally omitted to stay within HL7 constraints.
+
+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.
+
+### Advanced parsing options
+
+`parseSig` accepts a `ParseOptions` object. Highlights:
+
+- `context`: optional medication context (dosage form, strength, container
+  metadata) used to infer default units when a sig omits explicit units. Pass
+  `null` to explicitly disable context-based inference.
+- `smartMealExpansion`: when `true`, generic AC/PC/C tokens expand into specific EventTiming combinations (e.g. `1x2 po ac` → `ACM` + `ACV`).
+- `twoPerDayPair`: controls whether 2× AC/PC/C doses expand to breakfast+dinner (default) or breakfast+lunch.
+- Custom `routeMap`, `unitMap`, `freqMap`, and `whenMap` let you augment the built-in dictionaries without mutating them.
+
+### Next due dose generation
+
+`nextDueDoses` produces upcoming administration timestamps from an existing FHIR `Dosage`. Supply the order start, the reference window, and a clinic configuration that defines anchor times.
+
+```ts
+import { EventTiming, nextDueDoses, parseSig } from "ezmedicationinput";
+
+const { fhir } = parseSig("1x3 po pc", { context: { dosageForm: "tab" } });
+
+const schedule = nextDueDoses(fhir, {
+  orderedAt: "2024-01-01T08:15:00Z",
+  from: "2024-01-01T09:00:00Z",
+  limit: 5,
+  config: {
+    timeZone: "Asia/Bangkok",
+    eventClock: {
+      [EventTiming.Morning]: "08:00",
+      [EventTiming.Noon]: "12:00",
+      [EventTiming.Evening]: "18:00",
+      [EventTiming["Before Sleep"]]: "22:00",
+      [EventTiming.Breakfast]: "08:00",
+      [EventTiming.Lunch]: "12:30",
+      [EventTiming.Dinner]: "18:30"
+    },
+    mealOffsets: {
+      [EventTiming["Before Meal"]]: -30,
+      [EventTiming["After Meal"]]: 30
+    },
+    frequencyDefaults: {
+      byCode: { BID: ["08:00", "20:00"] }
+    }
+  }
+});
+
+// → ["2024-01-01T12:30:00+07:00", "2024-01-01T18:30:00+07:00", ...]
+```
+
+Key rules:
+
+- `when` values map to the clinic `eventClock`. Generic meal codes (`AC`, `PC`, `C`) use `mealOffsets` against breakfast/lunch/dinner anchors.
+- Interval-based schedules (`repeat.period` + `periodUnit`) step forward from `orderedAt`, respecting `dayOfWeek` filters.
+- Pure frequency schedules (`BID`, `TID`, etc.) fall back to clinic-defined institution times.
+- All timestamps are emitted as ISO strings that include the clinic time-zone offset.
+
+### Ocular & intravitreal shortcuts
+
+The parser recognizes ophthalmic shorthands such as `OD`, `OS`, `OU`, `LE`, `RE`, and `BE`, as well as intravitreal-specific tokens including `IVT`, `IVTOD`, `IVTOS`, `IVTLE`, `IVTBE`, `VOD`, and `VOS`. Intravitreal sigs require an eye side; the parser surfaces a warning if one is missing so downstream workflows can prompt the clinician for clarification.
+
+## Discouraged Tokens
+
+- `QD` (daily)
+- `QOD` (every other day)
+- `BLD` / `B-L-D` (with meals)
+
+By default these are accepted with a warning via `ParseResult.warnings`. Set `allowDiscouraged: false` in `ParseOptions` to reject inputs containing them.
+
+## Testing
+
+Run the Vitest test suite:
+
+```bash
+npm test
+```
+
+## License
+
+MIT

package/dist/context.d.ts

@@ -0,0 +1,3 @@
+import { MedicationContext } from "./types";
+export declare function normalizeDosageForm(form: string | undefined): string | undefined;
+export declare function inferUnitFromContext(ctx: MedicationContext | undefined): string | undefined;

package/dist/context.js

@@ -0,0 +1,29 @@
+import { DEFAULT_UNIT_BY_NORMALIZED_FORM, KNOWN_DOSAGE_FORMS_TO_DOSE } from "./maps";
+export function normalizeDosageForm(form) {
+    if (!form) {
+        return undefined;
+    }
+    const key = form.trim().toLowerCase();
+    return KNOWN_DOSAGE_FORMS_TO_DOSE[key] ?? key;
+}
+export function inferUnitFromContext(ctx) {
+    if (!ctx) {
+        return undefined;
+    }
+    if (ctx.defaultUnit) {
+        return ctx.defaultUnit;
+    }
+    if (ctx.dosageForm) {
+        const normalized = normalizeDosageForm(ctx.dosageForm);
+        if (normalized) {
+            const unit = DEFAULT_UNIT_BY_NORMALIZED_FORM[normalized];
+            if (unit) {
+                return unit;
+            }
+        }
+    }
+    if (ctx.containerUnit) {
+        return ctx.containerUnit;
+    }
+    return undefined;
+}

package/dist/fhir.d.ts

@@ -0,0 +1,4 @@
+import { ParsedSigInternal } from "./parser";
+import { FhirDosage } from "./types";
+export declare function toFhir(internal: ParsedSigInternal): FhirDosage;
+export declare function internalFromFhir(dosage: FhirDosage): ParsedSigInternal;

package/dist/fhir.js

@@ -0,0 +1,158 @@
+import { formatInternal } from "./format";
+import { ROUTE_BY_SNOMED, ROUTE_SNOMED, ROUTE_TEXT } from "./maps";
+import { EventTiming } from "./types";
+const SNOMED_SYSTEM = "http://snomed.info/sct";
+export function toFhir(internal) {
+    const dosage = {};
+    const repeat = {};
+    let hasRepeat = false;
+    if (internal.frequency !== undefined) {
+        repeat.frequency = internal.frequency;
+        hasRepeat = true;
+    }
+    if (internal.frequencyMax !== undefined) {
+        repeat.frequencyMax = internal.frequencyMax;
+        hasRepeat = true;
+    }
+    if (internal.period !== undefined && internal.periodUnit) {
+        repeat.period = internal.period;
+        repeat.periodUnit = internal.periodUnit;
+        hasRepeat = true;
+    }
+    if (internal.periodMax !== undefined) {
+        repeat.periodMax = internal.periodMax;
+        hasRepeat = true;
+    }
+    if (internal.dayOfWeek.length) {
+        repeat.dayOfWeek = [...internal.dayOfWeek];
+        hasRepeat = true;
+    }
+    if (internal.when.length) {
+        repeat.when = [...internal.when];
+        hasRepeat = true;
+    }
+    if (hasRepeat) {
+        dosage.timing = { repeat };
+    }
+    else {
+        dosage.timing = {};
+    }
+    if (internal.timingCode) {
+        dosage.timing = dosage.timing ?? {};
+        dosage.timing.code = {
+            coding: [{ code: internal.timingCode }],
+            text: internal.timingCode
+        };
+    }
+    if (internal.doseRange) {
+        dosage.doseAndRate = [
+            {
+                doseRange: {
+                    low: internal.doseRange.low !== undefined
+                        ? { value: internal.doseRange.low, unit: internal.unit }
+                        : undefined,
+                    high: internal.doseRange.high !== undefined
+                        ? { value: internal.doseRange.high, unit: internal.unit }
+                        : undefined
+                }
+            }
+        ];
+    }
+    else if (internal.dose !== undefined) {
+        dosage.doseAndRate = [
+            {
+                doseQuantity: {
+                    value: internal.dose,
+                    unit: internal.unit
+                }
+            }
+        ];
+    }
+    // Emit SNOMED-coded routes whenever we have parsed or inferred route data.
+    if (internal.routeCode || internal.routeText) {
+        const coding = internal.routeCode ? ROUTE_SNOMED[internal.routeCode] : undefined;
+        const text = internal.routeText ??
+            (internal.routeCode ? ROUTE_TEXT[internal.routeCode] : undefined);
+        if (coding) {
+            // Provide both text and coding so human-readable and coded systems align.
+            dosage.route = {
+                text,
+                coding: [
+                    {
+                        system: SNOMED_SYSTEM,
+                        code: coding.code,
+                        display: coding.display
+                    }
+                ]
+            };
+        }
+        else if (text) {
+            dosage.route = { text };
+        }
+    }
+    if (internal.siteText) {
+        dosage.site = { text: internal.siteText };
+    }
+    if (internal.asNeeded) {
+        dosage.asNeededBoolean = true;
+        if (internal.asNeededReason) {
+            dosage.asNeededFor = [{ text: internal.asNeededReason }];
+        }
+    }
+    const longText = formatInternal(internal, "long");
+    if (longText) {
+        dosage.text = longText;
+    }
+    return dosage;
+}
+export function internalFromFhir(dosage) {
+    const internal = {
+        input: dosage.text ?? "",
+        tokens: [],
+        consumed: new Set(),
+        dayOfWeek: dosage.timing?.repeat?.dayOfWeek
+            ? [...dosage.timing.repeat.dayOfWeek]
+            : [],
+        when: dosage.timing?.repeat?.when
+            ? dosage.timing.repeat.when.filter((value) => Object.values(EventTiming).includes(value))
+            : [],
+        warnings: [],
+        timingCode: dosage.timing?.code?.coding?.[0]?.code,
+        frequency: dosage.timing?.repeat?.frequency,
+        frequencyMax: dosage.timing?.repeat?.frequencyMax,
+        period: dosage.timing?.repeat?.period,
+        periodMax: dosage.timing?.repeat?.periodMax,
+        periodUnit: dosage.timing?.repeat?.periodUnit,
+        routeText: dosage.route?.text,
+        siteText: dosage.site?.text,
+        asNeeded: dosage.asNeededBoolean,
+        asNeededReason: dosage.asNeededFor?.[0]?.text
+    };
+    const routeCoding = dosage.route?.coding?.find((code) => code.system === SNOMED_SYSTEM);
+    if (routeCoding?.code) {
+        // Translate SNOMED codings back into the simplified enum for round-trip fidelity.
+        const mapped = ROUTE_BY_SNOMED[routeCoding.code];
+        if (mapped) {
+            internal.routeCode = mapped;
+            internal.routeText = ROUTE_TEXT[mapped];
+        }
+    }
+    const doseAndRate = dosage.doseAndRate?.[0];
+    if (doseAndRate?.doseRange) {
+        const { low, high } = doseAndRate.doseRange;
+        if (low?.value !== undefined && high?.value !== undefined) {
+            internal.doseRange = { low: low.value, high: high.value };
+        }
+        internal.unit = low?.unit ?? high?.unit ?? internal.unit;
+    }
+    else if (doseAndRate?.doseQuantity) {
+        const dose = doseAndRate.doseQuantity;
+        if (dose.value !== undefined) {
+            internal.dose = dose.value;
+        }
+        if (dose.unit) {
+            internal.unit = dose.unit;
+        }
+    }
+    return internal;
+}

package/dist/format.d.ts

@@ -0,0 +1,2 @@
+import { ParsedSigInternal } from "./parser";
+export declare function formatInternal(internal: ParsedSigInternal, style: "short" | "long"): string;

package/dist/format.js

@@ -0,0 +1,322 @@
+import { EventTiming, FhirPeriodUnit, RouteCode } from "./types";
+const ROUTE_SHORT = {
+    [RouteCode["Oral route"]]: "PO",
+    [RouteCode["Sublingual route"]]: "SL",
+    [RouteCode["Buccal route"]]: "BUC",
+    [RouteCode["Respiratory tract route (qualifier value)"]]: "INH",
+    [RouteCode["Nasal route"]]: "IN",
+    [RouteCode["Topical route"]]: "TOP",
+    [RouteCode["Transdermal route"]]: "TD",
+    [RouteCode["Subcutaneous route"]]: "SC",
+    [RouteCode["Intramuscular route"]]: "IM",
+    [RouteCode["Intravenous route"]]: "IV",
+    [RouteCode["Per rectum"]]: "PR",
+    [RouteCode["Per vagina"]]: "PV",
+    [RouteCode["Ophthalmic route"]]: "OPH",
+    [RouteCode["Intravitreal route (qualifier value)"]]: "IVT"
+};
+const WHEN_TEXT = {
+    [EventTiming["Before Sleep"]]: "at bedtime",
+    [EventTiming["Before Meal"]]: "before meals",
+    [EventTiming["Before Breakfast"]]: "before breakfast",
+    [EventTiming["Before Lunch"]]: "before lunch",
+    [EventTiming["Before Dinner"]]: "before dinner",
+    [EventTiming["After Meal"]]: "after meals",
+    [EventTiming["After Breakfast"]]: "after breakfast",
+    [EventTiming["After Lunch"]]: "after lunch",
+    [EventTiming["After Dinner"]]: "after dinner",
+    [EventTiming.Meal]: "with meals",
+    [EventTiming.Breakfast]: "with morning meal",
+    [EventTiming.Lunch]: "with lunch",
+    [EventTiming.Dinner]: "with evening meal",
+    [EventTiming.Morning]: "in the morning",
+    [EventTiming["Early Morning"]]: "in the early morning",
+    [EventTiming["Late Morning"]]: "in the late morning",
+    [EventTiming.Noon]: "at noon",
+    [EventTiming.Afternoon]: "in the afternoon",
+    [EventTiming["Early Afternoon"]]: "in the early afternoon",
+    [EventTiming["Late Afternoon"]]: "in the late afternoon",
+    [EventTiming.Evening]: "in the evening",
+    [EventTiming["Early Evening"]]: "in the early evening",
+    [EventTiming["Late Evening"]]: "in the late evening",
+    [EventTiming.Night]: "at night",
+    [EventTiming.Wake]: "after waking",
+    [EventTiming["After Sleep"]]: "after sleep",
+    [EventTiming.Immediate]: "immediately"
+};
+const DAY_NAMES = {
+    mon: "Monday",
+    tue: "Tuesday",
+    wed: "Wednesday",
+    thu: "Thursday",
+    fri: "Friday",
+    sat: "Saturday",
+    sun: "Sunday"
+};
+function pluralize(unit, value) {
+    if (Math.abs(value) === 1) {
+        if (unit === "tab")
+            return "tablet";
+        if (unit === "cap")
+            return "capsule";
+        return unit;
+    }
+    if (unit === "tab" || unit === "tablet")
+        return "tablets";
+    if (unit === "cap" || unit === "capsule")
+        return "capsules";
+    if (unit === "mL")
+        return "mL";
+    if (unit === "mg")
+        return "mg";
+    if (unit === "puff")
+        return value === 1 ? "puff" : "puffs";
+    if (unit === "patch")
+        return value === 1 ? "patch" : "patches";
+    if (unit === "drop")
+        return value === 1 ? "drop" : "drops";
+    if (unit === "suppository")
+        return value === 1 ? "suppository" : "suppositories";
+    return unit;
+}
+function describeFrequency(internal) {
+    const { frequency, frequencyMax, period, periodMax, periodUnit, timingCode } = internal;
+    if (frequency !== undefined &&
+        frequencyMax !== undefined &&
+        periodUnit === FhirPeriodUnit.Day &&
+        (!period || period === 1)) {
+        if (frequency === 1 && frequencyMax === 1) {
+            return "once daily";
+        }
+        if (frequency === 1 && frequencyMax === 2) {
+            return "one to two times daily";
+        }
+        return `${stripTrailingZero(frequency)} to ${stripTrailingZero(frequencyMax)} times daily`;
+    }
+    if (frequency && periodUnit === FhirPeriodUnit.Day && (!period || period === 1)) {
+        if (frequency === 1)
+            return "once daily";
+        if (frequency === 2)
+            return "twice daily";
+        if (frequency === 3)
+            return "three times daily";
+        if (frequency === 4)
+            return "four times daily";
+        return `${stripTrailingZero(frequency)} times daily`;
+    }
+    if (periodUnit === FhirPeriodUnit.Hour && period) {
+        if (periodMax && periodMax !== period) {
+            return `every ${stripTrailingZero(period)} to ${stripTrailingZero(periodMax)} hours`;
+        }
+        return `every ${stripTrailingZero(period)} hour${period === 1 ? "" : "s"}`;
+    }
+    if (periodUnit === FhirPeriodUnit.Day && period && period !== 1) {
+        if (period === 2 && (!periodMax || periodMax === 2)) {
+            return "every other day";
+        }
+        if (periodMax && periodMax !== period) {
+            return `every ${stripTrailingZero(period)} to ${stripTrailingZero(periodMax)} days`;
+        }
+        return `every ${stripTrailingZero(period)} days`;
+    }
+    if (periodUnit === FhirPeriodUnit.Week && period) {
+        if (period === 1 && (!periodMax || periodMax === 1)) {
+            return "once weekly";
+        }
+        if (periodMax && periodMax !== period) {
+            return `every ${stripTrailingZero(period)} to ${stripTrailingZero(periodMax)} weeks`;
+        }
+        return `every ${stripTrailingZero(period)} weeks`;
+    }
+    if (periodUnit === FhirPeriodUnit.Month && period) {
+        if (period === 1 && (!periodMax || periodMax === 1)) {
+            return "once monthly";
+        }
+        if (periodMax && periodMax !== period) {
+            return `every ${stripTrailingZero(period)} to ${stripTrailingZero(periodMax)} months`;
+        }
+        return `every ${stripTrailingZero(period)} months`;
+    }
+    if (timingCode) {
+        if (timingCode === "WK") {
+            return "once weekly";
+        }
+        if (timingCode === "MO") {
+            return "once monthly";
+        }
+        const map = {
+            BID: "twice daily",
+            TID: "three times daily",
+            QID: "four times daily",
+            QD: "once daily",
+            QOD: "every other day",
+            Q6H: "every 6 hours",
+            Q8H: "every 8 hours"
+        };
+        if (map[timingCode]) {
+            return map[timingCode];
+        }
+    }
+    if (frequency && periodUnit === undefined && period === undefined) {
+        if (frequency === 1)
+            return "once";
+        return `${stripTrailingZero(frequency)} times`;
+    }
+    return undefined;
+}
+function formatDoseShort(internal) {
+    if (internal.doseRange) {
+        const { low, high } = internal.doseRange;
+        const base = `${stripTrailingZero(low)}-${stripTrailingZero(high)}`;
+        if (internal.unit) {
+            return `${base} ${internal.unit}`;
+        }
+        return base;
+    }
+    if (internal.dose !== undefined) {
+        const dosePart = internal.unit
+            ? `${stripTrailingZero(internal.dose)} ${internal.unit}`
+            : `${stripTrailingZero(internal.dose)}`;
+        return dosePart.trim();
+    }
+    return undefined;
+}
+function formatDoseLong(internal) {
+    if (internal.doseRange) {
+        const { low, high } = internal.doseRange;
+        if (internal.unit) {
+            return `${stripTrailingZero(low)} to ${stripTrailingZero(high)} ${pluralize(internal.unit, high)}`;
+        }
+        return `${stripTrailingZero(low)} to ${stripTrailingZero(high)}`;
+    }
+    if (internal.dose !== undefined) {
+        if (internal.unit) {
+            return `${stripTrailingZero(internal.dose)} ${pluralize(internal.unit, internal.dose)}`;
+        }
+        return `${stripTrailingZero(internal.dose)}`;
+    }
+    return undefined;
+}
+function describeWhen(internal) {
+    if (!internal.when.length) {
+        return undefined;
+    }
+    const parts = internal.when
+        .map((code) => WHEN_TEXT[code] ?? code)
+        .filter(Boolean);
+    if (!parts.length) {
+        return undefined;
+    }
+    return parts.join(" and ");
+}
+function describeDayOfWeek(internal) {
+    if (!internal.dayOfWeek.length) {
+        return undefined;
+    }
+    const days = internal.dayOfWeek.map((d) => DAY_NAMES[d] ?? d);
+    if (days.length === 1) {
+        return `on ${days[0]}`;
+    }
+    return `on ${days.join(" and ")}`;
+}
+export function formatInternal(internal, style) {
+    if (style === "short") {
+        return formatShort(internal);
+    }
+    return formatLong(internal);
+}
+function formatShort(internal) {
+    const parts = [];
+    const dosePart = formatDoseShort(internal);
+    if (dosePart) {
+        parts.push(dosePart);
+    }
+    if (internal.routeCode) {
+        const short = ROUTE_SHORT[internal.routeCode];
+        if (short) {
+            parts.push(short);
+        }
+        else if (internal.routeText) {
+            parts.push(internal.routeText);
+        }
+    }
+    else if (internal.routeText) {
+        parts.push(internal.routeText);
+    }
+    if (internal.timingCode) {
+        parts.push(internal.timingCode);
+    }
+    else if (internal.frequency !== undefined &&
+        internal.frequencyMax !== undefined &&
+        internal.periodUnit === FhirPeriodUnit.Day &&
+        (!internal.period || internal.period === 1)) {
+        parts.push(`${stripTrailingZero(internal.frequency)}-${stripTrailingZero(internal.frequencyMax)}x/d`);
+    }
+    else if (internal.frequency &&
+        internal.periodUnit === FhirPeriodUnit.Day &&
+        (!internal.period || internal.period === 1)) {
+        parts.push(`${stripTrailingZero(internal.frequency)}x/d`);
+    }
+    else if (internal.period && internal.periodUnit) {
+        const base = stripTrailingZero(internal.period);
+        const qualifier = internal.periodMax && internal.periodMax !== internal.period
+            ? `${base}-${stripTrailingZero(internal.periodMax)}`
+            : base;
+        parts.push(`Q${qualifier}${internal.periodUnit.toUpperCase()}`);
+    }
+    if (internal.when.length) {
+        parts.push(internal.when.join(" "));
+    }
+    if (internal.dayOfWeek.length) {
+        parts.push(internal.dayOfWeek
+            .map((d) => d.charAt(0).toUpperCase() + d.slice(1, 3))
+            .join(","));
+    }
+    if (internal.asNeeded) {
+        if (internal.asNeededReason) {
+            parts.push(`PRN ${internal.asNeededReason}`);
+        }
+        else {
+            parts.push("PRN");
+        }
+    }
+    return parts.filter(Boolean).join(" ");
+}
+function formatLong(internal) {
+    const parts = [];
+    const dosePart = formatDoseLong(internal);
+    if (dosePart) {
+        parts.push(dosePart);
+    }
+    if (internal.routeText) {
+        parts.push(internal.routeText);
+    }
+    const freqText = describeFrequency(internal);
+    if (freqText) {
+        parts.push(freqText);
+    }
+    const whenText = describeWhen(internal);
+    if (whenText) {
+        parts.push(whenText);
+    }
+    const dayText = describeDayOfWeek(internal);
+    if (dayText) {
+        parts.push(dayText);
+    }
+    if (internal.asNeeded) {
+        parts.push(internal.asNeededReason
+            ? `as needed for ${internal.asNeededReason}`
+            : "as needed");
+    }
+    if (internal.siteText) {
+        parts.push(`at ${internal.siteText}`);
+    }
+    return parts.join(" ").trim();
+}
+function stripTrailingZero(value) {
+    const text = value.toString();
+    if (text.includes(".")) {
+        return text.replace(/\.0+$/, "").replace(/0+$/, "");
+    }
+    return text;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { FhirDosage, ParseOptions, ParseResult } from "./types";
+export { parseInternal } from "./parser";
+export * from "./types";
+export { nextDueDoses } from "./schedule";
+export declare function parseSig(input: string, options?: ParseOptions): ParseResult;
+export declare function formatSig(dosage: FhirDosage, style?: "short" | "long"): string;
+export declare function fromFhirDosage(dosage: FhirDosage): ParseResult;