@tomgiee/tsdp 1.0.0

package/dist/tests/unit/types/network.test.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Tests for network.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const network_1 = require("../../../src/types/network");
+describe('network', () => {
+    describe('createIP4Address', () => {
+        it('should create IPv4 address', () => {
+            const addr = (0, network_1.createIP4Address)('192.168.1.1');
+            expect(addr).toBe('192.168.1.1');
+        });
+    });
+    describe('createIP6Address', () => {
+        it('should create IPv6 address', () => {
+            const addr = (0, network_1.createIP6Address)('2001:db8::1');
+            expect(addr).toBe('2001:db8::1');
+        });
+    });
+    describe('createFQDN', () => {
+        it('should create FQDN', () => {
+            const fqdn = (0, network_1.createFQDN)('example.com');
+            expect(fqdn).toBe('example.com');
+        });
+    });
+    describe('createIP4MulticastAddress', () => {
+        it('should create IPv4 multicast address', () => {
+            const addr = (0, network_1.createIP4Address)('224.0.1.1');
+            const multicast = (0, network_1.createIP4MulticastAddress)(addr, 127);
+            expect(multicast.kind).toBe('ip4-multicast');
+            expect(multicast.address).toBe('224.0.1.1');
+            expect(multicast.ttl).toBe(127);
+            expect(multicast.numAddresses).toBeUndefined();
+        });
+        it('should create IPv4 multicast with numAddresses', () => {
+            const addr = (0, network_1.createIP4Address)('239.255.255.255');
+            const multicast = (0, network_1.createIP4MulticastAddress)(addr, 32, 3);
+            expect(multicast.kind).toBe('ip4-multicast');
+            expect(multicast.address).toBe('239.255.255.255');
+            expect(multicast.ttl).toBe(32);
+            expect(multicast.numAddresses).toBe(3);
+        });
+        it('should throw for invalid TTL', () => {
+            const addr = (0, network_1.createIP4Address)('224.0.1.1');
+            expect(() => (0, network_1.createIP4MulticastAddress)(addr, -1)).toThrow('Invalid TTL');
+            expect(() => (0, network_1.createIP4MulticastAddress)(addr, 256)).toThrow('Invalid TTL');
+        });
+        it('should throw for invalid numAddresses', () => {
+            const addr = (0, network_1.createIP4Address)('224.0.1.1');
+            expect(() => (0, network_1.createIP4MulticastAddress)(addr, 127, 0)).toThrow('Invalid numAddresses');
+            expect(() => (0, network_1.createIP4MulticastAddress)(addr, 127, -1)).toThrow('Invalid numAddresses');
+        });
+    });
+    describe('createIP6MulticastAddress', () => {
+        it('should create IPv6 multicast address', () => {
+            const addr = (0, network_1.createIP6Address)('FF02::1');
+            const multicast = (0, network_1.createIP6MulticastAddress)(addr);
+            expect(multicast.kind).toBe('ip6-multicast');
+            expect(multicast.address).toBe('FF02::1');
+            expect(multicast.numAddresses).toBeUndefined();
+        });
+        it('should create IPv6 multicast with numAddresses', () => {
+            const addr = (0, network_1.createIP6Address)('FF05::2');
+            const multicast = (0, network_1.createIP6MulticastAddress)(addr, 5);
+            expect(multicast.kind).toBe('ip6-multicast');
+            expect(multicast.address).toBe('FF05::2');
+            expect(multicast.numAddresses).toBe(5);
+        });
+        it('should throw for invalid numAddresses', () => {
+            const addr = (0, network_1.createIP6Address)('FF02::1');
+            expect(() => (0, network_1.createIP6MulticastAddress)(addr, 0)).toThrow('Invalid numAddresses');
+        });
+    });
+    describe('createFQDNMulticastAddress', () => {
+        it('should create FQDN multicast address', () => {
+            const fqdn = (0, network_1.createFQDN)('multicast.example.com');
+            const multicast = (0, network_1.createFQDNMulticastAddress)(fqdn);
+            expect(multicast.kind).toBe('fqdn-multicast');
+            expect(multicast.address).toBe('multicast.example.com');
+            expect(multicast.ttl).toBeUndefined();
+            expect(multicast.numAddresses).toBeUndefined();
+        });
+        it('should create FQDN multicast with TTL and numAddresses', () => {
+            const fqdn = (0, network_1.createFQDN)('multicast.example.com');
+            const multicast = (0, network_1.createFQDNMulticastAddress)(fqdn, 64, 2);
+            expect(multicast.kind).toBe('fqdn-multicast');
+            expect(multicast.address).toBe('multicast.example.com');
+            expect(multicast.ttl).toBe(64);
+            expect(multicast.numAddresses).toBe(2);
+        });
+    });
+    describe('type guards', () => {
+        it('isMulticastAddress should detect multicast', () => {
+            const addr = (0, network_1.createIP4Address)('224.0.1.1');
+            const multicast = (0, network_1.createIP4MulticastAddress)(addr, 127);
+            expect((0, network_1.isMulticastAddress)(multicast)).toBe(true);
+            const unicast = (0, network_1.createIP4Address)('192.168.1.1');
+            expect((0, network_1.isMulticastAddress)(unicast)).toBe(false);
+        });
+        it('isUnicastAddress should detect unicast', () => {
+            const unicast = (0, network_1.createIP4Address)('192.168.1.1');
+            expect((0, network_1.isUnicastAddress)(unicast)).toBe(true);
+            const addr = (0, network_1.createIP4Address)('224.0.1.1');
+            const multicast = (0, network_1.createIP4MulticastAddress)(addr, 127);
+            expect((0, network_1.isUnicastAddress)(multicast)).toBe(false);
+        });
+        it('isIP4MulticastAddress should detect IPv4 multicast', () => {
+            const addr = (0, network_1.createIP4Address)('224.0.1.1');
+            const multicast = (0, network_1.createIP4MulticastAddress)(addr, 127);
+            expect((0, network_1.isIP4MulticastAddress)(multicast)).toBe(true);
+            const addr6 = (0, network_1.createIP6Address)('FF02::1');
+            const multicast6 = (0, network_1.createIP6MulticastAddress)(addr6);
+            expect((0, network_1.isIP4MulticastAddress)(multicast6)).toBe(false);
+        });
+        it('isIP6MulticastAddress should detect IPv6 multicast', () => {
+            const addr = (0, network_1.createIP6Address)('FF02::1');
+            const multicast = (0, network_1.createIP6MulticastAddress)(addr);
+            expect((0, network_1.isIP6MulticastAddress)(multicast)).toBe(true);
+            const addr4 = (0, network_1.createIP4Address)('224.0.1.1');
+            const multicast4 = (0, network_1.createIP4MulticastAddress)(addr4, 127);
+            expect((0, network_1.isIP6MulticastAddress)(multicast4)).toBe(false);
+        });
+        it('isFQDNMulticastAddress should detect FQDN multicast', () => {
+            const fqdn = (0, network_1.createFQDN)('multicast.example.com');
+            const multicast = (0, network_1.createFQDNMulticastAddress)(fqdn);
+            expect((0, network_1.isFQDNMulticastAddress)(multicast)).toBe(true);
+            const addr = (0, network_1.createIP4Address)('224.0.1.1');
+            const multicast4 = (0, network_1.createIP4MulticastAddress)(addr, 127);
+            expect((0, network_1.isFQDNMulticastAddress)(multicast4)).toBe(false);
+        });
+    });
+});

