fhir-dosage-utils 1.0.0

package/dist/module.js

@@ -0,0 +1,1015 @@
+import $hgUW1$i18next from "i18next";
+import $hgUW1$i18nextchainedbackend from "i18next-chained-backend";
+import $hgUW1$i18nextresourcestobackend from "i18next-resources-to-backend";
+
+
+
+
+function $a620268c8b5a46fd$export$b1a6aed91fad1636({ quantity: quantity }) {
+    if (quantity.code !== undefined) return quantity.code;
+    if (quantity.unit !== undefined) return quantity.unit;
+    return "";
+}
+
+
+function $f2878500cc217687$export$f478f96b98da13a4({ code: code }) {
+    // If no code, skip it
+    if (code === undefined) return undefined;
+    // Take text first
+    if (code.text !== undefined) return code.text;
+    // If empty, skip it
+    if (code.coding === undefined || code.coding.length === 0) return undefined;
+    // Take first coding; display first then code
+    let firstCode = code.coding[0];
+    return firstCode.display || firstCode.code;
+}
+
+
+function $a31aaee21175037d$export$30c337e25ab8e95b({ extensions: extensions }) {
+    // If no extensions, skip it
+    if (extensions === undefined || extensions.length === 0) return undefined;
+    // KIS implementation : print it as provided, without doing anything
+    // Extensions have so many cases btw, that having a basic function does the trick
+    return extensions.map((extension)=>JSON.stringify(extension)).join(" ");
+}
+
+
+// translators
+// To avoid circular dependancies issue, let's have a single place for exports and imports
+// types
+function $7cf24331c38efaf1$export$7de3722258b87db9({ config: config, dos: dos, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.doseAndRate === undefined) return undefined;
+    // Find the first entry that match criteria
+    let doseQuantity = dos.doseAndRate.find((s)=>s.doseQuantity !== undefined);
+    // If not found, skip
+    if (doseQuantity === undefined) return undefined;
+    let quantity = doseQuantity.doseQuantity.value || 1;
+    let unit = config.fromFHIRQuantityUnitToString({
+        language: config.language,
+        quantity: doseQuantity.doseQuantity
+    });
+    return i18next.t("fields.doseQuantity", {
+        quantity: quantity,
+        unit: unit
+    });
+}
+
+
+// types
+function $465e6e43e1df9717$export$4cd16590995531a9({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.doseAndRate === undefined) return undefined;
+    // Find the first entry that match criteria
+    let doseRange = dos.doseAndRate.find((s)=>s.doseRange !== undefined);
+    // If not found, skip
+    if (doseRange === undefined) return undefined;
+    let low = doseRange.doseRange.low?.value;
+    let high = doseRange.doseRange.high?.value;
+    let quantityUnit = doseRange.doseRange.high !== undefined ? doseRange.doseRange.high : doseRange.doseRange.low;
+    // quantity unit
+    let unit = config.fromFHIRQuantityUnitToString({
+        language: config.language,
+        quantity: quantityUnit
+    });
+    // Three cases
+    // 1. Both low & high are present
+    if (high !== undefined && low !== undefined) return i18next.t("fields.doseRange.lowAndHigh", {
+        low: low,
+        high: high,
+        unit: unit
+    });
+    // 2. Only high is present
+    if (high !== undefined) return i18next.t("fields.doseRange.onlyHigh", {
+        high: high,
+        unit: unit
+    });
+    // 3. Only low is present
+    // Warning, this case is kind dangerous and clinically unsafe so minimal effort on this ...
+    return i18next.t("fields.doseRange.onlyLow", {
+        low: low,
+        unit: unit
+    });
+}
+
+
+// types
+function $bbbd1877a73b7a2b$export$4e24ef8c7997cc56({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.doseAndRate === undefined) return undefined;
+    // Find the first entry that match criteria
+    let rateQuantity = dos.doseAndRate.find((s)=>s.rateQuantity !== undefined);
+    // If not found, skip
+    if (rateQuantity === undefined) return undefined;
+    // information from rate
+    let value = rateQuantity.rateQuantity.value || 1;
+    // quantity unit
+    let unit = config.fromFHIRQuantityUnitToString({
+        language: config.language,
+        quantity: rateQuantity.rateQuantity
+    });
+    return i18next.t("fields.rateQuantity", {
+        quantity: value,
+        unit: unit
+    });
+}
+
+
+// types
+function $09db039855b6d015$export$d3dd7d3522271dba({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.doseAndRate === undefined) return undefined;
+    // Find the first entry that match criteria
+    let rateRange = dos.doseAndRate.find((s)=>s.rateRange !== undefined);
+    // If not found, skip
+    if (rateRange === undefined) return undefined;
+    // low / high
+    let low = rateRange.rateRange.low;
+    let high = rateRange.rateRange.high;
+    let quantityLow = low?.value;
+    let quantityHigh = high?.value;
+    // quantity unit
+    let unit = config.fromFHIRQuantityUnitToString({
+        language: config.language,
+        quantity: high || low
+    });
+    // Three cases
+    // 1. Both low & high are present
+    if (quantityHigh !== undefined && quantityLow !== undefined) return i18next.t("fields.rateRange.lowAndHigh", {
+        low: quantityLow,
+        high: quantityHigh,
+        unit: unit
+    });
+    // 2. Only high is present
+    if (quantityHigh !== undefined) return i18next.t("fields.rateRange.onlyHigh", {
+        high: quantityHigh,
+        unit: unit
+    });
+    // 3. Only low is present
+    // Warning, this case is kind dangerous and clinically unsafe so minimal effort on this ...
+    return i18next.t("fields.rateRange.onlyLow", {
+        low: quantityLow,
+        unit: unit
+    });
+}
+
+
+// types
+function $520e93a43a731e9b$export$b71cfd2510242de2({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.doseAndRate === undefined) return undefined;
+    // Find the first entry that match criteria
+    let rateRatio = dos.doseAndRate.find((s)=>s.rateRatio !== undefined);
+    // If not found, skip
+    if (rateRatio === undefined) return undefined;
+    // num / dem
+    let numerator = rateRatio.rateRatio.numerator;
+    let denominator = rateRatio.rateRatio.denominator;
+    let quantityNum = numerator?.value || 1;
+    let quantityDenom = denominator?.value || 1;
+    // units as text
+    let numeratorUnit = numerator !== undefined ? config.fromFHIRQuantityUnitToString({
+        language: config.language,
+        quantity: numerator
+    }) : "";
+    let denominatorUnit = denominator !== undefined ? config.fromFHIRQuantityUnitToString({
+        language: config.language,
+        quantity: denominator
+    }) : "";
+    return i18next.t("fields.rateRatio.rateRatio", {
+        count: quantityDenom,
+        quantityNumerator: quantityNum,
+        numeratorUnit: numeratorUnit,
+        denominatorUnit: denominatorUnit
+    });
+}
+
+
+function $9b80fa365533c8a7$export$675ae45fa2875f4a({ dos: dos, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.timing === undefined || dos.timing.repeat === undefined) return undefined;
+    // Pickup the repeat interesting attributes
+    let repeat = dos.timing.repeat;
+    let duration = repeat.duration;
+    let max = repeat.durationMax;
+    let unit = repeat.durationUnit;
+    // Do nothing if no unit, I am not a wizard
+    if (unit === undefined) return undefined;
+    else return [
+        // duration
+        duration !== undefined && i18next.t("fields.duration", {
+            durationText: i18next.t(`unitsOfTime:withCount.${unit}`, {
+                count: duration
+            })
+        }),
+        // durationMax
+        max !== undefined && i18next.t("fields.durationMax", {
+            durationMaxText: i18next.t(`unitsOfTime:withCount.${unit}`, {
+                count: max
+            })
+        })
+    ].filter((s)=>s !== false).join(" ");
+}
+
+
+function $7e1bdc5bf5cdf5bd$export$d663412e0c469ce2({ dos: dos, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.timing === undefined || dos.timing.repeat === undefined) return undefined;
+    // Pickup the repeat interesting attributes
+    let repeat = dos.timing.repeat;
+    let frequency = repeat.frequency;
+    let max = repeat.frequencyMax;
+    // Do nothing if no frequency / frequencyMax, I am not a wizard
+    if (frequency === undefined && max === undefined) return undefined;
+    else {
+        // Three cases
+        // 1. Frequency and frequencyMax are present
+        if (frequency !== undefined && max !== undefined) return i18next.t("fields.frequency.withfrequencyMax", {
+            count: max,
+            frequency: frequency
+        });
+        // 2. Only frequencyMax is present
+        if (max !== undefined) return i18next.t("fields.frequencyMax.frequencyMax", {
+            count: max
+        });
+        // 3. Only frequency is present
+        return i18next.t("fields.frequency.onlyFrequency", {
+            count: frequency
+        });
+    }
+}
+
+
+function $fcc6c325de921010$export$aa31b783699f637({ dos: dos, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.timing === undefined || dos.timing.repeat === undefined) return undefined;
+    // Pickup the repeat interesting attributes
+    let repeat = dos.timing.repeat;
+    let period = repeat.period;
+    let max = repeat.periodMax;
+    let unit = repeat.periodUnit;
+    // Do nothing if no unit, I am not a wizard
+    if (unit === undefined) return undefined;
+    else {
+        // Three cases
+        // 1. period and periodMax are present
+        if (period !== undefined && max !== undefined) return i18next.t("fields.periodMax.withPeriod", {
+            period: period,
+            count: max,
+            unit: i18next.t(`unitsOfTime:withoutCount.${unit}`, {
+                count: max
+            })
+        });
+        // 2. Only periodMax is present
+        if (max !== undefined) return i18next.t("fields.periodMax.onlyPeriodMax", {
+            count: max,
+            unit: i18next.t(`unitsOfTime:withoutCount.${unit}`, {
+                count: max
+            })
+        });
+        // 3. Only period present
+        return i18next.t("fields.period.period", {
+            count: period,
+            unit: i18next.t(`unitsOfTime:withoutCount.${unit}`, {
+                count: period
+            })
+        });
+    }
+}
+
+
+// Functions
+const $f475af73bad0ba43$var$linkworsdMap = {
+    and: "linkwords.and",
+    then: "linkwords.then"
+};
+function $f475af73bad0ba43$export$826742c1df3eca39(i18next, arr, linkWord = "and") {
+    // Split the array into two parts: all entries except the last one, and the last
+    const firstString = arr.slice(0, -1).join(", ");
+    const lastString = arr.slice(-1).join("");
+    // concatenate the result
+    const linkWordTechnicalKey = $f475af73bad0ba43$var$linkworsdMap[linkWord];
+    const linkWordAsString = arr.length > 1 ? ` ${i18next.t(linkWordTechnicalKey)} ` : "";
+    const finalString = firstString + linkWordAsString + lastString;
+    return finalString;
+}
+
+
+// Function to extract times
+function $f88800def2ddd9e9$var$extractTime(minutes) {
+    let days = Math.floor(minutes / 1440);
+    let hours = Math.floor(minutes % 1440 / 60);
+    let remainingMinutes = minutes % 60;
+    return {
+        days: days,
+        hours: hours,
+        minutes: remainingMinutes
+    };
+}
+// Function to transform offset into a string
+function $f88800def2ddd9e9$var$transformOffset(i18next, offset) {
+    if (offset === undefined || offset <= 0) return undefined;
+    // extract days / hours / minutes from it
+    let time = $f88800def2ddd9e9$var$extractTime(offset);
+    // generate part
+    let subParts = [
+        // days
+        time.days > 0 ? i18next.t("unitsOfTime:withCount.d", {
+            count: time.days
+        }) : undefined,
+        // hours
+        time.hours > 0 ? i18next.t("unitsOfTime:withCount.h", {
+            count: time.hours
+        }) : undefined,
+        // minutes
+        time.minutes > 0 ? i18next.t("unitsOfTime:withCount.min", {
+            count: time.minutes
+        }) : undefined
+    ].filter((s)=>s !== undefined);
+    return subParts.join(" ");
+}
+// Function to transform when[] into a string
+function $f88800def2ddd9e9$var$transformWhen(i18next, when) {
+    // Only run when array is not empty
+    if (when === undefined || when.length === 0) return undefined;
+    // Turn it into a string
+    const whens = when.map((whenCode)=>i18next.t(`eventTiming:${whenCode}`));
+    const finalString = (0, $f475af73bad0ba43$export$826742c1df3eca39)(i18next, whens);
+    return finalString;
+}
+function $f88800def2ddd9e9$export$433fa514f44031f3({ dos: dos, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.timing === undefined || dos.timing.repeat === undefined) return undefined;
+    // Pickup the repeat interesting attributes
+    let repeat = dos.timing.repeat;
+    let offset = repeat.offset;
+    let when = repeat.when;
+    // If both are undefined, don't do anything
+    if (offset === undefined && when === undefined) return undefined;
+    return [
+        // offset part
+        $f88800def2ddd9e9$var$transformOffset(i18next, offset),
+        // when part
+        $f88800def2ddd9e9$var$transformWhen(i18next, when)
+    ].filter((s)=>s !== undefined).join(" ");
+}
+
+
+// Function
+
+function $80e4a0390d11feb3$export$f6325e43097e9543({ dos: dos, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.timing === undefined || dos.timing.repeat === undefined) return undefined;
+    // Pickup the repeat interesting attributes
+    let repeat = dos.timing.repeat;
+    let dayOfWeek = repeat.dayOfWeek;
+    // If empty, skip it
+    if (dayOfWeek === undefined || dayOfWeek.length === 0) return undefined;
+    else {
+        // Turn it into a string
+        const dayOfWeeks = dayOfWeek.map((dayCode)=>i18next.t(`daysOfWeek:${dayCode}`));
+        const dayOfWeeksAsString = (0, $f475af73bad0ba43$export$826742c1df3eca39)(i18next, dayOfWeeks);
+        return i18next.t("fields.dayOfWeek.dayOfWeek", {
+            count: dayOfWeek.length,
+            dayOfWeek: dayOfWeeksAsString
+        });
+    }
+}
+
+
+// Functions
+
+/**
+ * time during the day, in the format hh:mm:ss (a subset of [ISO8601] icon).
+ * There is no date specified. Seconds must be provided due to schema type constraints but may be zero-filled
+ * and may be ignored at receiver discretion
+ */ function $a1b58a85293e76cc$var$formatString(time) {
+    // Split the time string by ":"
+    var parts = time.split(":");
+    // Check if the last part (seconds) is "00", if so, remove it
+    if (parts.length > 2 && parts[2] === "00") parts.pop();
+    // Join the remaining parts with ":"
+    return parts.join(":");
+}
+function $a1b58a85293e76cc$export$ee205fa48981886d({ dos: dos, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.timing === undefined || dos.timing.repeat === undefined) return undefined;
+    // Pickup the repeat interesting attributes
+    let repeat = dos.timing.repeat;
+    let timeOfDay = repeat.timeOfDay;
+    // If empty, skip it
+    if (timeOfDay === undefined || timeOfDay.length === 0) return undefined;
+    else {
+        // Turn it into a string
+        const timeOfDays = timeOfDay.map($a1b58a85293e76cc$var$formatString);
+        const timeOfDaysAsString = (0, $f475af73bad0ba43$export$826742c1df3eca39)(i18next, timeOfDays);
+        return i18next.t("fields.timeOfDay", {
+            timeOfDay: timeOfDaysAsString,
+            count: timeOfDays.length
+        });
+    }
+}
+
+
+// Function
+
+// Turn a list of codeable concept into a string
+function $ab507771e2827c53$var$fromCodeableConceptArrayToString(i18next, codes, config) {
+    const codesAsString = codes.map((code)=>config.fromCodeableConceptToString({
+            code: code,
+            language: config.language
+        })).filter((s)=>s !== undefined);
+    return (0, $f475af73bad0ba43$export$826742c1df3eca39)(i18next, codesAsString);
+}
+function $ab507771e2827c53$export$5c69a2202525487a({ dos: dos, config: config, i18next: i18next }) {
+    // Pickup the interesting attributes
+    let asNeededBoolean = dos.asNeededBoolean;
+    let asNeededCodeableConcept = dos.asNeededCodeableConcept;
+    let asNeededFor = dos.asNeededFor;
+    let asNeeded = dos.asNeeded;
+    // Codeable concept as list, to make algorithm simpler
+    let codeableList = asNeededFor || (asNeededCodeableConcept !== undefined ? [
+        asNeededCodeableConcept
+    ] : []);
+    if (codeableList.length > 0) return i18next.t("fields.asNeededFor", {
+        reasons: $ab507771e2827c53$var$fromCodeableConceptArrayToString(i18next, codeableList, config)
+    });
+    else {
+        // merge boolean to make it simpler
+        let booleanValue = asNeededBoolean || asNeeded || false;
+        if (booleanValue) return i18next.t("fields.asNeeded");
+        else return undefined;
+    }
+}
+
+
+// types
+// Duration to string
+function $ac69a26e361175ba$var$transformDurationToString(i18next, duration, config) {
+    let quantity = duration.value;
+    // If common units from HL7, do the job
+    if (duration.system === "http://hl7.org/fhir/ValueSet/duration-units") {
+        let code = duration.code;
+        return i18next.t(`unitsOfTime:withCount.${code}`, {
+            count: quantity
+        });
+    } else {
+        // otherwise, it is UCUM, ... so let the user do the job
+        let unit = config.fromFHIRQuantityUnitToString({
+            language: config.language,
+            quantity: duration
+        });
+        return `${quantity} ${unit}`;
+    }
+}
+function $ac69a26e361175ba$export$b927a06bc51aea32({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.timing === undefined || dos.timing.repeat === undefined) return undefined;
+    // Pickup the repeat interesting attributes
+    let repeat = dos.timing.repeat;
+    let boundsDuration = repeat.boundsDuration;
+    // Do nothing if no boundsDuration, I am not a wizard
+    if (boundsDuration === undefined) return undefined;
+    else {
+        let durationText = $ac69a26e361175ba$var$transformDurationToString(i18next, boundsDuration, config);
+        return i18next.t("fields.boundsDuration", {
+            durationText: durationText
+        });
+    }
+}
+
+
+// types
+// Quantity unit to string
+function $6b27b297c2af1001$var$transformQuantityUnitToString(i18next, quantity, config) {
+    let quantityValue = quantity.value;
+    // If common units from HL7, do the job
+    if (quantity.system === "http://hl7.org/fhir/ValueSet/duration-units") {
+        let code = quantity.code;
+        return i18next.t(`unitsOfTime:withoutCount.${code}`, {
+            count: quantityValue
+        });
+    } else // otherwise, it is UCUM, ... so let the user do the job
+    return config.fromFHIRQuantityUnitToString({
+        language: config.language,
+        quantity: quantity
+    });
+}
+function $6b27b297c2af1001$export$8c667cbf7bebaa93({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.timing === undefined || dos.timing.repeat === undefined) return undefined;
+    // Pickup the repeat interesting attributes
+    let repeat = dos.timing.repeat;
+    let boundsRange = repeat.boundsRange;
+    // Do nothing if no boundsRange, I am not a wizard
+    if (boundsRange === undefined) return undefined;
+    else {
+        let low = boundsRange.low;
+        let high = boundsRange.high;
+        // quantity unit
+        let unit = $6b27b297c2af1001$var$transformQuantityUnitToString(i18next, high || low, config);
+        // Three cases
+        // 1. Both low & high are present
+        if (high !== undefined && low !== undefined) return i18next.t("fields.boundsRange.lowAndHigh", {
+            low: low.value,
+            high: high.value,
+            unit: unit
+        });
+        // 2. Only high is present
+        if (high !== undefined) return i18next.t("fields.boundsRange.onlyHigh", {
+            high: high.value,
+            unit: unit
+        });
+        // 3. Only low is present
+        return i18next.t("fields.boundsRange.onlyLow", {
+            low: low.value,
+            unit: unit
+        });
+    }
+}
+
+
+function $73a945b97fd1a22f$export$498ca7f558a02e67({ dos: dos, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.timing === undefined || dos.timing.repeat === undefined) return undefined;
+    // Pickup the repeat interesting attributes
+    let repeat = dos.timing.repeat;
+    let count = repeat.count;
+    let countMax = repeat.countMax;
+    // Do nothing if no count, I am not a wizard
+    if (count === undefined && countMax === undefined) return undefined;
+    else {
+        // Three cases
+        // 1. Both count & countMax are present
+        if (count !== undefined && countMax !== undefined) return i18next.t("fields.countMax.countMax", {
+            count: countMax,
+            low: count
+        });
+        // 2. Only countMax is present
+        if (countMax !== undefined) return i18next.t("fields.count.count", {
+            count: countMax
+        });
+        // 3. Only count is present
+        return i18next.t("fields.count.count", {
+            count: count
+        });
+    }
+}
+
+
+// Functions
+
+// types
+// Function to clean up the params for dateStyle situation
+// Note: dateStyle and timeStyle can be used with each other,
+// but not with other date-time component options (e.g. weekday, hour, month, etc.).
+function $d3afe3c00981fd78$var$generateDateStyleFormatOptions(options) {
+    return {
+        year: options.dateStyle === undefined ? options.year || "numeric" : undefined,
+        month: options.dateStyle === undefined ? options.month || "2-digit" : undefined,
+        day: options.dateStyle === undefined ? options.day || "2-digit" : undefined,
+        weekday: options.dateStyle === undefined ? options.weekday : undefined
+    };
+}
+// Function to clean up the params for timeStyle situation
+function $d3afe3c00981fd78$var$generateTimeStyleFormatOptions(options) {
+    return {
+        hour: options.timeStyle === undefined ? options.hour || "2-digit" : undefined,
+        minute: options.timeStyle === undefined ? options.minute || "2-digit" : undefined,
+        second: options.timeStyle === undefined ? options.second || "2-digit" : undefined
+    };
+}
+function $d3afe3c00981fd78$export$a77f8869772ffca4({ config: config, datetimes: datetimes }) {
+    let options = config.dateTimeFormatOptions;
+    // prepare data for algorithm below
+    const entries = datetimes.map((datetime)=>{
+        // Convert it to date
+        let date = new Date(datetime);
+        // other properties
+        let hasTimePart = datetime.includes("T");
+        let hyphensCount = datetime.split("-").length - 1;
+        let hasMonths = hyphensCount >= 1;
+        let hasDays = hyphensCount >= 2;
+        return {
+            date: date,
+            hasTimePart: hasTimePart,
+            hasMonths: hasMonths,
+            hasDays: hasDays
+        };
+    });
+    // Time to do the magic
+    const result = entries.map(({ date: date, hasTimePart: hasTimePart, hasMonths: hasMonths, hasDays: hasDays })=>{
+        // If only year is defined, print it fully (e.g. 2024)
+        if (!hasMonths) {
+            let df1 = new Intl.DateTimeFormat(config.language, {
+                year: "numeric"
+            });
+            return df1.format(date);
+        }
+        // If only year and month are defined, print it nicely (e.g. 2024-03 => May 2024 )
+        if (!hasDays) {
+            let df2 = new Intl.DateTimeFormat(config.language, {
+                year: "numeric",
+                month: "long"
+            });
+            return df2.format(date);
+        }
+        // If only year / month and days are defined, print it according
+        if (!hasTimePart) {
+            let df3 = new Intl.DateTimeFormat(config.language, {
+                // retrieve value from user
+                dateStyle: options.dateStyle,
+                // fallback if dateStyle is not defined
+                ...$d3afe3c00981fd78$var$generateDateStyleFormatOptions(options)
+            });
+            return df3.format(date);
+        }
+        // Otherwise, we have a full datetime
+        let df4 = new Intl.DateTimeFormat(config.language, {
+            // retrieve value from user
+            dateStyle: options.dateStyle,
+            timeStyle: options.timeStyle,
+            // fallback if dateStyle / timeStyle is not defined
+            ...$d3afe3c00981fd78$var$generateDateStyleFormatOptions(options),
+            ...$d3afe3c00981fd78$var$generateTimeStyleFormatOptions(options)
+        });
+        return df4.format(date);
+    });
+    return result;
+}
+function $d3afe3c00981fd78$export$4699e913d5b6ffeb({ config: config, datetime: datetime }) {
+    // Can't do magic ;)
+    if (datetime === undefined) return undefined;
+    // Invoke previous function, and pick up the first entry
+    const result = $d3afe3c00981fd78$export$a77f8869772ffca4({
+        config: config,
+        datetimes: [
+            datetime
+        ]
+    });
+    return result[0];
+}
+
+
+function $5f0331fa51f3283d$export$3c2848bc0f0e3783({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.timing === undefined || dos.timing.event === undefined || dos.timing.event.length === 0) return undefined;
+    // Generate the string version of them
+    let events = dos.timing.event;
+    // List to string
+    let eventList = (0, $d3afe3c00981fd78$export$a77f8869772ffca4)({
+        config: config,
+        datetimes: events
+    });
+    let eventsAsString = (0, $f475af73bad0ba43$export$826742c1df3eca39)(i18next, eventList);
+    return i18next.t("fields.event.event", {
+        count: events.length,
+        event: eventsAsString
+    });
+}
+
+
+// Function
+
+function $f40067ed55113d89$export$21e3522d6e713036({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.additionalInstruction === undefined || dos.additionalInstruction.length === 0) return undefined;
+    // Turn it into strings
+    let additionalInstructions = dos.additionalInstruction.map((instruction)=>config.fromCodeableConceptToString({
+            code: instruction,
+            language: config.language
+        })).filter((s)=>s !== undefined);
+    return (0, $f475af73bad0ba43$export$826742c1df3eca39)(i18next, additionalInstructions);
+}
+
+
+// types
+function $08154e876fe3b2b0$export$6e78f21a88fc25ea({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.maxDosePerLifetime === undefined) return undefined;
+    const maxDosePerLifetime = dos.maxDosePerLifetime;
+    let unit = config.fromFHIRQuantityUnitToString({
+        language: config.language,
+        quantity: maxDosePerLifetime
+    });
+    return i18next.t("fields.maxDosePerLifetime", {
+        count: maxDosePerLifetime.value || 1,
+        unit: unit
+    });
+}
+
+
+// types
+function $e372e1d4df385570$export$58c8a9e040283a66({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.maxDosePerAdministration === undefined) return undefined;
+    const maxDosePerAdministration = dos.maxDosePerAdministration;
+    let unit = config.fromFHIRQuantityUnitToString({
+        language: config.language,
+        quantity: maxDosePerAdministration
+    });
+    return i18next.t("fields.maxDosePerAdministration", {
+        count: maxDosePerAdministration.value || 1,
+        unit: unit
+    });
+}
+
+
+// Functions
+
+function $f28938e27e1e9773$export$75a89431d80a701a({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.timing === undefined || dos.timing.repeat === undefined || dos.timing.repeat.boundsPeriod === undefined) return undefined;
+    // Generate the string version of them
+    const boundsPeriod = dos.timing.repeat.boundsPeriod;
+    let start = (0, $d3afe3c00981fd78$export$4699e913d5b6ffeb)({
+        config: config,
+        datetime: boundsPeriod.start
+    });
+    let end = (0, $d3afe3c00981fd78$export$4699e913d5b6ffeb)({
+        config: config,
+        datetime: boundsPeriod.end
+    });
+    // Three cases
+    // 1. Both start and end are present
+    if (start !== undefined && end !== undefined) return i18next.t("fields.boundsPeriod.startAndEnd", {
+        start: start,
+        end: end
+    });
+    // 2. Only start is present
+    if (start !== undefined) return i18next.t("fields.boundsPeriod.onlyStart", {
+        start: start
+    });
+    // 3. Only end is present
+    return i18next.t("fields.boundsPeriod.onlyEnd", {
+        end: end
+    });
+}
+
+
+
+function $252769c9f296cd6d$export$346b11a8cb220f02({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.maxDosePerPeriod === undefined) return undefined;
+    const maxDosePerPeriod = dos.maxDosePerPeriod;
+    // In R4, it was a single object
+    // In R5, it is an array
+    // So better to have a generic approach
+    const values = Array.isArray(maxDosePerPeriod) ? maxDosePerPeriod : [
+        maxDosePerPeriod
+    ];
+    // Only consider not empty array
+    if (values.length === 0) return undefined;
+    // Periods are expressed as ratio (like rateRatio)
+    const valuesAsString = values.map((period)=>{
+        // num / dem
+        let numerator = period.numerator;
+        let denominator = period.denominator;
+        let quantityNum = numerator?.value || 1;
+        let quantityDenom = denominator?.value || 1;
+        // units as text
+        let numeratorUnit = numerator !== undefined ? config.fromFHIRQuantityUnitToString({
+            language: config.language,
+            quantity: numerator
+        }) : "";
+        let denominatorUnit = denominator !== undefined ? config.fromFHIRQuantityUnitToString({
+            language: config.language,
+            quantity: denominator
+        }) : "";
+        return i18next.t("fields.maxDosePerPeriod.maxDosePerPeriod", {
+            count: quantityDenom,
+            quantityNumerator: quantityNum,
+            numeratorUnit: numeratorUnit,
+            denominatorUnit: denominatorUnit
+        });
+    });
+    const maxDosePerPeriodText = (0, $f475af73bad0ba43$export$826742c1df3eca39)(i18next, valuesAsString);
+    return i18next.t("fields.maxDosePerPeriod.general", {
+        count: values.length,
+        maxDosePerPeriodText: maxDosePerPeriodText
+    });
+}
+
+
+
+
+// Map
+const $9b1af2fba509609e$var$displayOrders = {
+    additionalInstruction: (input)=>(0, $f40067ed55113d89$export$21e3522d6e713036)(input),
+    asNeeded: (input)=>(0, $ab507771e2827c53$export$5c69a2202525487a)(input),
+    boundsDuration: (input)=>(0, $ac69a26e361175ba$export$b927a06bc51aea32)(input),
+    boundsRange: (input)=>(0, $6b27b297c2af1001$export$8c667cbf7bebaa93)(input),
+    boundsPeriod: (input)=>(0, $f28938e27e1e9773$export$75a89431d80a701a)(input),
+    code: ({ dos: dos, config: config })=>config.fromCodeableConceptToString({
+            language: config.language,
+            code: dos.timing?.code
+        }),
+    countCountMax: (input)=>(0, $73a945b97fd1a22f$export$498ca7f558a02e67)(input),
+    dayOfWeek: (input)=>(0, $80e4a0390d11feb3$export$f6325e43097e9543)(input),
+    doseQuantity: (input)=>(0, $7cf24331c38efaf1$export$7de3722258b87db9)(input),
+    doseRange: (input)=>(0, $465e6e43e1df9717$export$4cd16590995531a9)(input),
+    durationDurationMax: (input)=>(0, $9b80fa365533c8a7$export$675ae45fa2875f4a)(input),
+    event: (input)=>(0, $5f0331fa51f3283d$export$3c2848bc0f0e3783)(input),
+    extension: ({ dos: dos, config: config })=>config.fromExtensionsToString({
+            language: config.language,
+            extensions: dos.extension
+        }),
+    frequencyFrequencyMax: (input)=>(0, $7e1bdc5bf5cdf5bd$export$d663412e0c469ce2)(input),
+    frequencyFrequencyMaxPeriodPeriodMax: (input)=>{
+        let subParts = [
+            (0, $7e1bdc5bf5cdf5bd$export$d663412e0c469ce2)(input),
+            (0, $fcc6c325de921010$export$aa31b783699f637)(input)
+        ].filter((s)=>s !== undefined);
+        return subParts.length > 0 ? subParts.join(" ") : undefined;
+    },
+    maxDosePerAdministration: (input)=>(0, $e372e1d4df385570$export$58c8a9e040283a66)(input),
+    maxDosePerLifetime: (input)=>(0, $08154e876fe3b2b0$export$6e78f21a88fc25ea)(input),
+    maxDosePerPeriod: (input)=>(0, $252769c9f296cd6d$export$346b11a8cb220f02)(input),
+    method: ({ dos: dos, config: config })=>config.fromCodeableConceptToString({
+            language: config.language,
+            code: dos.method
+        }),
+    offsetWhen: (input)=>(0, $f88800def2ddd9e9$export$433fa514f44031f3)(input),
+    patientInstruction: ({ dos: dos })=>dos.patientInstruction,
+    periodPeriodMax: (input)=>(0, $fcc6c325de921010$export$aa31b783699f637)(input),
+    rateQuantity: (input)=>(0, $bbbd1877a73b7a2b$export$4e24ef8c7997cc56)(input),
+    rateRange: (input)=>(0, $09db039855b6d015$export$d3dd7d3522271dba)(input),
+    rateRatio: (input)=>(0, $520e93a43a731e9b$export$b71cfd2510242de2)(input),
+    route: ({ dos: dos, config: config })=>config.fromCodeableConceptToString({
+            language: config.language,
+            code: dos.route
+        }),
+    site: ({ dos: dos, config: config })=>config.fromCodeableConceptToString({
+            language: config.language,
+            code: dos.site
+        }),
+    text: ({ dos: dos })=>dos.text,
+    timeOfDay: (input)=>(0, $a1b58a85293e76cc$export$ee205fa48981886d)(input)
+};
+function $9b1af2fba509609e$export$9f330b4bf8c0975c({ entry: entry, ...args }) {
+    // Use map to provide a result without iterate on each key
+    return $9b1af2fba509609e$var$displayOrders[entry](args);
+}
+
+
+
+// backends i18next
+const $8435b8d847fb3eb7$var$localeImport = async (lng, ns)=>import(`./locales/${lng}/${ns}.json`);
+class $8435b8d847fb3eb7$export$1c191bca55f84a03 {
+    // Set up lib, according provided parameters
+    constructor(args){
+        this.config = {
+            // default attributes
+            language: "en",
+            fromFHIRQuantityUnitToString: (0, $a620268c8b5a46fd$export$b1a6aed91fad1636),
+            fromCodeableConceptToString: (0, $f2878500cc217687$export$f478f96b98da13a4),
+            fromExtensionsToString: (0, $a31aaee21175037d$export$30c337e25ab8e95b),
+            displayOrder: [
+                "method",
+                "doseQuantity",
+                "doseRange",
+                "rateRatio",
+                "rateQuantity",
+                "rateRange",
+                "durationDurationMax",
+                "frequencyFrequencyMaxPeriodPeriodMax",
+                "offsetWhen",
+                "dayOfWeek",
+                "timeOfDay",
+                "route",
+                "site",
+                "asNeeded",
+                "boundsDuration",
+                "boundsPeriod",
+                "boundsRange",
+                "countCountMax",
+                "event",
+                "code",
+                "maxDosePerPeriod",
+                "maxDosePerAdministration",
+                "maxDosePerLifetime",
+                "additionalInstruction",
+                "patientInstruction"
+            ],
+            displaySeparator: " - ",
+            dateTimeFormatOptions: {},
+            // attributes set by user
+            ...args
+        };
+        this.i18nInstance = (0, $hgUW1$i18next).createInstance();
+    }
+    /**
+   * To init i18next properly according requested criteria
+   */ async init() {
+        // You should wait for init to complete (wait for the callback or promise resolution)
+        // before using the t function!
+        return await this.i18nInstance.use((0, $hgUW1$i18nextchainedbackend)).init({
+            //debug: true,
+            fallbackLng: "en",
+            lng: this.config.language,
+            ns: [
+                "common",
+                "daysOfWeek",
+                "eventTiming",
+                "unitsOfTime"
+            ],
+            defaultNS: "common",
+            backend: {
+                backends: [
+                    (0, $hgUW1$i18nextresourcestobackend)(// have to cast the function to be webpack / builder friendly
+                    $8435b8d847fb3eb7$var$localeImport)
+                ]
+            }
+        });
+    }
+    /**
+   * Factory to create a fine-tuned instance of the utility class
+   */ static async build(args) {
+        const instance = new $8435b8d847fb3eb7$export$1c191bca55f84a03(args);
+        await instance.init();
+        return instance;
+    }
+    /**
+   * To change language
+   */ async changeLanguage(lng) {
+        this.config = {
+            ...this.config,
+            language: lng
+        };
+        return this.i18nInstance.changeLanguage(lng);
+    }
+    /**
+   * To change display order
+   */ changeDisplayOrder(order) {
+        this.config = {
+            ...this.config,
+            displayOrder: order
+        };
+    }
+    /**
+   * Turn a FHIR Dosage object into text
+   */ fromDosageToText(dos) {
+        // iterate on each key and generate a string from each part
+        let order = this.config.displayOrder;
+        let parts = order.map((entry)=>(0, $9b1af2fba509609e$export$9f330b4bf8c0975c)({
+                config: this.config,
+                dos: dos,
+                entry: entry,
+                i18next: this.i18nInstance
+            })).filter((s)=>s !== undefined);
+        // Join each part with a separator
+        return parts.join(this.config.displaySeparator);
+    }
+    /**
+   * Turn multiple FHIR Dosage object into text
+   */ fromMultipleDosageToText(dosages) {
+        // As we can have concurrent / sequential instructions, we need a generic algorithm to do the job
+        // 1. Collect all sequences number
+        let sequencesNumbers = dosages.map((d)=>d.sequence).filter((s)=>s !== undefined);
+        // 2. Convert it to a Set
+        let encounteredSequenceNumbers = new Set(sequencesNumbers);
+        // 3. We have a "sequential" situation in two cases
+        // A) No sequence number were provided
+        // B) All sequence numbers are different
+        if (encounteredSequenceNumbers.size === 0 || encounteredSequenceNumbers.size === dosages.length) {
+            const dosagesAsText = dosages.map((d)=>this.fromDosageToText(d));
+            return (0, $f475af73bad0ba43$export$826742c1df3eca39)(this.i18nInstance, dosagesAsText, "then");
+        }
+        // 4. We have both "sequential" and "concurrent" instructions - time to see what is the configuration
+        let groups = {};
+        let sequences = new Set();
+        for(let idx = 0; idx < dosages.length; idx++){
+            // Get dosage object
+            const dosage = dosages[idx];
+            // Get the sequence number (normally, in real world, it should be present in this case)
+            // If no sequence number, assume it is idx + 1
+            let sequenceNr = dosage.sequence || idx + 1;
+            // Generate the text version
+            let dosageAsText = this.fromDosageToText(dosage);
+            // Retrieve of create previous entries for this sequence number
+            let localGroup = groups[sequenceNr] || [];
+            // Add entry
+            localGroup.push(dosageAsText);
+            // Pushback result
+            groups[sequenceNr] = localGroup;
+            // For reminder of the parsed sequence
+            sequences.add(sequenceNr);
+        }
+        // 5. Now that data structures are filled, it is a piece of cake to generate the result
+        let sequentialInstructions = [
+            ...sequences.values()
+        ].map((sequence)=>{
+            let concurrentInstructions = groups[sequence];
+            return (0, $f475af73bad0ba43$export$826742c1df3eca39)(this.i18nInstance, concurrentInstructions, "and");
+        });
+        return (0, $f475af73bad0ba43$export$826742c1df3eca39)(this.i18nInstance, sequentialInstructions, "then");
+    }
+}
+
+
+var // Default export to make it user-friendly
+$149c1bd638913645$export$2e2bcd8739ae039 = (0, $8435b8d847fb3eb7$export$1c191bca55f84a03);
+
+
+export {$149c1bd638913645$export$2e2bcd8739ae039 as default};
+//# sourceMappingURL=module.js.map