@tomgiee/tsdp 1.0.0

package/dist/src/utils/format-validators.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Format validators for SDP (RFC 8866)
+ *
+ * Validates email, phone, and URI formats per RFC 8866 Section 5.5, 5.6 and Section 9 (Grammar)
+ */
+/**
+ * Validate email address format per RFC 8866 Section 9
+ *
+ * email-address = address-and-comment / dispname-and-address / addr-spec
+ * address-and-comment = addr-spec 1*SP "(" 1*email-safe ")"
+ * dispname-and-address = 1*email-safe 1*SP "<" addr-spec ">"
+ *
+ * @param input - Email field value
+ * @returns true if format is valid
+ */
+export declare function isValidEmailFormat(input: string): boolean;
+/**
+ * Parse email components
+ *
+ * @param input - Email field value
+ * @returns Parsed components or null if invalid
+ */
+export declare function parseEmailComponents(input: string): {
+    email: string;
+    displayName?: string;
+} | null;
+/**
+ * Validate phone number format per RFC 8866 Section 9
+ *
+ * phone-number = phone *SP "(" 1*email-safe ")" /
+ *                1*email-safe "<" phone ">" /
+ *                phone
+ *
+ * @param input - Phone field value
+ * @returns true if format is valid
+ */
+export declare function isValidPhoneFormat(input: string): boolean;
+/**
+ * Parse phone components
+ *
+ * @param input - Phone field value
+ * @returns Parsed components or null if invalid
+ */
+export declare function parsePhoneComponents(input: string): {
+    phone: string;
+    displayName?: string;
+} | null;
+/**
+ * Validate URI-reference format per RFC 3986
+ *
+ * URI-reference = URI / relative-ref
+ * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+ * relative-ref = relative-part [ "?" query ] [ "#" fragment ]
+ *
+ * This is a simplified validation that checks:
+ * 1. All characters are valid URI characters
+ * 2. If there's a scheme, it's properly formatted
+ * 3. Percent-encoding is valid (% followed by two hex digits)
+ * 4. No control characters or spaces
+ *
+ * @param input - URI field value
+ * @returns true if format is valid
+ */
+export declare function isValidURIReference(input: string): boolean;
+/**
+ * Parse URI components
+ *
+ * Extracts scheme and the rest of the URI if present
+ *
+ * @param input - URI field value
+ * @returns Parsed components or null if invalid
+ */
+export declare function parseURIComponents(input: string): {
+    scheme?: string;
+    rest: string;
+} | null;
+//# sourceMappingURL=format-validators.d.ts.map

package/dist/src/utils/format-validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-validators.d.ts","sourceRoot":"","sources":["../../../src/utils/format-validators.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAgJH;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAmCzD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,GACZ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAkChD;AAiDD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAqBzD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,GACZ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAgChD;AAuHD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CA2C1D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,GACZ;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAuB1C"}

package/dist/src/utils/format-validators.js