package/dist/tests/unit/types/primitives.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for primitives.ts
+ */
+export {};
+//# sourceMappingURL=primitives.test.d.ts.map

package/dist/tests/unit/types/primitives.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.test.d.ts","sourceRoot":"","sources":["../../../../tests/unit/types/primitives.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tests/unit/types/primitives.test.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Tests for primitives.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const primitives_1 = require("../../../src/types/primitives");
+describe('primitives', () => {
+    describe('createVersion', () => {
+        it('should create version 0', () => {
+            const version = (0, primitives_1.createVersion)(0);
+            expect(version).toBe(0);
+        });
+        it('should throw for non-zero version', () => {
+            expect(() => (0, primitives_1.createVersion)(1)).toThrow('Invalid SDP version');
+            expect(() => (0, primitives_1.createVersion)(2)).toThrow('Invalid SDP version');
+        });
+    });
+    describe('createSessionName', () => {
+        it('should create valid session name', () => {
+            const name = (0, primitives_1.createSessionName)('My Session');
+            expect(name).toBe('My Session');
+        });
+        it('should throw for empty session name', () => {
+            expect(() => (0, primitives_1.createSessionName)('')).toThrow('Session name cannot be empty');
+        });
+    });
+    describe('createUsername', () => {
+        it('should create valid username', () => {
+            const username = (0, primitives_1.createUsername)('jdoe');
+            expect(username).toBe('jdoe');
+        });
+        it('should throw for empty username', () => {
+            expect(() => (0, primitives_1.createUsername)('')).toThrow('Username cannot be empty');
+        });
+    });
+    describe('createNtpTime', () => {
+        it('should create valid NTP time', () => {
+            const time = (0, primitives_1.createNtpTime)(0);
+            expect(time).toBe(0);
+            const time2 = (0, primitives_1.createNtpTime)(3724394400);
+            expect(time2).toBe(3724394400);
+        });
+        it('should throw for negative time', () => {
+            expect(() => (0, primitives_1.createNtpTime)(-1)).toThrow('NTP time cannot be negative');
+        });
+    });
+    describe('createTypedTime', () => {
+        it('should create typed time with seconds', () => {
+            const time = (0, primitives_1.createTypedTime)(3600, 'seconds');
+            expect(time.value).toBe(3600);
+            expect(time.unit).toBe('seconds');
+        });
+        it('should create typed time with minutes', () => {
+            const time = (0, primitives_1.createTypedTime)(60, 'minutes');
+            expect(time.value).toBe(60);
+            expect(time.unit).toBe('minutes');
+        });
+        it('should create typed time with hours', () => {
+            const time = (0, primitives_1.createTypedTime)(24, 'hours');
+            expect(time.value).toBe(24);
+            expect(time.unit).toBe('hours');
+        });
+        it('should create typed time with days', () => {
+            const time = (0, primitives_1.createTypedTime)(7, 'days');
+            expect(time.value).toBe(7);
+            expect(time.unit).toBe('days');
+        });
+        it('should create negative typed time (for timezone offsets)', () => {
+            const time = (0, primitives_1.createTypedTime)(-1, 'hours');
+            expect(time.value).toBe(-1);
+            expect(time.unit).toBe('hours');
+        });
+    });
+    describe('isNumericString', () => {
+        it('should return true for valid numeric strings (RFC 8866 1*DIGIT)', () => {
+            expect((0, primitives_1.isNumericString)('0')).toBe(true);
+            expect((0, primitives_1.isNumericString)('123')).toBe(true);
+            expect((0, primitives_1.isNumericString)('2890844526')).toBe(true);
+            expect((0, primitives_1.isNumericString)('9876543210')).toBe(true);
+            expect((0, primitives_1.isNumericString)('00123')).toBe(true); // Leading zeros are valid digits
+        });
+        it('should return false for empty string', () => {
+            expect((0, primitives_1.isNumericString)('')).toBe(false);
+        });
+        it('should return false for strings with non-digit characters', () => {
+            expect((0, primitives_1.isNumericString)('abc')).toBe(false);
+            expect((0, primitives_1.isNumericString)('123abc')).toBe(false);
+            expect((0, primitives_1.isNumericString)('abc123')).toBe(false);
+            expect((0, primitives_1.isNumericString)('12a34')).toBe(false);
+        });
+        it('should return false for strings with spaces', () => {
+            expect((0, primitives_1.isNumericString)(' 123')).toBe(false);
+            expect((0, primitives_1.isNumericString)('123 ')).toBe(false);
+            expect((0, primitives_1.isNumericString)('12 34')).toBe(false);
+        });
+        it('should return false for strings with special characters', () => {
+            expect((0, primitives_1.isNumericString)('-123')).toBe(false); // Negative sign
+            expect((0, primitives_1.isNumericString)('+123')).toBe(false); // Plus sign
+            expect((0, primitives_1.isNumericString)('123.456')).toBe(false); // Decimal point
+            expect((0, primitives_1.isNumericString)('1,234')).toBe(false); // Comma
+            expect((0, primitives_1.isNumericString)('1e10')).toBe(false); // Scientific notation
+        });
+        it('should return false for strings with unicode digits', () => {
+            // Only ASCII digits 0-9 are valid per RFC 8866
+            expect((0, primitives_1.isNumericString)('١٢٣')).toBe(false); // Arabic numerals
+        });
+    });
+});

