@noeldemartin/solid-utils 0.1.1-next.1f0cf6ccc237588ae655211348e94eba9ba16c8d → 0.1.1-next.2c9924cd927c0b708aef3ff4426982469f3b86fd

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noeldemartin/solid-utils",
-  "version": "0.1.1-next.1f0cf6ccc237588ae655211348e94eba9ba16c8d",
+  "version": "0.1.1-next.2c9924cd927c0b708aef3ff4426982469f3b86fd",
   "description": "My JavaScript utilities for Solid",
   "main": "dist/noeldemartin-solid-utils.cjs.js",
   "module": "dist/noeldemartin-solid-utils.esm.js",
@@ -29,7 +29,7 @@
   "homepage": "https://github.com/noeldemartin/solid-utils",
   "dependencies": {
     "@babel/runtime": "^7.14.0",
-    "@noeldemartin/utils": "^0.2.1-next.1d98ba7681512958f6bf2401b26c5c6433670098",
+    "@noeldemartin/utils": "^0.2.1-next.9dca1131badcdf7e51828a07ba72e4a428503066",
     "@types/rdf-js": "^4.0.1",
     "core-js": "^3.12.1",
     "jest-diff": "^26.6.2",

package/src/errors/MalformedSolidDocumentError.ts

@@ -1,4 +1,4 @@
-import { Error } from '@noeldemartin/utils';
+import { JSError } from '@noeldemartin/utils';
 
 function errorMessage(
     documentUrl: string | null,
@@ -14,7 +14,7 @@ export enum SolidDocumentFormat {
     Turtle = 'Turtle',
 }
 
-export default class MalformedSolidDocumentError extends Error {
+export default class MalformedSolidDocumentError extends JSError {
 
     public readonly documentUrl: string | null;
     public readonly documentFormat: SolidDocumentFormat;

package/src/errors/NetworkRequestError.ts

@@ -1,11 +1,12 @@
-import { Error } from '@noeldemartin/utils';
+import { JSError } from '@noeldemartin/utils';
+import type { JSErrorOptions } from '@noeldemartin/utils';
 
-export default class NetworkRequestError extends Error {
+export default class NetworkRequestError extends JSError {
 
     public readonly url: string;
 
-    constructor(url: string) {
-        super(`Request failed trying to fetch ${url}`);
+    constructor(url: string, options?: JSErrorOptions) {
+        super(`Request failed trying to fetch ${url}`, options);
 
         this.url = url;
     }

package/src/errors/NotFoundError.ts

@@ -1,6 +1,6 @@
-import { Error } from '@noeldemartin/utils';
+import { JSError } from '@noeldemartin/utils';
 
-export default class NotFoundError extends Error {
+export default class NotFoundError extends JSError {
 
     public readonly url: string;
 

package/src/errors/UnauthorizedError.ts

@@ -1,4 +1,4 @@
-import { Error } from '@noeldemartin/utils';
+import { JSError } from '@noeldemartin/utils';
 
 function errorMessage(url: string, responseStatus?: number): string {
     const typeInfo = responseStatus === 403 ? ' (Forbidden)' : '';
@@ -6,7 +6,7 @@ function errorMessage(url: string, responseStatus?: number): string {
     return `Unauthorized${typeInfo}: ${url}`;
 }
 
-export default class UnauthorizedError extends Error {
+export default class UnauthorizedError extends JSError {
 
     public readonly url: string;
     public readonly responseStatus?: number;

package/src/errors/UnsuccessfulNetworkRequestError.ts

@@ -0,0 +1,23 @@
+import { JSError } from '@noeldemartin/utils';
+
+function getErrorMessage(messageOrResponse: string | Response, response?: Response): string {
+    response = response ?? messageOrResponse as Response;
+
+    return typeof messageOrResponse === 'string'
+        ? `${messageOrResponse} (returned ${response.status} status code)`
+        : `Request to ${response.url} returned ${response.status} status code`;
+}
+
+export default class UnsuccessfulRequestError extends JSError {
+
+    public response: Response;
+
+    constructor(response: Response);
+    constructor(message: string, response: Response);
+    constructor(messageOrResponse: string | Response, response?: Response) {
+        super(getErrorMessage(messageOrResponse, response));
+
+        this.response = response ?? messageOrResponse as Response;
+    }
+
+}

package/src/errors/index.ts

@@ -2,3 +2,4 @@ export { default as MalformedSolidDocumentError, SolidDocumentFormat } from './M
 export { default as NetworkRequestError } from './NetworkRequestError';
 export { default as NotFoundError } from './NotFoundError';
 export { default as UnauthorizedError } from './UnauthorizedError';
+export { default as UnsuccessfulRequestError } from './NetworkRequestError';

package/src/helpers/auth.ts

@@ -1,11 +1,17 @@
 import { objectWithoutEmpty, silenced, urlParentDirectory, urlRoot, urlRoute } from '@noeldemartin/utils';
 
+import SolidStore from '../models/SolidStore';
+import UnauthorizedError from '../errors/UnauthorizedError';
+import type SolidDocument from '../models/SolidDocument';
+
 import { fetchSolidDocument } from './io';
 import type { Fetch } from './io';
 
 export interface SolidUserProfile {
     webId: string;
     storageUrls: string[];
+    cloaked: boolean;
+    writableProfileUrl: string | null;
     name?: string;
     avatarUrl?: string;
     oidcIssuerUrl?: string;
@@ -13,16 +19,72 @@ export interface SolidUserProfile {
     privateTypeIndexUrl?: string;
 }
 
+async function fetchExtendedUserProfile(webIdDocument: SolidDocument, fetch?: Fetch): Promise<{
+    store: SolidStore;
+    cloaked: boolean;
+    writableProfileUrl: string | null;
+}> {
+    const store = new SolidStore(webIdDocument.getQuads());
+    const documents: Record<string, SolidDocument | false | null> = { [webIdDocument.url]: webIdDocument };
+    const addReferencedDocumentUrls = (document: SolidDocument) => document
+        .statements(undefined, 'foaf:isPrimaryTopicOf')
+        .map(quad => quad.object.value)
+        .forEach(profileDocumentUrl => documents[profileDocumentUrl] = documents[profileDocumentUrl] ?? null);
+    const loadProfileDocuments = async (): Promise<void> => {
+        for (const [url, document] of Object.entries(documents)) {
+            if (document !== null) {
+                continue;
+            }
+
+            try {
+                const document = await fetchSolidDocument(url, fetch);
+
+                documents[url] = document;
+                store.addQuads(document.getQuads());
+
+                addReferencedDocumentUrls(document);
+            } catch (error) {
+                if (error instanceof UnauthorizedError) {
+                    documents[url] = false;
+
+                    continue;
+                }
+
+                throw error;
+            }
+        }
+    };
+
+    addReferencedDocumentUrls(webIdDocument);
+
+    do {
+        await loadProfileDocuments();
+    } while (Object.values(documents).some(document => document === null));
+
+    return {
+        store,
+        cloaked: Object.values(documents).some(document => document === false),
+        writableProfileUrl:
+            webIdDocument.isUserWritable()
+                ? webIdDocument.url
+                : Object
+                    .values(documents)
+                    .find((document): document is SolidDocument => !!document && document.isUserWritable())
+                    ?.url ?? null,
+    };
+}
+
 async function fetchUserProfile(webId: string, fetch?: Fetch): Promise<SolidUserProfile> {
     const documentUrl = urlRoute(webId);
     const document = await fetchSolidDocument(documentUrl, fetch);
 
-    if (!document.isPersonalProfile())
-        throw new Error(`Document at ${documentUrl} is not a profile.`);
+    if (!document.isPersonalProfile() && !document.contains(webId, 'solid:oidcIssuer'))
+        throw new Error(`${webId} is not a valid webId.`);
 
-    const storageUrls = document.statements(webId, 'pim:storage').map(storage => storage.object.value);
-    const publicTypeIndex = document.statement(webId, 'solid:publicTypeIndex');
-    const privateTypeIndex = document.statement(webId, 'solid:privateTypeIndex');
+    const { store, writableProfileUrl, cloaked } = await fetchExtendedUserProfile(document, fetch);
+    const storageUrls = store.statements(webId, 'pim:storage').map(storage => storage.object.value);
+    const publicTypeIndex = store.statement(webId, 'solid:publicTypeIndex');
+    const privateTypeIndex = store.statement(webId, 'solid:privateTypeIndex');
 
     let parentUrl = urlParentDirectory(documentUrl);
     while (parentUrl && storageUrls.length === 0) {
@@ -37,19 +99,23 @@ async function fetchUserProfile(webId: string, fetch?: Fetch): Promise<SolidUser
         parentUrl = urlParentDirectory(parentUrl);
     }
 
-    return objectWithoutEmpty({
+    return {
         webId,
         storageUrls,
-        name:
-            document.statement(webId, 'vcard:fn')?.object.value ??
-            document.statement(webId, 'foaf:name')?.object.value,
-        avatarUrl:
-            document.statement(webId, 'vcard:hasPhoto')?.object.value ??
-            document.statement(webId, 'foaf:img')?.object.value,
-        oidcIssuerUrl: document.statement(webId, 'solid:oidcIssuer')?.object.value,
-        publicTypeIndexUrl: publicTypeIndex?.object.value,
-        privateTypeIndexUrl: privateTypeIndex?.object.value,
-    });
+        cloaked,
+        writableProfileUrl,
+        ...objectWithoutEmpty({
+            name:
+                store.statement(webId, 'vcard:fn')?.object.value ??
+                store.statement(webId, 'foaf:name')?.object.value,
+            avatarUrl:
+                store.statement(webId, 'vcard:hasPhoto')?.object.value ??
+                store.statement(webId, 'foaf:img')?.object.value,
+            oidcIssuerUrl: store.statement(webId, 'solid:oidcIssuer')?.object.value,
+            publicTypeIndexUrl: publicTypeIndex?.object.value,
+            privateTypeIndexUrl: privateTypeIndex?.object.value,
+        }),
+    };
 }
 
 export async function fetchLoginUserProfile(loginUrl: string, fetch?: Fetch): Promise<SolidUserProfile | null> {

package/src/helpers/index.ts

@@ -5,3 +5,4 @@ export * from './io';
 export * from './jsonld';
 export * from './testing';
 export * from './vocabs';
+export * from './wac';

package/src/helpers/interop.ts

@@ -1,59 +1,95 @@
 import { uuid } from '@noeldemartin/utils';
 
 import { createSolidDocument, fetchSolidDocument, solidDocumentExists, updateSolidDocument } from '@/helpers/io';
-import type SolidThing from '@/models/SolidThing';
 import type { Fetch } from '@/helpers/io';
 import type { SolidUserProfile } from '@/helpers/auth';
 
-async function mintPrivateTypeIndexUrl(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
-    fetch = fetch ?? window.fetch;
+type TypeIndexType = 'public' | 'private';
+
+async function mintTypeIndexUrl(user: SolidUserProfile, type: TypeIndexType, fetch?: Fetch): Promise<string> {
+    fetch = fetch ?? window.fetch.bind(fetch);
 
     const storageUrl = user.storageUrls[0];
-    const typeIndexUrl = `${storageUrl}settings/privateTypeIndex`;
+    const typeIndexUrl = `${storageUrl}settings/${type}TypeIndex`;
 
     return await solidDocumentExists(typeIndexUrl, fetch)
-        ? `${storageUrl}settings/privateTypeIndex-${uuid()}`
+        ? `${storageUrl}settings/${type}TypeIndex-${uuid()}`
         : typeIndexUrl;
 }
 
-export async function createPrivateTypeIndex(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
-    fetch = fetch ?? window.fetch;
+async function createTypeIndex(user: SolidUserProfile, type: TypeIndexType, fetch?: Fetch) {
+    if (user.writableProfileUrl === null) {
+        throw new Error('Can\'t create type index without a writable profile document');
+    }
 
-    const typeIndexUrl = await mintPrivateTypeIndexUrl(user, fetch);
-    const typeIndexBody = `
-        <> a
-            <http://www.w3.org/ns/solid/terms#TypeIndex>,
-            <http://www.w3.org/ns/solid/terms#UnlistedDocument> .
-    `;
+    fetch = fetch ?? window.fetch.bind(fetch);
+
+    const typeIndexUrl = await mintTypeIndexUrl(user, type, fetch);
+    const typeIndexBody = type === 'public'
+        ? '<> a <http://www.w3.org/ns/solid/terms#TypeIndex> .'
+        : `
+            <> a
+                <http://www.w3.org/ns/solid/terms#TypeIndex>,
+                <http://www.w3.org/ns/solid/terms#UnlistedDocument> .
+        `;
     const profileUpdateBody = `
         INSERT DATA {
-            <${user.webId}> <http://www.w3.org/ns/solid/terms#privateTypeIndex> <${typeIndexUrl}> .
+            <${user.webId}> <http://www.w3.org/ns/solid/terms#${type}TypeIndex> <${typeIndexUrl}> .
         }
     `;
 
     await Promise.all([
         createSolidDocument(typeIndexUrl, typeIndexBody, fetch),
-        updateSolidDocument(user.webId, profileUpdateBody, fetch),
+        updateSolidDocument(user.writableProfileUrl, profileUpdateBody, fetch),
     ]);
 
+    if (type === 'public') {
+        // TODO Implement updating ACLs for the listing itself to public
+    }
+
     return typeIndexUrl;
 }
 
-export async function findContainerRegistration(
+async function findRegistrations(
     typeIndexUrl: string,
-    childrenType: string,
+    type: string | string[],
+    predicate: string,
     fetch?: Fetch,
-): Promise<SolidThing | null> {
+): Promise<string[]> {
     const typeIndex = await fetchSolidDocument(typeIndexUrl, fetch);
-    const containerQuad = typeIndex
-        .statements(undefined, 'rdfs:type', 'solid:TypeRegistration')
-        .find(
-            statement =>
-                typeIndex.contains(statement.subject.value, 'solid:forClass', childrenType) &&
-                typeIndex.contains(statement.subject.value, 'solid:instanceContainer'),
-        );
-
-    return containerQuad
-        ? typeIndex.getThing(containerQuad.subject.value) ?? null
-        : null;
+    const types = Array.isArray(type) ? type : [type];
+
+    return types.map(
+        type => typeIndex
+            .statements(undefined, 'rdf:type', 'solid:TypeRegistration')
+            .filter(statement => typeIndex.contains(statement.subject.value, 'solid:forClass', type))
+            .map(statement => typeIndex.statements(statement.subject.value, predicate))
+            .flat()
+            .map(statement => statement.object.value)
+            .filter(url => !!url),
+    ).flat();
+}
+
+export async function createPublicTypeIndex(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
+    return createTypeIndex(user, 'public', fetch);
+}
+
+export async function createPrivateTypeIndex(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
+    return createTypeIndex(user, 'private', fetch);
+}
+
+export async function findContainerRegistrations(
+    typeIndexUrl: string,
+    type: string | string[],
+    fetch?: Fetch,
+): Promise<string[]> {
+    return findRegistrations(typeIndexUrl, type, 'solid:instanceContainer', fetch);
+}
+
+export async function findInstanceRegistrations(
+    typeIndexUrl: string,
+    type: string | string[],
+    fetch?: Fetch,
+): Promise<string[]> {
+    return findRegistrations(typeIndexUrl, type, 'solid:instance', fetch);
 }

package/src/helpers/io.ts

@@ -1,8 +1,8 @@
-import { arr, arrayFilter, arrayReplace,objectWithoutEmpty } from '@noeldemartin/utils';
+import md5 from 'md5';
+import { arr, arrayFilter, arrayReplace, objectWithoutEmpty, stringMatchAll, tap } from '@noeldemartin/utils';
 import { BlankNode as N3BlankNode, Quad as N3Quad, Parser as TurtleParser, Writer as TurtleWriter } from 'n3';
+import { fromRDF, toRDF } from 'jsonld';
 import type { JsonLdDocument } from 'jsonld';
-import { toRDF } from 'jsonld';
-import md5 from 'md5';
 import type { Quad } from 'rdf-js';
 import type { Term as N3Term } from 'n3';
 
@@ -13,10 +13,10 @@ import NetworkRequestError from '@/errors/NetworkRequestError';
 import NotFoundError from '@/errors/NotFoundError';
 import UnauthorizedError from '@/errors/UnauthorizedError';
 import { isJsonLDGraph } from '@/helpers/jsonld';
-import type { JsonLD } from '@/helpers/jsonld';
+import type { JsonLD, JsonLDGraph, JsonLDResource } from '@/helpers/jsonld';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export declare type AnyFetch = (input: any, options?: any) => Promise<any>;
+export declare type AnyFetch = (input: any, options?: any) => Promise<Response>;
 export declare type TypedFetch = (input: RequestInfo, options?: RequestInit) => Promise<Response>;
 export declare type Fetch = TypedFetch | AnyFetch;
 
@@ -44,7 +44,10 @@ async function fetchRawSolidDocument(url: string, fetch: Fetch): Promise<{ body:
         if (error instanceof UnauthorizedError)
             throw error;
 
-        throw new NetworkRequestError(url);
+        if (error instanceof NotFoundError)
+            throw error;
+
+        throw new NetworkRequestError(url, { cause: error });
     }
 }
 
@@ -52,26 +55,23 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
     const normalizedQuads = quads.slice(0);
     const quadsIndexes: Record<string, Set<number>> = {};
     const blankNodeIds = arr(quads)
-        .flatMap((quad, index) => {
-            const ids = arrayFilter([
-                quad.object.termType === 'BlankNode' ? quad.object.value : null,
-                quad.subject.termType === 'BlankNode' ? quad.subject.value : null,
-            ]);
-
-            for (const id of ids) {
-                quadsIndexes[id] = quadsIndexes[id] ?? new Set();
-                quadsIndexes[id].add(index);
-            }
-
-            return ids;
-        })
+        .flatMap(
+            (quad, index) => tap(
+                arrayFilter([
+                    quad.object.termType === 'BlankNode' ? quad.object.value : null,
+                    quad.subject.termType === 'BlankNode' ? quad.subject.value : null,
+                ]),
+                ids => ids.forEach(id => (quadsIndexes[id] ??= new Set()).add(index)),
+            ),
+        )
         .filter()
         .unique();
 
     for (const originalId of blankNodeIds) {
+        const quadIndexes = quadsIndexes[originalId] as Set<number>;
         const normalizedId = md5(
-            arr(quadsIndexes[originalId])
-                .map(index => quads[index])
+            arr(quadIndexes)
+                .map(index => quads[index] as Quad)
                 .filter(({ subject: { termType, value } }) => termType === 'BlankNode' && value === originalId)
                 .map(
                     ({ predicate, object }) => object.termType === 'BlankNode'
@@ -82,9 +82,12 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
                 .join(),
         );
 
-        for (const index of quadsIndexes[originalId]) {
-            const quad = normalizedQuads[index];
-            const terms: Record<string, N3Term> = { subject: quad.subject as N3Term, object: quad.object as N3Term };
+        for (const index of quadIndexes) {
+            const quad = normalizedQuads[index] as Quad;
+            const terms: Record<string, N3Term> = {
+                subject: quad.subject as N3Term,
+                object: quad.object as N3Term,
+            };
 
             for (const [termName, termValue] of Object.entries(terms)) {
                 if (termValue.termType !== 'BlankNode' || termValue.value !== originalId)
@@ -93,7 +96,15 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
                 terms[termName] = new N3BlankNode(normalizedId);
             }
 
-            arrayReplace(normalizedQuads, quad, new N3Quad(terms.subject, quad.predicate as N3Term, terms.object));
+            arrayReplace(
+                normalizedQuads,
+                quad,
+                new N3Quad(
+                    terms.subject as N3Term,
+                    quad.predicate as N3Term,
+                    terms.object as N3Term,
+                ),
+            );
         }
     }
 
@@ -106,7 +117,7 @@ export interface ParsingOptions {
 }
 
 export async function createSolidDocument(url: string, body: string, fetch?: Fetch): Promise<SolidDocument> {
-    fetch = fetch ?? window.fetch;
+    fetch = fetch ?? window.fetch.bind(window);
 
     const statements = await turtleToQuads(body);
 
@@ -126,6 +137,19 @@ export async function fetchSolidDocument(url: string, fetch?: Fetch): Promise<So
     return new SolidDocument(url, statements, headers);
 }
 
+export async function fetchSolidDocumentIfFound(url: string, fetch?: Fetch): Promise<SolidDocument | null> {
+    try {
+        const document = await fetchSolidDocument(url, fetch);
+
+        return document;
+    } catch (error) {
+        if (!(error instanceof NotFoundError))
+            throw error;
+
+        return null;
+    }
+}
+
 export async function jsonldToQuads(jsonld: JsonLD): Promise<Quad[]> {
     if (isJsonLDGraph(jsonld)) {
         const graphQuads = await Promise.all(jsonld['@graph'].map(jsonldToQuads));
@@ -149,6 +173,14 @@ export function normalizeSparql(sparql: string): string {
         .join(' ;\n');
 }
 
+export async function quadsToJsonLD(quads: Quad[]): Promise<JsonLDGraph> {
+    const graph = await fromRDF(quads);
+
+    return {
+        '@graph': graph as JsonLDResource[],
+    };
+}
+
 export function quadsToTurtle(quads: Quad[]): string {
     const writer = new TurtleWriter;
 
@@ -175,7 +207,7 @@ export async function sparqlToQuads(
     sparql: string,
     options: Partial<ParsingOptions> = {},
 ): Promise<Record<string, Quad[]>> {
-    const operations = sparql.matchAll(/(\w+) DATA {([^}]+)}/g);
+    const operations = stringMatchAll<3>(sparql, /(\w+) DATA {([^}]+)}/g);
     const quads: Record<string, Quad[]> = {};
 
     await Promise.all([...operations].map(async operation => {
@@ -189,7 +221,7 @@ export async function sparqlToQuads(
 }
 
 export function sparqlToQuadsSync(sparql: string, options: Partial<ParsingOptions> = {}): Record<string, Quad[]> {
-    const operations = sparql.matchAll(/(\w+) DATA {([^}]+)}/g);
+    const operations = stringMatchAll<3>(sparql, /(\w+) DATA {([^}]+)}/g);
     const quads: Record<string, Quad[]> = {};
 
     for (const operation of operations) {
@@ -253,7 +285,7 @@ export function turtleToQuadsSync(turtle: string, options: Partial<ParsingOption
 }
 
 export async function updateSolidDocument(url: string, body: string, fetch?: Fetch): Promise<void> {
-    fetch = fetch ?? window.fetch;
+    fetch = fetch ?? window.fetch.bind(window);
 
     await fetch(url, {
         method: 'PATCH',

package/src/helpers/testing.ts

@@ -1,4 +1,4 @@
-import { Error, arrayRemove, pull } from '@noeldemartin/utils';
+import { JSError, arrayRemove, pull, stringMatchAll } from '@noeldemartin/utils';
 import type { JsonLD } from '@/helpers/jsonld';
 import type { Quad, Quad_Object } from 'rdf-js';
 
@@ -9,7 +9,7 @@ const builtInPatterns: Record<string, string> = {
     '%uuid%': '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}',
 };
 
-class ExpectedQuadAssertionError extends Error {
+class ExpectedQuadAssertionError extends JSError {
 
     constructor(public readonly expectedQuad: Quad) {
         super(`Couldn't find the following triple: ${quadToTurtle(expectedQuad)}`);
@@ -32,37 +32,36 @@ function containsPatterns(value: string): boolean {
     return /\[\[(.*\]\[)?([^\]]+)\]\]/.test(value);
 }
 
-function quadValueEquals(expected: string, actual: string): boolean {
-    if (!containsPatterns(expected))
-        return expected === actual;
-
+function createPatternRegexp(expected: string): RegExp {
     const patternAliases = [];
+    const patternMatches = stringMatchAll<4, 1 | 2>(
+        expected,
+        /\[\[((.*?)\]\[)?([^\]]+)\]\]/g,
+    );
+    const patterns: string[] = [];
+    let expectedRegExp = expected;
 
-    if (!(expected in patternsRegExpsIndex)) {
-        const patternMatches = expected.matchAll(/\[\[((.*?)\]\[)?([^\]]+)\]\]/g);
-        const patterns: string[] = [];
-        let expectedRegExp = expected;
-
-        for (const patternMatch of patternMatches) {
-            if (patternMatch[2]) {
-                patternAliases.push(patternMatch[2]);
-            }
+    for (const patternMatch of patternMatches) {
+        patternMatch[2] && patternAliases.push(patternMatch[2]);
 
-            patterns.push(patternMatch[3]);
-
-            expectedRegExp = expectedRegExp.replace(patternMatch[0], `%PATTERN${patterns.length - 1}%`);
-        }
+        patterns.push(patternMatch[3]);
 
-        expectedRegExp = expectedRegExp.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+        expectedRegExp = expectedRegExp.replace(patternMatch[0], `%PATTERN${patterns.length - 1}%`);
+    }
 
-        for (const [patternIndex, pattern] of Object.entries(patterns)) {
-            expectedRegExp = expectedRegExp.replace(`%PATTERN${patternIndex}%`, builtInPatterns[pattern] ?? pattern);
-        }
+    expectedRegExp = expectedRegExp.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
 
-        patternsRegExpsIndex[expected] = new RegExp(expectedRegExp);
+    for (const [patternIndex, pattern] of Object.entries(patterns)) {
+        expectedRegExp = expectedRegExp.replace(`%PATTERN${patternIndex}%`, builtInPatterns[pattern] ?? pattern);
     }
 
-    return patternsRegExpsIndex[expected].test(actual);
+    return new RegExp(expectedRegExp);
+}
+
+function quadValueEquals(expected: string, actual: string): boolean {
+    return containsPatterns(expected)
+        ? (patternsRegExpsIndex[expected] ??= createPatternRegexp(expected)).test(actual)
+        : expected === actual;
 }
 
 function quadObjectEquals(expected: Quad_Object, actual: Quad_Object): boolean {

package/src/helpers/vocabs.ts

@@ -6,10 +6,12 @@ export interface ExpandIRIOptions {
 }
 
 const knownPrefixes: RDFContext = {
+    acl: 'http://www.w3.org/ns/auth/acl#',
     foaf: 'http://xmlns.com/foaf/0.1/',
     pim: 'http://www.w3.org/ns/pim/space#',
     purl: 'http://purl.org/dc/terms/',
-    rdfs: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
     schema: 'https://schema.org/',
     solid: 'http://www.w3.org/ns/solid/terms#',
     vcard: 'http://www.w3.org/2006/vcard/ns#',
@@ -25,7 +27,7 @@ export function expandIRI(iri: string, options: Partial<ExpandIRIOptions> = {}):
 
     const [prefix, name] = iri.split(':');
 
-    if (name) {
+    if (prefix && name) {
         const expandedPrefix = knownPrefixes[prefix] ?? options.extraContext?.[prefix] ?? null;
 
         if (!expandedPrefix)