@tomgiee/tsdp 1.0.0

package/dist/src/types/time.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Time description types for SDP (RFC 8866)
+ *
+ * Defines types for timing, repeat times, and timezone adjustments.
+ */
+import { NtpTime, TypedTime } from './primitives';
+/**
+ * Time Description (RFC 8866 Section 5.9-5.11)
+ *
+ * A time description consists of:
+ * - One timing field (t=)
+ * - Zero or more repeat fields (r=)
+ * - Zero or one timezone field (z=)
+ *
+ * At least one time description MUST be present in every session description.
+ */
+export interface TimeDescription {
+    /**
+     * Timing field (required)
+     */
+    readonly timing: Timing;
+    /**
+     * Repeat fields (optional, multiple allowed)
+     */
+    readonly repeats: readonly Repeat[];
+    /**
+     * Timezone field (optional, only one allowed)
+     */
+    readonly timezone?: Timezone;
+}
+/**
+ * Timing field (RFC 8866 Section 5.9)
+ *
+ * Format: t=<start-time> <stop-time>
+ *
+ * Specifies the start and stop times for a session.
+ * Times are in NTP format (seconds since Jan 1, 1900 00:00:00 UTC).
+ * A value of 0 means the session is unbounded or permanent.
+ */
+export interface Timing {
+    /**
+     * Start time of the session (NTP timestamp)
+     * 0 means the session is not bounded
+     */
+    readonly startTime: NtpTime;
+    /**
+     * Stop time of the session (NTP timestamp)
+     * 0 means the session is not bounded
+     */
+    readonly stopTime: NtpTime;
+}
+/**
+ * Repeat field (RFC 8866 Section 5.10)
+ *
+ * Format: r=<repeat-interval> <active-duration> <offsets-from-start-time>
+ *
+ * Specifies repeat times for a session.
+ * For example, a session that repeats daily for 1 hour starting at 10am.
+ */
+export interface Repeat {
+    /**
+     * Interval between repetitions
+     * For example: 7d for weekly, 1d for daily
+     */
+    readonly interval: TypedTime;
+    /**
+     * Duration of each repetition
+     * For example: 1h for one hour
+     */
+    readonly duration: TypedTime;
+    /**
+     * Offsets from the start time when the session becomes active
+     * For example: [0, 3600] for sessions at start time and 1 hour later
+     */
+    readonly offsets: readonly TypedTime[];
+}
+/**
+ * Timezone field (RFC 8866 Section 5.11)
+ *
+ * Format: z=<adjustment-time> <offset> [<adjustment-time> <offset> ...]
+ *
+ * Specifies timezone adjustments for repeat sessions.
+ * Useful for dealing with daylight saving time changes.
+ */
+export interface Timezone {
+    /**
+     * List of timezone adjustments
+     */
+    readonly adjustments: readonly TimezoneAdjustment[];
+}
+/**
+ * A single timezone adjustment
+ */
+export interface TimezoneAdjustment {
+    /**
+     * Time at which the adjustment takes effect (NTP timestamp)
+     */
+    readonly time: NtpTime;
+    /**
+     * Offset to apply at the adjustment time
+     * Positive for forward adjustment, negative for backward
+     */
+    readonly offset: TypedTime;
+}
+/**
+ * Create a Timing field
+ */
+export declare function createTiming(startTime: number, stopTime: number): Timing;
+/**
+ * Create a permanent/unbounded Timing (0 to 0)
+ */
+export declare function createPermanentTiming(): Timing;
+/**
+ * Create a Repeat field
+ */
+export declare function createRepeat(interval: TypedTime, duration: TypedTime, offsets: TypedTime[]): Repeat;
+/**
+ * Create a TimezoneAdjustment
+ */
+export declare function createTimezoneAdjustment(time: number, offset: TypedTime): TimezoneAdjustment;
+/**
+ * Create a Timezone field
+ */
+export declare function createTimezone(adjustments: TimezoneAdjustment[]): Timezone;
+/**
+ * Create a TimeDescription
+ */
+export declare function createTimeDescription(timing: Timing, repeats?: Repeat[], timezone?: Timezone): TimeDescription;
+//# sourceMappingURL=time.d.ts.map

