identifier-js 0.0.5 → 0.0.7

package/index.js

@@ -5,7 +5,7 @@ const patterns = new Map();
 // 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|[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])',
+    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})',
@@ -35,7 +35,7 @@ const uriRules = {
     userinfo: '(?:{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}))*)",
+    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})*)?',

package/package.json

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

package/tests/normalize.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, test } from 'vitest';
+import id from '../index.js';
+// not yet done
+const resolveTests = [
+    ['', 'hTTp://example.com/b/c/d/e', 'http://example.com/b/c/d/e'], // scheme to lowercase
+    ['', 'http://eXaMpLe.com/b/c/d/e', 'http://example.com/b/c/d/e'], // authority to lowercase
+    ['', 'http://example.com/b%2Ec/d/e', 'http://example.com/b.c/d/e'], // Unnecessary encoding segment
+    ['', 'http://example.com/b%2Fc/d/e', 'http://example.com/b%2Fc/d/e'], // Necessary encoding segment
+    ['', 'http://example.com/b%2fc/d/e', 'http://example.com/b%2Fc/d/e'], // Case normalization of encoding segment
+    ['', 'http://example.com/b?c%2Fd%3Fe', 'http://example.com/b?c/d?e'], // Unnecessary encoding query
+    ['#c%2Fd%3Fe', 'http://example.com/b', 'http://example.com/b#c/d?e'], // Unnecessary encoding fragment
+];
+
+describe('resolveReference', () => {
+    resolveTests.forEach(([reference, base, expected]) => {
+        test(`resolveReference('${reference}', '${base}') === '${expected}'`, () => {
+            const subject = id.normalizeReference(reference, base);
+            expect(subject).to.equal(expected);
+        });
+    });
+});

package/tests/resolve.rfc.test.js

@@ -44,6 +44,7 @@ const refs = {
     "g?y/../x"      :  "http://a/b/c/g?y/../x",
     "g#s/./x"       :  "http://a/b/c/g#s/./x",
     "g#s/../x"      :  "http://a/b/c/g#s/../x",
+    "http:g"        :  "http:g",
 }
 
 describe('resolveReference', () => {

package/tests/resolve.test.js

@@ -4,13 +4,6 @@ import id from '../index.js';
 const resolveTests = [
     ['urn:some:ip:prop', 'urn:some:ip:prop', 'urn:some:ip:prop'],
     ['urn:some:ip:prop', 'urn:some:other:prop', 'urn:some:ip:prop'],
-    ['', 'hTTp://example.com/b/c/d/e', 'http://example.com/b/c/d/e'], // scheme to lowercase
-    ['', 'http://eXaMpLe.com/b/c/d/e', 'http://example.com/b/c/d/e'], // authority to lowercase
-    ['', 'http://example.com/b%2Ec/d/e', 'http://example.com/b.c/d/e'], // Unnecessary encoding segment
-    ['', 'http://example.com/b%2Fc/d/e', 'http://example.com/b%2Fc/d/e'], // Necessary encoding segment
-    ['', 'http://example.com/b%2fc/d/e', 'http://example.com/b%2Fc/d/e'], // Case normalization of encoding segment
-    ['', 'http://example.com/b?c%2Fd%3Fe', 'http://example.com/b?c/d?e'], // Unnecessary encoding query
-    ['#c%2Fd%3Fe', 'http://example.com/b', 'http://example.com/b#c/d?e'], // Unnecessary encoding fragment
 ];
 
 describe('resolveReference', () => {

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');
+    });
+});