identifier-js 0.0.1 → 0.0.3

package/tests/parse.test.js

@@ -0,0 +1,472 @@
+import { describe, expect, test } from "vitest";
+import id from '../index.js';
+
+describe('parseUri', () => {
+    test('Full', () => {
+        expect(id.parseUri('https://jason@example.com:80/foo?bar#baz')).to.eql({
+            scheme: 'https',
+            authority: 'jason@example.com:80',
+            userinfo: 'jason',
+            host: 'example.com',
+            port: '80',
+            path: '/foo',
+            query: 'bar',
+            fragment: 'baz',
+        });
+    });
+
+    test('No path with query', () => {
+        expect(id.parseUri('https://example.org?bar')).to.eql({
+            scheme: 'https',
+            authority: 'example.org',
+            userinfo: undefined,
+            host: 'example.org',
+            port: undefined,
+            path: '',
+            query: 'bar',
+            fragment: undefined,
+        });
+    });
+
+    test('No path with fragment', () => {
+        expect(id.parseUri('https://example.org#baz')).to.eql({
+            scheme: 'https',
+            authority: 'example.org',
+            userinfo: undefined,
+            host: 'example.org',
+            port: undefined,
+            path: '',
+            query: undefined,
+            fragment: 'baz',
+        });
+    });
+
+    test('Scheme is required', () => {
+        expect(() => id.parseUri('//example.com/foo?bar#baz')).to.throw(Error, 'Invalid URI: //example.com/foo?bar#baz');
+    });
+
+    test('No authority', () => {
+        expect(id.parseUri('uri:/foo?bar#baz')).to.eql({
+            scheme: 'uri',
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: '/foo',
+            query: 'bar',
+            fragment: 'baz',
+        });
+    });
+
+    test('Rootless path', () => {
+        expect(id.parseUri('uri:foo?bar#baz')).to.eql({
+            scheme: 'uri',
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: 'foo',
+            query: 'bar',
+            fragment: 'baz',
+        });
+    });
+
+    test('Unicode is not allowed', () => {
+        expect(() => id.parseUri('http://examplé.org/rosé#')).to.throw(Error, 'Invalid URI: http://examplé.org/rosé#');
+    });
+});
+
+describe('isUriReference', () => {
+    test('Full', () => {
+        expect(id.parseUriReference('https://jason@example.com:80/foo?bar#baz')).to.eql({
+            scheme: 'https',
+            authority: 'jason@example.com:80',
+            userinfo: 'jason',
+            host: 'example.com',
+            port: '80',
+            path: '/foo',
+            query: 'bar',
+            fragment: 'baz',
+        });
+    });
+
+    test('No path with query', () => {
+        expect(id.parseUriReference('https://example.org?bar')).to.eql({
+            scheme: 'https',
+            authority: 'example.org',
+            userinfo: undefined,
+            host: 'example.org',
+            port: undefined,
+            path: '',
+            query: 'bar',
+            fragment: undefined,
+        });
+    });
+
+    test('No path with fragment', () => {
+        expect(id.parseUriReference('https://example.org#baz')).to.eql({
+            scheme: 'https',
+            authority: 'example.org',
+            userinfo: undefined,
+            host: 'example.org',
+            port: undefined,
+            path: '',
+            query: undefined,
+            fragment: 'baz',
+        });
+    });
+
+    test('No scheme with authority', () => {
+        expect(id.parseUriReference('//example.com/foo?bar#baz')).to.eql({
+            scheme: undefined,
+            authority: 'example.com',
+            userinfo: undefined,
+            host: 'example.com',
+            port: undefined,
+            path: '/foo',
+            query: 'bar',
+            fragment: 'baz',
+        });
+    });
+
+    test('No double slash', () => {
+        expect(id.parseUriReference('example.com/foo?bar#baz')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: 'example.com/foo',
+            query: 'bar',
+            fragment: 'baz',
+        });
+    });
+
+    test('No authority', () => {
+        expect(id.parseUriReference('/foo?bar#baz')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: '/foo',
+            query: 'bar',
+            fragment: 'baz',
+        });
+    });
+
+    test('No path', () => {
+        expect(id.parseUriReference('?bar#baz')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: '',
+            query: 'bar',
+            fragment: 'baz',
+        });
+    });
+
+    test('No query', () => {
+        expect(id.parseUriReference('#baz')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: '',
+            query: undefined,
+            fragment: 'baz',
+        });
+    });
+
+    test('Empty', () => {
+        expect(id.parseUriReference('')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: '',
+            query: undefined,
+            fragment: undefined,
+        });
+    });
+
+    test('Unicode is not allowed', () => {
+        expect(() => id.parseUriReference('/rosé#')).to.throw(Error, 'Invalid URI-reference: /rosé#');
+    });
+});
+
+describe('isAbsoluteUri', () => {
+    test('Full', () => {
+        expect(id.parseAbsoluteUri('https://jason@example.com:80/foo?bar')).to.eql({
+            scheme: 'https',
+            authority: 'jason@example.com:80',
+            userinfo: 'jason',
+            host: 'example.com',
+            port: '80',
+            path: '/foo',
+            query: 'bar',
+        });
+    });
+
+    test('Scheme is required', () => {
+        expect(() => id.parseAbsoluteUri('//example.com/foo?bar')).to.throw(Error, 'Invalid absolute-URI: //example.com/foo?bar');
+    });
+
+    test('Fragment is not allowed', () => {
+        expect(() => id.parseAbsoluteUri('https://example.com/foo?bar#baz')).to.throw(Error, 'Invalid absolute-URI: https://example.com/foo?bar#baz');
+    });
+
+    test('Unicode is not allowed', () => {
+        expect(() =>id. parseAbsoluteUri('http://examplé.org/rosé')).to.throw(Error, 'Invalid absolute-URI: http://examplé.org/rosé');
+    });
+});
+
+describe('parseIri', () => {
+    test('Full', () => {
+        expect(id.parseIri('http://jásón@examplé.org:80/rosé?fóo#bár')).to.eql({
+            scheme: 'http',
+            authority: 'jásón@examplé.org:80',
+            userinfo: 'jásón',
+            host: 'examplé.org',
+            port: '80',
+            path: '/rosé',
+            query: 'fóo',
+            fragment: 'bár',
+        });
+    });
+
+    test('No path with query', () => {
+        expect(id.parseIri('http://examplé.org?fóo')).to.eql({
+            scheme: 'http',
+            authority: 'examplé.org',
+            userinfo: undefined,
+            host: 'examplé.org',
+            port: undefined,
+            path: '',
+            query: 'fóo',
+            fragment: undefined,
+        });
+    });
+
+    test('No path with fragment', () => {
+        expect(id.parseIri('http://examplé.org#bár')).to.eql({
+            scheme: 'http',
+            authority: 'examplé.org',
+            userinfo: undefined,
+            host: 'examplé.org',
+            port: undefined,
+            path: '',
+            query: undefined,
+            fragment: 'bár',
+        });
+    });
+
+    test('Scheme is required', () => {
+        expect(() => id.parseIri('//examplé.com/rosé?fóo#bár')).to.throw(Error, 'Invalid IRI: //examplé.com/rosé?fóo#bár');
+    });
+
+    test('No authority', () => {
+        expect(id.parseIri('uri:/rosé?fóo#bár')).to.eql({
+            scheme: 'uri',
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: '/rosé',
+            query: 'fóo',
+            fragment: 'bár',
+        });
+    });
+
+    test('Rootless path', () => {
+        expect(id.parseIri('uri:rosé?fóo#bár')).to.eql({
+            scheme: 'uri',
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: 'rosé',
+            query: 'fóo',
+            fragment: 'bár',
+        });
+    });
+
+    test('Unicode is not allowed in scheme', () => {
+        expect(() => id.parseIri('examplé://examplé.org/rosé')).to.throw(Error, 'Invalid IRI: examplé://examplé.org/rosé');
+    });
+});
+
+describe('parseIriReference', () => {
+    test('Full', () => {
+        expect(id.parseIriReference('http://jásón@examplé.org:80/rosé?fóo#bár')).to.eql({
+            scheme: 'http',
+            authority: 'jásón@examplé.org:80',
+            userinfo: 'jásón',
+            host: 'examplé.org',
+            port: '80',
+            path: '/rosé',
+            query: 'fóo',
+            fragment: 'bár',
+        });
+    });
+
+    test('No path with query', () => {
+        expect(id.parseIriReference('http://examplé.org?fóo')).to.eql({
+            scheme: 'http',
+            authority: 'examplé.org',
+            userinfo: undefined,
+            host: 'examplé.org',
+            port: undefined,
+            path: '',
+            query: 'fóo',
+            fragment: undefined,
+        });
+    });
+
+    test('No path with fragment', () => {
+        expect(id.parseIriReference('http://examplé.org#bár')).to.eql({
+            scheme: 'http',
+            authority: 'examplé.org',
+            userinfo: undefined,
+            host: 'examplé.org',
+            port: undefined,
+            path: '',
+            query: undefined,
+            fragment: 'bár',
+        });
+    });
+
+    test('No scheme with authority', () => {
+        expect(id.parseIriReference('//examplé.org/rosé?fóo#bár')).to.eql({
+            scheme: undefined,
+            authority: 'examplé.org',
+            userinfo: undefined,
+            host: 'examplé.org',
+            port: undefined,
+            path: '/rosé',
+            query: 'fóo',
+            fragment: 'bár',
+        });
+    });
+
+    test('No double slash', () => {
+        expect(id.parseIriReference('examplé.org/rosé?fóo#bár')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: 'examplé.org/rosé',
+            query: 'fóo',
+            fragment: 'bár',
+        });
+    });
+
+    test('No authority', () => {
+        expect(id.parseIriReference('/rosé?fóo#bár')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: '/rosé',
+            query: 'fóo',
+            fragment: 'bár',
+        });
+    });
+
+    test('Rootless path', () => {
+        expect(id.parseIriReference('rosé?fóo#bár')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: 'rosé',
+            query: 'fóo',
+            fragment: 'bár',
+        });
+    });
+
+    test('Query and fragment', () => {
+        expect(id.parseIriReference('?fóo#bár')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: '',
+            query: 'fóo',
+            fragment: 'bár',
+        });
+    });
+
+    test('Query only', () => {
+        expect(id.parseIriReference('?fóo')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: '',
+            query: 'fóo',
+            fragment: undefined,
+        });
+    });
+
+    test('Fragment only', () => {
+        expect(id.parseIriReference('#bár')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: '',
+            query: undefined,
+            fragment: 'bár',
+        });
+    });
+
+    test('Empty', () => {
+        expect(id.parseIriReference('')).to.eql({
+            scheme: undefined,
+            authority: undefined,
+            userinfo: undefined,
+            host: undefined,
+            port: undefined,
+            path: '',
+            query: undefined,
+            fragment: undefined,
+        });
+    });
+});
+
+describe('parseAbsoluteIri', () => {
+    test('Full', () => {
+        expect(id.parseAbsoluteIri('http://jásón:jásón@examplé.org:80/rosé?fóo')).to.eql({
+            scheme: 'http',
+            authority: 'jásón:jásón@examplé.org:80',
+            userinfo: 'jásón:jásón',
+            host: 'examplé.org',
+            port: '80',
+            path: '/rosé',
+            query: 'fóo',
+        });
+    });
+
+    test('Scheme is required', () => {
+        expect(() => id.parseAbsoluteIri('//examplé.org/rosé?fóo')).to.throw(Error, 'Invalid absolute-IRI: //examplé.org/rosé?fóo');
+    });
+
+    test('Fragment is not allowed', () => {
+        expect(() => id.parseAbsoluteIri('http://examplé.org/rosé?fóo#bár')).to.throw(Error, 'Invalid absolute-IRI: http://examplé.org/rosé?fóo#bár');
+    });
+
+    test('Unicode is not allowed in scheme', () => {
+        expect(() => id.parseAbsoluteIri('examplé://examplé.org/rosé')).to.throw(Error, 'Invalid absolute-IRI: examplé://examplé.org/rosé');
+    });
+});