package/dist/src/types/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../../src/types/time.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,SAAS,EAAkC,MAAM,cAAc,CAAC;AAMlF;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAEpC;;OAEG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CAC9B;AAMD;;;;;;;;GAQG;AACH,MAAM,WAAW,MAAM;IACrB;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAMD;;;;;;;GAOG;AACH,MAAM,WAAW,MAAM;IACrB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAE7B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAE7B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC;CACxC;AAMD;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;CAC5B;AAMD;;GAEG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAWxE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAK9C;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,SAAS,EACnB,QAAQ,EAAE,SAAS,EACnB,OAAO,EAAE,SAAS,EAAE,GACnB,MAAM,CASR;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,kBAAkB,CAK5F;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,kBAAkB,EAAE,GAAG,QAAQ,CAO1E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,MAAM,EAAO,EACtB,QAAQ,CAAC,EAAE,QAAQ,GAClB,eAAe,CAMjB"}

package/dist/src/types/time.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Time description types for SDP (RFC 8866)
+ *
+ * Defines types for timing, repeat times, and timezone adjustments.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTiming = createTiming;
+exports.createPermanentTiming = createPermanentTiming;
+exports.createRepeat = createRepeat;
+exports.createTimezoneAdjustment = createTimezoneAdjustment;
+exports.createTimezone = createTimezone;
+exports.createTimeDescription = createTimeDescription;
+const primitives_1 = require("./primitives");
+// ============================================================================
+// Helper Functions for Creating Time Types
+// ============================================================================
+/**
+ * Create a Timing field
+ */
+function createTiming(startTime, stopTime) {
+    if (startTime < 0 || stopTime < 0) {
+        throw new Error('NTP times must be non-negative');
+    }
+    if (startTime !== 0 && stopTime !== 0 && startTime > stopTime) {
+        throw new Error('Start time must be before or equal to stop time');
+    }
+    return {
+        startTime: (0, primitives_1.createNtpTime)(startTime),
+        stopTime: (0, primitives_1.createNtpTime)(stopTime),
+    };
+}
+/**
+ * Create a permanent/unbounded Timing (0 to 0)
+ */
+function createPermanentTiming() {
+    return {
+        startTime: (0, primitives_1.createNtpTime)(0),
+        stopTime: (0, primitives_1.createNtpTime)(0),
+    };
+}
+/**
+ * Create a Repeat field
+ */
+function createRepeat(interval, duration, offsets) {
+    if (offsets.length === 0) {
+        throw new Error('At least one offset is required for repeat');
+    }
+    return {
+        interval,
+        duration,
+        offsets,
+    };
+}
+/**
+ * Create a TimezoneAdjustment
+ */
+function createTimezoneAdjustment(time, offset) {
+    return {
+        time: (0, primitives_1.createNtpTime)(time),
+        offset,
+    };
+}
+/**
+ * Create a Timezone field
+ */
+function createTimezone(adjustments) {
+    if (adjustments.length === 0) {
+        throw new Error('At least one adjustment is required for timezone');
+    }
+    return {
+        adjustments,
+    };
+}
+/**
+ * Create a TimeDescription
+ */
+function createTimeDescription(timing, repeats = [], timezone) {
+    return {
+        timing,
+        repeats,
+        timezone,
+    };
+}

