@outburn/format-converter 1.0.5 → 2.0.0

package/README.md

@@ -27,6 +27,8 @@ import { FormatConverter, TypeConverter, FormatDetector } from '@outburn/format-
 ```
 
 ### Browser (Limited functionality)
+
+**Using IIFE (script tag):**
 ```html
 <script src="node_modules/@outburn/format-converter/dist/browser.js"></script>
 <script>
@@ -35,12 +37,31 @@ const { TypeConverter, FormatDetector } = FormatUtils;
 </script>
 ```
 
+**Using ESM (module import):**
+```typescript
+import { TypeConverter, FormatDetector } from '@outburn/format-converter/browser';
+// FormatConverter is not available in browser due to HL7.js dependency
+```
+
+**Available exports:**
+```typescript
+// Classes
+import { TypeConverter, FormatDetector } from '@outburn/format-converter/browser';
+
+// Types
+import type { ITypeConverter, IFormatDetector } from '@outburn/format-converter/browser';
+
+// Enums
+import { ContentType, ContentFormat, EditorLanguage } from '@outburn/format-converter/browser';
+```
+
 **Browser limitations:**
 - ❌ `FormatConverter` is not available (requires HL7.js which is not browser-compatible)
 - ❌ HL7 v2 parsing and conversion
 - ✅ `TypeConverter` for type detection and conversion
 - ✅ `FormatDetector` for format detection (JSON, XML, CSV, HL7)
-- ✅ All type definitions and enums
+- ✅ All type definitions and enums (`ContentType`, `ContentFormat`, `EditorLanguage`)
+- ✅ TypeScript interfaces (`ITypeConverter`, `IFormatDetector`)
 
 For full functionality including HL7 processing, use the Node.js version.
 
@@ -346,7 +367,7 @@ npm run lint
 
 ## License
 MIT
-© Outburn Ltd. 2022–2025. All Rights Reserved.
+© Outburn Ltd. 2025. All Rights Reserved.
 
 ## Disclaimer
 This project is part of the [FUME](https://github.com/Outburn-IL/fume-community) open-source initiative and intended for use in FHIR tooling and development environments.

package/dist/browser.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Enumeration of supported content formats for detection and conversion.
+ * Used by format detection algorithms to categorize input data and determine
+ * appropriate conversion strategies.
+ */
+declare const ContentFormat: {
+    /** JavaScript Object Notation format */
+    readonly JSON: "json";
+    /** Comma-Separated Values format */
+    readonly CSV: "csv";
+    /** eXtensible Markup Language format */
+    readonly XML: "xml";
+    /** Health Level 7 Version 2.x message format */
+    readonly HL7: "hl7";
+    /** Unknown or unsupported format */
+    readonly UNKNOWN: "unknown";
+};
+type ContentFormat = typeof ContentFormat[keyof typeof ContentFormat];
+
+/**
+ * Enumeration of supported MIME types/content types for data format identification.
+ * These values correspond to standard HTTP Content-Type header values and are used
+ * for format detection and conversion operations.
+ */
+declare const ContentType: {
+    /** Standard MIME type for JSON data */
+    readonly JSON: "application/json";
+    /** Standard MIME type for CSV data */
+    readonly CSV: "text/csv";
+    /** Standard MIME type for XML data */
+    readonly XML: "application/xml";
+    /** Custom MIME type for HL7 Version 2.x messages in ER7 encoding */
+    readonly HL7V2: "x-application/hl7-v2+er7";
+};
+type ContentType = typeof ContentType[keyof typeof ContentType];
+
+/**
+ * Enumeration of supported editor language identifiers for syntax highlighting and editor configuration.
+ * These values are used to determine the appropriate language mode for displaying content
+ * in code editors or other text editing interfaces.
+ */
+declare const EditorLanguage: {
+    /** JSON language mode for syntax highlighting */
+    readonly JSON: "json";
+    /** XML language mode for syntax highlighting */
+    readonly XML: "xml";
+    /** Plain text mode with no syntax highlighting */
+    readonly PLAINTEXT: "plaintext";
+};
+type EditorLanguage = typeof EditorLanguage[keyof typeof EditorLanguage];
+
+/**
+ * Interface for format detection operations, providing methods to analyze and identify
+ * various aspects of input data including content type, format, and appropriate editor language.
+ */
+interface IFormatDetector {
+    /**
+     * Detects the content type of the given input string.
+     * @param input Input string to analyze
+     * @returns Detected ContentType or null if undetectable
+     */
+    detectContentType: (input: string) => ContentType | null;
+    /**
+     * Detects the content format of the given input string.
+     * @param input Input string to analyze
+     * @returns Detected ContentFormat
+     */
+    detectFormat: (input: string) => ContentFormat;
+    /**
+     * Detects the appropriate editor language for the given input string.
+     * @param input Input string to analyze
+     * @returns Detected EditorLanguage
+     */
+    detectEditorLanguage: (input: string) => EditorLanguage;
+}
+
+/**
+ * Interface for type conversion operations, providing methods to convert between
+ * different content type representations (ContentType, ContentFormat, EditorLanguage, and string).
+ */
+interface ITypeConverter {
+    /**
+     * Converts a ContentType to its corresponding ContentFormat.
+     * @param contentType The ContentType to convert
+     * @returns The corresponding ContentFormat
+     */
+    contentTypeToContentFormat: (contentType: ContentType) => ContentFormat;
+    /**
+     * Converts a ContentType to its corresponding EditorLanguage.
+     * @param contentType The ContentType to convert
+     * @returns The corresponding EditorLanguage
+     */
+    contentTypeToEditorLanguage: (contentType: ContentType) => EditorLanguage;
+    /**
+     * Converts a ContentFormat to its corresponding ContentType.
+     * @param format The ContentFormat to convert
+     * @returns The corresponding ContentType, or null if conversion is not possible
+     */
+    contentFormatToContentType: (format: ContentFormat) => ContentType | null;
+    /**
+     * Converts a ContentFormat to its corresponding EditorLanguage.
+     * @param format The ContentFormat to convert
+     * @returns The corresponding EditorLanguage
+     */
+    contentFormatToEditorLanguage: (format: ContentFormat) => EditorLanguage;
+    /**
+     * Converts a string representation to its corresponding ContentFormat.
+     * @param format The string representation of a format
+     * @returns The corresponding ContentFormat, or null if conversion is not possible
+     */
+    stringToContentFormat: (format: string) => ContentFormat | null;
+    /**
+     * Converts a string representation to its corresponding ContentType.
+     * @param contentType The string representation of a content type
+     * @returns The corresponding ContentType, or null if conversion is not possible
+     */
+    stringToContentType: (contentType: string) => ContentType | null;
+    /**
+     * Converts a string representation to its corresponding EditorLanguage.
+     * @param editorLanguage The string representation of an editor language
+     * @returns The corresponding EditorLanguage, or null if conversion is not possible
+     */
+    stringToEditorLanguage: (editorLanguage: string) => EditorLanguage | null;
+}
+
+declare class TypeConverter implements ITypeConverter {
+    private static contentTypeToContentFormatMap;
+    private static contentFormatToContentTypeMap;
+    private static contentFormatToEditorLanguageMap;
+    private static contentFormats;
+    private static contentTypes;
+    private static editorLanguages;
+    contentTypeToContentFormat(contentType: ContentType): ContentFormat;
+    contentTypeToEditorLanguage(contentType: ContentType): EditorLanguage;
+    contentFormatToContentType(format: ContentFormat): ContentType | null;
+    contentFormatToEditorLanguage(format: ContentFormat): EditorLanguage;
+    stringToContentFormat(format: string): ContentFormat | null;
+    stringToContentType(contentType: string): ContentType | null;
+    stringToEditorLanguage(editorLanguage: string): EditorLanguage | null;
+}
+
+/**
+ * A service class responsible for detecting and identifying various content formats and types.
+ *
+ * The FormatDetector analyzes input strings to determine their format (JSON, XML, CSV, HL7, etc.)
+ * and provides corresponding content types and editor language mappings. It uses a series of
+ * validation functions to identify the most likely format of the input data.
+ *
+ * @example
+ * ```typescript
+ * const detector = new FormatDetector();
+ * const format = detector.detectFormat('{"key": "value"}');
+ * // Returns: ContentFormat.JSON
+ *
+ * const contentType = detector.detectContentType('<root></root>');
+ * // Returns: ContentType corresponding to XML format
+ * ```
+ */
+declare class FormatDetector implements IFormatDetector {
+    private static readonly typeConverter;
+    detectContentType(input: string): ContentType | null;
+    detectFormat(input: string): ContentFormat;
+    detectEditorLanguage(input: string): EditorLanguage;
+}
+
+export { ContentFormat, ContentType, EditorLanguage, FormatDetector, type IFormatDetector, type ITypeConverter, TypeConverter };

package/dist/browser.js

@@ -0,0 +1,2 @@
+var FormatUtils=(function(exports){'use strict';var r={JSON:"application/json",CSV:"text/csv",XML:"application/xml",HL7V2:"x-application/hl7-v2+er7"};var e={JSON:"json",CSV:"csv",XML:"xml",HL7:"hl7",UNKNOWN:"unknown"};var a={JSON:"json",XML:"xml",PLAINTEXT:"plaintext"};var s=class s{contentTypeToContentFormat(t){return s.contentTypeToContentFormatMap[t]}contentTypeToEditorLanguage(t){let o=this.contentTypeToContentFormat(t);return this.contentFormatToEditorLanguage(o)}contentFormatToContentType(t){return s.contentFormatToContentTypeMap[t]||null}contentFormatToEditorLanguage(t){return s.contentFormatToEditorLanguageMap[t]}stringToContentFormat(t){let o=t.toLowerCase();return s.contentFormats.find(c=>c===o)||null}stringToContentType(t){let o=t.toLowerCase();return s.contentTypes.find(c=>o.startsWith(c))||null}stringToEditorLanguage(t){let o=t.toLowerCase();return s.editorLanguages.find(c=>c===o)||null}};s.contentTypeToContentFormatMap={[r.JSON]:e.JSON,[r.CSV]:e.CSV,[r.XML]:e.XML,[r.HL7V2]:e.HL7},s.contentFormatToContentTypeMap={[e.JSON]:r.JSON,[e.CSV]:r.CSV,[e.XML]:r.XML,[e.HL7]:r.HL7V2,[e.UNKNOWN]:null},s.contentFormatToEditorLanguageMap={[e.JSON]:a.JSON,[e.XML]:a.XML,[e.CSV]:a.PLAINTEXT,[e.HL7]:a.PLAINTEXT,[e.UNKNOWN]:a.PLAINTEXT},s.contentFormats=[e.JSON,e.CSV,e.XML,e.HL7,e.UNKNOWN],s.contentTypes=[r.JSON,r.CSV,r.XML,r.HL7V2],s.editorLanguages=[a.JSON,a.XML,a.PLAINTEXT];var i=s;var y=n=>typeof n=="string"&&n.trimStart().startsWith("MSH|"),C=n=>{try{return JSON.parse(n),!0}catch(t){return  false}},L=n=>{let t=n,o={curlyBraces:(t.match(/[{}]/g)||[]).length,colons:(t.match(/:/g)||[]).length,keyValueStructure:/{[^}]*:[^}]*}/.test(n)},c=/{[^}]*"[^"]*"\s*:\s*/.test(n);return (o.curlyBraces>=2||o.curlyBraces>=1&&c)&&o.colons>=1&&(o.keyValueStructure||/{.*:.*}/.test(n)||c)},u=n=>{let t={openingTags:(n.match(/<[^/!?][^>]*?>/g)||[]).length,closingTags:(n.match(/<\/[^>]+>/g)||[]).length,selfClosingTags:(n.match(/<[^>]+\/>/g)||[]).length,xmlNamespaces:(n.match(/xmlns(:[a-zA-Z0-9]+)?=/g)||[]).length};return (/^<\?xml.*?\?>/.test(n)||t.xmlNamespaces>=1||t.openingTags>=1)&&(t.openingTags===t.closingTags||t.selfClosingTags>=1)},T=n=>{let t=n.split(/\r?\n/),o=t[0],c={rowCount:t.length,commaCounts:t.map(l=>(l.match(/,/g)||[]).length)},m={curlyBraces:(o.match(/[{}]/g)||[]).length,squareBrackets:(o.match(/[\[\]]/g)||[]).length,angularBrackets:(o.match(/[<>]/g)||[]).length,colons:(o.match(/:/g)||[]).length};return (c.rowCount>1||c.commaCounts.some(l=>l>0))&&m.curlyBraces===0&&m.squareBrackets===0&&m.angularBrackets===0&&m.colons===0},g=class g{detectContentType(t){let o=this.detectFormat(t);return g.typeConverter.contentFormatToContentType(o)}detectFormat(t){try{return (t==null?void 0:t.trim())?C(t)?e.JSON:y(t)?e.HL7:L(t)?e.JSON:u(t)?e.XML:T(t)?e.CSV:e.UNKNOWN:e.UNKNOWN}catch(o){return e.UNKNOWN}}detectEditorLanguage(t){switch(this.detectFormat(t)){case e.JSON:return a.JSON;case e.XML:return a.XML;default:return a.PLAINTEXT}}};g.typeConverter=new i;var p=g;exports.ContentFormat=e;exports.ContentType=r;exports.EditorLanguage=a;exports.FormatDetector=p;exports.TypeConverter=i;return exports;})({});//# sourceMappingURL=browser.js.map
+//# sourceMappingURL=browser.js.map

package/dist/browser.mjs

@@ -0,0 +1,2 @@
+var r={JSON:"application/json",CSV:"text/csv",XML:"application/xml",HL7V2:"x-application/hl7-v2+er7"};var e={JSON:"json",CSV:"csv",XML:"xml",HL7:"hl7",UNKNOWN:"unknown"};var a={JSON:"json",XML:"xml",PLAINTEXT:"plaintext"};var s=class s{contentTypeToContentFormat(t){return s.contentTypeToContentFormatMap[t]}contentTypeToEditorLanguage(t){let o=this.contentTypeToContentFormat(t);return this.contentFormatToEditorLanguage(o)}contentFormatToContentType(t){return s.contentFormatToContentTypeMap[t]||null}contentFormatToEditorLanguage(t){return s.contentFormatToEditorLanguageMap[t]}stringToContentFormat(t){let o=t.toLowerCase();return s.contentFormats.find(c=>c===o)||null}stringToContentType(t){let o=t.toLowerCase();return s.contentTypes.find(c=>o.startsWith(c))||null}stringToEditorLanguage(t){let o=t.toLowerCase();return s.editorLanguages.find(c=>c===o)||null}};s.contentTypeToContentFormatMap={[r.JSON]:e.JSON,[r.CSV]:e.CSV,[r.XML]:e.XML,[r.HL7V2]:e.HL7},s.contentFormatToContentTypeMap={[e.JSON]:r.JSON,[e.CSV]:r.CSV,[e.XML]:r.XML,[e.HL7]:r.HL7V2,[e.UNKNOWN]:null},s.contentFormatToEditorLanguageMap={[e.JSON]:a.JSON,[e.XML]:a.XML,[e.CSV]:a.PLAINTEXT,[e.HL7]:a.PLAINTEXT,[e.UNKNOWN]:a.PLAINTEXT},s.contentFormats=[e.JSON,e.CSV,e.XML,e.HL7,e.UNKNOWN],s.contentTypes=[r.JSON,r.CSV,r.XML,r.HL7V2],s.editorLanguages=[a.JSON,a.XML,a.PLAINTEXT];var i=s;var y=n=>typeof n=="string"&&n.trimStart().startsWith("MSH|"),C=n=>{try{return JSON.parse(n),!0}catch(t){return  false}},L=n=>{let t=n,o={curlyBraces:(t.match(/[{}]/g)||[]).length,colons:(t.match(/:/g)||[]).length,keyValueStructure:/{[^}]*:[^}]*}/.test(n)},c=/{[^}]*"[^"]*"\s*:\s*/.test(n);return (o.curlyBraces>=2||o.curlyBraces>=1&&c)&&o.colons>=1&&(o.keyValueStructure||/{.*:.*}/.test(n)||c)},u=n=>{let t={openingTags:(n.match(/<[^/!?][^>]*?>/g)||[]).length,closingTags:(n.match(/<\/[^>]+>/g)||[]).length,selfClosingTags:(n.match(/<[^>]+\/>/g)||[]).length,xmlNamespaces:(n.match(/xmlns(:[a-zA-Z0-9]+)?=/g)||[]).length};return (/^<\?xml.*?\?>/.test(n)||t.xmlNamespaces>=1||t.openingTags>=1)&&(t.openingTags===t.closingTags||t.selfClosingTags>=1)},T=n=>{let t=n.split(/\r?\n/),o=t[0],c={rowCount:t.length,commaCounts:t.map(l=>(l.match(/,/g)||[]).length)},m={curlyBraces:(o.match(/[{}]/g)||[]).length,squareBrackets:(o.match(/[\[\]]/g)||[]).length,angularBrackets:(o.match(/[<>]/g)||[]).length,colons:(o.match(/:/g)||[]).length};return (c.rowCount>1||c.commaCounts.some(l=>l>0))&&m.curlyBraces===0&&m.squareBrackets===0&&m.angularBrackets===0&&m.colons===0},g=class g{detectContentType(t){let o=this.detectFormat(t);return g.typeConverter.contentFormatToContentType(o)}detectFormat(t){try{return (t==null?void 0:t.trim())?C(t)?e.JSON:y(t)?e.HL7:L(t)?e.JSON:u(t)?e.XML:T(t)?e.CSV:e.UNKNOWN:e.UNKNOWN}catch(o){return e.UNKNOWN}}detectEditorLanguage(t){switch(this.detectFormat(t)){case e.JSON:return a.JSON;case e.XML:return a.XML;default:return a.PLAINTEXT}}};g.typeConverter=new i;var p=g;export{e as ContentFormat,r as ContentType,a as EditorLanguage,p as FormatDetector,i as TypeConverter};//# sourceMappingURL=browser.mjs.map
+//# sourceMappingURL=browser.mjs.map

package/dist/index.cjs

@@ -13,56 +13,92 @@ var HL7Dictionary__default = /*#__PURE__*/_interopDefault(HL7Dictionary);
 var hl7js__default = /*#__PURE__*/_interopDefault(hl7js);
 var jsonata__default = /*#__PURE__*/_interopDefault(jsonata);
 
+// src/types/ContentType.ts
+var ContentType = {
+  /** Standard MIME type for JSON data */
+  JSON: "application/json",
+  /** Standard MIME type for CSV data */
+  CSV: "text/csv",
+  /** Standard MIME type for XML data */
+  XML: "application/xml",
+  /** Custom MIME type for HL7 Version 2.x messages in ER7 encoding */
+  HL7V2: "x-application/hl7-v2+er7"
+};
+
+// src/types/ContentFormat.ts
+var ContentFormat = {
+  /** JavaScript Object Notation format */
+  JSON: "json",
+  /** Comma-Separated Values format */
+  CSV: "csv",
+  /** eXtensible Markup Language format */
+  XML: "xml",
+  /** Health Level 7 Version 2.x message format */
+  HL7: "hl7",
+  /** Unknown or unsupported format */
+  UNKNOWN: "unknown"
+};
+
+// src/types/EditorLanguage.ts
+var EditorLanguage = {
+  /** JSON language mode for syntax highlighting */
+  JSON: "json",
+  /** XML language mode for syntax highlighting */
+  XML: "xml",
+  /** Plain text mode with no syntax highlighting */
+  PLAINTEXT: "plaintext"
+};
+
 // src/TypeConverter.ts
 var TypeConverter = class _TypeConverter {
   static {
     this.contentTypeToContentFormatMap = {
-      ["application/json" /* JSON */]: "json" /* JSON */,
-      ["text/csv" /* CSV */]: "csv" /* CSV */,
-      ["application/xml" /* XML */]: "xml" /* XML */,
-      ["x-application/hl7-v2+er7" /* HL7V2 */]: "hl7" /* HL7 */
+      [ContentType.JSON]: ContentFormat.JSON,
+      [ContentType.CSV]: ContentFormat.CSV,
+      [ContentType.XML]: ContentFormat.XML,
+      [ContentType.HL7V2]: ContentFormat.HL7
     };
   }
   static {
     this.contentFormatToContentTypeMap = {
-      ["json" /* JSON */]: "application/json" /* JSON */,
-      ["csv" /* CSV */]: "text/csv" /* CSV */,
-      ["xml" /* XML */]: "application/xml" /* XML */,
-      ["hl7" /* HL7 */]: "x-application/hl7-v2+er7" /* HL7V2 */,
-      ["unknown" /* UNKNOWN */]: null
+      [ContentFormat.JSON]: ContentType.JSON,
+      [ContentFormat.CSV]: ContentType.CSV,
+      [ContentFormat.XML]: ContentType.XML,
+      [ContentFormat.HL7]: ContentType.HL7V2,
+      [ContentFormat.UNKNOWN]: null
     };
   }
   static {
     this.contentFormatToEditorLanguageMap = {
-      ["json" /* JSON */]: "json" /* JSON */,
-      ["xml" /* XML */]: "xml" /* XML */,
-      ["csv" /* CSV */]: "plaintext" /* PLAINTEXT */,
-      ["hl7" /* HL7 */]: "plaintext" /* PLAINTEXT */,
-      ["unknown" /* UNKNOWN */]: "plaintext" /* PLAINTEXT */
+      [ContentFormat.JSON]: EditorLanguage.JSON,
+      [ContentFormat.XML]: EditorLanguage.XML,
+      [ContentFormat.CSV]: EditorLanguage.PLAINTEXT,
+      [ContentFormat.HL7]: EditorLanguage.PLAINTEXT,
+      [ContentFormat.UNKNOWN]: EditorLanguage.PLAINTEXT
     };
   }
   static {
     this.contentFormats = [
-      "json" /* JSON */,
-      "csv" /* CSV */,
-      "xml" /* XML */,
-      "hl7" /* HL7 */,
-      "unknown" /* UNKNOWN */
+      ContentFormat.JSON,
+      ContentFormat.CSV,
+      ContentFormat.XML,
+      ContentFormat.HL7,
+      ContentFormat.UNKNOWN
     ];
   }
   static {
     this.contentTypes = [
-      "application/json" /* JSON */,
-      "text/csv" /* CSV */,
-      "application/xml" /* XML */,
-      "x-application/hl7-v2+er7" /* HL7V2 */
+      ContentType.JSON,
+      ContentType.CSV,
+      ContentType.XML,
+      ContentType.HL7V2
     ];
   }
   static {
     this.editorLanguages = [
-      "json" /* JSON */,
-      "xml" /* XML */,
-      "plaintext" /* PLAINTEXT */
+      EditorLanguage.JSON,
+      EditorLanguage.XML,
+      EditorLanguage.PLAINTEXT
     ];
   }
   contentTypeToContentFormat(contentType) {
@@ -547,29 +583,29 @@ var FormatConverter = class _FormatConverter {
   async toJson(input, contentType) {
     if (!contentType || contentType === "") {
       this.logger.info("No content type provided, defaulting to 'application/json'");
-      contentType = "application/json" /* JSON */;
+      contentType = ContentType.JSON;
     }
     const suggestedContentType = typeof contentType === "string" ? _FormatConverter.typeConverter.stringToContentType(contentType) : contentType;
     if (!suggestedContentType) {
-      throw new Error(`Unsupported Content-Type: ${suggestedContentType}`);
+      throw new Error(`Unsupported Content-Type: ${contentType}`);
     }
     let parsedJson;
-    if (suggestedContentType === "x-application/hl7-v2+er7" /* HL7V2 */) {
+    if (suggestedContentType === ContentType.HL7V2) {
       this.logger.info("Content-Type suggests HL7 V2.x message");
       this.logger.info("Trying to parse HL7 V2.x message as JSON...");
       parsedJson = await this.hl7v2ToJson(input);
       this.logger.info("Parsed HL7 V2.x message to JSON successfully.");
-    } else if (suggestedContentType === "text/csv" /* CSV */) {
+    } else if (suggestedContentType === ContentType.CSV) {
       this.logger.info("Content-Type suggests CSV input");
       this.logger.info("Trying to parse CSV as JSON...");
       parsedJson = await this.csvToJson(input);
       this.logger.info("Parsed CSV to JSON successfully.");
-    } else if (suggestedContentType === "application/xml" /* XML */) {
+    } else if (suggestedContentType === ContentType.XML) {
       this.logger.info("Content-Type suggests XML input");
       this.logger.info("Trying to parse XML as JSON...");
       parsedJson = await this.xmlToJson(input);
       this.logger.info("Parsed XML to JSON successfully.");
-    } else if (suggestedContentType === "application/json" /* JSON */) {
+    } else if (suggestedContentType === ContentType.JSON) {
       this.logger.info("Content-Type suggests JSON input");
       parsedJson = input;
       this.logger.info("Parsed input to JSON successfully.");
@@ -643,26 +679,26 @@ var FormatDetector = class _FormatDetector {
   detectFormat(input) {
     try {
       const trimmedInput = input?.trim();
-      if (!trimmedInput) return "unknown" /* UNKNOWN */;
-      if (isValidJson(input)) return "json" /* JSON */;
-      if (isPossiblyHL7(input)) return "hl7" /* HL7 */;
-      if (isJsonLikely(input)) return "json" /* JSON */;
-      if (isXmlLikely(input)) return "xml" /* XML */;
-      if (isCsvLikely(input)) return "csv" /* CSV */;
-      return "unknown" /* UNKNOWN */;
+      if (!trimmedInput) return ContentFormat.UNKNOWN;
+      if (isValidJson(input)) return ContentFormat.JSON;
+      if (isPossiblyHL7(input)) return ContentFormat.HL7;
+      if (isJsonLikely(input)) return ContentFormat.JSON;
+      if (isXmlLikely(input)) return ContentFormat.XML;
+      if (isCsvLikely(input)) return ContentFormat.CSV;
+      return ContentFormat.UNKNOWN;
     } catch (e) {
-      return "unknown" /* UNKNOWN */;
+      return ContentFormat.UNKNOWN;
     }
   }
   detectEditorLanguage(input) {
     const format = this.detectFormat(input);
     switch (format) {
-      case "json" /* JSON */:
-        return "json" /* JSON */;
-      case "xml" /* XML */:
-        return "xml" /* XML */;
+      case ContentFormat.JSON:
+        return EditorLanguage.JSON;
+      case ContentFormat.XML:
+        return EditorLanguage.XML;
       default:
-        return "plaintext" /* PLAINTEXT */;
+        return EditorLanguage.PLAINTEXT;
     }
   }
 };

package/dist/index.d.ts

@@ -9,48 +9,51 @@ interface ILogger {
  * Used by format detection algorithms to categorize input data and determine
  * appropriate conversion strategies.
  */
-declare const enum ContentFormat {
+declare const ContentFormat: {
     /** JavaScript Object Notation format */
-    JSON = "json",
+    readonly JSON: "json";
     /** Comma-Separated Values format */
-    CSV = "csv",
+    readonly CSV: "csv";
     /** eXtensible Markup Language format */
-    XML = "xml",
+    readonly XML: "xml";
     /** Health Level 7 Version 2.x message format */
-    HL7 = "hl7",
+    readonly HL7: "hl7";
     /** Unknown or unsupported format */
-    UNKNOWN = "unknown"
-}
+    readonly UNKNOWN: "unknown";
+};
+type ContentFormat = typeof ContentFormat[keyof typeof ContentFormat];
 
 /**
  * Enumeration of supported MIME types/content types for data format identification.
  * These values correspond to standard HTTP Content-Type header values and are used
  * for format detection and conversion operations.
  */
-declare const enum ContentType {
+declare const ContentType: {
     /** Standard MIME type for JSON data */
-    JSON = "application/json",
+    readonly JSON: "application/json";
     /** Standard MIME type for CSV data */
-    CSV = "text/csv",
+    readonly CSV: "text/csv";
     /** Standard MIME type for XML data */
-    XML = "application/xml",
+    readonly XML: "application/xml";
     /** Custom MIME type for HL7 Version 2.x messages in ER7 encoding */
-    HL7V2 = "x-application/hl7-v2+er7"
-}
+    readonly HL7V2: "x-application/hl7-v2+er7";
+};
+type ContentType = typeof ContentType[keyof typeof ContentType];
 
 /**
  * Enumeration of supported editor language identifiers for syntax highlighting and editor configuration.
  * These values are used to determine the appropriate language mode for displaying content
  * in code editors or other text editing interfaces.
  */
-declare const enum EditorLanguage {
+declare const EditorLanguage: {
     /** JSON language mode for syntax highlighting */
-    JSON = "json",
+    readonly JSON: "json";
     /** XML language mode for syntax highlighting */
-    XML = "xml",
+    readonly XML: "xml";
     /** Plain text mode with no syntax highlighting */
-    PLAINTEXT = "plaintext"
-}
+    readonly PLAINTEXT: "plaintext";
+};
+type EditorLanguage = typeof EditorLanguage[keyof typeof EditorLanguage];
 
 /**
  * Interface for format detection operations, providing methods to analyze and identify
@@ -177,6 +180,18 @@ declare class TypeConverter implements ITypeConverter {
     stringToEditorLanguage(editorLanguage: string): EditorLanguage | null;
 }
 
+/**
+ * A format converter that transforms various input formats to JSON.
+ *
+ * Supports conversion from multiple content types including HL7 V2.x messages,
+ * CSV data, XML documents, and JSON strings to standardized JSON format.
+ *
+ * @example
+ * ```typescript
+ * const converter = new FormatConverter(logger);
+ * const jsonData = await converter.toJson(csvInput, ContentType.CSV);
+ * ```
+ */
 declare class FormatConverter implements IFormatConverter {
     private static readonly typeConverter;
     private logger;
@@ -187,6 +202,23 @@ declare class FormatConverter implements IFormatConverter {
     hl7v2ToJson: (message: string) => Promise<any>;
 }
 
+/**
+ * A service class responsible for detecting and identifying various content formats and types.
+ *
+ * The FormatDetector analyzes input strings to determine their format (JSON, XML, CSV, HL7, etc.)
+ * and provides corresponding content types and editor language mappings. It uses a series of
+ * validation functions to identify the most likely format of the input data.
+ *
+ * @example
+ * ```typescript
+ * const detector = new FormatDetector();
+ * const format = detector.detectFormat('{"key": "value"}');
+ * // Returns: ContentFormat.JSON
+ *
+ * const contentType = detector.detectContentType('<root></root>');
+ * // Returns: ContentType corresponding to XML format
+ * ```
+ */
 declare class FormatDetector implements IFormatDetector {
     private static readonly typeConverter;
     detectContentType(input: string): ContentType | null;

package/dist/index.mjs

@@ -4,56 +4,92 @@ import HL7Dictionary from 'hl7-dictionary';
 import hl7js from 'hl7js';
 import jsonata from 'jsonata';
 
+// src/types/ContentType.ts
+var ContentType = {
+  /** Standard MIME type for JSON data */
+  JSON: "application/json",
+  /** Standard MIME type for CSV data */
+  CSV: "text/csv",
+  /** Standard MIME type for XML data */
+  XML: "application/xml",
+  /** Custom MIME type for HL7 Version 2.x messages in ER7 encoding */
+  HL7V2: "x-application/hl7-v2+er7"
+};
+
+// src/types/ContentFormat.ts
+var ContentFormat = {
+  /** JavaScript Object Notation format */
+  JSON: "json",
+  /** Comma-Separated Values format */
+  CSV: "csv",
+  /** eXtensible Markup Language format */
+  XML: "xml",
+  /** Health Level 7 Version 2.x message format */
+  HL7: "hl7",
+  /** Unknown or unsupported format */
+  UNKNOWN: "unknown"
+};
+
+// src/types/EditorLanguage.ts
+var EditorLanguage = {
+  /** JSON language mode for syntax highlighting */
+  JSON: "json",
+  /** XML language mode for syntax highlighting */
+  XML: "xml",
+  /** Plain text mode with no syntax highlighting */
+  PLAINTEXT: "plaintext"
+};
+
 // src/TypeConverter.ts
 var TypeConverter = class _TypeConverter {
   static {
     this.contentTypeToContentFormatMap = {
-      ["application/json" /* JSON */]: "json" /* JSON */,
-      ["text/csv" /* CSV */]: "csv" /* CSV */,
-      ["application/xml" /* XML */]: "xml" /* XML */,
-      ["x-application/hl7-v2+er7" /* HL7V2 */]: "hl7" /* HL7 */
+      [ContentType.JSON]: ContentFormat.JSON,
+      [ContentType.CSV]: ContentFormat.CSV,
+      [ContentType.XML]: ContentFormat.XML,
+      [ContentType.HL7V2]: ContentFormat.HL7
     };
   }
   static {
     this.contentFormatToContentTypeMap = {
-      ["json" /* JSON */]: "application/json" /* JSON */,
-      ["csv" /* CSV */]: "text/csv" /* CSV */,
-      ["xml" /* XML */]: "application/xml" /* XML */,
-      ["hl7" /* HL7 */]: "x-application/hl7-v2+er7" /* HL7V2 */,
-      ["unknown" /* UNKNOWN */]: null
+      [ContentFormat.JSON]: ContentType.JSON,
+      [ContentFormat.CSV]: ContentType.CSV,
+      [ContentFormat.XML]: ContentType.XML,
+      [ContentFormat.HL7]: ContentType.HL7V2,
+      [ContentFormat.UNKNOWN]: null
     };
   }
   static {
     this.contentFormatToEditorLanguageMap = {
-      ["json" /* JSON */]: "json" /* JSON */,
-      ["xml" /* XML */]: "xml" /* XML */,
-      ["csv" /* CSV */]: "plaintext" /* PLAINTEXT */,
-      ["hl7" /* HL7 */]: "plaintext" /* PLAINTEXT */,
-      ["unknown" /* UNKNOWN */]: "plaintext" /* PLAINTEXT */
+      [ContentFormat.JSON]: EditorLanguage.JSON,
+      [ContentFormat.XML]: EditorLanguage.XML,
+      [ContentFormat.CSV]: EditorLanguage.PLAINTEXT,
+      [ContentFormat.HL7]: EditorLanguage.PLAINTEXT,
+      [ContentFormat.UNKNOWN]: EditorLanguage.PLAINTEXT
     };
   }
   static {
     this.contentFormats = [
-      "json" /* JSON */,
-      "csv" /* CSV */,
-      "xml" /* XML */,
-      "hl7" /* HL7 */,
-      "unknown" /* UNKNOWN */
+      ContentFormat.JSON,
+      ContentFormat.CSV,
+      ContentFormat.XML,
+      ContentFormat.HL7,
+      ContentFormat.UNKNOWN
     ];
   }
   static {
     this.contentTypes = [
-      "application/json" /* JSON */,
-      "text/csv" /* CSV */,
-      "application/xml" /* XML */,
-      "x-application/hl7-v2+er7" /* HL7V2 */
+      ContentType.JSON,
+      ContentType.CSV,
+      ContentType.XML,
+      ContentType.HL7V2
     ];
   }
   static {
     this.editorLanguages = [
-      "json" /* JSON */,
-      "xml" /* XML */,
-      "plaintext" /* PLAINTEXT */
+      EditorLanguage.JSON,
+      EditorLanguage.XML,
+      EditorLanguage.PLAINTEXT
     ];
   }
   contentTypeToContentFormat(contentType) {
@@ -538,29 +574,29 @@ var FormatConverter = class _FormatConverter {
   async toJson(input, contentType) {
     if (!contentType || contentType === "") {
       this.logger.info("No content type provided, defaulting to 'application/json'");
-      contentType = "application/json" /* JSON */;
+      contentType = ContentType.JSON;
     }
     const suggestedContentType = typeof contentType === "string" ? _FormatConverter.typeConverter.stringToContentType(contentType) : contentType;
     if (!suggestedContentType) {
-      throw new Error(`Unsupported Content-Type: ${suggestedContentType}`);
+      throw new Error(`Unsupported Content-Type: ${contentType}`);
     }
     let parsedJson;
-    if (suggestedContentType === "x-application/hl7-v2+er7" /* HL7V2 */) {
+    if (suggestedContentType === ContentType.HL7V2) {
       this.logger.info("Content-Type suggests HL7 V2.x message");
       this.logger.info("Trying to parse HL7 V2.x message as JSON...");
       parsedJson = await this.hl7v2ToJson(input);
       this.logger.info("Parsed HL7 V2.x message to JSON successfully.");
-    } else if (suggestedContentType === "text/csv" /* CSV */) {
+    } else if (suggestedContentType === ContentType.CSV) {
       this.logger.info("Content-Type suggests CSV input");
       this.logger.info("Trying to parse CSV as JSON...");
       parsedJson = await this.csvToJson(input);
       this.logger.info("Parsed CSV to JSON successfully.");
-    } else if (suggestedContentType === "application/xml" /* XML */) {
+    } else if (suggestedContentType === ContentType.XML) {
       this.logger.info("Content-Type suggests XML input");
       this.logger.info("Trying to parse XML as JSON...");
       parsedJson = await this.xmlToJson(input);
       this.logger.info("Parsed XML to JSON successfully.");
-    } else if (suggestedContentType === "application/json" /* JSON */) {
+    } else if (suggestedContentType === ContentType.JSON) {
       this.logger.info("Content-Type suggests JSON input");
       parsedJson = input;
       this.logger.info("Parsed input to JSON successfully.");
@@ -634,26 +670,26 @@ var FormatDetector = class _FormatDetector {
   detectFormat(input) {
     try {
       const trimmedInput = input?.trim();
-      if (!trimmedInput) return "unknown" /* UNKNOWN */;
-      if (isValidJson(input)) return "json" /* JSON */;
-      if (isPossiblyHL7(input)) return "hl7" /* HL7 */;
-      if (isJsonLikely(input)) return "json" /* JSON */;
-      if (isXmlLikely(input)) return "xml" /* XML */;
-      if (isCsvLikely(input)) return "csv" /* CSV */;
-      return "unknown" /* UNKNOWN */;
+      if (!trimmedInput) return ContentFormat.UNKNOWN;
+      if (isValidJson(input)) return ContentFormat.JSON;
+      if (isPossiblyHL7(input)) return ContentFormat.HL7;
+      if (isJsonLikely(input)) return ContentFormat.JSON;
+      if (isXmlLikely(input)) return ContentFormat.XML;
+      if (isCsvLikely(input)) return ContentFormat.CSV;
+      return ContentFormat.UNKNOWN;
     } catch (e) {
-      return "unknown" /* UNKNOWN */;
+      return ContentFormat.UNKNOWN;
     }
   }
   detectEditorLanguage(input) {
     const format = this.detectFormat(input);
     switch (format) {
-      case "json" /* JSON */:
-        return "json" /* JSON */;
-      case "xml" /* XML */:
-        return "xml" /* XML */;
+      case ContentFormat.JSON:
+        return EditorLanguage.JSON;
+      case ContentFormat.XML:
+        return EditorLanguage.XML;
       default:
-        return "plaintext" /* PLAINTEXT */;
+        return EditorLanguage.PLAINTEXT;
     }
   }
 };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@outburn/format-converter",
-  "version": "1.0.5",
+  "version": "2.0.0",
   "description": "A TypeScript library for converting between various data formats including CSV, XML, HL7 v2, and JSON with specialized healthcare message parsing",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
-  "browser": "./dist/browser.js",
+  "browser": "./dist/browser.mjs",
   "types": "./dist/index.d.ts",
   "type": "module",
   "exports": {
@@ -13,7 +13,11 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
     },
-    "./browser": "./dist/browser.js"
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.mjs",
+      "default": "./dist/browser.mjs"
+    }
   },
   "scripts": {
     "clean": "rimraf dist",
@@ -26,6 +30,7 @@
   "files": [
     "dist/**/*.cjs",
     "dist/**/*.mjs",
+    "dist/**/*.js",
     "dist/**/*.d.ts",
     "README.md",
     "LICENSE"
@@ -53,20 +58,20 @@
   "license": "MIT",
   "dependencies": {
     "csvtojson": "^2.0.14",
-    "fast-xml-parser": "^4.5.3",
+    "fast-xml-parser": "^5.3.4",
     "hl7-dictionary": "^1.0.1",
     "hl7js": "^0.0.6",
     "jsonata": "^2.1.0"
   },
   "devDependencies": {
-    "@types/node": "^24.10.1",
-    "eslint": "^9.39.1",
+    "@types/node": "^25.2.0",
+    "eslint": "^9.39.2",
     "rimraf": "^6.1.2",
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.48.1",
-    "vitest": "^4.0.15"
+    "typescript-eslint": "^8.54.0",
+    "vitest": "^4.0.18"
   },
   "repository": {
     "type": "git",