package/tests/performance.js

@@ -0,0 +1,46 @@
+'use strict';
+//
+const { isAbsoluteIri, isAbsoluteUri, isIPv4, isIPv6, isIri, isIriReference, isUUID, isUUIDv4, isUri, isUriReference, parseAbsoluteIri, parseAbsoluteUri, parseIri, parseIriReference, parseUri, parseUriReference } = require('..');
+//
+const uri = 'https://user:pass@munich-und-uberacht.de:15/path.to/the/ccc.txt?ddd=ddd#/eee/fff/ggg';
+const iri = 'https://user:pass@münich-und-uberacht.de:15/path.to/the/ccc.txt?ddd=ddd#/eee/fff/ggg';
+
+const iterations = 1000000;
+
+console.log(`  Number of iterations: ${iterations}`);
+
+// URI_reference
+console.time('   parse URI_reference');
+for (let i = 0; i < iterations; i++) parseUriReference(uri);
+console.timeEnd('   parse URI_reference');
+
+console.time('validate URI_reference');
+for (let i = 0; i < iterations; i++) isUriReference(uri);
+console.timeEnd('validate URI_reference');
+
+// URI
+console.time('             parse URI');
+for (let i = 0; i < iterations; i++) parseUri(uri);
+console.timeEnd('             parse URI');
+
+console.time('          validate URI');
+for (let i = 0; i < iterations; i++) isUri(uri);
+console.timeEnd('          validate URI');
+
+// IRI_reference
+console.time('   parse IRI_reference');
+for (let i = 0; i < iterations; i++) parseIriReference(iri);
+console.timeEnd('   parse IRI_reference');
+
+console.time('validate IRI_reference');
+for (let i = 0; i < iterations; i++) isIriReference(iri);
+console.timeEnd('validate IRI_reference');
+
+// IRI
+console.time('             parse IRI');
+for (let i = 0; i < iterations; i++) parseIri(iri);
+console.timeEnd('             parse IRI');
+
+console.time('          validate IRI');
+for (let i = 0; i < iterations; i++) isIri(iri);
+console.timeEnd('          validate IRI');