@@ -0,0 +1,504 @@
+"use strict";
+/**
+ * Format validators for SDP (RFC 8866)
+ *
+ * Validates email, phone, and URI formats per RFC 8866 Section 5.5, 5.6 and Section 9 (Grammar)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidEmailFormat = isValidEmailFormat;
+exports.parseEmailComponents = parseEmailComponents;
+exports.isValidPhoneFormat = isValidPhoneFormat;
+exports.parsePhoneComponents = parsePhoneComponents;
+exports.isValidURIReference = isValidURIReference;
+exports.parseURIComponents = parseURIComponents;
+// ============================================================================
+// Email-safe Character Validation
+// ============================================================================
+/**
+ * Check if a character is email-safe per RFC 8866 Section 9
+ *
+ * email-safe = %x01-09/%x0B-0C/%x0E-27/%x2A-3B/%x3D/%x3F-FF
+ * (any byte except NUL, CR, LF, or the quoting characters ()<>)
+ *
+ * @param ch - Character to check
+ * @returns true if character is email-safe
+ */
+function isEmailSafe(ch) {
+    const code = ch.charCodeAt(0);
+    return ((code >= 0x01 && code <= 0x09) || // %x01-09
+        (code >= 0x0b && code <= 0x0c) || // %x0B-0C
+        (code >= 0x0e && code <= 0x27) || // %x0E-27 (includes most printable chars except ()
+        (code >= 0x2a && code <= 0x3b) || // %x2A-3B (includes *, +, -, ., digits, :, ;)
+        code === 0x3d || // %x3D (=)
+        (code >= 0x3f && code <= 0xff) // %x3F-FF (includes ?, @, A-Z, a-z, etc.)
+    );
+}
+/**
+ * Check if an entire string is email-safe
+ */
+function isEmailSafeString(str) {
+    for (const ch of str) {
+        if (!isEmailSafe(ch)) {
+            return false;
+        }
+    }
+    return str.length > 0;
+}
+// ============================================================================
+// ReDoS-safe Format Parsing Helpers
+// ============================================================================
+/**
+ * Parse "display <content>" format without regex to avoid ReDoS
+ * @param input - String to parse
+ * @param requireSpaceBeforeOpen - Whether space is required before <
+ * @returns Parsed parts or null if invalid format
+ */
+function parseAngleBracketFormat(input, requireSpaceBeforeOpen) {
+    // Must end with >
+    if (!input.endsWith('>'))
+        return null;
+    // Find the last < (in case display name contains <, though it shouldn't)
+    const openIdx = input.lastIndexOf('<');
+    if (openIdx === -1 || openIdx === 0)
+        return null;
+    const content = input.substring(openIdx + 1, input.length - 1);
+    if (content.length === 0)
+        return null;
+    const beforeOpen = input.substring(0, openIdx);
+    const display = beforeOpen.trimEnd();
+    if (display.length === 0)
+        return null;
+    // Check if there's whitespace before < when required
+    if (requireSpaceBeforeOpen) {
+        if (beforeOpen.length === display.length) {
+            // No trailing whitespace found
+            return null;
+        }
+    }
+    return { display, content };
+}
+/**
+ * Parse "content (comment)" format without regex to avoid ReDoS
+ * @param input - String to parse
+ * @returns Parsed parts or null if invalid format
+ */
+function parseParenthesisFormat(input) {
+    // Must end with )
+    if (!input.endsWith(')'))
+        return null;
+    // Find the last (
+    const openIdx = input.lastIndexOf('(');
+    if (openIdx === -1 || openIdx === 0)
+        return null;
+    const comment = input.substring(openIdx + 1, input.length - 1);
+    if (comment.length === 0)
+        return null;
+    const content = input.substring(0, openIdx).trimEnd();
+    if (content.length === 0)
+        return null;
+    return { content, comment };
+}
+// ============================================================================
+// Email Format Validation (RFC 8866 Section 5.6, Section 9)
+// ============================================================================
+/**
+ * Basic addr-spec validation
+ *
+ * This is a simplified validation for RFC 5322 addr-spec.
+ * Full RFC 5322 addr-spec parsing is complex; this validates the common pattern.
+ *
+ * @param email - Email address to validate
+ * @returns true if appears to be a valid email addr-spec
+ */
+function isValidAddrSpec(email) {
+    // Basic pattern: local-part@domain
+    // Must have exactly one @ not at start or end
+    const atIndex = email.indexOf('@');
+    if (atIndex <= 0 || atIndex === email.length - 1) {
+        return false;
+    }
+    // Check no second @
+    if (email.indexOf('@', atIndex + 1) !== -1) {
+        return false;
+    }
+    const localPart = email.substring(0, atIndex);
+    const domain = email.substring(atIndex + 1);
+    // Local part and domain must not be empty
+    if (localPart.length === 0 || domain.length === 0) {
+        return false;
+    }
+    // Domain must have at least one character and no leading/trailing dots
+    if (domain.startsWith('.') || domain.endsWith('.')) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Validate email address format per RFC 8866 Section 9
+ *
+ * email-address = address-and-comment / dispname-and-address / addr-spec
+ * address-and-comment = addr-spec 1*SP "(" 1*email-safe ")"
+ * dispname-and-address = 1*email-safe 1*SP "<" addr-spec ">"
+ *
+ * @param input - Email field value
+ * @returns true if format is valid
+ */
+function isValidEmailFormat(input) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return false;
+    }
+    // Check for dispname-and-address format: Display Name <email@domain>
+    // Must have at least one character before the angle brackets (1*email-safe)
+    const angleParsed = parseAngleBracketFormat(trimmed, true);
+    if (angleParsed) {
+        return isEmailSafeString(angleParsed.display) && isValidAddrSpec(angleParsed.content);
+    }
+    // Reject angle brackets without proper format (e.g., "<email@domain>" without display name)
+    if (trimmed.includes('<') || trimmed.includes('>')) {
+        return false;
+    }
+    // Check for address-and-comment format: email@domain (Display Name)
+    const parenParsed = parseParenthesisFormat(trimmed);
+    if (parenParsed) {
+        // Content must not contain whitespace (it's an addr-spec)
+        if (/\s/.test(parenParsed.content)) {
+            return false;
+        }
+        return isValidAddrSpec(parenParsed.content) && isEmailSafeString(parenParsed.comment);
+    }
+    // Reject unclosed or empty parentheses
+    if (trimmed.includes('(') || trimmed.includes(')')) {
+        return false;
+    }
+    // Plain addr-spec format: email@domain
+    return isValidAddrSpec(trimmed);
+}
+/**
+ * Parse email components
+ *
+ * @param input - Email field value
+ * @returns Parsed components or null if invalid
+ */
+function parseEmailComponents(input) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    // Check for dispname-and-address format: Display Name <email@domain>
+    const angleParsed = parseAngleBracketFormat(trimmed, true);
+    if (angleParsed) {
+        if (isEmailSafeString(angleParsed.display) && isValidAddrSpec(angleParsed.content)) {
+            return { email: angleParsed.content, displayName: angleParsed.display };
+        }
+        return null;
+    }
+    // Check for address-and-comment format: email@domain (Display Name)
+    const parenParsed = parseParenthesisFormat(trimmed);
+    if (parenParsed) {
+        // Content must not contain whitespace (it's an addr-spec)
+        if (/\s/.test(parenParsed.content)) {
+            return null;
+        }
+        if (isValidAddrSpec(parenParsed.content) && isEmailSafeString(parenParsed.comment)) {
+            return { email: parenParsed.content, displayName: parenParsed.comment };
+        }
+        return null;
+    }
+    // Plain addr-spec format: email@domain
+    if (isValidAddrSpec(trimmed)) {
+        return { email: trimmed };
+    }
+    return null;
+}
+// ============================================================================
+// Phone Format Validation (RFC 8866 Section 5.6, Section 9)
+// ============================================================================
+/**
+ * Validate phone number format per RFC 8866 Section 9
+ *
+ * phone = ["+"] DIGIT 1*(SP / "-" / DIGIT)
+ *
+ * A phone must:
+ * - Optionally start with "+"
+ * - Have at least one digit after optional "+"
+ * - Contain only digits, spaces, and hyphens after the first digit
+ *
+ * @param phone - Phone number to validate
+ * @returns true if format is valid
+ */
+function isValidPhone(phone) {
+    if (phone.length === 0) {
+        return false;
+    }
+    let index = 0;
+    // Optional leading "+"
+    if (phone[index] === '+') {
+        index++;
+    }
+    // Must have at least one digit
+    if (index >= phone.length || !/[0-9]/.test(phone[index])) {
+        return false;
+    }
+    index++;
+    // Rest must be digits, spaces, or hyphens (1*(SP / "-" / DIGIT))
+    while (index < phone.length) {
+        const ch = phone[index];
+        if (ch !== ' ' && ch !== '-' && !/[0-9]/.test(ch)) {
+            return false;
+        }
+        index++;
+    }
+    return true;
+}
+/**
+ * Validate phone number format per RFC 8866 Section 9
+ *
+ * phone-number = phone *SP "(" 1*email-safe ")" /
+ *                1*email-safe "<" phone ">" /
+ *                phone
+ *
+ * @param input - Phone field value
+ * @returns true if format is valid
+ */
+function isValidPhoneFormat(input) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return false;
+    }
+    // Check for dispname-and-phone format: Display Name <+1 555 1234>
+    // Space before < is optional for phone format
+    const angleParsed = parseAngleBracketFormat(trimmed, false);
+    if (angleParsed) {
+        return isEmailSafeString(angleParsed.display) && isValidPhone(angleParsed.content.trim());
+    }
+    // Check for phone-and-comment format: +1 555 1234 (Display Name)
+    const parenParsed = parseParenthesisFormat(trimmed);
+    if (parenParsed) {
+        return isValidPhone(parenParsed.content) && isEmailSafeString(parenParsed.comment);
+    }
+    // Plain phone format: +1 555 1234
+    return isValidPhone(trimmed);
+}
+/**
+ * Parse phone components
+ *
+ * @param input - Phone field value
+ * @returns Parsed components or null if invalid
+ */
+function parsePhoneComponents(input) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    // Check for dispname-and-phone format: Display Name <+1 555 1234>
+    // Space before < is optional for phone format
+    const angleParsed = parseAngleBracketFormat(trimmed, false);
+    if (angleParsed) {
+        const phone = angleParsed.content.trim();
+        if (isEmailSafeString(angleParsed.display) && isValidPhone(phone)) {
+            return { phone, displayName: angleParsed.display };
+        }
+        return null;
+    }
+    // Check for phone-and-comment format: +1 555 1234 (Display Name)
+    const parenParsed = parseParenthesisFormat(trimmed);
+    if (parenParsed) {
+        if (isValidPhone(parenParsed.content) && isEmailSafeString(parenParsed.comment)) {
+            return { phone: parenParsed.content, displayName: parenParsed.comment };
+        }
+        return null;
+    }
+    // Plain phone format: +1 555 1234
+    if (isValidPhone(trimmed)) {
+        return { phone: trimmed };
+    }
+    return null;
+}
+// ============================================================================
+// URI Format Validation (RFC 8866 Section 5.5, RFC 3986)
+// ============================================================================
+/**
+ * Check if a character is valid in a URI per RFC 3986
+ *
+ * Valid URI characters include:
+ * - unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * - reserved = gen-delims / sub-delims
+ * - gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"
+ * - sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * - pct-encoded = "%" HEXDIG HEXDIG
+ *
+ * @param ch - Character to check
+ * @returns true if character is valid in a URI
+ */
+function isURIChar(ch) {
+    const code = ch.charCodeAt(0);
+    // ALPHA (A-Z, a-z)
+    if ((code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a)) {
+        return true;
+    }
+    // DIGIT (0-9)
+    if (code >= 0x30 && code <= 0x39) {
+        return true;
+    }
+    // unreserved: - . _ ~
+    if (ch === '-' || ch === '.' || ch === '_' || ch === '~') {
+        return true;
+    }
+    // gen-delims: : / ? # [ ] @
+    if (ch === ':' || ch === '/' || ch === '?' || ch === '#' || ch === '[' || ch === ']' || ch === '@') {
+        return true;
+    }
+    // sub-delims: ! $ & ' ( ) * + , ; =
+    if (ch === '!' || ch === '$' || ch === '&' || ch === "'" || ch === '(' || ch === ')' ||
+        ch === '*' || ch === '+' || ch === ',' || ch === ';' || ch === '=') {
+        return true;
+    }
+    // percent-encoding marker
+    if (ch === '%') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if a string is a valid URI scheme per RFC 3986
+ *
+ * scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+ *
+ * @param scheme - Potential scheme string
+ * @returns true if valid scheme
+ */
+function isValidScheme(scheme) {
+    if (scheme.length === 0) {
+        return false;
+    }
+    // First character must be ALPHA
+    const firstCode = scheme.charCodeAt(0);
+    if (!((firstCode >= 0x41 && firstCode <= 0x5a) || (firstCode >= 0x61 && firstCode <= 0x7a))) {
+        return false;
+    }
+    // Rest must be ALPHA / DIGIT / "+" / "-" / "."
+    for (let i = 1; i < scheme.length; i++) {
+        const code = scheme.charCodeAt(i);
+        const ch = scheme[i];
+        if (!((code >= 0x41 && code <= 0x5a) || // A-Z
+            (code >= 0x61 && code <= 0x7a) || // a-z
+            (code >= 0x30 && code <= 0x39) || // 0-9
+            ch === '+' || ch === '-' || ch === '.')) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Validate percent-encoding in a URI
+ *
+ * Checks that all % characters are followed by exactly two hex digits
+ *
+ * @param uri - URI string to check
+ * @returns true if all percent-encoding is valid
+ */
+function hasValidPercentEncoding(uri) {
+    let i = 0;
+    while (i < uri.length) {
+        if (uri[i] === '%') {
+            // Must be followed by exactly two hex digits
+            if (i + 2 >= uri.length) {
+                return false;
+            }
+            const hex1 = uri[i + 1];
+            const hex2 = uri[i + 2];
+            if (!/[0-9A-Fa-f]/.test(hex1) || !/[0-9A-Fa-f]/.test(hex2)) {
+                return false;
+            }
+            i += 3;
+        }
+        else {
+            i++;
+        }
+    }
+    return true;
+}
+/**
+ * Validate URI-reference format per RFC 3986
+ *
+ * URI-reference = URI / relative-ref
+ * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+ * relative-ref = relative-part [ "?" query ] [ "#" fragment ]
+ *
+ * This is a simplified validation that checks:
+ * 1. All characters are valid URI characters
+ * 2. If there's a scheme, it's properly formatted
+ * 3. Percent-encoding is valid (% followed by two hex digits)
+ * 4. No control characters or spaces
+ *
+ * @param input - URI field value
+ * @returns true if format is valid
+ */
+function isValidURIReference(input) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return false;
+    }
+    // Check for control characters or spaces (not allowed)
+    for (const ch of trimmed) {
+        const code = ch.charCodeAt(0);
+        if (code <= 0x20 || code === 0x7f) {
+            return false;
+        }
+    }
+    // Check all characters are valid URI characters
+    for (const ch of trimmed) {
+        if (!isURIChar(ch)) {
+            return false;
+        }
+    }
+    // Check percent-encoding is valid
+    if (!hasValidPercentEncoding(trimmed)) {
+        return false;
+    }
+    // Check if there's a scheme (look for first ":")
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex > 0) {
+        // Potential scheme - validate it
+        const potentialScheme = trimmed.substring(0, colonIndex);
+        // If the potential scheme contains / or @ or ?, it's not a scheme
+        // (it's part of a relative reference like //host or path/to/file)
+        if (!potentialScheme.includes('/') && !potentialScheme.includes('@') && !potentialScheme.includes('?')) {
+            // This looks like a scheme, validate it
+            if (!isValidScheme(potentialScheme)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Parse URI components
+ *
+ * Extracts scheme and the rest of the URI if present
+ *
+ * @param input - URI field value
+ * @returns Parsed components or null if invalid
+ */
+function parseURIComponents(input) {
+    if (!isValidURIReference(input)) {
+        return null;
+    }
+    const trimmed = input.trim();
+    // Check if there's a scheme
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex > 0) {
+        const potentialScheme = trimmed.substring(0, colonIndex);
+        if (!potentialScheme.includes('/') && !potentialScheme.includes('@') && !potentialScheme.includes('?')) {
+            if (isValidScheme(potentialScheme)) {
+                return {
+                    scheme: potentialScheme,
+                    rest: trimmed.substring(colonIndex + 1),
+                };
+            }
+        }
+    }
+    // Relative reference (no scheme)
+    return { rest: trimmed };
+}

package/dist/src/utils/line-reader.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Line reading utilities for SDP (RFC 8866)
+ *
+ * RFC 8866 specifies CRLF as the standard line terminator, but parsers
+ * SHOULD accept LF alone for robustness. This module handles all three
+ * cases: CRLF, LF, and CR.
+ */
+/**
+ * Parsed line structure
+ */
+export interface ParsedLine {
+    /** Line type (single character before '=') */
+    readonly type: string;
+    /** Line value (everything after '=') */
+    readonly value: string;
+    /** Original line number (1-indexed) */
+    readonly lineNumber: number;
+}
+/**
+ * Split input text into lines, handling CRLF, LF, and CR
+ *
+ * RFC 8866 Section 5: Text fields use UTF-8 encoding, line ending is CRLF,
+ * but parsers SHOULD accept LF alone for compatibility.
+ *
+ * @param input - Raw SDP text
+ * @returns Array of lines (line endings removed)
+ */
+export declare function splitLines(input: string): string[];
+/**
+ * Parse a single SDP line into type and value
+ *
+ * SDP line format: <type>=<value>
+ * where <type> is a single character
+ *
+ * @param line - Single SDP line
+ * @returns Parsed line with type and value, or null if invalid
+ */
+export declare function parseLine(line: string): {
+    type: string;
+    value: string;
+} | null;
+/**
+ * Parse all lines in SDP input into structured format
+ *
+ * @param input - Raw SDP text
+ * @returns Array of parsed lines (skips empty/invalid lines)
+ */
+export declare function parseLines(input: string): ParsedLine[];
+/**
+ * Join lines back into SDP text format with CRLF line endings
+ *
+ * Always outputs standard CRLF line endings per RFC 8866,
+ * even if input used LF or CR.
+ *
+ * @param lines - Array of line strings (without line endings)
+ * @returns SDP text with CRLF line endings
+ */
+export declare function joinLines(lines: string[]): string;
+/**
+ * Format a line in SDP format: <type>=<value>
+ *
+ * @param type - Single character line type
+ * @param value - Line value
+ * @returns Formatted SDP line (without line ending)
+ */
+export declare function formatLine(type: string, value: string): string;
+/**
+ * Validate that a line type is a valid SDP field
+ *
+ * Valid SDP field types per RFC 8866:
+ * v, o, s, i, u, e, p, c, b, t, r, z, k, a, m
+ *
+ * @param type - Line type character
+ * @returns true if valid SDP field type
+ */
+export declare function isValidLineType(type: string): boolean;
+/**
+ * Get display name for a line type
+ *
+ * @param type - Line type character
+ * @returns Human-readable field name
+ */
+export declare function getLineTypeName(type: string): string;
+//# sourceMappingURL=line-reader.d.ts.map

package/dist/src/utils/line-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-reader.d.ts","sourceRoot":"","sources":["../../../src/utils/line-reader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,uCAAuC;IACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA+BlD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAoB9E;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,EAAE,CAiBtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAEjD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoBpD"}