package/dist/src/utils/address-parser.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Network address parsing and validation utilities (RFC 8866)
+ *
+ * Handles IPv4, IPv6 (RFC 5952), and FQDN (RFC 1035) address formats
+ */
+import { IP4Address, IP6Address, FQDN, UnicastAddress } from '../types/network';
+import { AddrType } from '../types/primitives';
+/**
+ * Check if a string is a valid IPv4 address
+ *
+ * Format: a.b.c.d where each octet is 0-255
+ *
+ * @param input - String to check
+ * @returns true if valid IPv4 address
+ */
+export declare function isIP4Address(input: string): boolean;
+/**
+ * Check if an IPv4 address is multicast (224.0.0.0 - 239.255.255.255)
+ *
+ * @param input - IPv4 address string
+ * @returns true if multicast address
+ */
+export declare function isIP4MulticastAddress(input: string): boolean;
+/**
+ * Parse an IPv4 address string
+ *
+ * @param input - IPv4 address string
+ * @returns IP4Address
+ * @throws ParseError if invalid
+ */
+export declare function parseIP4Address(input: string): IP4Address;
+/**
+ * Check if a string is a valid IPv6 address (RFC 5952)
+ *
+ * Supports all IPv6 formats:
+ * - Full form: 2001:0db8:0000:0000:0000:0000:0000:0001
+ * - Compressed: 2001:db8::1
+ * - Mixed IPv4: ::ffff:192.0.2.1
+ *
+ * @param input - String to check
+ * @returns true if valid IPv6 address
+ */
+export declare function isIP6Address(input: string): boolean;
+/**
+ * Check if an IPv6 address is multicast (starts with FF)
+ *
+ * @param input - IPv6 address string
+ * @returns true if multicast address
+ */
+export declare function isIP6MulticastAddress(input: string): boolean;
+/**
+ * Parse an IPv6 address string
+ *
+ * @param input - IPv6 address string
+ * @returns IP6Address
+ * @throws ParseError if invalid
+ */
+export declare function parseIP6Address(input: string): IP6Address;
+/**
+ * Check if a string is a valid FQDN (RFC 1035)
+ *
+ * Rules:
+ * - Labels separated by dots
+ * - Each label: 1-63 characters
+ * - Label format: alphanumeric + hyphens, must start/end with alphanumeric
+ * - Total length <= 253 characters
+ *
+ * @param input - String to check
+ * @returns true if valid FQDN
+ */
+export declare function isFQDN(input: string): boolean;
+/**
+ * Parse an FQDN string
+ *
+ * @param input - FQDN string
+ * @returns FQDN
+ * @throws ParseError if invalid
+ */
+export declare function parseFQDN(input: string): FQDN;
+/**
+ * Parse a unicast address based on address type
+ *
+ * For IP4: IPv4 address or FQDN
+ * For IP6: IPv6 address or FQDN
+ * For other: Extension address
+ *
+ * @param input - Address string
+ * @param addrType - Address type (IP4, IP6, or extension)
+ * @returns UnicastAddress
+ * @throws ParseError if invalid for the given address type
+ */
+export declare function parseUnicastAddress(input: string, addrType: AddrType): UnicastAddress;
+/**
+ * Detect the type of an address string
+ *
+ * @param input - Address string
+ * @returns AddrType ('IP4', 'IP6', or 'extension')
+ */
+export declare function detectAddressType(input: string): AddrType;
+//# sourceMappingURL=address-parser.d.ts.map

package/dist/src/utils/address-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address-parser.d.ts","sourceRoot":"","sources":["../../../src/utils/address-parser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,UAAU,EACV,UAAU,EACV,IAAI,EAEJ,cAAc,EAKf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAO/C;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CA4BnD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAU5D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAKzD;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAsFnD;AAeD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAoB5D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAKzD;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CA4B7C;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAK7C;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,cAAc,CAkCrF;AAMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAgBzD"}

package/dist/src/utils/address-parser.js

