@imranq2/fhirpatientsummary 1.0.4 → 1.0.6

package/dist/index.js

@@ -0,0 +1,2451 @@
+// src/structures/ips_sections.ts
+var IPSSections = /* @__PURE__ */ ((IPSSections2) => {
+  IPSSections2["PATIENT"] = "Patient";
+  IPSSections2["ALLERGIES"] = "AllergyIntoleranceSection";
+  IPSSections2["MEDICATIONS"] = "MedicationSection";
+  IPSSections2["PROBLEMS"] = "ProblemSection";
+  IPSSections2["IMMUNIZATIONS"] = "ImmunizationSection";
+  IPSSections2["VITAL_SIGNS"] = "VitalSignsSection";
+  IPSSections2["MEDICAL_DEVICES"] = "MedicalDeviceSection";
+  IPSSections2["DIAGNOSTIC_REPORTS"] = "DiagnosticReportSection";
+  IPSSections2["PROCEDURES"] = "ProcedureSection";
+  IPSSections2["FAMILY_HISTORY"] = "FamilyHistorySection";
+  IPSSections2["SOCIAL_HISTORY"] = "SocialHistorySection";
+  IPSSections2["PREGNANCY_HISTORY"] = "PregnancyHistorySection";
+  IPSSections2["FUNCTIONAL_STATUS"] = "FunctionalStatusSection";
+  IPSSections2["MEDICAL_HISTORY"] = "MedicalHistorySection";
+  IPSSections2["CARE_PLAN"] = "CarePlanSection";
+  IPSSections2["CLINICAL_IMPRESSION"] = "ClinicalImpressionSection";
+  IPSSections2["ADVANCE_DIRECTIVES"] = "AdvanceDirectivesSection";
+  return IPSSections2;
+})(IPSSections || {});
+
+// src/structures/ips_section_loinc_codes.ts
+var IPS_SECTION_LOINC_CODES = {
+  ["Patient" /* PATIENT */]: "54126-4",
+  ["AllergyIntoleranceSection" /* ALLERGIES */]: "48765-2",
+  ["MedicationSection" /* MEDICATIONS */]: "10160-0",
+  ["ProblemSection" /* PROBLEMS */]: "11450-4",
+  ["ImmunizationSection" /* IMMUNIZATIONS */]: "11369-6",
+  ["VitalSignsSection" /* VITAL_SIGNS */]: "8716-3",
+  ["MedicalDeviceSection" /* MEDICAL_DEVICES */]: "46264-8",
+  ["DiagnosticReportSection" /* DIAGNOSTIC_REPORTS */]: "30954-2",
+  ["ProcedureSection" /* PROCEDURES */]: "47519-4",
+  ["FamilyHistorySection" /* FAMILY_HISTORY */]: "10157-6",
+  ["SocialHistorySection" /* SOCIAL_HISTORY */]: "29762-2",
+  ["PregnancyHistorySection" /* PREGNANCY_HISTORY */]: "10162-6",
+  ["FunctionalStatusSection" /* FUNCTIONAL_STATUS */]: "47420-5",
+  ["MedicalHistorySection" /* MEDICAL_HISTORY */]: "11348-0",
+  ["CarePlanSection" /* CARE_PLAN */]: "18776-5",
+  ["ClinicalImpressionSection" /* CLINICAL_IMPRESSION */]: "51848-0",
+  ["AdvanceDirectivesSection" /* ADVANCE_DIRECTIVES */]: "42348-3"
+};
+var IPS_SECTION_DISPLAY_NAMES = {
+  ["Patient" /* PATIENT */]: "Patient summary Document",
+  ["AllergyIntoleranceSection" /* ALLERGIES */]: "Allergies and adverse reactions Document",
+  ["MedicationSection" /* MEDICATIONS */]: "History of Medication use Narrative",
+  ["ProblemSection" /* PROBLEMS */]: "Problem list - Reported",
+  ["ImmunizationSection" /* IMMUNIZATIONS */]: "History of Immunization Narrative",
+  ["VitalSignsSection" /* VITAL_SIGNS */]: "Vital signs",
+  ["MedicalDeviceSection" /* MEDICAL_DEVICES */]: "History of medical device use",
+  ["DiagnosticReportSection" /* DIAGNOSTIC_REPORTS */]: "Relevant diagnostic tests/laboratory data Narrative",
+  ["ProcedureSection" /* PROCEDURES */]: "History of Procedures Document",
+  ["FamilyHistorySection" /* FAMILY_HISTORY */]: "History of family member diseases Narrative",
+  ["SocialHistorySection" /* SOCIAL_HISTORY */]: "Social history Narrative",
+  ["PregnancyHistorySection" /* PREGNANCY_HISTORY */]: "History of pregnancies Narrative",
+  ["FunctionalStatusSection" /* FUNCTIONAL_STATUS */]: "Functional status assessment note",
+  ["MedicalHistorySection" /* MEDICAL_HISTORY */]: "History of Past illness NarrativeHistory and physical note Document",
+  ["CarePlanSection" /* CARE_PLAN */]: "Plan of care note",
+  ["ClinicalImpressionSection" /* CLINICAL_IMPRESSION */]: "Evaluation note",
+  ["AdvanceDirectivesSection" /* ADVANCE_DIRECTIVES */]: "Advance directives Document"
+};
+
+// src/structures/ips_section_resource_map.ts
+var IPSSectionResourceMap = {
+  ["Patient" /* PATIENT */]: ["Patient"],
+  ["AllergyIntoleranceSection" /* ALLERGIES */]: ["AllergyIntolerance"],
+  ["MedicationSection" /* MEDICATIONS */]: ["MedicationRequest", "MedicationStatement"],
+  ["ProblemSection" /* PROBLEMS */]: ["Condition"],
+  ["ImmunizationSection" /* IMMUNIZATIONS */]: ["Immunization"],
+  ["VitalSignsSection" /* VITAL_SIGNS */]: ["Observation"],
+  ["MedicalDeviceSection" /* MEDICAL_DEVICES */]: ["Device"],
+  ["DiagnosticReportSection" /* DIAGNOSTIC_REPORTS */]: ["DiagnosticReport", "Observation"],
+  // Diagnostic reports can include Observations
+  ["ProcedureSection" /* PROCEDURES */]: ["Procedure"],
+  ["FamilyHistorySection" /* FAMILY_HISTORY */]: ["FamilyMemberHistory"],
+  ["SocialHistorySection" /* SOCIAL_HISTORY */]: ["Observation"],
+  // Social history is often Observation
+  ["PregnancyHistorySection" /* PREGNANCY_HISTORY */]: ["Observation"],
+  // Pregnancy history is often Observation
+  ["FunctionalStatusSection" /* FUNCTIONAL_STATUS */]: ["Observation"],
+  // Functional status is often Observation
+  ["MedicalHistorySection" /* MEDICAL_HISTORY */]: ["Condition"],
+  // Medical history is often Condition
+  ["CarePlanSection" /* CARE_PLAN */]: ["CarePlan"],
+  ["ClinicalImpressionSection" /* CLINICAL_IMPRESSION */]: ["ClinicalImpression"],
+  ["AdvanceDirectivesSection" /* ADVANCE_DIRECTIVES */]: ["DocumentReference"]
+  // Advance directives are often stored as DocumentReference
+};
+var IPSSectionResourceFilters = {
+  // Only include active allergies
+  ["AllergyIntoleranceSection" /* ALLERGIES */]: (resource) => resource.resourceType === "AllergyIntolerance" && resource.clinicalStatus?.coding?.some((c) => c.code === "active"),
+  // Only include active medication requests/statements
+  ["MedicationSection" /* MEDICATIONS */]: (resource) => resource.resourceType === "MedicationRequest" && resource.status === "active" || resource.resourceType === "MedicationStatement" && resource.status === "active",
+  // Only include active problems/conditions
+  ["ProblemSection" /* PROBLEMS */]: (resource) => resource.resourceType === "Condition" && resource.clinicalStatus?.coding?.some((c) => c.code === "active"),
+  // Only include completed immunizations
+  ["ImmunizationSection" /* IMMUNIZATIONS */]: (resource) => resource.resourceType === "Immunization" && resource.status === "completed",
+  // Only include vital sign Observations (category.coding contains 'vital-signs')
+  ["VitalSignsSection" /* VITAL_SIGNS */]: (resource) => resource.resourceType === "Observation" && resource.category?.some((cat) => cat.coding?.some((c) => c.code === "vital-signs")),
+  // Only include active devices
+  ["MedicalDeviceSection" /* MEDICAL_DEVICES */]: (resource) => resource.resourceType === "Device" && resource.status === "active",
+  // Only include finalized diagnostic reports
+  ["DiagnosticReportSection" /* DIAGNOSTIC_REPORTS */]: (resource) => ["DiagnosticReport", "Observation"].includes(resource.resourceType) && resource.status === "final",
+  // Only include completed procedures
+  ["ProcedureSection" /* PROCEDURES */]: (resource) => resource.resourceType === "Procedure" && resource.status === "completed",
+  // Only include family history resources
+  ["FamilyHistorySection" /* FAMILY_HISTORY */]: (resource) => resource.resourceType === "FamilyMemberHistory",
+  // Only include social history Observations (category.coding contains 'social-history')
+  ["SocialHistorySection" /* SOCIAL_HISTORY */]: (resource) => resource.resourceType === "Observation" && resource.category?.some((cat) => cat.coding?.some((c) => c.code === "social-history")),
+  // Only include pregnancy history Observations (category.coding contains 'pregnancy')
+  ["PregnancyHistorySection" /* PREGNANCY_HISTORY */]: (resource) => resource.resourceType === "Observation" && resource.category?.some((cat) => cat.coding?.some((c) => c.code === "pregnancy")),
+  // Only include functional status Observations (category.coding contains 'functional-status')
+  ["FunctionalStatusSection" /* FUNCTIONAL_STATUS */]: (resource) => resource.resourceType === "Observation" && resource.category?.some((cat) => cat.coding?.some((c) => c.code === "functional-status")),
+  // Only include active medical history Conditions
+  ["MedicalHistorySection" /* MEDICAL_HISTORY */]: (resource) => resource.resourceType === "Condition" && resource.clinicalStatus?.coding?.some((c) => c.code === "active"),
+  // Only include active care plans
+  ["CarePlanSection" /* CARE_PLAN */]: (resource) => resource.resourceType === "CarePlan" && resource.status === "active",
+  // Only include ClinicalImpression resources
+  ["ClinicalImpressionSection" /* CLINICAL_IMPRESSION */]: (resource) => resource.resourceType === "ClinicalImpression",
+  // Patient section: only Patient resource
+  ["Patient" /* PATIENT */]: (resource) => resource.resourceType === "Patient"
+};
+var IPSSectionResourceHelper = class {
+  static getResourceTypesForSection(section) {
+    return IPSSectionResourceMap[section] || [];
+  }
+  static getResourceFilterForSection(section) {
+    return IPSSectionResourceFilters[section];
+  }
+};
+
+// src/narratives/templates/typescript/TemplateUtilities.ts
+import { DateTime } from "luxon";
+var TemplateUtilities = class {
+  /**
+   * Constructor to initialize the TemplateUtilities with a FHIR Bundle
+   * @param bundle - FHIR Bundle containing resources
+   */
+  constructor(bundle) {
+    this.bundle = bundle;
+  }
+  /**
+   * Formats a CodeableConcept object
+   * @param cc - The CodeableConcept object
+   * @param field - Optional specific field to return
+   * @returns Formatted string representation
+   */
+  codeableConcept(cc, field) {
+    if (!cc) {
+      return "";
+    }
+    if (field) {
+      if (cc[field]) {
+        return cc[field];
+      } else if (cc.coding && cc.coding[0] && cc.coding[0][field]) {
+        return cc.coding[0][field];
+      }
+    }
+    if (cc.text) {
+      return cc.text;
+    } else if ("display" in cc && cc.display) {
+      return cc.display;
+    } else if (cc.coding && cc.coding[0]) {
+      if (cc.coding[0].display) {
+        return cc.coding[0].display;
+      } else if (cc.coding[0].code) {
+        return cc.coding[0].code;
+      }
+    }
+    return "";
+  }
+  resolveReference(ref) {
+    if (!ref || !this.bundle || !this.bundle.entry) {
+      return null;
+    }
+    const referenceParts = ref.reference?.split("/");
+    if (!referenceParts || referenceParts.length !== 2) {
+      return null;
+    }
+    const referenceResourceType = referenceParts[0];
+    const referenceResourceId = referenceParts[1];
+    const resource = this.bundle.entry.find((entry) => {
+      return entry.resource && entry.resource.resourceType === referenceResourceType && entry.resource.id === referenceResourceId;
+    });
+    return resource ? resource.resource : null;
+  }
+  /**
+   * Renders a Device reference
+   * @param deviceRef - Reference to a Device resource
+   * @returns Formatted device description
+   */
+  renderDevice(deviceRef) {
+    const device = deviceRef && this.resolveReference(deviceRef);
+    if (device && device.resourceType === "Device" && device.type) {
+      return this.codeableConcept(device.type, "display");
+    }
+    return "";
+  }
+  /**
+   * Renders an Organization reference
+   * @param orgRef - Reference to an Organization resource
+   * @returns Organization name
+   */
+  renderOrganization(orgRef) {
+    const organization = orgRef && this.resolveReference(orgRef);
+    if (organization && organization.resourceType === "Organization" && organization.name) {
+      return organization.name;
+    }
+    return "";
+  }
+  /**
+   * Renders a vaccine manufacturer
+   * @param immunization - Immunization resource
+   * @returns Manufacturer name
+   */
+  renderVaccineManufacturer(immunization) {
+    const organization = immunization.manufacturer && this.resolveReference(immunization.manufacturer);
+    if (organization && organization.resourceType === "Organization" && organization.name) {
+      return organization.name;
+    }
+    return "";
+  }
+  /**
+   * Renders a medication
+   * @param medicationType - Resource containing medication information
+   * @returns Formatted medication description
+   */
+  renderMedicationStatement(medicationType) {
+    if (typeof medicationType !== "object" || medicationType === null) {
+      return "";
+    }
+    if (medicationType.medicationCodeableConcept) {
+      return this.codeableConcept(medicationType.medicationCodeableConcept);
+    } else if (medicationType.medicationReference) {
+      return this.renderMedicationRef(medicationType.medicationReference);
+    }
+    return "";
+  }
+  /**
+   * Renders a medication reference
+   * @param medicationRef - Reference to a Medication resource
+   * @returns Formatted medication description
+   */
+  renderMedicationRef(medicationRef) {
+    const medication = medicationRef && this.resolveReference(medicationRef);
+    if (medication) {
+      return this.renderMedicationCode(medication);
+    }
+    return "";
+  }
+  /**
+   * Renders a medication code
+   * @param medication - Medication resource
+   * @returns Formatted medication code
+   */
+  renderMedicationCode(medication) {
+    if (medication && medication.code) {
+      return this.codeableConcept(medication.code, "display");
+    }
+    return "";
+  }
+  /**
+   * Renders a dose number
+   * @param doseNumber - Dose number object
+   * @returns Formatted dose number
+   */
+  renderDoseNumber(doseNumber) {
+    if (doseNumber && doseNumber.value !== void 0) {
+      return doseNumber.value.toString();
+    }
+    return "";
+  }
+  /**
+   * Renders the unit of a value
+   * @param value - Value object
+   * @returns Unit string
+   */
+  renderValueUnit(value) {
+    if (value && value.constructor?.name === "Quantity" && value.unit) {
+      return value.unit;
+    }
+    return "";
+  }
+  /**
+   * Renders an effective date
+   * @param effective - Date value
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns Formatted date string
+   */
+  renderEffective(effective, timezone) {
+    return this.formatDateTime(effective, timezone);
+  }
+  /**
+   * Renders a time value
+   * @param time - Time value
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns Formatted time string
+   */
+  renderTime(time, timezone) {
+    return this.formatDateTime(time, timezone);
+  }
+  /**
+   * Renders a date value
+   * @param date - Date value
+   * @returns Formatted date string (date only, no time component)
+   */
+  renderDate(date) {
+    return this.formatDateTime(date, void 0, true);
+  }
+  /**
+   * Renders a recorded date
+   * @param recorded - Date value
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns Formatted date string
+   */
+  renderRecorded(recorded, timezone) {
+    return this.formatDateTime(recorded, timezone);
+  }
+  /**
+   * Concatenates a list of items, optionally extracting a specific attribute
+   * @param list - Array of items
+   * @param attr - Optional attribute to extract from each item
+   * @returns Comma-separated string of items
+   */
+  concat(list, attr) {
+    if (!list || !Array.isArray(list)) {
+      return "";
+    }
+    const items = [];
+    for (const item of list) {
+      if (attr && item && typeof item === "object" && attr in item) {
+        items.push(item[attr]);
+      } else if (!attr && item !== void 0) {
+        items.push(item);
+      }
+    }
+    return items.filter((item) => typeof item === "string" || typeof item === "number").join(", ");
+  }
+  /**
+   * Safely concatenates a list of items, handling undefined/null lists
+   * @param list - Array of items (or undefined/null)
+   * @param attr - Optional attribute to extract from each item
+   * @returns Comma-separated string of items
+   */
+  safeConcat(list, attr) {
+    return this.concat(list || [], attr);
+  }
+  /**
+   * Concatenates text from a list of CodeableConcept objects
+   * @param list - Array of CodeableConcept objects
+   * @returns Comma-separated string of text values
+   */
+  concatCodeableConcept(list) {
+    if (!list || !Array.isArray(list)) {
+      return "";
+    }
+    const items = [];
+    for (const item of list) {
+      if (item && item.text) {
+        items.push(item.text);
+      }
+    }
+    return items.join(", ");
+  }
+  /**
+   * Concatenates reaction manifestations
+   * @param list - Array of reaction objects
+   * @returns Comma-separated string of manifestation texts
+   */
+  concatReactionManifestation(list) {
+    if (!list || !Array.isArray(list)) {
+      return "";
+    }
+    const texts = [];
+    for (const item of list) {
+      if (item && item.manifestation && item.manifestation[0] && item.manifestation[0].text) {
+        texts.push(item.manifestation[0].text);
+      }
+    }
+    return texts.join(", ");
+  }
+  /**
+   * Concatenates dose numbers
+   * @param list - Array of dose objects
+   * @returns Comma-separated string of dose numbers
+   */
+  concatDoseNumber(list) {
+    if (!list || !Array.isArray(list)) {
+      return "";
+    }
+    const doseNumbers = [];
+    for (const item of list) {
+      if (item && item.doseNumberPositiveInt) {
+        doseNumbers.push(item.doseNumberPositiveInt.toString());
+      }
+    }
+    return doseNumbers.join(", ");
+  }
+  /**
+   * Concatenates dosage routes
+   * @param list - Array of dosage objects
+   * @returns Comma-separated string of route texts
+   */
+  concatDosageRoute(list) {
+    if (!list || !Array.isArray(list)) {
+      return "";
+    }
+    const routes = [];
+    for (const item of list) {
+      if (item && item.route && item.route.text) {
+        routes.push(item.route.text);
+      }
+    }
+    return routes.join(", ");
+  }
+  /**
+   * Returns the first item from a list of CodeableConcept objects
+   * @param list - Array of CodeableConcept objects
+   * @returns Display text from the first item
+   */
+  firstFromCodeableConceptList(list) {
+    if (list && Array.isArray(list) && list[0]) {
+      return this.codeableConcept(list[0], "display");
+    }
+    return "";
+  }
+  /**
+   * Concatenates reference range texts
+   * @param list - Array of reference range objects
+   * @returns Comma-separated string of texts
+   */
+  concatReferenceRange(list) {
+    if (!list || !Array.isArray(list)) {
+      return "";
+    }
+    const texts = [];
+    for (const item of list) {
+      if (item && item.text) {
+        texts.push(item.text);
+      }
+    }
+    return texts.join(", ");
+  }
+  /**
+   * Renders component codes
+   * @param list - Array of component objects
+   * @returns Comma-separated string of code texts
+   */
+  renderComponent(list) {
+    if (!list || !Array.isArray(list)) {
+      return "";
+    }
+    const texts = [];
+    for (const item of list) {
+      if (item && item.code && item.code.text) {
+        texts.push(item.code.text);
+      }
+    }
+    return texts.join(", ");
+  }
+  narrativeLinkExtension(source) {
+    if (!source) {
+      return void 0;
+    }
+    if (source.extension && Array.isArray(source.extension)) {
+      const extension = source.extension.find(
+        (ext) => ext.url === "http://hl7.org/fhir/StructureDefinition/narrativeLink"
+      );
+      if (extension) {
+        return extension;
+      }
+      return void 0;
+    }
+    return source;
+  }
+  /**
+   * Extracts narrative link ID from extension or resource
+   * @param source - Extension object or resource with extensions array
+   * @returns Extracted ID or empty string
+   */
+  narrativeLinkId(source) {
+    const extension = this.narrativeLinkExtension(source);
+    if (!extension) {
+      return "";
+    }
+    return this.extractIdFromExtension(extension);
+  }
+  /**
+   * Helper method to extract ID from an extension object
+   * @param extension - Extension object
+   * @returns Extracted ID or empty string
+   */
+  extractIdFromExtension(extension) {
+    if (typeof extension === "object" && extension.value && extension.value.value && typeof extension.value.value === "string" && extension.value.value.includes("#")) {
+      return extension.value.value.split("#")[1];
+    }
+    return "";
+  }
+  extractObservationValue(observation) {
+    const valueFields = [
+      "valueString",
+      "valueInteger",
+      "valueBoolean",
+      "valueQuantity",
+      "valueCodeableConcept",
+      "valueDateTime",
+      "valueTime",
+      "valuePeriod"
+    ];
+    for (const field of valueFields) {
+      const observationElement = observation[`${field}`];
+      if (observationElement !== void 0) {
+        switch (field) {
+          case "valueQuantity":
+            return this.formatQuantityValue(observationElement);
+          case "valueCodeableConcept":
+            return this.formatCodeableConceptValue(observationElement);
+          default:
+            return observationElement;
+        }
+      }
+    }
+    if (observation?.component && observation.component.length > 0) {
+      for (const component of observation.component) {
+        const componentValue = this.extractObservationValue(component);
+        if (componentValue !== null) {
+          return componentValue;
+        }
+      }
+    }
+    if (observation.dataAbsentReason) {
+      return this.formatCodeableConceptValue(observation.dataAbsentReason);
+    }
+    return null;
+  }
+  formatQuantityValue(quantity) {
+    if (!quantity) return "";
+    const parts = [];
+    if (quantity.comparator) parts.push(quantity.comparator);
+    if (quantity.value !== void 0) parts.push(quantity.value.toString());
+    if (quantity.unit) parts.push(quantity.unit);
+    return parts.join(" ").trim();
+  }
+  formatCodeableConceptValue(concept) {
+    if (!concept) return "";
+    if (concept.text) return concept.text;
+    if (concept.coding && concept.coding.length > 0) {
+      return concept.coding[0].display || concept.coding[0].code || "";
+    }
+    return "";
+  }
+  extractObservationValueUnit(observation) {
+    if (observation.valueQuantity && observation.valueQuantity.unit) {
+      return observation.valueQuantity.unit;
+    }
+    if (observation.component && observation.component.length > 0) {
+      for (const component of observation.component) {
+        const unit = this.extractObservationValueUnit(component);
+        if (unit) {
+          return unit;
+        }
+      }
+    }
+    return "";
+  }
+  /**
+   * Gets the medication name from various types of medication references or resources
+   * @param medicationSource - Can be a Reference to Medication, a CodeableConcept, or a Medication resource
+   * @returns The medication name as a string
+   */
+  getMedicationName(medicationSource) {
+    if (!medicationSource) {
+      return "";
+    }
+    if (typeof medicationSource === "object" && "resourceType" in medicationSource && medicationSource.resourceType === "Medication") {
+      return this.renderMedicationCode(medicationSource);
+    }
+    if (typeof medicationSource === "object" && ("coding" in medicationSource || "text" in medicationSource)) {
+      return this.codeableConcept(medicationSource);
+    }
+    if (typeof medicationSource === "object" && "reference" in medicationSource) {
+      const medication = this.resolveReference(medicationSource);
+      if (medication && medication.code) {
+        return this.codeableConcept(medication.code);
+      }
+    }
+    return "";
+  }
+  /**
+   * Renders text as HTML, escaping special characters and replacing newlines with <br />
+   * @param text - The text to render
+   * @private
+   */
+  renderTextAsHtml(text) {
+    if (!text || text.trim() === "") {
+      return "";
+    }
+    const escapedText = text.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    return escapedText.replace(/\n/g, "<br />");
+  }
+  /**
+   * Renders note elements from a FHIR resource in a standardized format
+   * Can render as simple comma-separated text or as styled HTML with timestamps
+   *
+   * @param notes - Array of note objects (or undefined/null)
+   * @param timezone - Optional timezone to use for date formatting
+   * @param options - Rendering options
+   * @returns Formatted string representation of notes
+   */
+  renderNotes(notes, timezone, options = {}) {
+    if (!notes || !Array.isArray(notes) || notes.length === 0) {
+      return "";
+    }
+    if (!options.styled) {
+      return notes.map((n) => this.renderTextAsHtml(n.text)).join("<br />");
+    }
+    let noteHtml = "<ul>";
+    for (const note of notes) {
+      if (note.text) {
+        const noteType = note.authorString || "Overview";
+        noteHtml += `<li class="Note"><span class="NoteTitle">${noteType} (${this.renderTime(note.time, timezone)}):</span><br />`;
+        if (options.warning) {
+          noteHtml += `<span class="WarningMsg"><em>Formatting of this note might be different from the original.</em></span><br />`;
+        }
+        noteHtml += `<span class="NoteText">${this.renderTextAsHtml(note.text)}<br /></span></li>`;
+      }
+    }
+    noteHtml += "</ul>";
+    return noteHtml;
+  }
+  /**
+   * Helper method to format dates with Luxon
+   * @param dateValue - The date value to format
+   * @param timezone - Optional timezone
+   * @param dateOnly - Whether to format as date only (without time)
+   * @returns Formatted date string
+   * @private
+   */
+  formatDateTime(dateValue, timezone, dateOnly = false) {
+    if (!dateValue) return "";
+    try {
+      let dateTime;
+      if (dateValue instanceof Date) {
+        dateTime = DateTime.fromJSDate(dateValue);
+      } else if (typeof dateValue === "string") {
+        dateTime = DateTime.fromISO(dateValue);
+        if (!dateValue.includes("T")) {
+          dateOnly = true;
+        }
+      } else {
+        dateTime = DateTime.fromISO(String(dateValue));
+      }
+      if (!dateTime.isValid) {
+        return String(dateValue);
+      }
+      if (timezone && !dateOnly) {
+        dateTime = dateTime.toUTC().setZone(timezone);
+      }
+      const formatOptions = dateOnly ? { year: "numeric", month: "2-digit", day: "2-digit" } : {
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        hour12: true,
+        timeZoneName: "short"
+      };
+      return dateTime.toLocaleString(formatOptions);
+    } catch {
+      return String(dateValue);
+    }
+  }
+  /**
+   * Renders the onset age in a human-readable format
+   * @param onsetAge - The onset age value, which can be a string, number, or an object with value and unit
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  renderOnset(onsetAge, timezone) {
+    if (!onsetAge) {
+      return "";
+    }
+    if (typeof onsetAge === "object" && "value" in onsetAge && "unit" in onsetAge) {
+      return `${onsetAge.value} ${onsetAge.unit}`;
+    }
+    return "";
+  }
+  /**
+   * Renders a period of time in a human-readable format
+   * @param effectivePeriod - The effective period object containing start and end dates
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   */
+  renderPeriod(effectivePeriod, timezone) {
+    if (!effectivePeriod || !effectivePeriod.start || !effectivePeriod.end) {
+      return "";
+    }
+    const start = this.renderTime(effectivePeriod.start, timezone);
+    const end = this.renderTime(effectivePeriod.end, timezone);
+    return `${start} - ${end}`;
+  }
+  /**
+   * Renders a reference to a FHIR resource
+   * @param itemReference - The reference object containing the resource type and ID
+   */
+  renderReference(itemReference) {
+    if (itemReference && itemReference.reference) {
+      const parts = itemReference.reference.split("/");
+      if (parts.length === 2) {
+        const resourceType = parts[0];
+        const resourceId = parts[1];
+        const resource = this.bundle.entry?.find((entry) => entry.resource?.resourceType === resourceType && entry.resource?.id === resourceId);
+        if (resource) {
+          return `${resourceType}/${resourceId}`;
+        }
+      }
+    }
+  }
+  /**
+   * Formats a range of values in a human-readable format
+   * @param valueRange - The range object containing low and high values
+   */
+  formatRange(valueRange) {
+    if (!valueRange || !valueRange.low || !valueRange.high) {
+      return "";
+    }
+    const low = valueRange.low.value !== void 0 ? valueRange.low.value.toString() : "";
+    const high = valueRange.high.value !== void 0 ? valueRange.high.value.toString() : "";
+    const lowUnit = valueRange.low.unit ? ` ${valueRange.low.unit}` : "";
+    const highUnit = valueRange.high.unit ? ` ${valueRange.high.unit}` : "";
+    return `${low}${lowUnit} - ${high}${highUnit}`;
+  }
+  /**
+   * Formats a ratio value in a human-readable format
+   * @param valueRatio - The ratio object containing numerator and denominator values
+   */
+  formatRatio(valueRatio) {
+    if (!valueRatio || !valueRatio.numerator || !valueRatio.denominator) {
+      return "";
+    }
+    const numerator = valueRatio.numerator.value !== void 0 ? valueRatio.numerator.value.toString() : "";
+    const denominator = valueRatio.denominator.value !== void 0 ? valueRatio.denominator.value.toString() : "";
+    const numeratorUnit = valueRatio.numerator.unit ? ` ${valueRatio.numerator.unit}` : "";
+    const denominatorUnit = valueRatio.denominator.unit ? ` ${valueRatio.denominator.unit}` : "";
+    return `${numerator}${numeratorUnit} / ${denominator}${denominatorUnit}`;
+  }
+};
+
+// src/narratives/templates/typescript/PatientTemplate.ts
+var PatientTemplate = class _PatientTemplate {
+  /**
+   * Generate HTML narrative for Patient resource
+   * @param resource - FHIR Bundle containing Patient resource
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _PatientTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Patient resource
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = "";
+    for (const entry of resource.entry || []) {
+      if (entry.resource?.resourceType === "Patient") {
+        const patient = entry.resource;
+        html += `
+        <div>
+          <h2>Patient Summary</h2>
+          <ul>
+            <li><strong>Name(s):</strong>${this.renderNames(patient)}</li>
+            <li><strong>Gender:</strong>${patient.gender ? this.capitalize(patient.gender) : ""}</li>
+            <li><strong>Date of Birth:</strong>${patient.birthDate || ""}</li>
+            <li><strong>Identifier(s):</strong>${this.renderIdentifiers(patient)}</li>
+            <li><strong>Telecom:</strong>${this.renderTelecom(patient)}</li>
+            <li><strong>Address(es):</strong>${this.renderAddresses(patient)}</li>
+            <li><strong>Marital Status:</strong> ${patient.maritalStatus?.text || ""}</li>
+            <li><strong>Deceased:</strong>${this.renderDeceased(patient)}</li>
+            <li><strong>Language(s):</strong>${this.renderCommunication(templateUtilities, patient)}</li>
+          </ul>
+        </div>`;
+      }
+    }
+    return html;
+  }
+  /**
+   * Renders patient names as HTML list items
+   * @param patient - Patient resource
+   * @returns HTML string of list items
+   */
+  static renderNames(patient) {
+    if (!patient.name || patient.name.length === 0) {
+      return "";
+    }
+    return patient.name.map((name) => {
+      const nameText = name.text || ((name.given || []).join(" ") + " " + (name.family || "")).trim();
+      return `<ul><li>${nameText}</li></ul>`;
+    }).join("");
+  }
+  /**
+   * Renders patient identifiers as HTML list items
+   * @param patient - Patient resource
+   * @returns HTML string of list items
+   */
+  static renderIdentifiers(patient) {
+    if (!patient.identifier || patient.identifier.length === 0) {
+      return "";
+    }
+    return patient.identifier.map((id) => {
+      const system = id.system || "";
+      const value = id.value || "";
+      return `<ul><li>${system}: ${value}</li></ul>`;
+    }).join("");
+  }
+  /**
+   * Renders patient telecom information as HTML list items
+   * @param patient - Patient resource
+   * @returns HTML string of list items
+   */
+  static renderTelecom(patient) {
+    if (!patient.telecom || patient.telecom.length === 0) {
+      return "";
+    }
+    return patient.telecom.map((telecom) => {
+      const system = telecom.system ? this.capitalize(telecom.system) : "";
+      const value = telecom.value || "";
+      const use = telecom.use ? ` (${telecom.use})` : "";
+      return `<ul><li>${system}: ${value}${use}</li></ul>`;
+    }).join("");
+  }
+  /**
+   * Renders patient addresses as HTML list items
+   * @param patient - Patient resource
+   * @returns HTML string of list items
+   */
+  static renderAddresses(patient) {
+    if (!patient.address || patient.address.length === 0) {
+      return "";
+    }
+    return patient.address.map((address) => {
+      const addressText = address.text || ((address.line || []).join(", ") + ", " + (address.city || "") + ", " + (address.country || "")).trim();
+      return `<ul><li>${addressText}</li></ul>`;
+    }).join("");
+  }
+  /**
+   * Renders patient deceased status
+   * @param patient - Patient resource
+   * @returns HTML string for deceased status
+   */
+  static renderDeceased(patient) {
+    if (patient.deceasedBoolean !== void 0) {
+      return patient.deceasedBoolean ? "Yes" : "No";
+    }
+    if (patient.deceasedDateTime) {
+      return patient.deceasedDateTime;
+    }
+    return "";
+  }
+  /**
+   * Renders patient communication preferences as HTML list items
+   * @param templateUtilities - Instance of TemplateUtilities for utility functions
+   * @param patient - Patient resource
+   * @returns HTML string of list items
+   */
+  static renderCommunication(templateUtilities, patient) {
+    if (!patient.communication || patient.communication.length === 0) {
+      return "";
+    }
+    return patient.communication.map((comm) => {
+      if (!comm.language) return "";
+      const language = templateUtilities.codeableConcept(comm.language);
+      const preferred = comm.preferred ? " (preferred)" : "";
+      return `<ul><li>${language}${preferred}</li></ul>`;
+    }).join("");
+  }
+  /**
+   * Capitalizes first letter of a string
+   * @param str - String to capitalize
+   * @returns Capitalized string
+   */
+  static capitalize(str) {
+    if (!str) return "";
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+};
+
+// src/narratives/templates/typescript/AllergyIntoleranceTemplate.ts
+var AllergyIntoleranceTemplate = class _AllergyIntoleranceTemplate {
+  /**
+   * Generate HTML narrative for AllergyIntolerance resources
+   * @param resource - FHIR Bundle containing AllergyIntolerance resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _AllergyIntoleranceTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing AllergyIntolerance resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    const activeAllergies = [];
+    const resolvedAllergies = [];
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        const allergy = entry.resource;
+        const status = allergy.clinicalStatus?.coding?.[0]?.code || "";
+        if (status === "inactive" || status === "resolved") {
+          resolvedAllergies.push(allergy);
+        } else {
+          activeAllergies.push(allergy);
+        }
+      }
+    }
+    let html = `<div xmlns="http://www.w3.org/1999/xhtml">`;
+    html += `
+      <div class="ActiveAllergies">
+        <h3>Active Allergies and Intolerances</h3>
+        <table class="ActiveAllergyTable">
+          <thead>
+            <tr>
+              <th>Allergen</th>
+              <th>Status</th>
+              <th>Category</th>
+              <th>Reaction</th>
+              <th>Severity</th>
+              <th>Onset Date</th>
+              <th>Comments</th>
+            </tr>
+          </thead>
+          <tbody>`;
+    if (activeAllergies.length > 0) {
+      html += this.generateAllergyRows(activeAllergies, templateUtilities, timezone);
+    } else {
+      html += `
+          <tr>
+            <td colspan="7">No active allergies recorded</td>
+          </tr>`;
+    }
+    html += `
+          </tbody>
+        </table>
+      </div>`;
+    html += `
+      <div class="ResolvedAllergies">
+        <h3>Resolved Allergies and Intolerances</h3>
+        <table class="ResolvedAllergyTable">
+          <thead>
+            <tr>
+              <th>Allergen</th>
+              <th>Status</th>
+              <th>Category</th>
+              <th>Reaction</th>
+              <th>Severity</th>
+              <th>Onset Date</th>
+              <th>Comments</th>
+              <th>Resolved Date</th>
+            </tr>
+          </thead>
+          <tbody>`;
+    if (resolvedAllergies.length > 0) {
+      html += this.generateAllergyRows(resolvedAllergies, templateUtilities, timezone, true);
+    } else {
+      html += `
+          <tr>
+            <td colspan="8">No resolved allergies recorded</td>
+          </tr>`;
+    }
+    html += `
+          </tbody>
+        </table>
+      </div>
+    </div>`;
+    return html;
+  }
+  /**
+   * Helper method to generate HTML table rows for allergies
+   * @param allergies - Array of allergy resources to process
+   * @param templateUtilities - Utilities for formatting
+   * @param includeResolved - Whether to include resolved date column
+   * @param timezone - Optional timezone to use for date formatting
+   * @returns HTML string with table rows
+   */
+  static generateAllergyRows(allergies, templateUtilities, timezone, includeResolved = false) {
+    let html = "";
+    for (const allergy of allergies) {
+      html += `
+        <tr id="${templateUtilities.narrativeLinkId(allergy.extension)}">
+          <td class="Name"><span class="AllergenName">${templateUtilities.codeableConcept(allergy.code)}</span></td>
+          <td class="Status">${templateUtilities.codeableConcept(allergy.clinicalStatus) || "-"}</td>
+          <td class="Category">${templateUtilities.safeConcat(allergy.category, "value") || "-"}</td>
+          <td class="Reaction">${templateUtilities.concatReactionManifestation(allergy.reaction) || "-"}</td>
+          <td class="Severity">${templateUtilities.safeConcat(allergy.reaction, "severity") || "-"}</td>
+          <td class="OnsetDate">${templateUtilities.renderTime(allergy.onsetDateTime, timezone) || "-"}</td>
+          <td class="Comments">${templateUtilities.renderNotes(allergy.note, timezone, { styled: true, warning: true })}</td>`;
+      if (includeResolved) {
+        let endDate = "-";
+        if (allergy.extension && Array.isArray(allergy.extension)) {
+          const endDateExt = allergy.extension.find(
+            (ext) => ext.url === "http://hl7.org/fhir/StructureDefinition/allergyintolerance-resolutionDate"
+          );
+          if (endDateExt && endDateExt.valueDateTime) {
+            endDate = templateUtilities.renderDate(endDateExt.valueDateTime);
+          }
+        }
+        html += `
+          <td class="ResolvedDate">${endDate}</td>`;
+      }
+      html += `</tr>`;
+    }
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/MedicationSummaryTemplate.ts
+var MedicationSummaryTemplate = class _MedicationSummaryTemplate {
+  /**
+   * Generate HTML narrative for Medication resources
+   * @param resource - FHIR Bundle containing Medication resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _MedicationSummaryTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Medication resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = "";
+    const medicationRequests = this.getMedicationRequests(templateUtilities, resource);
+    if (medicationRequests.length > 0) {
+      html += this.renderMedicationRequests(templateUtilities, medicationRequests);
+    }
+    const medicationStatements = this.getMedicationStatements(templateUtilities, resource);
+    if (medicationStatements.length > 0) {
+      html += this.renderMedicationStatements(templateUtilities, medicationStatements);
+    }
+    return html;
+  }
+  /**
+   * Extract MedicationRequest resources from the bundle
+   * @param templateUtilities - Instance of TemplateUtilities for utility functions
+   * @param resource - FHIR Bundle
+   * @returns Array of MedicationRequest resources
+   */
+  static getMedicationRequests(templateUtilities, resource) {
+    if (!resource.entry || !Array.isArray(resource.entry)) {
+      return [];
+    }
+    return resource.entry.filter((entry) => entry.resource?.resourceType === "MedicationRequest").map((entry) => ({
+      resource: entry.resource,
+      extension: templateUtilities.narrativeLinkExtension(entry.resource)
+    }));
+  }
+  /**
+   * Extract MedicationStatement resources from the bundle
+   * @param templateUtilities - Instance of TemplateUtilities for utility functions
+   * @param resource - FHIR Bundle
+   * @returns Array of MedicationStatement resources
+   */
+  static getMedicationStatements(templateUtilities, resource) {
+    if (!resource.entry || !Array.isArray(resource.entry)) {
+      return [];
+    }
+    return resource.entry.filter((entry) => entry.resource?.resourceType === "MedicationStatement").map((entry) => ({
+      resource: entry.resource,
+      extension: templateUtilities.narrativeLinkExtension(entry.resource)
+    }));
+  }
+  /**
+   * Render HTML table for MedicationRequest resources
+   * @param templateUtilities - Instance of TemplateUtilities for utility functions
+   * @param medications - Array of MedicationRequest resources
+   * @returns HTML string for rendering
+   */
+  static renderMedicationRequests(templateUtilities, medications) {
+    let html = `<div xmlns="http://www.w3.org/1999/xhtml">
+      <table>
+        <thead>
+          <tr>
+            <th>Medication</th>
+            <th>Sig</th>
+            <th>Dispense Quantity</th>
+            <th>Refills</th>
+            <th>Start Date</th>
+            <th>End Date</th>
+            <th>Status</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    for (const { resource: mr, extension } of medications) {
+      const narrativeLinkId = templateUtilities.narrativeLinkId(extension);
+      const status = mr.status ? String(mr.status) : "-";
+      const medication = templateUtilities.getMedicationName(
+        mr.medicationReference || mr.medicationCodeableConcept
+      );
+      const sig = templateUtilities.concat(mr.dosageInstruction, "text") || "-";
+      let dispenseQuantity = "-";
+      if (mr.dispenseRequest?.quantity) {
+        const quantity = mr.dispenseRequest.quantity;
+        if (quantity.value) {
+          dispenseQuantity = `${quantity.value} ${quantity.unit || quantity.code || ""}`.trim();
+        }
+      }
+      const refills = mr.dispenseRequest?.numberOfRepeatsAllowed?.toString() || "-";
+      let startDate = "-";
+      let endDate = "-";
+      if (mr.dispenseRequest?.validityPeriod) {
+        startDate = mr.dispenseRequest.validityPeriod.start || "-";
+        endDate = mr.dispenseRequest.validityPeriod.end || "-";
+      } else {
+        startDate = mr.authoredOn || "-";
+      }
+      html += `
+        <tr${narrativeLinkId ? ` id="${narrativeLinkId}"` : ""}>
+          <td>${medication}<ul></ul></td>
+          <td>${sig}</td>
+          <td>${dispenseQuantity}</td>
+          <td>${refills}</td>
+          <td>${startDate}</td>
+          <td>${endDate}</td>
+          <td>${status}</td>
+        </tr>`;
+    }
+    html += `
+        </tbody>
+      </table></div>`;
+    return html;
+  }
+  /**
+   * Render HTML table for MedicationStatement resources
+   * @param templateUtilities - Instance of TemplateUtilities for utility functions
+   * @param medications - Array of MedicationStatement resources
+   * @returns HTML string for rendering
+   */
+  static renderMedicationStatements(templateUtilities, medications) {
+    let html = `<div xmlns="http://www.w3.org/1999/xhtml">
+      <table>
+        <thead>
+          <tr>
+            <th>Medication</th>
+            <th>Sig</th>
+            <th>Dispense Quantity</th>
+            <th>Refills</th>
+            <th>Start Date</th>
+            <th>End Date</th>
+            <th>Status</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    for (const { resource: ms, extension } of medications) {
+      const narrativeLinkId = templateUtilities.narrativeLinkId(extension);
+      const status = ms.status ? String(ms.status) : "-";
+      const medication = templateUtilities.getMedicationName(
+        ms.medicationReference || ms.medicationCodeableConcept
+      );
+      const sig = templateUtilities.concat(ms.dosage, "text") || "-";
+      const dispenseQuantity = "-";
+      const refills = "-";
+      let startDate = "-";
+      let endDate = "-";
+      if (ms.effectiveDateTime) {
+        startDate = ms.effectiveDateTime;
+      } else if (ms.effectivePeriod) {
+        startDate = ms.effectivePeriod.start || "-";
+        endDate = ms.effectivePeriod.end || "-";
+      }
+      html += `
+        <tr${narrativeLinkId ? ` id="${narrativeLinkId}"` : ""}>
+          <td>${medication}<ul></ul></td>
+          <td>${sig}</td>
+          <td>${dispenseQuantity}</td>
+          <td>${refills}</td>
+          <td>${startDate}</td>
+          <td>${endDate}</td>
+          <td>${status}</td>
+        </tr>`;
+    }
+    html += `
+        </tbody>
+      </table></div>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/ImmunizationsTemplate.ts
+var ImmunizationsTemplate = class _ImmunizationsTemplate {
+  /**
+   * Generate HTML narrative for Immunization resources
+   * @param resource - FHIR Bundle containing Immunization resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _ImmunizationsTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Immunization resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>Immunizations</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Immunization</th>
+            <th>Status</th>
+            <th>Dose Number</th>
+            <th>Manufacturer</th>
+            <th>Lot Number</th>
+            <th>Comments</th>
+            <th>Date</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        if (entry.resource?.resourceType === "Immunization") {
+          const imm = entry.resource;
+          html += `
+            <tr id="${templateUtilities.narrativeLinkId(imm)}">
+              <td>${templateUtilities.codeableConcept(imm.vaccineCode)}</td>
+              <td>${imm.status || ""}</td>
+              <td>${templateUtilities.concatDoseNumber(imm.protocolApplied)}</td>
+              <td>${templateUtilities.renderVaccineManufacturer(imm)}</td>
+              <td>${imm.lotNumber || ""}</td>
+              <td>${templateUtilities.renderNotes(imm.note, timezone)}</td>
+              <td>${templateUtilities.renderTime(imm.occurrenceDateTime, timezone)}</td>
+            </tr>`;
+        }
+      }
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/ProblemListTemplate.ts
+var ProblemListTemplate = class _ProblemListTemplate {
+  /**
+   * Generate HTML narrative for Problem List
+   * @param resource - FHIR Bundle containing Condition resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _ProblemListTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Condition resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `<div xmlns="http://www.w3.org/1999/xhtml">`;
+    const activeConditions = [];
+    const resolvedConditions = [];
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        const cond = entry.resource;
+        if (cond.resourceType === "Composition") {
+          continue;
+        }
+        const isResolved = cond.clinicalStatus?.coding?.some((c) => c.code === "resolved" || c.code === "inactive" || c.display?.toLowerCase().includes("resolved"));
+        if (isResolved) {
+          resolvedConditions.push(cond);
+        } else {
+          activeConditions.push(cond);
+        }
+      }
+    }
+    if (activeConditions.length > 0) {
+      html += `<div class="ActiveProblems">
+        <h3>Active Problems</h3>
+        <table class="ActiveProblemTable">
+          <thead>
+            <tr>
+              <th>Problem</th>
+              <th>Priority</th>
+              <th>Noted Date</th>
+              <th>Diagnosed Date</th>
+              <th>Notes</th>
+            </tr>
+          </thead>
+          <tbody>`;
+      for (const cond of activeConditions) {
+        html += `<tr id="${templateUtilities.narrativeLinkId(cond)}">
+          <td class="Name">${templateUtilities.codeableConcept(cond.code)}</td>
+          <td class="Priority">${templateUtilities.codeableConcept(cond.severity)}</td>
+          <td class="NotedDate">${templateUtilities.renderDate(cond.onsetDateTime)}</td>
+          <td class="DiagnosedDate">${templateUtilities.renderDate(cond.recordedDate)}</td>
+          <td class="Notes">${templateUtilities.renderNotes(cond.note, timezone, { styled: true, warning: true })}</td>
+        </tr>`;
+      }
+      html += `</tbody>
+        </table>
+      </div>`;
+    }
+    if (activeConditions.length > 0 && resolvedConditions.length > 0) {
+      html += `<br />`;
+    }
+    if (resolvedConditions.length > 0) {
+      html += `<div class="ResolvedProblems">
+        <h3>Resolved Problems</h3>
+        <table class="ResolvedProblemTable">
+          <thead>
+            <tr>
+              <th>Problem</th>
+              <th>Priority</th>
+              <th>Noted Date</th>
+              <th>Diagnosed Date</th>
+              <th>Resolved Date</th>
+              <th>Notes</th>
+            </tr>
+          </thead>
+          <tbody>`;
+      for (const cond of resolvedConditions) {
+        html += `<tr id="${templateUtilities.narrativeLinkId(cond)}">
+          <td class="Name">${templateUtilities.codeableConcept(cond.code)}</td>
+          <td class="Priority">${templateUtilities.codeableConcept(cond.severity)}</td>
+          <td class="NotedDate">${templateUtilities.renderDate(cond.onsetDateTime)}</td>
+          <td class="DiagnosedDate">${templateUtilities.renderDate(cond.recordedDate)}</td>
+          <td class="ResolvedDate">${templateUtilities.renderDate(cond.abatementDateTime)}</td>
+          <td class="Notes">${templateUtilities.renderNotes(cond.note, timezone, { styled: true, warning: true })}</td>
+        </tr>`;
+      }
+      html += `</tbody>
+        </table>
+      </div>`;
+    }
+    html += `</div>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/VitalSignsTemplate.ts
+var VitalSignsTemplate = class _VitalSignsTemplate {
+  /**
+   * Generate HTML narrative for Vital Signs
+   * @param resource - FHIR Bundle containing Observation resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _VitalSignsTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Observation resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>Vital Signs</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Code</th>
+            <th>Result</th>
+            <th>Unit</th>
+            <th>Interpretation</th>
+            <th>Component(s)</th>
+            <th>Comments</th>
+            <th>Date</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        const obs = entry.resource;
+        if (obs.resourceType === "Composition") {
+          continue;
+        }
+        html += `
+          <tr id="${templateUtilities.narrativeLinkId(obs)}">
+            <td>${templateUtilities.codeableConcept(obs.code, "display")}</td>
+            <td>${templateUtilities.extractObservationValue(obs)}</td>
+            <td>${templateUtilities.extractObservationValueUnit(obs)}</td>
+            <td>${templateUtilities.firstFromCodeableConceptList(obs.interpretation)}</td>
+            <td>${templateUtilities.renderComponent(obs.component)}</td>
+            <td>${templateUtilities.renderNotes(obs.note, timezone)}</td>
+            <td>${templateUtilities.renderEffective(obs.effectiveDateTime, timezone)}</td>
+          </tr>`;
+      }
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/MedicalDevicesTemplate.ts
+var MedicalDevicesTemplate = class _MedicalDevicesTemplate {
+  /**
+   * Generate HTML narrative for Medical Device resources
+   * @param resource - FHIR Bundle containing Device resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _MedicalDevicesTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Device resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>Medical Devices</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Device</th>
+            <th>Status</th>
+            <th>Comments</th>
+            <th>Date Recorded</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        if (entry.resource?.resourceType === "DeviceUseStatement") {
+          const dus = entry.resource;
+          html += `
+            <tr id="${templateUtilities.narrativeLinkId(dus)}">
+              <td>${templateUtilities.renderDevice(dus.device)}</td>
+              <td>${dus.status || ""}</td>
+              <td>${templateUtilities.renderNotes(dus.note, timezone)}</td>
+              <td>${templateUtilities.renderRecorded(dus.recordedOn, timezone)}</td>
+            </tr>`;
+        }
+      }
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/DiagnosticResultsTemplate.ts
+var DiagnosticResultsTemplate = class _DiagnosticResultsTemplate {
+  /**
+   * Generate HTML narrative for Diagnostic Results
+   * @param resource - FHIR Bundle containing Observation and DiagnosticReport resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _DiagnosticResultsTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Observation and DiagnosticReport resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = "";
+    const observations = this.getObservations(resource);
+    if (observations.length > 0) {
+      html += this.renderObservations(templateUtilities, observations, timezone);
+    }
+    const diagnosticReports = this.getDiagnosticReports(resource);
+    if (diagnosticReports.length > 0) {
+      html += this.renderDiagnosticReports(templateUtilities, diagnosticReports, timezone);
+    }
+    return html;
+  }
+  /**
+   * Extract Observation resources from the bundle
+   * @param resource - FHIR Bundle
+   * @returns Array of Observation resources
+   */
+  static getObservations(resource) {
+    if (!resource.entry || !Array.isArray(resource.entry)) {
+      return [];
+    }
+    return resource.entry.filter((entry) => entry.resource?.resourceType === "Observation").map((entry) => entry.resource);
+  }
+  /**
+   * Extract DiagnosticReport resources from the bundle
+   * @param resource - FHIR Bundle
+   * @returns Array of DiagnosticReport resources
+   */
+  static getDiagnosticReports(resource) {
+    if (!resource.entry || !Array.isArray(resource.entry)) {
+      return [];
+    }
+    return resource.entry.filter((entry) => entry.resource?.resourceType === "DiagnosticReport").map((entry) => entry.resource);
+  }
+  /**
+   * Render HTML table for Observation resources
+   * @param templateUtilities - Instance of TemplateUtilities for utility functions
+   * @param observations - Array of Observation resources
+   * @param timezone - Optional timezone to use for date formatting
+   * @returns HTML string for rendering
+   */
+  static renderObservations(templateUtilities, observations, timezone) {
+    let html = `
+      <h5>Diagnostic Results: Observations</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Code</th>
+            <th>Result</th>
+            <th>Unit</th>
+            <th>Interpretation</th>
+            <th>Reference Range</th>
+            <th>Comments</th>
+            <th>Date</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    for (const obs of observations) {
+      html += `
+        <tr id="${templateUtilities.narrativeLinkId(obs)}">
+          <td>${templateUtilities.codeableConcept(obs.code)}</td>
+          <td>${templateUtilities.extractObservationValue(obs)}</td>
+          <td>${templateUtilities.extractObservationValueUnit(obs)}</td>
+          <td>${templateUtilities.firstFromCodeableConceptList(obs.interpretation)}</td>
+          <td>${templateUtilities.concatReferenceRange(obs.referenceRange)}</td>
+          <td>${templateUtilities.renderNotes(obs.note, timezone)}</td>
+          <td>${templateUtilities.renderTime(obs.effectiveDateTime, timezone)}</td>
+        </tr>`;
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+  /**
+   * Render HTML table for DiagnosticReport resources
+   * @param templateUtilities - Instance of TemplateUtilities for utility functions
+   * @param reports - Array of DiagnosticReport resources
+   * @param timezone - Optional timezone to use for date formatting
+   * @returns HTML string for rendering
+   */
+  static renderDiagnosticReports(templateUtilities, reports, timezone) {
+    let html = `
+      <h5>Diagnostic Results: Reports</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Report</th>
+            <th>Status</th>
+            <th>Category</th>
+            <th>Result</th>
+            <th>Issued</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    for (const report of reports) {
+      let resultCount = "";
+      if (report.result && Array.isArray(report.result)) {
+        resultCount = `${report.result.length} result${report.result.length !== 1 ? "s" : ""}`;
+      }
+      html += `
+        <tr id="${templateUtilities.narrativeLinkId(report)}">
+          <td>${templateUtilities.codeableConcept(report.code)}</td>
+          <td>${report.status || ""}</td>
+          <td>${templateUtilities.firstFromCodeableConceptList(report.category)}</td>
+          <td>${resultCount}</td>
+          <td>${report.issued ? templateUtilities.renderTime(report.issued, timezone) : ""}</td>
+        </tr>`;
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/HistoryOfProceduresTemplate.ts
+var HistoryOfProceduresTemplate = class _HistoryOfProceduresTemplate {
+  /**
+   * Generate HTML narrative for Procedure resources
+   * @param resource - FHIR Bundle containing Procedure resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _HistoryOfProceduresTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Procedure resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>History Of Procedures</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Procedure</th>
+            <th>Comments</th>
+            <th>Date</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        const proc = entry.resource;
+        if (proc.resourceType === "Composition") {
+          continue;
+        }
+        html += `
+          <tr id="${templateUtilities.narrativeLinkId(proc)}">
+            <td>${templateUtilities.codeableConcept(proc.code, "display")}</td>
+            <td>${templateUtilities.renderNotes(proc.note, timezone)}</td>
+            <td>${templateUtilities.renderTime(proc.performedDateTime, timezone)}</td>
+          </tr>`;
+      }
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/SocialHistoryTemplate.ts
+var SocialHistoryTemplate = class _SocialHistoryTemplate {
+  /**
+   * Generate HTML narrative for Social History
+   * @param resource - FHIR Bundle containing Observation resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _SocialHistoryTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Observation resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>Social History</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Code</th>
+            <th>Result</th>
+            <th>Unit</th>
+            <th>Comments</th>
+            <th>Date</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        const obs = entry.resource;
+        if (obs.resourceType === "Composition") {
+          continue;
+        }
+        html += `
+          <tr id="${templateUtilities.narrativeLinkId(obs)}">
+            <td>${templateUtilities.codeableConcept(obs.code, "display")}</td>
+            <td>${templateUtilities.extractObservationValue(obs)}</td>
+            <td>${templateUtilities.extractObservationValueUnit(obs)}</td>
+            <td>${templateUtilities.renderNotes(obs.note, timezone)}</td>
+            <td>${templateUtilities.renderTime(obs.effectiveDateTime, timezone)}</td>
+          </tr>`;
+      }
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/PastHistoryOfIllnessTemplate.ts
+var PastHistoryOfIllnessTemplate = class {
+  /**
+   * Generate HTML narrative for Past History of Illnesses
+   * @param resource - FHIR Bundle containing Condition resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>Past History of Illnesses</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Medical Problems</th>
+            <th>Status</th>
+            <th>Comments</th>
+            <th>Date</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        const cond = entry.resource;
+        if (cond.resourceType === "Composition") {
+          continue;
+        }
+        html += `
+          <tr id="${templateUtilities.narrativeLinkId(cond)}">
+            <td>${templateUtilities.codeableConcept(cond.code, "display")}</td>
+            <td>${templateUtilities.codeableConcept(cond.clinicalStatus, "code")}</td>
+            <td>${templateUtilities.renderNotes(cond.note, timezone)}</td>
+            <td>${templateUtilities.renderTime(cond.onsetDateTime, timezone)}</td>
+          </tr>`;
+      }
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/PlanOfCareTemplate.ts
+var PlanOfCareTemplate = class {
+  /**
+   * Generate HTML narrative for Plan of Care
+   * @param resource - FHIR Bundle containing CarePlan resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  generateNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>Plan of Care</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Activity</th>
+            <th>Intent</th>
+            <th>Comments</th>
+            <th>Planned Start</th>
+            <th>Planned End</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        const cp = entry.resource;
+        if (cp.resourceType === "Composition") {
+          continue;
+        }
+        html += `
+          <tr id="${templateUtilities.narrativeLinkId(cp)}">
+            <td>${cp.description || ""}</td>
+            <td>${cp.intent || cp.intent || ""}</td>
+            <td>${templateUtilities.concat(cp.note, "text")}</td>
+            <td>${cp.period?.start || ""}</td>
+            <td>${cp.period?.end || ""}</td>
+          </tr>`;
+      }
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/FunctionalStatusTemplate.ts
+var FunctionalStatusTemplate = class _FunctionalStatusTemplate {
+  /**
+   * Generate HTML narrative for Functional Status
+   * @param resource - FHIR Bundle containing Observation resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _FunctionalStatusTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Observation resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>Functional Status</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Assessment</th>
+            <th>Status</th>
+            <th>Finding</th>
+            <th>Comments</th>
+            <th>Date</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        const ci = entry.resource;
+        if (ci.resourceType === "Composition") {
+          continue;
+        }
+        html += `
+          <tr id="${templateUtilities.narrativeLinkId(ci)}">
+            <td>${templateUtilities.codeableConcept(ci.code, "display")}</td>
+            <td>${ci.status || ""}</td>
+            <td>${ci.summary || ""}</td>
+            <td>${templateUtilities.renderNotes(ci.note, timezone)}</td>
+            <td>${templateUtilities.renderEffective(ci.effectiveDateTime, timezone)}</td>
+          </tr>`;
+      }
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/PregnancyTemplate.ts
+var PregnancyTemplate = class _PregnancyTemplate {
+  /**
+   * Generate HTML narrative for Pregnancy
+   * @param resource - FHIR Bundle containing Observation resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _PregnancyTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Observation resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>Pregnancy</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Code</th>
+            <th>Result</th>
+            <th>Comments</th>
+            <th>Date</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        const obs = entry.resource;
+        if (obs.resourceType === "Composition") {
+          continue;
+        }
+        html += `
+          <tr id="${templateUtilities.narrativeLinkId(obs)}">
+            <td>${templateUtilities.codeableConcept(obs.code, "display")}</td>
+            <td>${templateUtilities.extractObservationValue(obs)}</td>
+            <td>${templateUtilities.renderNotes(obs.note, timezone)}</td>
+            <td>${templateUtilities.renderEffective(obs.effectiveDateTime, timezone)}</td>
+          </tr>`;
+      }
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/AdvanceDirectivesTemplate.ts
+var AdvanceDirectivesTemplate = class _AdvanceDirectivesTemplate {
+  /**
+   * Generate HTML narrative for Advance Directives
+   * @param resource - FHIR Bundle containing Advance Directive resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    return _AdvanceDirectivesTemplate.generateStaticNarrative(resource, timezone);
+  }
+  /**
+   * Internal static implementation that actually generates the narrative
+   * @param resource - FHIR Bundle containing Advance Directive resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static generateStaticNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>Advance Directives</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Scope</th>
+            <th>Status</th>
+            <th>Action Controlled</th>
+            <th>Date</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      for (const entry of resource.entry) {
+        const consent = entry.resource;
+        if (consent.resourceType === "Composition") {
+          continue;
+        }
+        html += `
+          <tr id="${templateUtilities.narrativeLinkId(consent)}">
+            <td>${templateUtilities.codeableConcept(consent.scope, "display")}</td>
+            <td>${consent.status || ""}</td>
+            <td>${consent.provision?.action ? templateUtilities.concatCodeableConcept(consent.provision.action) : ""}</td>
+            <td>${consent.dateTime || ""}</td>
+          </tr>`;
+      }
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/FamilyHistoryTemplate.ts
+var FamilyHistoryTemplate = class {
+  /**
+   * Generate HTML narrative for Family History
+   * @param resource - FHIR Bundle containing FamilyMemberHistory resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>Family History</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Relationship</th>
+            <th>Condition</th>
+            <th>Status</th>
+            <th>Onset</th>
+            <th>Notes</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      let hasFamilyHistory = false;
+      for (const entry of resource.entry) {
+        const familyHistory = entry.resource;
+        if (!familyHistory || familyHistory.resourceType !== "FamilyMemberHistory") {
+          continue;
+        }
+        hasFamilyHistory = true;
+        const fmh = familyHistory;
+        const relationship = templateUtilities.codeableConcept(fmh.relationship, "display");
+        if (fmh.condition && Array.isArray(fmh.condition)) {
+          for (const condition of fmh.condition) {
+            const conditionCode = templateUtilities.codeableConcept(condition.code, "display");
+            const status = fmh.status || "";
+            let onset = "";
+            if (condition.onsetAge) {
+              onset = templateUtilities.renderOnset(condition.onsetAge, timezone);
+            }
+            const notes = condition.note ? templateUtilities.renderNotes(condition.note, timezone) : templateUtilities.renderNotes(fmh.note, timezone);
+            html += `
+          <tr id="${templateUtilities.narrativeLinkId(fmh)}">
+            <td>${relationship}</td>
+            <td>${conditionCode}</td>
+            <td>${status}</td>
+            <td>${onset}</td>
+            <td>${notes}</td>
+          </tr>`;
+          }
+        } else {
+          html += `
+          <tr id="${templateUtilities.narrativeLinkId(fmh)}">
+            <td>${relationship}</td>
+            <td>Not specified</td>
+            <td>${fmh.status || ""}</td>
+            <td></td>
+            <td>${templateUtilities.renderNotes(fmh.note, timezone)}</td>
+          </tr>`;
+        }
+      }
+      if (!hasFamilyHistory) {
+        html += `
+          <tr>
+            <td colspan="5">No family history recorded</td>
+          </tr>`;
+      }
+    } else {
+      html += `
+          <tr>
+            <td colspan="5">No family history recorded</td>
+          </tr>`;
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/ClinicalImpressionTemplate.ts
+var ClinicalImpressionTemplate = class {
+  /**
+   * Generate HTML narrative for Clinical Impressions
+   * @param resource - FHIR Bundle containing ClinicalImpression resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  generateNarrative(resource, timezone) {
+    const templateUtilities = new TemplateUtilities(resource);
+    let html = `
+      <h5>Clinical Impressions</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Date</th>
+            <th>Status</th>
+            <th>Description</th>
+            <th>Summary</th>
+            <th>Findings</th>
+            <th>Notes</th>
+          </tr>
+        </thead>
+        <tbody>`;
+    if (resource.entry && Array.isArray(resource.entry)) {
+      let hasClinicalImpressions = false;
+      for (const entry of resource.entry) {
+        const res = entry.resource;
+        if (!res || res.resourceType !== "ClinicalImpression") {
+          continue;
+        }
+        hasClinicalImpressions = true;
+        const impression = res;
+        let formattedDate = "";
+        if (impression.effectiveDateTime) {
+          formattedDate = templateUtilities.renderTime(impression.effectiveDateTime, timezone);
+        } else if (impression.effectivePeriod) {
+          formattedDate = templateUtilities.renderPeriod(impression.effectivePeriod, timezone);
+        } else if (impression.date) {
+          formattedDate = templateUtilities.renderDate(impression.date);
+        }
+        const status = impression.status || "";
+        const description = impression.description || "";
+        const summary = impression.summary || "";
+        let findingsHtml = "";
+        if (impression.finding && impression.finding.length > 0) {
+          findingsHtml = "<ul>";
+          for (const finding of impression.finding) {
+            const findingText = finding.itemCodeableConcept ? templateUtilities.codeableConcept(finding.itemCodeableConcept, "display") : finding.itemReference ? templateUtilities.renderReference(finding.itemReference) : "";
+            const cause = finding.basis || "";
+            findingsHtml += `<li>${findingText}${cause ? ` - ${cause}` : ""}</li>`;
+          }
+          findingsHtml += "</ul>";
+        }
+        const notes = templateUtilities.renderNotes(impression.note, timezone);
+        html += `
+          <tr id="${templateUtilities.narrativeLinkId(impression)}">
+            <td>${formattedDate}</td>
+            <td>${status}</td>
+            <td>${description}</td>
+            <td>${summary}</td>
+            <td>${findingsHtml}</td>
+            <td>${notes}</td>
+          </tr>`;
+      }
+      if (!hasClinicalImpressions) {
+        html += `
+          <tr>
+            <td colspan="6">No clinical impressions recorded</td>
+          </tr>`;
+      }
+    } else {
+      html += `
+          <tr>
+            <td colspan="6">No clinical impressions recorded</td>
+          </tr>`;
+    }
+    html += `
+        </tbody>
+      </table>`;
+    return html;
+  }
+};
+
+// src/narratives/templates/typescript/TypeScriptTemplateMapper.ts
+var TypeScriptTemplateMapper = class {
+  /**
+   * Generates HTML narrative for a specific IPS section
+   * @param section - The IPS section
+   * @param resource - FHIR Bundle containing resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns HTML string for rendering
+   */
+  static generateNarrative(section, resource, timezone) {
+    const templateClass = this.sectionToTemplate[section];
+    if (!templateClass) {
+      throw new Error(`No template found for section: ${section}`);
+    }
+    return templateClass.generateNarrative(resource, timezone);
+  }
+};
+// Map of section types to their template classes
+// Each template either needs to be instantiated or has a static generateNarrative method
+TypeScriptTemplateMapper.sectionToTemplate = {
+  ["Patient" /* PATIENT */]: new PatientTemplate(),
+  ["AllergyIntoleranceSection" /* ALLERGIES */]: new AllergyIntoleranceTemplate(),
+  ["MedicationSection" /* MEDICATIONS */]: new MedicationSummaryTemplate(),
+  ["ImmunizationSection" /* IMMUNIZATIONS */]: new ImmunizationsTemplate(),
+  ["ProblemSection" /* PROBLEMS */]: new ProblemListTemplate(),
+  ["VitalSignsSection" /* VITAL_SIGNS */]: new VitalSignsTemplate(),
+  ["MedicalDeviceSection" /* MEDICAL_DEVICES */]: new MedicalDevicesTemplate(),
+  ["DiagnosticReportSection" /* DIAGNOSTIC_REPORTS */]: new DiagnosticResultsTemplate(),
+  ["ProcedureSection" /* PROCEDURES */]: new HistoryOfProceduresTemplate(),
+  ["FamilyHistorySection" /* FAMILY_HISTORY */]: new FamilyHistoryTemplate(),
+  ["SocialHistorySection" /* SOCIAL_HISTORY */]: new SocialHistoryTemplate(),
+  ["PregnancyHistorySection" /* PREGNANCY_HISTORY */]: new PregnancyTemplate(),
+  ["FunctionalStatusSection" /* FUNCTIONAL_STATUS */]: new FunctionalStatusTemplate(),
+  ["MedicalHistorySection" /* MEDICAL_HISTORY */]: new PastHistoryOfIllnessTemplate(),
+  ["CarePlanSection" /* CARE_PLAN */]: new PlanOfCareTemplate(),
+  ["ClinicalImpressionSection" /* CLINICAL_IMPRESSION */]: new ClinicalImpressionTemplate(),
+  ["AdvanceDirectivesSection" /* ADVANCE_DIRECTIVES */]: new AdvanceDirectivesTemplate()
+};
+
+// src/generators/narrative_generator.ts
+var NarrativeGenerator = class {
+  /**
+   * Generates narrative HTML content for a section
+   * @param section - IPS section type
+   * @param resources - Array of domain resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns Generated HTML content or undefined if no resources
+   */
+  static generateNarrativeContent(section, resources, timezone) {
+    if (!resources || resources.length === 0) {
+      return void 0;
+    }
+    try {
+      const bundle = {
+        resourceType: "Bundle",
+        type: "collection",
+        entry: resources.map((resource) => ({
+          resource
+        }))
+      };
+      return TypeScriptTemplateMapper.generateNarrative(section, bundle, timezone);
+    } catch (error) {
+      console.error(`Error generating narrative for section ${section}:`, error);
+      return `<div class="error">Error generating narrative: ${error instanceof Error ? error.message : String(error)}</div>`;
+    }
+  }
+  /**
+   * Creates a complete FHIR Narrative object
+   * @param content - HTML content
+   * @returns FHIR Narrative object
+   */
+  static createNarrative(content) {
+    content = content.replace(/\s+/g, " ").trim();
+    const divMatch = content.match(/^<div[^>]*>(.*?)<\/div>$/);
+    if (divMatch) {
+      content = divMatch[1];
+    }
+    return {
+      status: "generated",
+      div: `<div xmlns="http://www.w3.org/1999/xhtml">${content}</div>`
+    };
+  }
+  /**
+   * Generates a complete FHIR Narrative object for a section
+   * @param section - IPS section type
+   * @param resources - Array of domain resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @returns FHIR Narrative object or undefined if no resources
+   */
+  static generateNarrative(section, resources, timezone) {
+    const content = this.generateNarrativeContent(section, resources, timezone);
+    if (!content) {
+      return void 0;
+    }
+    return this.createNarrative(content);
+  }
+  /**
+   * Wrap content in XHTML div with FHIR namespace
+   * @param content - HTML content to wrap
+   * @returns XHTML div string
+   */
+  static wrapInXhtml(content) {
+    return `<div xmlns="http://www.w3.org/1999/xhtml">${content}</div>`;
+  }
+};
+
+// src/generators/fhir_summary_generator.ts
+var ComprehensiveIPSCompositionBuilder = class {
+  constructor() {
+    this.sections = [];
+    this.mandatorySectionsAdded = /* @__PURE__ */ new Set();
+    this.resources = /* @__PURE__ */ new Set();
+  }
+  /**
+   * sets the patient resource for the IPS Composition.
+   * This is not needed if you are calling read_bundle, but can be used to set the patient resource directly.
+   * @param patient - FHIR Patient resource to set
+   */
+  setPatient(patient) {
+    if (!patient || patient.resourceType !== "Patient") {
+      throw new Error("Invalid Patient resource");
+    }
+    this.patient = patient;
+    return this;
+  }
+  // Comprehensive method to add sections with validation
+  addSection(sectionType, resources, timezone, options) {
+    const validResources = resources;
+    for (const resource of validResources) {
+      this.resources.add(resource);
+    }
+    if (validResources.length === 0) {
+      if (!options?.isOptional) {
+        throw new Error(`No valid resources for mandatory section: ${sectionType}`);
+      }
+      return this;
+    }
+    if (sectionType !== "Patient" /* PATIENT */) {
+      const narrative = NarrativeGenerator.generateNarrative(sectionType, validResources, timezone);
+      const sectionEntry = {
+        title: IPS_SECTION_DISPLAY_NAMES[sectionType] || sectionType,
+        code: {
+          coding: [{
+            system: "http://loinc.org",
+            code: options?.customLoincCode || IPS_SECTION_LOINC_CODES[sectionType],
+            display: IPS_SECTION_DISPLAY_NAMES[sectionType] || sectionType
+          }],
+          text: IPS_SECTION_DISPLAY_NAMES[sectionType] || sectionType
+        },
+        text: narrative,
+        entry: validResources.map((resource) => ({
+          reference: `${resource.resourceType}/${resource.id}`,
+          display: resource.resourceType
+        }))
+      };
+      if (!options?.isOptional) {
+        this.mandatorySectionsAdded.add(sectionType);
+      }
+      this.sections.push(sectionEntry);
+    }
+    return this;
+  }
+  /**
+   * Reads a FHIR Bundle and extracts resources for each section defined in IPSSections.
+   * @param bundle - FHIR Bundle containing resources
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   */
+  read_bundle(bundle, timezone) {
+    if (!bundle.entry) {
+      return this;
+    }
+    const patientEntry = bundle.entry.find((e) => e.resource?.resourceType === "Patient");
+    if (!patientEntry || !patientEntry.resource) {
+      throw new Error("Patient resource not found in the bundle");
+    }
+    this.patient = patientEntry.resource;
+    for (const sectionType of Object.values(IPSSections)) {
+      const resourceTypesForSection = IPSSectionResourceHelper.getResourceTypesForSection(sectionType);
+      const customFilter = IPSSectionResourceHelper.getResourceFilterForSection(sectionType);
+      let resources = bundle.entry.map((e) => e.resource).filter((r) => typeof r?.resourceType === "string" && resourceTypesForSection.includes(r.resourceType));
+      if (customFilter) {
+        resources = resources.filter(customFilter);
+      }
+      if (resources.length > 0) {
+        this.addSection(sectionType, resources, timezone, { isOptional: true });
+      }
+    }
+    return this;
+  }
+  /**
+   * Builds the final Composition sections, ensuring all mandatory sections are present.
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  build(timezone) {
+    const mandatorySections = [
+      "AllergyIntoleranceSection" /* ALLERGIES */,
+      "MedicationSection" /* MEDICATIONS */,
+      "ProblemSection" /* PROBLEMS */,
+      "ImmunizationSection" /* IMMUNIZATIONS */
+    ];
+    const missingMandatorySections = mandatorySections.filter(
+      (section) => !this.mandatorySectionsAdded.has(section)
+    );
+    if (missingMandatorySections.length > 0) {
+      throw new Error(
+        `Missing mandatory IPS sections: ${missingMandatorySections.join(", ")}`
+      );
+    }
+    return this.sections;
+  }
+  /**
+   * Builds a complete FHIR Bundle containing the Composition and all resources.
+   * @param authorOrganizationId - ID of the authoring organization (e.g., hospital or clinic)
+   * @param authorOrganizationName - Name of the authoring organization
+   * @param baseUrl - Base URL for the FHIR server (e.g., 'https://example.com/fhir')
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   */
+  build_bundle(authorOrganizationId, authorOrganizationName, baseUrl, timezone) {
+    if (baseUrl.endsWith("/")) {
+      baseUrl = baseUrl.slice(0, -1);
+    }
+    if (!this.patient) {
+      throw new Error("Patient resource must be set before building the bundle");
+    }
+    const composition = {
+      id: `Composition-${this.patient.id}`,
+      resourceType: "Composition",
+      status: "final",
+      type: {
+        coding: [{
+          system: "http://loinc.org",
+          code: "60591-5",
+          display: "Patient summary Document"
+        }]
+      },
+      subject: {
+        reference: `Patient/${this.patient.id}`
+      },
+      author: [{
+        reference: `Organization/${authorOrganizationId}`,
+        // Assuming patient is also a practitioner for simplicity
+        display: authorOrganizationName
+      }],
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      title: "International Patient Summary",
+      section: this.sections,
+      text: this.createCompositionNarrative(timezone)
+    };
+    const bundle = {
+      resourceType: "Bundle",
+      type: "document",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      identifier: {
+        "system": "urn:ietf:rfc:3986",
+        "value": "urn:uuid:4dcfd353-49fd-4ab0-b521-c8d57ced74d6"
+      },
+      entry: []
+    };
+    bundle.entry?.push({
+      fullUrl: `${baseUrl}/Composition/${composition.id}`,
+      resource: composition
+    });
+    bundle.entry?.push({
+      fullUrl: `${baseUrl}/Patient/${this.patient.id}`,
+      resource: this.patient
+    });
+    this.resources.forEach((resource) => {
+      if (resource.resourceType !== "Patient") {
+        bundle.entry?.push(
+          {
+            fullUrl: `${baseUrl}/${resource.resourceType}/${resource.id}`,
+            resource
+          }
+        );
+      }
+    });
+    bundle.entry?.push({
+      fullUrl: `${baseUrl}/Organization/${authorOrganizationId}`,
+      resource: {
+        resourceType: "Organization",
+        id: authorOrganizationId,
+        name: authorOrganizationName
+      }
+    });
+    return bundle;
+  }
+  /**
+   * Creates a narrative for the composition based on the patient and sections.
+   * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+   * @private
+   */
+  createCompositionNarrative(timezone) {
+    const patient = this.patient;
+    let fullNarrativeContent = "";
+    const patientNarrative = NarrativeGenerator.generateNarrativeContent(
+      "Patient" /* PATIENT */,
+      [patient],
+      timezone
+    );
+    fullNarrativeContent = fullNarrativeContent.concat(patientNarrative || "");
+    for (const sectionType of Object.values(IPSSections)) {
+      const resourceTypesForSection = IPSSectionResourceHelper.getResourceTypesForSection(sectionType);
+      const allResources = Array.from(this.resources);
+      const resources = allResources.filter((r) => resourceTypesForSection.includes(r.resourceType));
+      if (resources.length > 0) {
+        const sectionNarrative = NarrativeGenerator.generateNarrativeContent(sectionType, resources, timezone);
+        fullNarrativeContent = fullNarrativeContent.concat(sectionNarrative || "");
+      }
+    }
+    return {
+      status: "generated",
+      div: NarrativeGenerator.wrapInXhtml(fullNarrativeContent)
+    };
+  }
+};
+
+// src/index.ts
+var myPackage = (taco = "") => `${taco} from my package`;
+export {
+  ComprehensiveIPSCompositionBuilder,
+  NarrativeGenerator,
+  myPackage
+};