package/tests/resolve.rfc.test.js

@@ -0,0 +1,62 @@
+import { describe, expect, test } from 'vitest';
+import id from '../index.js';
+//
+const base = 'http://a/b/c/d;p?q';
+const refs = {
+    "g:h"           :  "g:h",
+    "g"             :  "http://a/b/c/g",
+    "./g"           :  "http://a/b/c/g",
+    "g/"            :  "http://a/b/c/g/",
+    "/g"            :  "http://a/g",
+    "//g"           :  "http://g",
+    "?y"            :  "http://a/b/c/d;p?y",
+    "g?y"           :  "http://a/b/c/g?y",
+    "#s"            :  "http://a/b/c/d;p?q#s",
+    "g#s"           :  "http://a/b/c/g#s",
+    "g?y#s"         :  "http://a/b/c/g?y#s",
+    ";x"            :  "http://a/b/c/;x",
+    "g;x"           :  "http://a/b/c/g;x",
+    "g;x?y#s"       :  "http://a/b/c/g;x?y#s",
+    ""              :  "http://a/b/c/d;p?q",
+    "."             :  "http://a/b/c/",
+    "./"            :  "http://a/b/c/",
+    ".."            :  "http://a/b/",
+    "../"           :  "http://a/b/",
+    "../g"          :  "http://a/b/g",
+    "../.."         :  "http://a/",
+    "../../"        :  "http://a/",
+    "../../g"       :  "http://a/g",
+    "../../../g"    :  "http://a/g",
+    "../../../../g" :  "http://a/g",
+    "/./g"          :  "http://a/g",
+    "/../g"         :  "http://a/g",
+    "g."            :  "http://a/b/c/g.",
+    ".g"            :  "http://a/b/c/.g",
+    "g.."           :  "http://a/b/c/g..",
+    "..g"           :  "http://a/b/c/..g",
+    "./../g"        :  "http://a/b/g",
+    "./g/."         :  "http://a/b/c/g/",
+    "g/./h"         :  "http://a/b/c/g/h",
+    "g/../h"        :  "http://a/b/c/h",
+    "g;x=1/./y"     :  "http://a/b/c/g;x=1/y",
+    "g;x=1/../y"    :  "http://a/b/c/y",
+    "g?y/./x"       :  "http://a/b/c/g?y/./x",
+    "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",
+}
+
+describe('resolveReference', () => {
+    Object.keys(refs).forEach((reference) => {
+        const expected = refs[reference];
+        test(`resolveReference('${reference}', '${base}') === '${expected}'`, () => {
+            const subject = id.resolveReference(reference, base);
+            expect(subject).to.equal(expected);
+        });
+    });
+});
+
+// WHATWG is adding the / if no path after authority and scheme is one of their handled: http, https, ftp, ws, wss, etc
+// Object.keys(refs).forEach((key) => {
+//     if (new URL(key, base).href !== refs[key]) console.log('[whatwg url]: Error! expected vs result:', refs[key], '=>', new URL(key, base).href);
+// });