package/dist/tests/unit/utils/address-parser.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for address-parser.ts
+ */
+export {};
+//# sourceMappingURL=address-parser.test.d.ts.map

package/dist/tests/unit/utils/address-parser.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address-parser.test.d.ts","sourceRoot":"","sources":["../../../../tests/unit/utils/address-parser.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tests/unit/utils/address-parser.test.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Tests for address-parser.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const address_parser_1 = require("../../../src/utils/address-parser");
+describe('address-parser', () => {
+    describe('IPv4 validation', () => {
+        describe('isIP4Address', () => {
+            it('should validate valid IPv4 addresses', () => {
+                expect((0, address_parser_1.isIP4Address)('0.0.0.0')).toBe(true);
+                expect((0, address_parser_1.isIP4Address)('192.168.1.1')).toBe(true);
+                expect((0, address_parser_1.isIP4Address)('10.0.0.1')).toBe(true);
+                expect((0, address_parser_1.isIP4Address)('172.16.0.1')).toBe(true);
+                expect((0, address_parser_1.isIP4Address)('198.51.100.1')).toBe(true);
+                expect((0, address_parser_1.isIP4Address)('255.255.255.255')).toBe(true);
+            });
+            it('should reject invalid IPv4 addresses', () => {
+                expect((0, address_parser_1.isIP4Address)('256.1.1.1')).toBe(false);
+                expect((0, address_parser_1.isIP4Address)('192.168.1')).toBe(false);
+                expect((0, address_parser_1.isIP4Address)('192.168.1.1.1')).toBe(false);
+                expect((0, address_parser_1.isIP4Address)('192.168.-1.1')).toBe(false);
+                expect((0, address_parser_1.isIP4Address)('192.168.1.256')).toBe(false);
+                expect((0, address_parser_1.isIP4Address)('abc.def.ghi.jkl')).toBe(false);
+            });
+            it('should reject leading zeros', () => {
+                expect((0, address_parser_1.isIP4Address)('192.168.01.1')).toBe(false);
+                expect((0, address_parser_1.isIP4Address)('192.168.001.1')).toBe(false);
+            });
+            it('should accept single zero', () => {
+                expect((0, address_parser_1.isIP4Address)('0.0.0.0')).toBe(true);
+            });
+        });
+        describe('isIP4MulticastAddress', () => {
+            it('should validate IPv4 multicast addresses', () => {
+                expect((0, address_parser_1.isIP4MulticastAddress)('224.0.0.1')).toBe(true);
+                expect((0, address_parser_1.isIP4MulticastAddress)('239.255.255.255')).toBe(true);
+                expect((0, address_parser_1.isIP4MulticastAddress)('225.1.2.3')).toBe(true);
+            });
+            it('should reject non-multicast IPv4 addresses', () => {
+                expect((0, address_parser_1.isIP4MulticastAddress)('192.168.1.1')).toBe(false);
+                expect((0, address_parser_1.isIP4MulticastAddress)('223.255.255.255')).toBe(false);
+                expect((0, address_parser_1.isIP4MulticastAddress)('240.0.0.1')).toBe(false);
+            });
+            it('should reject invalid addresses', () => {
+                expect((0, address_parser_1.isIP4MulticastAddress)('invalid')).toBe(false);
+                expect((0, address_parser_1.isIP4MulticastAddress)('256.1.1.1')).toBe(false);
+            });
+        });
+        describe('parseIP4Address', () => {
+            it('should parse valid IPv4 address', () => {
+                const addr = (0, address_parser_1.parseIP4Address)('192.168.1.1');
+                expect(addr).toBe('192.168.1.1');
+            });
+            it('should throw for invalid IPv4 address', () => {
+                expect(() => (0, address_parser_1.parseIP4Address)('256.1.1.1')).toThrow('Invalid IPv4 address');
+                expect(() => (0, address_parser_1.parseIP4Address)('invalid')).toThrow('Invalid IPv4 address');
+            });
+        });
+    });
+    describe('IPv6 validation', () => {
+        describe('isIP6Address', () => {
+            it('should validate full IPv6 addresses', () => {
+                expect((0, address_parser_1.isIP6Address)('2001:0db8:0000:0000:0000:0000:0000:0001')).toBe(true);
+                expect((0, address_parser_1.isIP6Address)('2001:db8:0:0:0:0:0:1')).toBe(true);
+            });
+            it('should validate compressed IPv6 addresses', () => {
+                expect((0, address_parser_1.isIP6Address)('2001:db8::1')).toBe(true);
+                expect((0, address_parser_1.isIP6Address)('::1')).toBe(true);
+                expect((0, address_parser_1.isIP6Address)('::')).toBe(true);
+                expect((0, address_parser_1.isIP6Address)('fe80::1')).toBe(true);
+                expect((0, address_parser_1.isIP6Address)('2001:db8:85a3::8a2e:370:7334')).toBe(true);
+            });
+            it('should validate IPv6 with mixed IPv4', () => {
+                expect((0, address_parser_1.isIP6Address)('::ffff:192.0.2.1')).toBe(true);
+                expect((0, address_parser_1.isIP6Address)('2001:db8::192.0.2.1')).toBe(true);
+            });
+            it('should reject invalid IPv6 addresses', () => {
+                expect((0, address_parser_1.isIP6Address)('gggg::1')).toBe(false);
+                expect((0, address_parser_1.isIP6Address)('2001:db8:::1')).toBe(false);
+                expect((0, address_parser_1.isIP6Address)('2001:db8::1::2')).toBe(false);
+            });
+            it('should reject addresses with too many groups', () => {
+                expect((0, address_parser_1.isIP6Address)('1:2:3:4:5:6:7:8:9')).toBe(false);
+            });
+        });
+        describe('isIP6MulticastAddress', () => {
+            it('should validate IPv6 multicast addresses', () => {
+                expect((0, address_parser_1.isIP6MulticastAddress)('FF02::1')).toBe(true);
+                expect((0, address_parser_1.isIP6MulticastAddress)('FF05::2')).toBe(true);
+                expect((0, address_parser_1.isIP6MulticastAddress)('ff01::1')).toBe(true);
+            });
+            it('should reject non-multicast IPv6 addresses', () => {
+                expect((0, address_parser_1.isIP6MulticastAddress)('2001:db8::1')).toBe(false);
+                expect((0, address_parser_1.isIP6MulticastAddress)('fe80::1')).toBe(false);
+                expect((0, address_parser_1.isIP6MulticastAddress)('::1')).toBe(false);
+            });
+        });
+        describe('parseIP6Address', () => {
+            it('should parse valid IPv6 address', () => {
+                const addr = (0, address_parser_1.parseIP6Address)('2001:db8::1');
+                expect(addr).toBe('2001:db8::1');
+            });
+            it('should throw for invalid IPv6 address', () => {
+                expect(() => (0, address_parser_1.parseIP6Address)('invalid')).toThrow('Invalid IPv6 address');
+                expect(() => (0, address_parser_1.parseIP6Address)('gggg::1')).toThrow('Invalid IPv6 address');
+            });
+        });
+    });
+    describe('FQDN validation', () => {
+        describe('isFQDN', () => {
+            it('should validate valid FQDNs', () => {
+                expect((0, address_parser_1.isFQDN)('example.com')).toBe(true);
+                expect((0, address_parser_1.isFQDN)('www.example.com')).toBe(true);
+                expect((0, address_parser_1.isFQDN)('sub.domain.example.com')).toBe(true);
+                expect((0, address_parser_1.isFQDN)('sip.example.org')).toBe(true);
+            });
+            it('should validate single label', () => {
+                expect((0, address_parser_1.isFQDN)('localhost')).toBe(true);
+                expect((0, address_parser_1.isFQDN)('server1')).toBe(true);
+            });
+            it('should validate labels with hyphens', () => {
+                expect((0, address_parser_1.isFQDN)('my-server.example.com')).toBe(true);
+                expect((0, address_parser_1.isFQDN)('example-1.com')).toBe(true);
+            });
+            it('should reject invalid FQDNs', () => {
+                expect((0, address_parser_1.isFQDN)('')).toBe(false);
+                expect((0, address_parser_1.isFQDN)('-invalid.com')).toBe(false);
+                expect((0, address_parser_1.isFQDN)('invalid-.com')).toBe(false);
+                expect((0, address_parser_1.isFQDN)('invalid..com')).toBe(false);
+                expect((0, address_parser_1.isFQDN)('.invalid.com')).toBe(false);
+                expect((0, address_parser_1.isFQDN)('invalid.com.')).toBe(false);
+            });
+            it('should reject labels that are too long', () => {
+                const longLabel = 'a'.repeat(64);
+                expect((0, address_parser_1.isFQDN)(`${longLabel}.com`)).toBe(false);
+            });
+            it('should reject FQDNs that are too long', () => {
+                const longFQDN = 'a'.repeat(254);
+                expect((0, address_parser_1.isFQDN)(longFQDN)).toBe(false);
+            });
+            it('should accept labels with numbers', () => {
+                expect((0, address_parser_1.isFQDN)('server1.example.com')).toBe(true);
+                expect((0, address_parser_1.isFQDN)('123.example.com')).toBe(true);
+            });
+        });
+        describe('parseFQDN', () => {
+            it('should parse valid FQDN', () => {
+                const fqdn = (0, address_parser_1.parseFQDN)('example.com');
+                expect(fqdn).toBe('example.com');
+            });
+            it('should throw for invalid FQDN', () => {
+                expect(() => (0, address_parser_1.parseFQDN)('-invalid.com')).toThrow('Invalid FQDN');
+                expect(() => (0, address_parser_1.parseFQDN)('')).toThrow('Invalid FQDN');
+            });
+        });
+    });
+    describe('parseUnicastAddress', () => {
+        it('should parse IPv4 address for IP4 type', () => {
+            const addr = (0, address_parser_1.parseUnicastAddress)('192.168.1.1', 'IP4');
+            expect(addr).toBe('192.168.1.1');
+        });
+        it('should parse FQDN for IP4 type', () => {
+            const addr = (0, address_parser_1.parseUnicastAddress)('example.com', 'IP4');
+            expect(addr).toBe('example.com');
+        });
+        it('should parse IPv6 address for IP6 type', () => {
+            const addr = (0, address_parser_1.parseUnicastAddress)('2001:db8::1', 'IP6');
+            expect(addr).toBe('2001:db8::1');
+        });
+        it('should parse FQDN for IP6 type', () => {
+            const addr = (0, address_parser_1.parseUnicastAddress)('example.com', 'IP6');
+            expect(addr).toBe('example.com');
+        });
+        it('should parse extension address for unknown type', () => {
+            const addr = (0, address_parser_1.parseUnicastAddress)('some-address', 'ATM');
+            expect(addr).toBe('some-address');
+        });
+        it('should throw for invalid IPv4 with IP4 type', () => {
+            expect(() => (0, address_parser_1.parseUnicastAddress)('-invalid.', 'IP4')).toThrow('Invalid address for type IP4');
+        });
+        it('should throw for invalid IPv6 with IP6 type', () => {
+            expect(() => (0, address_parser_1.parseUnicastAddress)('-invalid.', 'IP6')).toThrow('Invalid address for type IP6');
+        });
+    });
+    describe('detectAddressType', () => {
+        it('should detect IPv4 addresses', () => {
+            expect((0, address_parser_1.detectAddressType)('192.168.1.1')).toBe('IP4');
+            expect((0, address_parser_1.detectAddressType)('10.0.0.1')).toBe('IP4');
+        });
+        it('should detect IPv6 addresses', () => {
+            expect((0, address_parser_1.detectAddressType)('2001:db8::1')).toBe('IP6');
+            expect((0, address_parser_1.detectAddressType)('::1')).toBe('IP6');
+        });
+        it('should detect FQDNs as IP4', () => {
+            expect((0, address_parser_1.detectAddressType)('example.com')).toBe('IP4');
+            expect((0, address_parser_1.detectAddressType)('www.example.com')).toBe('IP4');
+        });
+        it('should detect unknown types as extension', () => {
+            expect((0, address_parser_1.detectAddressType)('-invalid.')).toBe('extension');
+        });
+    });
+});

package/dist/tests/unit/utils/format-validators.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for format-validators.ts
+ */
+export {};
+//# sourceMappingURL=format-validators.test.d.ts.map

package/dist/tests/unit/utils/format-validators.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-validators.test.d.ts","sourceRoot":"","sources":["../../../../tests/unit/utils/format-validators.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}