@@ -0,0 +1,338 @@
+"use strict";
+/**
+ * Network address parsing and validation utilities (RFC 8866)
+ *
+ * Handles IPv4, IPv6 (RFC 5952), and FQDN (RFC 1035) address formats
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIP4Address = isIP4Address;
+exports.isIP4MulticastAddress = isIP4MulticastAddress;
+exports.parseIP4Address = parseIP4Address;
+exports.isIP6Address = isIP6Address;
+exports.isIP6MulticastAddress = isIP6MulticastAddress;
+exports.parseIP6Address = parseIP6Address;
+exports.isFQDN = isFQDN;
+exports.parseFQDN = parseFQDN;
+exports.parseUnicastAddress = parseUnicastAddress;
+exports.detectAddressType = detectAddressType;
+const network_1 = require("../types/network");
+const errors_1 = require("../types/errors");
+// ============================================================================
+// IPv4 Address Validation
+// ============================================================================
+/**
+ * Check if a string is a valid IPv4 address
+ *
+ * Format: a.b.c.d where each octet is 0-255
+ *
+ * @param input - String to check
+ * @returns true if valid IPv4 address
+ */
+function isIP4Address(input) {
+    // Must have exactly 4 octets
+    const parts = input.split('.');
+    if (parts.length !== 4) {
+        return false;
+    }
+    // Each octet must be 0-255
+    return parts.every(part => {
+        // Must be numeric
+        if (!/^\d+$/.test(part)) {
+            return false;
+        }
+        const num = parseInt(part, 10);
+        // Must be 0-255
+        if (num < 0 || num > 255) {
+            return false;
+        }
+        // No leading zeros (except for "0" itself)
+        if (part.length > 1 && part[0] === '0') {
+            return false;
+        }
+        return true;
+    });
+}
+/**
+ * Check if an IPv4 address is multicast (224.0.0.0 - 239.255.255.255)
+ *
+ * @param input - IPv4 address string
+ * @returns true if multicast address
+ */
+function isIP4MulticastAddress(input) {
+    if (!isIP4Address(input)) {
+        return false;
+    }
+    const parts = input.split('.');
+    const firstOctet = parseInt(parts[0], 10);
+    // Multicast range: 224-239
+    return firstOctet >= 224 && firstOctet <= 239;
+}
+/**
+ * Parse an IPv4 address string
+ *
+ * @param input - IPv4 address string
+ * @returns IP4Address
+ * @throws ParseError if invalid
+ */
+function parseIP4Address(input) {
+    if (!isIP4Address(input)) {
+        throw new errors_1.ParseError(`Invalid IPv4 address: '${input}'`, 0, 0);
+    }
+    return (0, network_1.createIP4Address)(input);
+}
+// ============================================================================
+// IPv6 Address Validation
+// ============================================================================
+/**
+ * Check if a string is a valid IPv6 address (RFC 5952)
+ *
+ * Supports all IPv6 formats:
+ * - Full form: 2001:0db8:0000:0000:0000:0000:0000:0001
+ * - Compressed: 2001:db8::1
+ * - Mixed IPv4: ::ffff:192.0.2.1
+ *
+ * @param input - String to check
+ * @returns true if valid IPv6 address
+ */
+function isIP6Address(input) {
+    // IPv6 address validation regex (comprehensive)
+    // Handles all forms including compression and mixed IPv4
+    // Special case: "::"
+    if (input === '::') {
+        return true;
+    }
+    // Check for invalid characters
+    if (!/^[0-9a-fA-F:.]+$/.test(input)) {
+        return false;
+    }
+    // Can have at most one occurrence of "::"
+    const doubleColonCount = (input.match(/::/g) || []).length;
+    if (doubleColonCount > 1) {
+        return false;
+    }
+    // Split by :: to handle compression
+    if (input.includes('::')) {
+        const parts = input.split('::');
+        if (parts.length !== 2) {
+            return false;
+        }
+        const before = parts[0] ? parts[0].split(':') : [];
+        const after = parts[1] ? parts[1].split(':') : [];
+        // Check for mixed IPv4 in the last part
+        const lastPart = after.length > 0 ? after[after.length - 1] : before[before.length - 1];
+        const hasMixedIPv4 = lastPart && lastPart.includes('.');
+        if (hasMixedIPv4) {
+            // Validate IPv4 part
+            if (!isIP4Address(lastPart)) {
+                return false;
+            }
+            // Remove IPv4 part for hex validation
+            if (after.length > 0) {
+                after.pop();
+            }
+            else {
+                before.pop();
+            }
+            // IPv4 counts as 2 hex groups
+            const totalGroups = before.length + after.length + 2;
+            if (totalGroups > 8) {
+                return false;
+            }
+        }
+        else {
+            const totalGroups = before.length + after.length;
+            if (totalGroups >= 8) {
+                return false; // Compression not needed
+            }
+        }
+        // Validate hex groups
+        return [...before, ...after].every(isValidHexGroup);
+    }
+    else {
+        // No compression, must have exactly 8 groups (or 6 + IPv4)
+        const groups = input.split(':');
+        // Check for mixed IPv4 in last group
+        const lastGroup = groups[groups.length - 1];
+        if (lastGroup && lastGroup.includes('.')) {
+            // Mixed form: 6 hex groups + IPv4
+            if (groups.length !== 7) {
+                return false;
+            }
+            if (!isIP4Address(lastGroup)) {
+                return false;
+            }
+            // Validate first 6 hex groups
+            return groups.slice(0, 6).every(isValidHexGroup);
+        }
+        else {
+            // Pure IPv6: must have 8 groups
+            if (groups.length !== 8) {
+                return false;
+            }
+            return groups.every(isValidHexGroup);
+        }
+    }
+}
+/**
+ * Check if a string is a valid IPv6 hex group (1-4 hex digits)
+ *
+ * @param group - Hex group string
+ * @returns true if valid
+ */
+function isValidHexGroup(group) {
+    if (group.length === 0 || group.length > 4) {
+        return false;
+    }
+    return /^[0-9a-fA-F]+$/.test(group);
+}
+/**
+ * Check if an IPv6 address is multicast (starts with FF)
+ *
+ * @param input - IPv6 address string
+ * @returns true if multicast address
+ */
+function isIP6MulticastAddress(input) {
+    if (!isIP6Address(input)) {
+        return false;
+    }
+    // Normalize :: compression for checking
+    // Multicast addresses start with FF (binary: 11111111)
+    const upperInput = input.toUpperCase();
+    // Check if first group starts with FF
+    if (upperInput.startsWith('FF')) {
+        return true;
+    }
+    // Check after :: compression
+    if (upperInput.startsWith('::FF')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Parse an IPv6 address string
+ *
+ * @param input - IPv6 address string
+ * @returns IP6Address
+ * @throws ParseError if invalid
+ */
+function parseIP6Address(input) {
+    if (!isIP6Address(input)) {
+        throw new errors_1.ParseError(`Invalid IPv6 address: '${input}'`, 0, 0);
+    }
+    return (0, network_1.createIP6Address)(input);
+}
+// ============================================================================
+// FQDN Validation
+// ============================================================================
+/**
+ * Check if a string is a valid FQDN (RFC 1035)
+ *
+ * Rules:
+ * - Labels separated by dots
+ * - Each label: 1-63 characters
+ * - Label format: alphanumeric + hyphens, must start/end with alphanumeric
+ * - Total length <= 253 characters
+ *
+ * @param input - String to check
+ * @returns true if valid FQDN
+ */
+function isFQDN(input) {
+    // Total length limit
+    if (input.length === 0 || input.length > 253) {
+        return false;
+    }
+    // Split into labels
+    const labels = input.split('.');
+    // Each label must be valid
+    return labels.every(label => {
+        // Label length: 1-63 characters
+        if (label.length === 0 || label.length > 63) {
+            return false;
+        }
+        // Must start and end with alphanumeric
+        if (!/^[a-zA-Z0-9]/.test(label) || !/[a-zA-Z0-9]$/.test(label)) {
+            return false;
+        }
+        // Can only contain alphanumeric and hyphens
+        if (!/^[a-zA-Z0-9-]+$/.test(label)) {
+            return false;
+        }
+        return true;
+    });
+}
+/**
+ * Parse an FQDN string
+ *
+ * @param input - FQDN string
+ * @returns FQDN
+ * @throws ParseError if invalid
+ */
+function parseFQDN(input) {
+    if (!isFQDN(input)) {
+        throw new errors_1.ParseError(`Invalid FQDN: '${input}'`, 0, 0);
+    }
+    return (0, network_1.createFQDN)(input);
+}
+// ============================================================================
+// Unicast Address Parsing
+// ============================================================================
+/**
+ * Parse a unicast address based on address type
+ *
+ * For IP4: IPv4 address or FQDN
+ * For IP6: IPv6 address or FQDN
+ * For other: Extension address
+ *
+ * @param input - Address string
+ * @param addrType - Address type (IP4, IP6, or extension)
+ * @returns UnicastAddress
+ * @throws ParseError if invalid for the given address type
+ */
+function parseUnicastAddress(input, addrType) {
+    switch (addrType) {
+        case 'IP4':
+            // Try IPv4 first, then FQDN
+            if (isIP4Address(input)) {
+                return (0, network_1.createIP4Address)(input);
+            }
+            if (isFQDN(input)) {
+                return (0, network_1.createFQDN)(input);
+            }
+            throw new errors_1.ParseError(`Invalid address for type IP4: '${input}' (expected IPv4 or FQDN)`, 0, 0);
+        case 'IP6':
+            // Try IPv6 first, then FQDN
+            if (isIP6Address(input)) {
+                return (0, network_1.createIP6Address)(input);
+            }
+            if (isFQDN(input)) {
+                return (0, network_1.createFQDN)(input);
+            }
+            throw new errors_1.ParseError(`Invalid address for type IP6: '${input}' (expected IPv6 or FQDN)`, 0, 0);
+        default:
+            // Extension address type
+            return (0, network_1.createExtensionAddress)(input);
+    }
+}
+// ============================================================================
+// Address Type Detection
+// ============================================================================
+/**
+ * Detect the type of an address string
+ *
+ * @param input - Address string
+ * @returns AddrType ('IP4', 'IP6', or 'extension')
+ */
+function detectAddressType(input) {
+    if (isIP4Address(input)) {
+        return 'IP4';
+    }
+    if (isIP6Address(input)) {
+        return 'IP6';
+    }
+    if (isFQDN(input)) {
+        // FQDNs can work with both IP4 and IP6, default to IP4
+        return 'IP4';
+    }
+    // Unknown type
+    return 'extension';
+}