package/tests/resolve.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, test } from 'vitest';
+import id from '../index.js';
+
+const resolveTests = [
+    // ['', 'urn:some:ip:prop', 'urn:some:ip:prop'], // invalid base (resolveReference throw)
+    // ['#', 'urn:some:ip:prop', 'urn:some:ip:prop'], // invalid base (resolveReference throw)
+    ['urn:some:ip:prop', 'urn:some:ip:prop', 'urn:some:ip:prop'],
+    ['urn:some:other:prop', 'urn:some:ip: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
+    ['http://example.com/b', '#c%2Fd%3Fe', 'http://example.com/b#c/d?e'], // Unnecessary encoding fragment
+];
+
+describe('resolveReference', () => {
+    resolveTests.forEach(([baseIri, iriReference, expected]) => {
+        test(`resolveReference('${iriReference}', '${baseIri}') === '${expected}'`, () => {
+            const subject = id.resolveReference(iriReference, baseIri);
+            expect(subject).to.equal(expected);
+        });
+    });
+});

package/tests/to-absolute.test.js

@@ -0,0 +1,12 @@
+import { describe, expect, test } from 'vitest';
+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é');
+    });
+
+    test('Scheme is required', () => {
+        expect(() => id.toAbsoluteReference('//example.com/foo?bar#baz')).to.throw(Error, 'Invalid IRI: //example.com/foo?bar#baz');
+    });
+});

