identifier-js 0.0.4 → 0.0.6

package/index.js

@@ -2,25 +2,26 @@
 // a valid URI is always a valid IRI
 const { recursiveCompile } = require('url-templates');
 const patterns = new Map();
-// RFC3986/RFC3987 common rules
+// RFC3986/RFC3987 common rules + https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.2:~:text=DNS%29%2E-,A,of%20%5BRFC1123%5D%2E
 const commonRules = {
     scheme: '[a-zA-Z][a-zA-Z0-9+.-]*',
-    port: '[0-9]*',
+    port: '(?:0|[1-9]\\d{0,3}|[1-5]\\d{4}|6[0-4]\\d{3}|65[0-4]\\d{2}|655[0-2]\\d|6553[0-5])?',
     IP_literal: '\\[(?:{IPv6address}|{IPvFuture})\\]',
     IPv6address: '(?:(?:{h16}:){6}{ls32}|::(?:{h16}:){5}{ls32}|(?:(?:{h16})?)::(?:{h16}:){4}{ls32}|(?:(?:{h16}:)?{h16})?::(?:{h16}:){3}{ls32}|(?:(?:{h16}:){0,2}{h16})?::(?:{h16}:){2}{ls32}|(?:(?:{h16}:){0,3}{h16})?::(?:{h16}:){1}{ls32}|(?:(?:{h16}:){0,4}{h16})?::{ls32}|(?:(?:{h16}:){0,5}{h16})?::{h16}|(?:(?:{h16}:){0,6}{h16})?::)',
     ls32: '(?:{h16}:{h16}|{IPv4address})',
-    h16: '{hexdig}{1,4}',
+    h16: '{hex_digit}{1,4}',
     IPv4address: '(?:{dec_octet}\\.){3}{dec_octet}',
     dec_octet: '(?:\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])',
-    IPvFuture: 'v{hexdig}+\\.(?:{unreserved}|{sub_delims}|:)+',
+    IPvFuture: 'v{hex_digit}+\\.(?:{unreserved}|{sub_delims}|:)+',
     unreserved: '[a-zA-Z0-9_.~-]',
     reserved: '(?:{gen_delims}|{sub_delims})',
-    pct_encoded: '%{hexdig}{2}',
+    pct_encoded: '%{hex_digit}{2}',
     gen_delims: '[:/?#[\\]@]',
     sub_delims: "[!&'()*+,;=$]",
-    hexdig: '[0-9A-Fa-f]',
-    UUID: '[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}',
-    UUID_v4: '[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}',
+    hex_digit: '[0-9A-Fa-f]',
+    alpha_digit: '[a-zA-Z0-9]',
+    UUID: '{hex_digit}{8}-{hex_digit}{4}-{hex_digit}{4}-{hex_digit}{4}-{hex_digit}{12}',
+    UUID_v4: '{hex_digit}{8}-{hex_digit}{4}-4{hex_digit}{3}-[89abAB]{hex_digit}{3}-{hex_digit}{12}',
 };
 // RFC3986 rules
 const uriRules = {
@@ -31,9 +32,10 @@ const uriRules = {
     hier_part: '(?:\/\/{authority}{path_abempty}|{path_absolute}|{path_rootless}|{path_empty})',
     relative_part: '(?:\/\/{authority}{path_abempty}|{path_absolute}|{path_noscheme}|{path_empty})',
     authority: '(?:{userinfo}@)?{host}(?::{port})?',
-    host: '(?:{IP_literal}|{IPv4address}|{reg_name})',
     userinfo: '(?:{unreserved}|{pct_encoded}|{sub_delims}|:)*',
-    reg_name: '(?:{unreserved}|{pct_encoded}|{sub_delims})*',
+    host: '(?:{IP_literal}|{IPv4address}|{reg_name})',
+    a_label: '(?:{alpha_digit})(?:(?:{alpha_digit}|-){0,61}(?:{alpha_digit}))?',
+    reg_name: "(?:(?=.{1,255}(?:[:/?#]|$))(?:{a_label})(?:\\.{a_label})*)",
     path: '(?:{path_abempty}|{path_absolute}|{path_noscheme}|{path_rootless}|{path_empty})',
     path_abempty: '(?:\/{segment})*',
     path_absolute: '\/(?:{segment_nz}(?:\/{segment})*)?',
@@ -58,7 +60,9 @@ const iriRules = {
     iauthority: '(?:{iuserinfo}@)?{ihost}(?::{port})?',
     iuserinfo: '(?:{iunreserved}|{pct_encoded}|{sub_delims}|:)*',
     ihost: '(?:{IP_literal}|{IPv4address}|{ireg_name})',
-    ireg_name: '(?:{iunreserved}|{pct_encoded}|{sub_delims})*',
+    separator: '[\\x2E\\uFF0E\\u3002\\uFF61]',
+    u_label: '(?:{uchar})(?:(?:{uchar}|-){0,61}(?:{uchar}))?',
+    ireg_name: '(?:(?=.{1,255}(?:[:/?#]|$))(?:{u_label})(?:{separator}(?:{u_label}))*)',
     ipath: '(?:{ipath_abempty}|{ipath_absolute}|{ipath_noscheme}|{ipath_rootless}|{ipath_empty})',
     ipath_empty: '',
     ipath_rootless: '{isegment_nz}(?:\/{isegment})*',
@@ -71,8 +75,9 @@ const iriRules = {
     iquery: '(?:{ipchar}|{iprivate}|\/|\\?)*',
     ifragment: '(?:{ipchar}|\/|\\?)*',
     ipchar: '(?:{iunreserved}|{pct_encoded}|{sub_delims}|:|@)',
-    iunreserved: '(?:[a-zA-Z0-9._~-]|{ucschar})',
+    iunreserved: '(?:{unreserved}|{ucschar})',
     iprivate: '[\\uE000-\\uF8FF\\u{F0000}-\\u{FFFFD}\\u{100000}-\\u{10FFFD}]',
+    uchar: '[\\u200C\\u200D\\u00B7\\u0375\\u30FB\\u05F3\\u05F4\\p{L}\\p{N}\\p{Mn}\\p{Mc}]',
     ucschar: '[\\xA0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u{10000}-\\u{1FFFD}\\u{20000}-\\u{2FFFD}\\u{30000}-\\u{3FFFD}\\u{40000}-\\u{4FFFD}\\u{50000}-\\u{5FFFD}\\u{60000}-\\u{6FFFD}\\u{70000}-\\u{7FFFD}\\u{80000}-\\u{8FFFD}\\u{90000}-\\u{9FFFD}\\u{A0000}-\\u{AFFFD}\\u{B0000}-\\u{BFFFD}\\u{C0000}-\\u{CFFFD}\\u{D0000}-\\u{DFFFD}\\u{E1000}-\\u{EFFFD}]',
 };
 // pattern RFC group names

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "identifier-js",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "A RFC3986 / RFC3987 compliant fast parser/validator/resolver/composer for NodeJS and browser.",
   "keywords": [
     "IRI",

package/tests/to-absolute.test.js

@@ -3,7 +3,7 @@ import id from '../index.js';
 
 describe('toAbsoluteReference', () => {
     test('Base with a fragment', () => {
-        expect(id.toAbsoluteReference('http://examplé://examplé.org/rosé#dasd')).to.equal('http://examplé://examplé.org/rosé');
+        expect(id.toAbsoluteReference('http://examplé.org/rosé#dasd')).to.equal('http://examplé.org/rosé');
     });
 
     test('Scheme is required', () => {

package/tests/validation-hostnames.test.js

@@ -0,0 +1,94 @@
+import { describe, expect, test } from 'vitest';
+import id from '../index.js';
+
+describe('isUri with hostnames', () => {
+    test('Valid label - alphanumeric', () => {
+        expect(id.isUri('https://example')).to.equal(true);
+    });
+
+    test('Valid label - hyphen in middle', () => {
+        expect(id.isUri('https://exa-mple')).to.equal(true);
+    });
+
+    test('Invalid label - hyphen at start', () => {
+        expect(() => id.isUri('https://-example')).to.throw(Error, 'Invalid URI: https://-example');
+    });
+
+    test('Invalid label - hyphen at end', () => {
+        expect(() => id.isUri('https://example-')).to.throw(Error, 'Invalid URI: https://example-');
+    });
+
+    test('Valid multiple labels', () => {
+        expect(id.isUri('https://example-domain.com')).to.equal(true);
+    });
+
+    test('Invalid - leading dot', () => {
+        expect(() => id.isUri('https://.example.com')).to.throw(Error, 'Invalid URI: https://.example.com');
+    });
+
+    test('Invalid - trailing dot', () => {
+        expect(() => id.isUri('https://example.com.')).to.throw(Error, 'Invalid URI: https://example.com.');
+    });
+
+    test('Invalid - consecutive dots', () => {
+        expect(() => id.isUri('https://example..com')).to.throw(Error, 'Invalid URI: https://example..com');
+    });
+
+    test('Invalid - unicode character', () => {
+        expect(() => id.isUri('https://exämple')).to.throw(Error, 'Invalid URI: https://exämple');
+    });
+});
+
+describe('isIri with hostnames', () => {
+    test('Valid label - alphanumeric', () => {
+        expect(id.isIri('https://example')).to.equal(true);
+    });
+
+    test('Valid label - hyphen in middle', () => {
+        expect(id.isIri('https://exa-mple')).to.equal(true);
+    });
+
+    test('Invalid label - hyphen at start', () => {
+        expect(() => id.isIri('https://-example')).to.throw(Error, 'Invalid IRI: https://-example');
+    });
+
+    test('Invalid label - hyphen at end', () => {
+        expect(() => id.isIri('https://example-')).to.throw(Error, 'Invalid IRI: https://example-');
+    });
+
+    test('Valid unicode label - Latin extended', () => {
+        expect(id.isIri('https://exämple')).to.equal(true);
+    });
+
+    test('Valid unicode label - Chinese', () => {
+        expect(id.isIri('https://例子')).to.equal(true);
+    });
+
+    test('Valid unicode label - Hindi', () => {
+        expect(id.isIri('https://उदाहरण')).to.equal(true);
+    });
+
+    test('Valid unicode label - Japanese', () => {
+        expect(id.isIri('https://例え.テスト')).to.equal(true);
+    });
+
+    test('Valid label with middle dot', () => {
+        expect(id.isIri('https://exa·mple')).to.equal(true);
+    });
+
+    test('Invalid - leading dot', () => {
+        expect(() => id.isIri('https://.example')).to.throw(Error, 'Invalid IRI: https://.example');
+    });
+
+    test('Invalid - trailing dot', () => {
+        expect(() => id.isIri('https://example.')).to.throw(Error, 'Invalid IRI: https://example.');
+    });
+
+    test('Invalid - consecutive dots', () => {
+        expect(() => id.isIri('https://example..test')).to.throw(Error, 'Invalid IRI: https://example..test');
+    });
+
+    test('Invalid - emoji in label', () => {
+        expect(() => id.isIri('https://example😀')).to.throw(Error, 'Invalid IRI: https://example😀');
+    });
+});

package/tests/validation-ip-port.test.js

@@ -0,0 +1,246 @@
+import { describe, expect, test } from 'vitest';
+import id from '../index.js';
+
+describe('isUri – IPv4 host validation', () => {
+    test('Valid full IPv4 address', () => {
+        expect(id.isUri('https://1.2.3.4')).to.equal(true);
+    });
+
+    test('Invalid IPv4 address, but valid as hostname', () => {
+        expect(id.isUri('https://999.999.999.999')).to.equal(true);
+    });
+});
+
+describe('isIri – IPv4 host validation', () => {
+    test('Valid full IPv4 address', () => {
+        expect(id.isIri('https://1.2.3.4')).to.equal(true);
+    });
+
+    test('Invalid IPv4 address, but valid as hostname', () => {
+        expect(id.isIri('https://999.999.999.999')).to.equal(true);
+    });
+});
+
+describe('isUri – IPv6 host validation', () => {
+    test('Valid full (uncompressed) IPv6 address', () => {
+        expect(id.isUri('https://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]')).to.equal(true);
+    });
+
+    test('Valid full IPv6 address (no zero compression)', () => {
+        expect(id.isUri('https://[2001:db8:85a3:0:0:8a2e:370:7334]')).to.equal(true);
+    });
+
+    test('Valid IPv6 address with zero compression (::)', () => {
+        expect(id.isUri('https://[2001:db8:85a3::8a2e:370:7334]')).to.equal(true);
+    });
+
+    test('Valid loopback IPv6 address (::1)', () => {
+        expect(id.isUri('https://[::1]')).to.equal(true);
+    });
+
+    test('Valid unspecified IPv6 address (::)', () => {
+        expect(id.isUri('https://[::]')).to.equal(true);
+    });
+
+    test('Valid compressed IPv6 address (trailing compression)', () => {
+        expect(id.isUri('https://[2001:db8::]')).to.equal(true);
+    });
+
+    test('Valid IPv6 with embedded IPv4 (IPv4-mapped)', () => {
+        expect(id.isUri('https://[::ffff:192.168.1.1]')).to.equal(true);
+    });
+
+    test('Valid IPv6 with embedded IPv4 (mixed notation)', () => {
+        expect(id.isUri('https://[2001:db8::192.168.1.1]')).to.equal(true);
+    });
+
+    test('Valid link-local IPv6 address', () => {
+        expect(id.isUri('https://[fe80::1]')).to.equal(true);
+    });
+
+    test('Valid maximum-length IPv6 address', () => {
+        expect(id.isUri('https://[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]')).to.equal(true);
+    });
+
+    test('Invalid IPv6 – excessive colon sequence', () => {
+        expect(() => id.isUri('https://[2001:db8:85a3:::8a2e:370:7334]')).to.throw(Error, 'Invalid URI: https://[2001:db8:85a3:::8a2e:370:7334]');
+    });
+
+    test('Invalid IPv6 – multiple zero compressions (::)', () => {
+        expect(() => id.isUri('https://[2001:db8:85a3::8a2e::7334]')).to.throw(Error, 'Invalid URI: https://[2001:db8:85a3::8a2e::7334]');
+    });
+
+    test('Invalid IPv6 – segment exceeds 16-bit limit', () => {
+        expect(() => id.isUri('https://[12345::]')).to.throw(Error, 'Invalid URI: https://[12345::]');
+    });
+
+    test('Invalid IPv6 – insufficient segments without compression', () => {
+        expect(() => id.isUri('https://[2001:db8:85a3:8a2e:370:7334]')).to.throw(Error, 'Invalid URI: https://[2001:db8:85a3:8a2e:370:7334]');
+    });
+
+    test('Invalid IPv6 – too many segments', () => {
+        expect(() => id.isUri('https://[2001:db8:85a3:0000:0000:8a2e:0370:7334:1234]')).to.throw(Error, 'Invalid URI: https://[2001:db8:85a3:0000:0000:8a2e:0370:7334:1234]');
+    });
+
+    test('Invalid IPv6 – embedded IPv4 out of range', () => {
+        expect(() => id.isUri('https://[::ffff:999.168.1.1]')).to.throw(Error, 'Invalid URI: https://[::ffff:999.168.1.1]');
+    });
+
+    test('Invalid IPv6 – non-hexadecimal character in segment', () => {
+        expect(() => id.isUri('https://[2001:db8::g1]')).to.throw(Error, 'Invalid URI: https://[2001:db8::g1]');
+    });
+
+    test('Invalid IPv6 – leading colon without compression', () => {
+        expect(() => id.isUri('https://[:2001:db8::1]')).to.throw(Error, 'Invalid URI: https://[:2001:db8::1]');
+    });
+
+    test('Invalid IPv6 – trailing colon without compression', () => {
+        expect(() => id.isUri('https://[2001:db8::1:]')).to.throw(Error, 'Invalid URI: https://[2001:db8::1:]');
+    });
+
+    test('Invalid IPv6 – empty address literal', () => {
+        expect(() => id.isUri('https://[]')).to.throw(Error, 'Invalid URI: https://[]');
+    });
+});
+
+describe('isIri – IPv6 host validation', () => {
+    test('Valid full (uncompressed) IPv6 address', () => {
+        expect(id.isIri('https://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]')).to.equal(true);
+    });
+
+    test('Valid full IPv6 address (no zero compression)', () => {
+        expect(id.isIri('https://[2001:db8:85a3:0:0:8a2e:370:7334]')).to.equal(true);
+    });
+
+    test('Valid IPv6 address with zero compression (::)', () => {
+        expect(id.isIri('https://[2001:db8:85a3::8a2e:370:7334]')).to.equal(true);
+    });
+
+    test('Valid loopback IPv6 address (::1)', () => {
+        expect(id.isIri('https://[::1]')).to.equal(true);
+    });
+
+    test('Valid unspecified IPv6 address (::)', () => {
+        expect(id.isIri('https://[::]')).to.equal(true);
+    });
+
+    test('Valid compressed IPv6 address (trailing compression)', () => {
+        expect(id.isIri('https://[2001:db8::]')).to.equal(true);
+    });
+
+    test('Valid IPv6 with embedded IPv4 (IPv4-mapped)', () => {
+        expect(id.isIri('https://[::ffff:192.168.1.1]')).to.equal(true);
+    });
+
+    test('Valid IPv6 with embedded IPv4 (mixed notation)', () => {
+        expect(id.isIri('https://[2001:db8::192.168.1.1]')).to.equal(true);
+    });
+
+    test('Valid link-local IPv6 address', () => {
+        expect(id.isIri('https://[fe80::1]')).to.equal(true);
+    });
+
+    test('Valid maximum-length IPv6 address', () => {
+        expect(id.isIri('https://[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]')).to.equal(true);
+    });
+
+    test('Invalid IPv6 – excessive colon sequence', () => {
+        expect(() => id.isIri('https://[2001:db8:85a3:::8a2e:370:7334]')).to.throw(Error, 'Invalid IRI: https://[2001:db8:85a3:::8a2e:370:7334]');
+    });
+
+    test('Invalid IPv6 – multiple zero compressions (::)', () => {
+        expect(() => id.isIri('https://[2001:db8:85a3::8a2e::7334]')).to.throw(Error, 'Invalid IRI: https://[2001:db8:85a3::8a2e::7334]');
+    });
+
+    test('Invalid IPv6 – segment exceeds 16-bit limit', () => {
+        expect(() => id.isIri('https://[12345::]')).to.throw(Error, 'Invalid IRI: https://[12345::]');
+    });
+
+    test('Invalid IPv6 – insufficient segments without compression', () => {
+        expect(() => id.isIri('https://[2001:db8:85a3:8a2e:370:7334]')).to.throw(Error, 'Invalid IRI: https://[2001:db8:85a3:8a2e:370:7334]');
+    });
+
+    test('Invalid IPv6 – too many segments', () => {
+        expect(() => id.isIri('https://[2001:db8:85a3:0000:0000:8a2e:0370:7334:1234]')).to.throw(Error, 'Invalid IRI: https://[2001:db8:85a3:0000:0000:8a2e:0370:7334:1234]');
+    });
+
+    test('Invalid IPv6 – embedded IPv4 out of range', () => {
+        expect(() => id.isIri('https://[::ffff:999.168.1.1]')).to.throw(Error, 'Invalid IRI: https://[::ffff:999.168.1.1]');
+    });
+
+    test('Invalid IPv6 – non-hexadecimal character in segment', () => {
+        expect(() => id.isIri('https://[2001:db8::g1]')).to.throw(Error, 'Invalid IRI: https://[2001:db8::g1]');
+    });
+
+    test('Invalid IPv6 – leading colon without compression', () => {
+        expect(() => id.isIri('https://[:2001:db8::1]')).to.throw(Error, 'Invalid IRI: https://[:2001:db8::1]');
+    });
+
+    test('Invalid IPv6 – trailing colon without compression', () => {
+        expect(() => id.isIri('https://[2001:db8::1:]')).to.throw(Error, 'Invalid IRI: https://[2001:db8::1:]');
+    });
+
+    test('Invalid IPv6 – empty address literal', () => {
+        expect(() => id.isIri('https://[]')).to.throw(Error, 'Invalid IRI: https://[]');
+    });
+});
+
+describe('isUri – port validation', () => {
+    test('Valid port', () => {
+        expect(id.isUri('https://example.com:80')).to.equal(true);
+    });
+
+    test('Valid port zero', () => {
+        expect(id.isUri('https://example.com:0')).to.equal(true);
+    });
+
+    test('Valid port at max edge', () => {
+        expect(id.isUri('https://example.com:65535')).to.equal(true);
+    });
+
+    test('Valid port empty', () => {
+        expect(id.isUri('https://example.com:/')).to.equal(true);
+    });
+
+    test('Invalid "space" port', () => {
+        expect(() => id.isUri('https://example.com: /')).to.throw(Error, 'Invalid URI: https://example.com: /');
+    });
+
+    test('Invalid port char', () => {
+        expect(() => id.isUri('https://example.com:ff')).to.throw(Error, 'Invalid URI: https://example.com:ff');
+    });
+
+    test('Invalid port beyond edge', () => {
+        expect(() => id.isUri('https://example.com:65536')).to.throw(Error, 'Invalid URI: https://example.com:65536');
+    });
+});
+
+describe('isIri – port validation', () => {
+    test('Valid port', () => {
+        expect(id.isIri('https://example.com:80')).to.equal(true);
+    });
+
+    test('Valid port zero', () => {
+        expect(id.isIri('https://example.com:0')).to.equal(true);
+    });
+
+    test('Valid port at max edge', () => {
+        expect(id.isIri('https://example.com:65535')).to.equal(true);
+    });
+
+    test('Valid port empty', () => {
+        expect(id.isIri('https://example.com:/')).to.equal(true);
+    });
+
+    test('Invalid "space" port', () => {
+        expect(() => id.isIri('https://example.com: /')).to.throw(Error, 'Invalid IRI: https://example.com: /');
+    });
+
+    test('Invalid port char', () => {
+        expect(() => id.isIri('https://example.com:ff')).to.throw(Error, 'Invalid IRI: https://example.com:ff');
+    });
+
+    test('Invalid port beyond edge', () => {
+        expect(() => id.isIri('https://example.com:65536')).to.throw(Error, 'Invalid IRI: https://example.com:65536');
+    });
+});