package/tests/to-relative.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, test } from 'vitest';
+import id from '../index.js';
+
+describe('toRelativeReference IRI', () => {
+    test.each([
+        ['https://examplé.com/var/lib', 'https://examplé.com', '/var/lib'],
+        ['https://examplé.com/var/lib', 'https://examplé.com/z', 'var/lib'],
+        ['https://examplé.com/a/var/lib', 'https://examplé.com/a', 'a/var/lib'],
+        ['https://examplé.com/a/var/lib', 'https://examplé.com/a/', 'var/lib'],
+        ['https://examplé.com/foo/test/bar/package.json', 'https://examplé.com/foo/test', 'test/bar/package.json'],
+        ['https://examplé.com/var', 'https://examplé.com/var/lib', '../var'],
+        ['https://examplé.com/bin', 'https://examplé.com/var/lib', '../bin'],
+        ['https://examplé.com/var/lib', 'https://examplé.com/var/lib', ''],
+        ['https://examplé.com/var/apache', 'https://examplé.com/var/lib', 'apache'],
+        ['https://examplé.com/Users/a/web/b', 'https://examplé.com/Users/a/web/b/test/mails', '../../b'],
+        ['https://examplé.com/foo/bar/baz', 'https://examplé.com/foo/bar/baz-quux', 'baz'],
+        ['https://examplé.com/foo/bar/baz-quux', 'https://examplé.com/foo/bar/baz', 'baz-quux'],
+        ['https://examplé.com/baz', 'https://examplé.com/baz-quux', 'baz'],
+        ['https://examplé.com/baz-quux', 'https://examplé.com/baz', 'baz-quux'],
+        ['https://examplé.com/', 'https://examplé.com/page1/page2/foo', '../../'],
+    ])('toRelativeIri(%s, %s) => %s', (target, base, expected) => {
+        const relative = id.toRelativeReference(target, base);
+        expect(relative).to.equal(expected);
+        expect(id.resolveReference(relative, base)).to.equal(target); // sanity check
+    });
+});
+
+describe('toRelativeReference URI', () => {
+    test.each([
+        ['https://example.com/var/lib', 'https://example.com', '/var/lib'],
+        ['https://example.com/var/lib', 'https://example.com/z', 'var/lib'],
+        ['https://example.com/a/var/lib', 'https://example.com/a', 'a/var/lib'],
+        ['https://example.com/a/var/lib', 'https://example.com/a/', 'var/lib'],
+        ['https://example.com/foo/test/bar/package.json', 'https://example.com/foo/test', 'test/bar/package.json'],
+        ['https://example.com/var', 'https://example.com/var/lib', '../var'],
+        ['https://example.com/bin', 'https://example.com/var/lib', '../bin'],
+        ['https://example.com/var/lib', 'https://example.com/var/lib', ''],
+        ['https://example.com/var/apache', 'https://example.com/var/lib', 'apache'],
+        ['https://example.com/Users/a/web/b', 'https://example.com/Users/a/web/b/test/mails', '../../b'],
+        ['https://example.com/foo/bar/baz', 'https://example.com/foo/bar/baz-quux', 'baz'],
+        ['https://example.com/foo/bar/baz-quux', 'https://example.com/foo/bar/baz', 'baz-quux'],
+        ['https://example.com/baz', 'https://example.com/baz-quux', 'baz'],
+        ['https://example.com/baz-quux', 'https://example.com/baz', 'baz-quux'],
+        ['https://example.com/', 'https://example.com/page1/page2/foo', '../../'],
+    ])('toRelativeIri(%s, %s) => %s', (target, base, expected) => {
+        const relative = id.toRelativeReference(target, base);
+        expect(relative).to.equal(expected);
+        expect(id.resolveReference(relative, base)).to.equal(target); // sanity check
+    });
+});