@solid/lit-pod/dist/index.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var crossFetch = require('cross-fetch');
var LinkHeader = _interopDefault(require('http-link-header'));
var dataset = require('@rdfjs/dataset');
var n3 = require('n3');

/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

function __awaiter(thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * @ignore Internal fallback for when no fetcher is provided; not to be used downstream.
 */
const fetch = (resource, init) => {
    // Implementation note: it's up to the client application to resolve these module names to the
    // respective npm packages. At least one commonly used tool (Webpack) is only able to do that if
    // the module names are literal strings.
    // Additionally, Webpack throws a warning in a way that halts compilation for at least Next.js
    // when using native Javascript dynamic imports (`import()`), whereas `require()` just logs a
    // warning. Since the use of package names instead of file names requires a bundles anyway, this
    // should not have any practical consequences. For more background, see:
    // https://github.com/webpack/webpack/issues/7713
    let fetch;
    try {
        fetch = require("@inrupt/solid-auth-fetcher").fetch;
    }
    catch (e) {
        try {
            fetch = require("solid-auth-client").fetch;
        }
        catch (e) {
            fetch = require("cross-fetch");
        }
    }
    return fetch(resource, init);
};

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
const defaultFetchFileOptions = {
    fetch: fetch,
};
const RESERVED_HEADERS = ["Slug", "If-None-Match", "Content-Type"];
/**
 * Some of the headers must be set by the library, rather than directly.
 */
function containsReserved(header) {
    return RESERVED_HEADERS.some((reserved) => header.has(reserved));
}
/**
 * Fetches a file at a given URL, and returns it as a blob of data.
 *
 * Please note that this function is still experimental: its API can change in non-major releases.
 *
 * @param url The URL of the fetched file
 * @param options Fetching options: a custom fetcher and/or headers.
 */
function unstable_fetchFile(input, options = defaultFetchFileOptions) {
    return __awaiter(this, void 0, void 0, function* () {
        const config = Object.assign(Object.assign({}, defaultFetchFileOptions), options);
        return config.fetch(input, config.init);
    });
}
/**
 * Deletes a file at a given URL
 *
 * Please note that this function is still experimental: its API can change in non-major releases.
 *
 * @param input The URL of the file to delete
 */
function unstable_deleteFile(input, options = defaultFetchFileOptions) {
    return __awaiter(this, void 0, void 0, function* () {
        const config = Object.assign(Object.assign({}, defaultFetchFileOptions), options);
        return config.fetch(input, Object.assign(Object.assign({}, config.init), { method: "DELETE" }));
    });
}
/**
 * Saves a file in a folder at a given URL. The server will return the final
 * filename (which may or may not be the given `slug`), it will return it in
 * the response's Location header.
 *
 * @param folderUrl The URL of the folder where the new file is saved
 * @param file The file to be written
 * @param options Additional parameters for file creation (e.g. a slug)
 */
function unstable_saveFileInContainer(folderUrl, file, options = defaultFetchFileOptions) {
    return __awaiter(this, void 0, void 0, function* () {
        return writeFile(folderUrl, file, "POST", options);
    });
}
/**
 * Saves a file at a given URL, erasing any previous content.
 *
 * @param fileUrl The URL where the file is saved
 * @param file The file to be written
 * @param options Additional parameters for file creation (e.g. a slug)
 */
function unstable_overwriteFile(fileUrl, file, options = defaultFetchFileOptions) {
    return __awaiter(this, void 0, void 0, function* () {
        return writeFile(fileUrl, file, "PUT", options);
    });
}
/**
 * Internal function that performs the actual write HTTP query, either POST
 * or PUT depending on the use case.
 *
 * @param fileUrl The URL where the file is saved
 * @param file The file to be written
 * @param method The HTTP method
 * @param options Additional parameters for file creation (e.g. a slug)
 */
function writeFile(targetUrl, file, method, options) {
    var _a, _b;
    return __awaiter(this, void 0, void 0, function* () {
        const config = Object.assign(Object.assign({}, defaultFetchFileOptions), options);
        const headers = new crossFetch.Headers((_b = (_a = config.init) === null || _a === void 0 ? void 0 : _a.headers) !== null && _b !== void 0 ? _b : {});
        if (containsReserved(headers)) {
            throw new Error(`No reserved header (${RESERVED_HEADERS.join(", ")}) should be set in the optional RequestInit.`);
        }
        // If a slug is in the parameters, set the request headers accordingly
        if (config.slug !== undefined) {
            headers.append("Slug", config.slug);
        }
        headers.append("Content-Type", file.type);
        return yield config.fetch(targetUrl, Object.assign(Object.assign({}, config.init), { headers,
            method, body: file }));
    });
}

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * @internal
 */
const DataFactory = { quad: dataset.quad, literal: dataset.literal, namedNode: dataset.namedNode, blankNode: dataset.blankNode };
/**
 * Clone a Dataset.
 *
 * Note that the Quads are not cloned, i.e. if you modify the Quads in the output Dataset, the Quads
 * in the input Dataset will also be changed.
 *
 * @internal
 * @param input Dataset to clone.
 * @returns A new Dataset with the same Quads as `input`.
 */
function clone(input) {
    const output = dataset.dataset();
    for (const quad of input) {
        output.add(quad);
    }
    return output;
}
/**
 * @internal
 * @param input Dataset to clone.
 * @param callback Function that takes a Quad, and returns a boolean indicating whether that Quad should be included in the cloned Dataset.
 * @returns A new Dataset with the same Quads as `input`, excluding the ones for which `callback` returned `false`.
 */
function filter(input, callback) {
    const output = dataset.dataset();
    for (const quad of input) {
        if (callback(quad)) {
            output.add(quad);
        }
    }
    return output;
}

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * @param quads Triples that should be serialised to Turtle
 * @internal Utility method for internal use; not part of the public API.
 */
function triplesToTurtle(quads) {
    return __awaiter(this, void 0, void 0, function* () {
        const format = "text/turtle";
        const writer = new n3.Writer({ format: format });
        // Remove any potentially lingering references to Named Graphs in Quads;
        // they'll be determined by the URL the Turtle will be sent to:
        const triples = quads.map((quad) => DataFactory.quad(quad.subject, quad.predicate, quad.object, undefined));
        writer.addQuads(triples);
        const writePromise = new Promise((resolve, reject) => {
            writer.end((error, result) => {
                /* istanbul ignore if [n3.js doesn't actually pass an error nor a result, apparently: https://github.com/rdfjs/N3.js/blob/62682e48c02d8965b4d728cb5f2cbec6b5d1b1b8/src/N3Writer.js#L290] */
                if (error) {
                    return reject(error);
                }
                resolve(result);
            });
        });
        const rawTurtle = yield writePromise;
        return rawTurtle;
    });
}
/**
 * @param raw Turtle that should be parsed into Triples
 * @internal Utility method for internal use; not part of the public API.
 */
function turtleToTriples(raw, resourceIri) {
    return __awaiter(this, void 0, void 0, function* () {
        const format = "text/turtle";
        const parser = new n3.Parser({ format: format, baseIRI: resourceIri });
        const parsingPromise = new Promise((resolve, reject) => {
            const parsedTriples = [];
            parser.parse(raw, (error, triple, _prefixes) => {
                if (error) {
                    return reject(error);
                }
                if (triple) {
                    parsedTriples.push(triple);
                }
                else {
                    resolve(parsedTriples);
                }
            });
        });
        return parsingPromise;
    });
}

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * IRIs of the XML Schema data types we support
 * @internal
 */
const xmlSchemaTypes = {
    boolean: "http://www.w3.org/2001/XMLSchema#boolean",
    dateTime: "http://www.w3.org/2001/XMLSchema#dateTime",
    decimal: "http://www.w3.org/2001/XMLSchema#decimal",
    integer: "http://www.w3.org/2001/XMLSchema#integer",
    string: "http://www.w3.org/2001/XMLSchema#string",
    langString: "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString",
};
/**
 * @internal
 * @param value Value to serialise.
 * @returns String representation of `value`.
 */
function serializeBoolean(value) {
    return value ? "1" : "0";
}
/**
 * @internal
 * @param value Value to deserialise.
 * @returns Deserialized boolean, or null if the given value is not a valid serialised boolean.
 */
function deserializeBoolean(value) {
    if (value === "1") {
        return true;
    }
    else if (value === "0") {
        return false;
    }
    else {
        return null;
    }
}
/**
 * @internal
 * @param value Value to serialise.
 * @returns String representation of `value`.
 */
function serializeDatetime(value) {
    // To align with rdflib, we ignore miliseconds:
    // https://github.com/linkeddata/rdflib.js/blob/d84af88f367b8b5f617c753d8241c5a2035458e8/src/literal.js#L74
    const roundedDate = new Date(Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate(), value.getUTCHours(), value.getUTCMinutes(), value.getUTCSeconds(), 0));
    // Truncate the `.000Z` at the end (i.e. the miliseconds), to plain `Z`:
    const rdflibStyleString = roundedDate.toISOString().replace(/\.000Z$/, "Z");
    return rdflibStyleString;
}
/**
 * @internal
 * @param value Value to deserialise.
 * @returns Deserialized datetime, or null if the given value is not a valid serialised datetime.
 */
function deserializeDatetime(literalString) {
    if (literalString === null ||
        literalString.length <= 17 ||
        literalString.indexOf("Z") === -1) {
        return null;
    }
    // See https://github.com/linkeddata/rdflib.js/blob/d84af88f367b8b5f617c753d8241c5a2035458e8/src/literal.js#L87
    const utcFullYear = parseInt(literalString.substring(0, 4), 10);
    const utcMonth = parseInt(literalString.substring(5, 7), 10) - 1;
    const utcDate = parseInt(literalString.substring(8, 10), 10);
    const utcHours = parseInt(literalString.substring(11, 13), 10);
    const utcMinutes = parseInt(literalString.substring(14, 16), 10);
    const utcSeconds = parseInt(literalString.substring(17, literalString.indexOf("Z")), 10);
    const date = new Date(0);
    date.setUTCFullYear(utcFullYear);
    date.setUTCMonth(utcMonth);
    date.setUTCDate(utcDate);
    date.setUTCHours(utcHours);
    date.setUTCMinutes(utcMinutes);
    date.setUTCSeconds(utcSeconds);
    return date;
}
/**
 * @internal
 * @param value Value to serialise.
 * @returns String representation of `value`.
 */
function serializeDecimal(value) {
    return value.toString();
}
/**
 * @internal
 * @param value Value to deserialise.
 * @returns Deserialized decimal, or null if the given value is not a valid serialised decimal.
 */
function deserializeDecimal(literalString) {
    const deserialized = Number.parseFloat(literalString);
    if (Number.isNaN(deserialized)) {
        return null;
    }
    return deserialized;
}
/**
 * @internal
 * @param value Value to serialise.
 * @returns String representation of `value`.
 */
function serializeInteger(value) {
    return value.toString();
}
/**
 * @internal
 * @param value Value to deserialise.
 * @returns Deserialized integer, or null if the given value is not a valid serialised integer.
 */
function deserializeInteger(literalString) {
    const deserialized = Number.parseInt(literalString, 10);
    if (Number.isNaN(deserialized)) {
        return null;
    }
    return deserialized;
}
/**
 * @internal
 * @param locale Locale to transform into a consistent format.
 */
function normalizeLocale(locale) {
    return locale.toLowerCase();
}
/**
 * @internal Library users shouldn't need to be exposed to raw NamedNodes.
 * @param value The value that might or might not be a Named Node.
 * @returns Whether `value` is a Named Node.
 */
function isNamedNode(value) {
    return (typeof value === "object" &&
        typeof value.termType === "string" &&
        value.termType === "NamedNode");
}
/**
 * @internal Library users shouldn't need to be exposed to raw Literals.
 * @param value The value that might or might not be a Literal.
 * @returns Whether `value` is a Literal.
 */
function isLiteral(value) {
    return (typeof value === "object" &&
        typeof value.termType === "string" &&
        value.termType === "Literal");
}
/**
 * @internal Library users shouldn't need to be exposed to LocalNodes.
 * @param value The value that might or might not be a Node with no known IRI yet.
 * @returns Whether `value` is a Node with no known IRI yet.
 */
function isLocalNode(value) {
    return (typeof value === "object" &&
        typeof value.termType === "string" &&
        value.termType === "BlankNode" &&
        typeof value.name === "string");
}
/**
 * Construct a new LocalNode.
 *
 * @internal Library users shouldn't need to be exposed to LocalNodes.
 * @param name Name to identify this node by.
 * @returns A LocalNode whose name will be resolved when it is persisted to a Pod.
 */
function getLocalNode(name) {
    const localNode = Object.assign(DataFactory.blankNode(), {
        name: name,
    });
    return localNode;
}
/**
 * Ensure that a given value is a Named Node.
 *
 * If the given parameter is a Named Node already, it will be returned as-is. If it is a string, it
 * will check whether it is a valid IRI. If not, it will throw an error; otherwise a Named Node
 * representing the given IRI will be returned.
 *
 * @internal Library users shouldn't need to be exposed to raw NamedNodes.
 * @param iri The IRI that should be converted into a Named Node, if it isn't one yet.
 */
function asNamedNode(iri) {
    if (isNamedNode(iri)) {
        return iri;
    }
    // If the runtime environment supports URL, instantiate one.
    // If thte given IRI is not a valid URL, it will throw an error.
    // See: https://developer.mozilla.org/en-US/docs/Web/API/URL
    /* istanbul ignore else [URL is available in our testing environment, so we cannot test the alternative] */
    if (typeof URL !== "undefined") {
        new URL(iri);
    }
    return DataFactory.namedNode(iri);
}
/**
 * Check whether two current- or potential NamedNodes are/will be equal.
 *
 * @internal Utility method; library users should not need to interact with LocalNodes directly.
 */
function isEqual(node1, node2, options = {}) {
    if (isNamedNode(node1) && isNamedNode(node2)) {
        return node1.equals(node2);
    }
    if (isLocalNode(node1) && isLocalNode(node2)) {
        return node1.name === node2.name;
    }
    if (typeof options.resourceIri === "undefined") {
        // If we don't know what IRI to resolve the LocalNode to,
        // we cannot conclude that it is equal to the NamedNode's full IRI:
        return false;
    }
    const namedNode1 = isNamedNode(node1)
        ? node1
        : resolveIriForLocalNode(node1, options.resourceIri);
    const namedNode2 = isNamedNode(node2)
        ? node2
        : resolveIriForLocalNode(node2, options.resourceIri);
    return namedNode1.equals(namedNode2);
}
/**
 * @internal Utility method; library users should not need to interact with LocalNodes directly.
 * @param quad The Quad to resolve LocalNodes in.
 * @param resourceIri The IRI of the Resource to resolve the LocalNodes against.
 */
function resolveIriForLocalNodes(quad, resourceIri) {
    const subject = isLocalNode(quad.subject)
        ? resolveIriForLocalNode(quad.subject, resourceIri)
        : quad.subject;
    const object = isLocalNode(quad.object)
        ? resolveIriForLocalNode(quad.object, resourceIri)
        : quad.object;
    return Object.assign(Object.assign({}, quad), { subject: subject, object: object });
}
/**
 * @internal Utility method; library users should not need to interact with LocalNodes directly.
 * @param localNode The LocalNode to resolve to a NamedNode.
 * @param resourceIri The Resource in which the Node will be saved.
 */
function resolveIriForLocalNode(localNode, resourceIri) {
    return DataFactory.namedNode(resolveLocalIri(localNode.name, resourceIri));
}
/**
 * @internal API for internal use only.
 * @param name The name identifying a Thing.
 * @param resourceIri The Resource in which the Thing can be found.
 */
function resolveLocalIri(name, resourceIri) {
    /* istanbul ignore if [The URL interface is available in the testing environment, so we cannot test this] */
    if (typeof URL === "undefined") {
        throw new Error("The URL interface is not available, so an IRI cannot be determined.");
    }
    const thingIri = new URL(resourceIri);
    thingIri.hash = name;
    return thingIri.href;
}

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
// TODO: These should be replaced by auto-generated constants,
//       if we can ensure that unused constants will be excluded from bundles.
/** @internal */
const acl = {
    Authorization: "http://www.w3.org/ns/auth/acl#Authorization",
    accessTo: "http://www.w3.org/ns/auth/acl#accessTo",
    agent: "http://www.w3.org/ns/auth/acl#agent",
    default: "http://www.w3.org/ns/auth/acl#default",
    mode: "http://www.w3.org/ns/auth/acl#mode",
};
/** @internal */
const rdf = {
    type: "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
};

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * Verify whether a given LitDataset includes metadata about where it was retrieved from.
 *
 * @param dataset A [[LitDataset]] that may have metadata attached about the Resource it was retrieved from.
 * @returns True if `dataset` includes metadata about the Resource it was retrieved from, false if not.
 */
function hasDatasetInfo(dataset) {
    const potentialDatasetInfo = dataset;
    return typeof potentialDatasetInfo.datasetInfo === "object";
}
/** @internal */
function hasChangelog(dataset) {
    const potentialChangeLog = dataset;
    return (typeof potentialChangeLog.changeLog === "object" &&
        Array.isArray(potentialChangeLog.changeLog.additions) &&
        Array.isArray(potentialChangeLog.changeLog.deletions));
}
/**
 * Given a [[LitDataset]], verify whether it has ACL data attached to it.
 *
 * This should generally only be true for LitDatasets fetched by
 * [[unstable_fetchLitDatasetWithAcl]].
 *
 * @param dataset A [[LitDataset]].
 * @returns Whether the given `dataset` has ACL data attached to it.
 * @internal
 */
function unstable_hasAccessibleAcl(dataset) {
    return typeof dataset.datasetInfo.unstable_aclUrl === "string";
}

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * Extract Quads with a given Subject from a [[LitDataset]] into a [[Thing]].
 *
 * @param litDataset The [[LitDataset]] to extract the [[Thing]] from.
 * @param thingUrl The URL of the desired [[Thing]].
 * @param options Not yet implemented.
 */
function getThingOne(litDataset, thingUrl, options = {}) {
    const subject = isLocalNode(thingUrl) ? thingUrl : asNamedNode(thingUrl);
    const scope = options.scope
        ? asNamedNode(options.scope)
        : null;
    const thingDataset = litDataset.match(subject, null, null, scope);
    if (isLocalNode(subject)) {
        const thing = Object.assign(thingDataset, {
            name: subject.name,
        });
        return thing;
    }
    else {
        const thing = Object.assign(thingDataset, {
            url: subject.value,
        });
        return thing;
    }
}
/**
 * Get all [[Thing]]s about which a [[LitDataset]] contains Quads.
 *
 * @param litDataset The [[LitDataset]] to extract the [[Thing]]s from.
 * @param options Not yet implemented.
 */
function getThingAll(litDataset, options = {}) {
    const subjectNodes = new Array();
    for (const quad of litDataset) {
        // Because NamedNode objects with the same IRI are actually different
        // object instances, we have to manually check whether `subjectNodes` does
        // not yet include `quadSubject` before adding it.
        const quadSubject = quad.subject;
        if (isNamedNode(quadSubject) &&
            !subjectNodes.some((subjectNode) => isEqual(subjectNode, quadSubject))) {
            subjectNodes.push(quadSubject);
        }
        if (isLocalNode(quadSubject) &&
            !subjectNodes.some((subjectNode) => isEqual(subjectNode, quadSubject))) {
            subjectNodes.push(quadSubject);
        }
    }
    const things = subjectNodes.map((subjectNode) => getThingOne(litDataset, subjectNode, options));
    return things;
}
/**
 * Insert a [[Thing]] into a [[LitDataset]], replacing previous instances of that Thing.
 *
 * @param litDataset The LitDataset to insert a Thing into.
 * @param thing The Thing to insert into the given LitDataset.
 * @returns A new LitDataset equal to the given LitDataset, but with the given Thing.
 */
function setThing(litDataset, thing) {
    const newDataset = removeThing(litDataset, thing);
    for (const quad of thing) {
        newDataset.add(quad);
        newDataset.changeLog.additions.push(quad);
    }
    return newDataset;
}
/**
 * Remove a Thing from a LitDataset.
 *
 * @param litDataset The LitDataset to remove a Thing from.
 * @param thing The Thing to remove from `litDataset`.
 * @returns A new [[LitDataset]] equal to the input LitDataset, excluding the given Thing.
 */
function removeThing(litDataset, thing) {
    const newLitDataset = withChangeLog(cloneLitStructs(litDataset));
    const resourceIri = hasDatasetInfo(newLitDataset)
        ? newLitDataset.datasetInfo.fetchedFrom
        : undefined;
    const thingSubject = toNode(thing);
    for (const quad of litDataset) {
        if (!isNamedNode(quad.subject) && !isLocalNode(quad.subject)) {
            // This data is unexpected, and hence unlikely to be added by us. Thus, leave it intact:
            newLitDataset.add(quad);
        }
        else if (!isEqual(thingSubject, quad.subject, { resourceIri: resourceIri })) {
            newLitDataset.add(quad);
        }
        else {
            newLitDataset.changeLog.deletions.push(quad);
        }
    }
    return newLitDataset;
}
function withChangeLog(litDataset) {
    const newLitDataset = hasChangelog(litDataset)
        ? litDataset
        : Object.assign(litDataset, {
            changeLog: { additions: [], deletions: [] },
        });
    return newLitDataset;
}
function cloneLitStructs(litDataset) {
    const freshDataset = dataset.dataset();
    if (hasChangelog(litDataset)) {
        freshDataset.changeLog = {
            additions: [...litDataset.changeLog.additions],
            deletions: [...litDataset.changeLog.deletions],
        };
    }
    if (hasDatasetInfo(litDataset)) {
        freshDataset.datasetInfo = Object.assign({}, litDataset.datasetInfo);
    }
    return freshDataset;
}
function createThing(options = {}) {
    var _a;
    if (typeof options.url !== "undefined") {
        const url = options.url;
        /* istanbul ignore else [URL is defined is the testing environment, so we cannot test this] */
        if (typeof URL !== "undefined") {
            // Throws an error if the IRI is invalid:
            new URL(url);
        }
        const thing = Object.assign(dataset.dataset(), { url: url });
        return thing;
    }
    const name = (_a = options.name) !== null && _a !== void 0 ? _a : generateName();
    const thing = Object.assign(dataset.dataset(), { name: name });
    return thing;
}
function asUrl(thing, baseUrl) {
    if (isThingLocal(thing)) {
        if (typeof baseUrl === "undefined") {
            throw new Error("The URL of a Thing that has not been persisted cannot be determined without a base URL.");
        }
        return resolveLocalIri(thing.name, baseUrl);
    }
    return thing.url;
}
/** @hidden Alias of [[asUrl]] for those who prefer IRI terminology. */
const asIri = asUrl;
/**
 * @param thing The [[Thing]] of which a URL might or might not be known.
 * @return Whether `thing` has no known URL yet.
 */
function isThingLocal(thing) {
    return (typeof thing.name === "string" &&
        typeof thing.url === "undefined");
}
/**
 * @internal
 * @param thing The Thing whose Subject Node you're interested in.
 * @returns A Node that can be used as the Subject for this Thing's Quads.
 */
function toNode(thing) {
    if (isNamedNode(thing) || isLocalNode(thing)) {
        return thing;
    }
    if (typeof thing === "string") {
        return asNamedNode(thing);
    }
    if (isThingLocal(thing)) {
        return getLocalNode(thing.name);
    }
    return asNamedNode(asUrl(thing));
}
function cloneThing(thing) {
    const cloned = clone(thing);
    if (isThingLocal(thing)) {
        cloned.name = thing.name;
        return cloned;
    }
    cloned.url = thing.url;
    return cloned;
}
function filterThing(thing, callback) {
    const filtered = filter(thing, callback);
    if (isThingLocal(thing)) {
        filtered.name = thing.name;
        return filtered;
    }
    filtered.url = thing.url;
    return filtered;
}
/**
 * Generate a string that can be used as the unique identifier for a Thing
 *
 * This function works by starting with a date string (so that Things can be
 * sorted chronologically), followed by a random number generated by taking a
 * random number between 0 and 1, and cutting off the `0.`.
 *
 * @internal
 * @returns An string that's likely to be unique
 */
const generateName = () => {
    return (Date.now().toString() + Math.random().toString().substring("0.".length));
};

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * @param thing The [[Thing]] to read a URL value from.
 * @param predicate The given Predicate for which you want the URL value.
 * @returns A URL value for the given Predicate, if present, or null otherwise.
 */
function getUrlOne(thing, predicate) {
    const namedNodeMatcher = getNamedNodeMatcher(predicate);
    const matchingQuad = findOne(thing, namedNodeMatcher);
    if (matchingQuad === null) {
        return null;
    }
    return matchingQuad.object.value;
}
/** @hidden Alias of [[getUrlOne]] for those who prefer IRI terminology. */
const getIriOne = getUrlOne;
/**
 * @param thing The [[Thing]] to read the URL values from.
 * @param predicate The given Predicate for which you want the URL values.
 * @returns The URL values for the given Predicate.
 */
function getUrlAll(thing, predicate) {
    const iriMatcher = getNamedNodeMatcher(predicate);
    const matchingQuads = findAll(thing, iriMatcher);
    return matchingQuads.map((quad) => quad.object.value);
}
/** @hidden Alias of [[getUrlAll]] for those who prefer IRI terminology. */
const getIriAll = getUrlAll;
/**
 * @param thing The [[Thing]] to read a boolean value from.
 * @param predicate The given Predicate for which you want the boolean value.
 * @returns A boolean value for the given Predicate, if present, or null otherwise.
 */
function getBooleanOne(thing, predicate) {
    const literalString = getLiteralOneOfType(thing, predicate, xmlSchemaTypes.boolean);
    if (literalString === null) {
        return null;
    }
    return deserializeBoolean(literalString);
}
/**
 * @param thing The [[Thing]] to read the boolean values from.
 * @param predicate The given Predicate for which you want the boolean values.
 * @returns The boolean values for the given Predicate.
 */
function getBooleanAll(thing, predicate) {
    const literalStrings = getLiteralAllOfType(thing, predicate, xmlSchemaTypes.boolean);
    return literalStrings
        .map(deserializeBoolean)
        .filter((possibleBoolean) => possibleBoolean !== null);
}
/**
 * @param thing The [[Thing]] to read a datetime value from.
 * @param predicate The given Predicate for which you want the datetime value.
 * @returns A datetime value for the given Predicate, if present, or null otherwise.
 */
function getDatetimeOne(thing, predicate) {
    const literalString = getLiteralOneOfType(thing, predicate, xmlSchemaTypes.dateTime);
    if (literalString === null) {
        return null;
    }
    return deserializeDatetime(literalString);
}
/**
 * @param thing The [[Thing]] to read the datetime values from.
 * @param predicate The given Predicate for which you want the datetime values.
 * @returns The datetime values for the given Predicate.
 */
function getDatetimeAll(thing, predicate) {
    const literalStrings = getLiteralAllOfType(thing, predicate, xmlSchemaTypes.dateTime);
    return literalStrings
        .map(deserializeDatetime)
        .filter((potentialDatetime) => potentialDatetime !== null);
}
/**
 * @param thing The [[Thing]] to read a decimal value from.
 * @param predicate The given Predicate for which you want the decimal value.
 * @returns A decimal value for the given Predicate, if present, or null otherwise.
 */
function getDecimalOne(thing, predicate) {
    const literalString = getLiteralOneOfType(thing, predicate, xmlSchemaTypes.decimal);
    if (literalString === null) {
        return null;
    }
    return deserializeDecimal(literalString);
}
/**
 * @param thing The [[Thing]] to read the decimal values from.
 * @param predicate The given Predicate for which you want the decimal values.
 * @returns The decimal values for the given Predicate.
 */
function getDecimalAll(thing, predicate) {
    const literalStrings = getLiteralAllOfType(thing, predicate, xmlSchemaTypes.decimal);
    return literalStrings
        .map((literalString) => deserializeDecimal(literalString))
        .filter((potentialDecimal) => potentialDecimal !== null);
}
/**
 * @param thing The [[Thing]] to read an integer value from.
 * @param predicate The given Predicate for which you want the integer value.
 * @returns An integer value for the given Predicate, if present, or null otherwise.
 */
function getIntegerOne(thing, predicate) {
    const literalString = getLiteralOneOfType(thing, predicate, xmlSchemaTypes.integer);
    if (literalString === null) {
        return null;
    }
    return deserializeInteger(literalString);
}
/**
 * @param thing The [[Thing]] to read the integer values from.
 * @param predicate The given Predicate for which you want the integer values.
 * @returns The integer values for the given Predicate.
 */
function getIntegerAll(thing, predicate) {
    const literalStrings = getLiteralAllOfType(thing, predicate, xmlSchemaTypes.integer);
    return literalStrings
        .map((literalString) => deserializeInteger(literalString))
        .filter((potentialInteger) => potentialInteger !== null);
}
/**
 * @param thing The [[Thing]] to read a localised string value from.
 * @param predicate The given Predicate for which you want the localised string value.
 * @param locale The desired locale for the string value.
 * @returns A localised string value for the given Predicate, if present in `locale`, or null otherwise.
 */
function getStringInLocaleOne(thing, predicate, locale) {
    const localeStringMatcher = getLocaleStringMatcher(predicate, locale);
    const matchingQuad = findOne(thing, localeStringMatcher);
    if (matchingQuad === null) {
        return null;
    }
    return matchingQuad.object.value;
}
/**
 * @param thing The [[Thing]] to read the localised string values from.
 * @param predicate The given Predicate for which you want the localised string values.
 * @param locale The desired locale for the string values.
 * @returns The localised string values for the given Predicate.
 */
function getStringInLocaleAll(thing, predicate, locale) {
    const localeStringMatcher = getLocaleStringMatcher(predicate, locale);
    const matchingQuads = findAll(thing, localeStringMatcher);
    return matchingQuads.map((quad) => quad.object.value);
}
/**
 * @param thing The [[Thing]] to read a string value from.
 * @param predicate The given Predicate for which you want the string value.
 * @returns A string value for the given Predicate, if present, or null otherwise.
 */
function getStringUnlocalizedOne(thing, predicate) {
    const literalString = getLiteralOneOfType(thing, predicate, xmlSchemaTypes.string);
    return literalString;
}
/**
 * @param thing The [[Thing]] to read the string values from.
 * @param predicate The given Predicate for which you want the string values.
 * @returns The string values for the given Predicate.
 */
function getStringUnlocalizedAll(thing, predicate) {
    const literalStrings = getLiteralAllOfType(thing, predicate, xmlSchemaTypes.string);
    return literalStrings;
}
/**
 * @param thing The [[Thing]] to read a NamedNode value from.
 * @param predicate The given Predicate for which you want the NamedNode value.
 * @returns A NamedNode value for the given Predicate, if present, or null otherwise.
 * @ignore This should not be needed due to the other get*One() functions. If you do find yourself needing it, please file a feature request for your use case.
 */
function getNamedNodeOne(thing, predicate) {
    const namedNodeMatcher = getNamedNodeMatcher(predicate);
    const matchingQuad = findOne(thing, namedNodeMatcher);
    if (matchingQuad === null) {
        return null;
    }
    return matchingQuad.object;
}
/**
 * @param thing The [[Thing]] to read the NamedNode values from.
 * @param predicate The given Predicate for which you want the NamedNode values.
 * @returns The NamedNode values for the given Predicate.
 * @ignore This should not be needed due to the other get*One() functions. If you do find yourself needing it, please file a feature request for your use case.
 */
function getNamedNodeAll(thing, predicate) {
    const namedNodeMatcher = getNamedNodeMatcher(predicate);
    const matchingQuads = findAll(thing, namedNodeMatcher);
    return matchingQuads.map((quad) => quad.object);
}
/**
 * @param thing The [[Thing]] to read a Literal value from.
 * @param predicate The given Predicate for which you want the Literal value.
 * @returns A Literal value for the given Predicate, if present, or null otherwise.
 * @ignore This should not be needed due to the other get*One() functions. If you do find yourself needing it, please file a feature request for your use case.
 */
function getLiteralOne(thing, predicate) {
    const literalMatcher = getLiteralMatcher(predicate);
    const matchingQuad = findOne(thing, literalMatcher);
    if (matchingQuad === null) {
        return null;
    }
    return matchingQuad.object;
}
/**
 * @param thing The [[Thing]] to read the Literal values from.
 * @param predicate The given Predicate for which you want the Literal values.
 * @returns The Literal values for the given Predicate.
 * @ignore This should not be needed due to the other get*All() functions. If you do find yourself needing it, please file a feature request for your use case.
 */
function getLiteralAll(thing, predicate) {
    const literalMatcher = getLiteralMatcher(predicate);
    const matchingQuads = findAll(thing, literalMatcher);
    return matchingQuads.map((quad) => quad.object);
}
/**
 * @param thing The [[Thing]] to extract a Quad from.
 * @param matcher Callback function that returns a boolean indicating whether a given Quad should be included.
 * @returns First Quad in `thing` for which `matcher` returned true.
 */
function findOne(thing, matcher) {
    for (const quad of thing) {
        if (matcher(quad)) {
            return quad;
        }
    }
    return null;
}
/**
 * @param thing The [[Thing]] to extract Quads from.
 * @param matcher Callback function that returns a boolean indicating whether a given Quad should be included.
 * @returns All Quads in `thing` for which `matcher` returned true.
 */
function findAll(thing, matcher) {
    const matched = [];
    for (const quad of thing) {
        if (matcher(quad)) {
            matched.push(quad);
        }
    }
    return matched;
}
function getNamedNodeMatcher(predicate) {
    const predicateNode = asNamedNode(predicate);
    const matcher = function matcher(quad) {
        return predicateNode.equals(quad.predicate) && isNamedNode(quad.object);
    };
    return matcher;
}
function getLiteralMatcher(predicate) {
    const predicateNode = asNamedNode(predicate);
    const matcher = function matcher(quad) {
        return predicateNode.equals(quad.predicate) && isLiteral(quad.object);
    };
    return matcher;
}
function getLiteralOfTypeMatcher(predicate, datatype) {
    const predicateNode = asNamedNode(predicate);
    const matcher = function matcher(quad) {
        return (predicateNode.equals(quad.predicate) &&
            isLiteral(quad.object) &&
            quad.object.datatype.value === datatype);
    };
    return matcher;
}
function getLocaleStringMatcher(predicate, locale) {
    const predicateNode = asNamedNode(predicate);
    const matcher = function matcher(quad) {
        return (predicateNode.equals(quad.predicate) &&
            isLiteral(quad.object) &&
            quad.object.datatype.value === xmlSchemaTypes.langString &&
            quad.object.language.toLowerCase() === locale.toLowerCase());
    };
    return matcher;
}
/**
 * @param thing The [Thing]] to read a Literal of the given type from.
 * @param predicate The given Predicate for which you want the Literal value.
 * @param literalType Set type of the Literal data.
 * @returns The stringified value for the given Predicate and type, if present, or null otherwise.
 */
function getLiteralOneOfType(thing, predicate, literalType) {
    const literalOfTypeMatcher = getLiteralOfTypeMatcher(predicate, literalType);
    const matchingQuad = findOne(thing, literalOfTypeMatcher);
    if (matchingQuad === null) {
        return null;
    }
    return matchingQuad.object.value;
}
/**
 * @param thing The [Thing]] to read the Literals of the given type from.
 * @param predicate The given Predicate for which you want the Literal values.
 * @param literalType Set type of the Literal data.
 * @returns The stringified values for the given Predicate and type.
 */
function getLiteralAllOfType(thing, predicate, literalType) {
    const literalOfTypeMatcher = getLiteralOfTypeMatcher(predicate, literalType);
    const matchingQuads = findAll(thing, literalOfTypeMatcher);
    return matchingQuads.map((quad) => quad.object.value);
}

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/** @internal */
function internal_fetchResourceAcl(dataset, options = defaultFetchOptions) {
    return __awaiter(this, void 0, void 0, function* () {
        if (!unstable_hasAccessibleAcl(dataset)) {
            return null;
        }
        try {
            const aclLitDataset = yield fetchLitDataset(dataset.datasetInfo.unstable_aclUrl, options);
            return Object.assign(aclLitDataset, {
                accessTo: dataset.datasetInfo.fetchedFrom,
            });
        }
        catch (e) {
            // Since a Solid server adds a `Link` header to an ACL even if that ACL does not exist,
            // failure to fetch the ACL is expected to happen - we just return `null` and let callers deal
            // with it.
            return null;
        }
    });
}
/** @internal */
function internal_fetchFallbackAcl(dataset, options = defaultFetchOptions) {
    return __awaiter(this, void 0, void 0, function* () {
        const resourceUrl = new URL(dataset.datasetInfo.fetchedFrom);
        const resourcePath = resourceUrl.pathname;
        // Note: we're currently assuming that the Origin is the root of the Pod. However, it is not yet
        //       set in stone that that will always be the case. We might need to check the Container's
        //       metadata at some point in time to check whether it is actually the root of the Pod.
        //       See: https://github.com/solid/specification/issues/153#issuecomment-624630022
        if (resourcePath === "/") {
            // We're already at the root, so there's no Container we can retrieve:
            return null;
        }
        const containerPath = getContainerPath(resourcePath);
        const containerIri = new URL(containerPath, resourceUrl.origin).href;
        const containerInfo = yield internal_fetchLitDatasetInfo(containerIri, options);
        if (!unstable_hasAccessibleAcl(containerInfo)) {
            // If the current user does not have access to this Container's ACL,
            // we cannot determine whether its ACL is the one that applies. Thus, return null:
            return null;
        }
        const containerAcl = yield internal_fetchResourceAcl(containerInfo, options);
        if (containerAcl === null) {
            return internal_fetchFallbackAcl(containerInfo, options);
        }
        return containerAcl;
    });
}
function getContainerPath(resourcePath) {
    const resourcePathWithoutTrailingSlash = resourcePath.substring(resourcePath.length - 1) === "/"
        ? resourcePath.substring(0, resourcePath.length - 1)
        : resourcePath;
    const containerPath = resourcePath.substring(0, resourcePathWithoutTrailingSlash.lastIndexOf("/")) + "/";
    return containerPath;
}
/**
 * Verify whether an ACL was found for the given LitDataset.
 *
 * A LitDataset fetched with [[unstable_fetchLitDatasetWithAcl]] _might_ have an ACL attached, but
 * we cannot be sure: it might be that none exists for this specific Resource (in which case the
 * fallback ACL applies), or the currently authenticated user (if any) might not have Control access
 * to the fetched Resource.
 *
 * This function verifies that the LitDataset's ACL is accessible.
 *
 * @param dataset A [[LitDataset]] that might have an ACL attached.
 * @returns Whether `dataset` has an ACL attached.
 */
function unstable_hasResourceAcl(dataset) {
    return typeof dataset.acl.resourceAcl !== "undefined";
}
function unstable_getResourceAcl(dataset) {
    if (!unstable_hasResourceAcl(dataset)) {
        return null;
    }
    return dataset.acl.resourceAcl;
}
/**
 * Verify whether a fallback ACL was found for the given LitDataset.
 *
 * A LitDataset fetched with [[unstable_fetchLitDatasetWithAcl]] _might_ have a fallback ACL
 * attached, but we cannot be sure: the currently authenticated user (if any) might not have Control
 * access to one of the fetched Resource's Containers.
 *
 * This function verifies that the fallback ACL is accessible.
 *
 * @param dataset A [[LitDataset]] that might have a fallback ACL attached.
 * @returns Whether `dataset` has a fallback ACL attached.
 */
function unstable_hasFallbackAcl(dataset) {
    return dataset.acl.fallbackAcl !== null;
}
function unstable_getFallbackAcl(dataset) {
    if (!unstable_hasFallbackAcl(dataset)) {
        return null;
    }
    return dataset.acl.fallbackAcl;
}
/** @internal */
function internal_getAclRules(aclDataset) {
    const things = getThingAll(aclDataset);
    return things.filter(isAclRule);
}
function isAclRule(thing) {
    return getIriAll(thing, rdf.type).includes(acl.Authorization);
}
/** @internal */
function internal_getResourceAclRulesForResource(aclRules, resource) {
    return aclRules.filter((rule) => appliesToResource(rule, resource));
}
function appliesToResource(aclRule, resource) {
    return getIriAll(aclRule, acl.accessTo).includes(resource);
}
/** @internal */
function internal_getDefaultAclRulesForResource(aclRules, resource) {
    return aclRules.filter((rule) => isDefaultForResource(rule, resource));
}
function isDefaultForResource(aclRule, resource) {
    return getIriAll(aclRule, acl.default).includes(resource);
}
/** @internal */
function internal_getAccessModes(rule) {
    const ruleAccessModes = getIriAll(rule, acl.mode);
    const writeAccess = ruleAccessModes.includes(accessModeIriStrings.write);
    return writeAccess
        ? {
            read: ruleAccessModes.includes(accessModeIriStrings.read),
            append: true,
            write: true,
            control: ruleAccessModes.includes(accessModeIriStrings.control),
        }
        : {
            read: ruleAccessModes.includes(accessModeIriStrings.read),
            append: ruleAccessModes.includes(accessModeIriStrings.append),
            write: false,
            control: ruleAccessModes.includes(accessModeIriStrings.control),
        };
}
/** @internal */
function internal_combineAccessModes(modes) {
    return modes.reduce((accumulator, current) => {
        const writeAccess = accumulator.write || current.write;
        return writeAccess
            ? {
                read: accumulator.read || current.read,
                append: true,
                write: true,
                control: accumulator.control || current.control,
            }
            : {
                read: accumulator.read || current.read,
                append: accumulator.append || current.append,
                write: false,
                control: accumulator.control || current.control,
            };
    }, { read: false, append: false, write: false, control: false });
}
/**
 * IRIs of potential Access Modes
 * @internal
 */
const accessModeIriStrings = {
    read: "http://www.w3.org/ns/auth/acl#Read",
    append: "http://www.w3.org/ns/auth/acl#Append",
    write: "http://www.w3.org/ns/auth/acl#Write",
    control: "http://www.w3.org/ns/auth/acl#Control",
};

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * Initialise a new [[LitDataset]] in memory.
 *
 * @returns An empty [[LitDataset]].
 */
function createLitDataset() {
    return dataset.dataset();
}
/**
 * @internal
 */
const defaultFetchOptions = {
    fetch: fetch,
};
/**
 * Fetch a LitDataset from the given URL. Currently requires the LitDataset to be available as [Turtle](https://www.w3.org/TR/turtle/).
 *
 * @param url URL to fetch a [[LitDataset]] from.
 * @param options Optional parameter `options.fetch`: An alternative `fetch` function to make the HTTP request, compatible with the browser-native [fetch API](https://developer.mozilla.org/docs/Web/API/WindowOrWorkerGlobalScope/fetch#parameters).
 * @returns Promise resolving to a [[LitDataset]] containing the data at the given Resource, or rejecting if fetching it failed.
 */
function fetchLitDataset(url, options = defaultFetchOptions) {
    return __awaiter(this, void 0, void 0, function* () {
        const config = Object.assign(Object.assign({}, defaultFetchOptions), options);
        const response = yield config.fetch(url);
        if (!response.ok) {
            throw new Error(`Fetching the Resource failed: ${response.status} ${response.statusText}.`);
        }
        const data = yield response.text();
        const triples = yield turtleToTriples(data, url);
        const resource = dataset.dataset();
        triples.forEach((triple) => resource.add(triple));
        const datasetInfo = parseDatasetInfo(response);
        const resourceWithDatasetInfo = Object.assign(resource, { datasetInfo: datasetInfo });
        return resourceWithDatasetInfo;
    });
}
/**
 * @internal
 */
function internal_fetchLitDatasetInfo(url, options = defaultFetchOptions) {
    return __awaiter(this, void 0, void 0, function* () {
        const config = Object.assign(Object.assign({}, defaultFetchOptions), options);
        const response = yield config.fetch(url, { method: "HEAD" });
        if (!response.ok) {
            throw new Error(`Fetching the Resource metadata failed: ${response.status} ${response.statusText}.`);
        }
        const datasetInfo = parseDatasetInfo(response);
        return { datasetInfo: datasetInfo };
    });
}
function parseDatasetInfo(response) {
    const datasetInfo = {
        fetchedFrom: response.url,
    };
    const linkHeader = response.headers.get("Link");
    if (linkHeader) {
        const parsedLinks = LinkHeader.parse(linkHeader);
        const aclLinks = parsedLinks.get("rel", "acl");
        if (aclLinks.length === 1) {
            datasetInfo.unstable_aclUrl = new URL(aclLinks[0].uri, datasetInfo.fetchedFrom).href;
        }
    }
    const wacAllowHeader = response.headers.get("WAC-Allow");
    if (wacAllowHeader) {
        datasetInfo.unstable_permissions = parseWacAllowHeader(wacAllowHeader);
    }
    return datasetInfo;
}
/**
 * Experimental: fetch a LitDataset and its associated Access Control List.
 *
 * This is an experimental function that fetches both a Resource, the linked ACL Resource (if
 * available), and the ACL that applies to it if the linked ACL Resource is not available. This can
 * result in many HTTP requests being executed, in lieu of the Solid spec mandating servers to
 * provide this info in a single request. Therefore, and because this function is still
 * experimental, prefer [[fetchLitDataset]] instead.
 *
 * If the Resource does not advertise the ACL Resource (because the authenticated user does not have
 * access to it), the `acl` property in the returned value will be null. `acl.resourceAcl` will be
 * undefined if the Resource's linked ACL Resource could not be fetched (because it does not exist),
 * and `acl.fallbackAcl` will be null if the applicable Container's ACL is not accessible to the
 * authenticated user.
 *
 * @param url URL of the LitDataset to fetch.
 * @param options Optional parameter `options.fetch`: An alternative `fetch` function to make the HTTP request, compatible with the browser-native [fetch API](https://developer.mozilla.org/docs/Web/API/WindowOrWorkerGlobalScope/fetch#parameters).
 * @returns A LitDataset and the ACLs that apply to it, if available to the authenticated user.
 */
function unstable_fetchLitDatasetWithAcl(url, options = defaultFetchOptions) {
    return __awaiter(this, void 0, void 0, function* () {
        const litDataset = yield fetchLitDataset(url, options);
        if (!unstable_hasAccessibleAcl(litDataset)) {
            return Object.assign(litDataset, { acl: null });
        }
        const [resourceAcl, fallbackAcl] = yield Promise.all([
            internal_fetchResourceAcl(litDataset, options),
            internal_fetchFallbackAcl(litDataset, options),
        ]);
        const acl = {
            fallbackAcl: fallbackAcl,
            resourceAcl: resourceAcl !== null ? resourceAcl : undefined,
        };
        return Object.assign(litDataset, { acl: acl });
    });
}
const defaultSaveOptions = {
    fetch: fetch,
};
/**
 * Given a LitDataset, store it in a Solid Pod (overwriting the existing data at the given URL).
 *
 * @param url URL to save `litDataset` to.
 * @param litDataset The [[LitDataset]] to save.
 * @param options Optional parameter `options.fetch`: An alternative `fetch` function to make the HTTP request, compatible with the browser-native [fetch API](https://developer.mozilla.org/docs/Web/API/WindowOrWorkerGlobalScope/fetch#parameters).
 * @returns A Promise resolving to a [[LitDataset]] containing the stored data, or rejecting if saving it failed.
 */
function saveLitDatasetAt(url, litDataset, options = defaultSaveOptions) {
    return __awaiter(this, void 0, void 0, function* () {
        const config = Object.assign(Object.assign({}, defaultSaveOptions), options);
        let requestInit;
        if (isUpdate(litDataset, url)) {
            const deleteStatement = litDataset.changeLog.deletions.length > 0
                ? `DELETE DATA {${(yield triplesToTurtle(litDataset.changeLog.deletions.map(getNamedNodesForLocalNodes))).trim()}};`
                : "";
            const insertStatement = litDataset.changeLog.additions.length > 0
                ? `INSERT DATA {${(yield triplesToTurtle(litDataset.changeLog.additions.map(getNamedNodesForLocalNodes))).trim()}};`
                : "";
            requestInit = {
                method: "PATCH",
                body: `${deleteStatement} ${insertStatement}`,
                headers: {
                    "Content-Type": "application/sparql-update",
                },
            };
        }
        else {
            requestInit = {
                method: "PUT",
                body: yield triplesToTurtle(Array.from(litDataset).map(getNamedNodesForLocalNodes)),
                headers: {
                    "Content-Type": "text/turtle",
                    "If-None-Match": "*",
                    Link: '<http://www.w3.org/ns/ldp#Resource>; rel="type"',
                },
            };
        }
        const response = yield config.fetch(url, requestInit);
        if (!response.ok) {
            throw new Error(`Storing the Resource failed: ${response.status} ${response.statusText}.`);
        }
        const datasetInfo = hasDatasetInfo(litDataset)
            ? Object.assign(Object.assign({}, litDataset.datasetInfo), { fetchedFrom: url }) : { fetchedFrom: url };
        const storedDataset = Object.assign(litDataset, {
            changeLog: { additions: [], deletions: [] },
            datasetInfo: datasetInfo,
        });
        const storedDatasetWithResolvedIris = resolveLocalIrisInLitDataset(storedDataset);
        return storedDatasetWithResolvedIris;
    });
}
function isUpdate(litDataset, url) {
    return (hasChangelog(litDataset) &&
        hasDatasetInfo(litDataset) &&
        typeof litDataset.datasetInfo.fetchedFrom === "string" &&
        litDataset.datasetInfo.fetchedFrom === url);
}
const defaultSaveInContainerOptions = {
    fetch: fetch,
};
/**
 * Given a LitDataset, store it in a Solid Pod in a new Resource inside a Container.
 *
 * @param containerUrl URL of the Container in which to create a new Resource.
 * @param litDataset The [[LitDataset]] to save to a new Resource in the given Container.
 * @param options Optional parameter `options.fetch`: An alternative `fetch` function to make the HTTP request, compatible with the browser-native [fetch API](https://developer.mozilla.org/docs/Web/API/WindowOrWorkerGlobalScope/fetch#parameters).
 * @returns A Promise resolving to a [[LitDataset]] containing the stored data linked to the new Resource, or rejecting if saving it failed.
 */
function saveLitDatasetInContainer(containerUrl, litDataset, options = defaultSaveInContainerOptions) {
    return __awaiter(this, void 0, void 0, function* () {
        const config = Object.assign(Object.assign({}, defaultSaveOptions), options);
        const rawTurtle = yield triplesToTurtle(Array.from(litDataset).map(getNamedNodesForLocalNodes));
        const headers = {
            "Content-Type": "text/turtle",
            Link: '<http://www.w3.org/ns/ldp#Resource>; rel="type"',
        };
        if (options.slugSuggestion) {
            headers.slug = options.slugSuggestion;
        }
        const response = yield config.fetch(containerUrl, {
            method: "POST",
            body: rawTurtle,
            headers: headers,
        });
        if (!response.ok) {
            throw new Error(`Storing the Resource in the Container failed: ${response.status} ${response.statusText}.`);
        }
        const locationHeader = response.headers.get("Location");
        if (locationHeader === null) {
            throw new Error("Could not determine the location for the newly saved LitDataset.");
        }
        const resourceIri = new URL(locationHeader, new URL(containerUrl).origin)
            .href;
        const datasetInfo = {
            fetchedFrom: resourceIri,
        };
        const resourceWithDatasetInfo = Object.assign(litDataset, { datasetInfo: datasetInfo });
        const resourceWithResolvedIris = resolveLocalIrisInLitDataset(resourceWithDatasetInfo);
        return resourceWithResolvedIris;
    });
}
function getNamedNodesForLocalNodes(quad) {
    const subject = isLocalNode(quad.subject)
        ? getNamedNodeFromLocalNode(quad.subject)
        : quad.subject;
    const object = isLocalNode(quad.object)
        ? getNamedNodeFromLocalNode(quad.object)
        : quad.object;
    return Object.assign(Object.assign({}, quad), { subject: subject, object: object });
}
function getNamedNodeFromLocalNode(localNode) {
    return DataFactory.namedNode("#" + localNode.name);
}
function resolveLocalIrisInLitDataset(litDataset) {
    const resourceIri = litDataset.datasetInfo.fetchedFrom;
    const unresolvedQuads = Array.from(litDataset);
    unresolvedQuads.forEach((unresolvedQuad) => {
        const resolvedQuad = resolveIriForLocalNodes(unresolvedQuad, resourceIri);
        litDataset.delete(unresolvedQuad);
        litDataset.add(resolvedQuad);
    });
    return litDataset;
}
/**
 * Parse a WAC-Allow header into user and public access booleans.
 *
 * @param wacAllowHeader A WAC-Allow header in the format `user="read append write control",public="read"`
 * @see https://github.com/solid/solid-spec/blob/cb1373a369398d561b909009bd0e5a8c3fec953b/api-rest.md#wac-allow-headers
 */
function parseWacAllowHeader(wacAllowHeader) {
    function parsePermissionStatement(permissionStatement) {
        const permissions = permissionStatement.split(" ");
        const writePermission = permissions.includes("write");
        return writePermission
            ? {
                read: permissions.includes("read"),
                append: true,
                write: true,
                control: permissions.includes("control"),
            }
            : {
                read: permissions.includes("read"),
                append: permissions.includes("append"),
                write: false,
                control: permissions.includes("control"),
            };
    }
    function getStatementFor(header, scope) {
        const relevantEntries = header
            .split(",")
            .map((rawEntry) => rawEntry.split("="))
            .filter((parts) => parts.length === 2 && parts[0].trim() === scope);
        // There should only be one statement with the given scope:
        if (relevantEntries.length !== 1) {
            return "";
        }
        const relevantStatement = relevantEntries[0][1].trim();
        // The given statement should be wrapped in double quotes to be valid:
        if (relevantStatement.charAt(0) !== '"' ||
            relevantStatement.charAt(relevantStatement.length - 1) !== '"') {
            return "";
        }
        // Return the statment without the wrapping quotes, e.g.: read append write control
        return relevantStatement.substring(1, relevantStatement.length - 1);
    }
    return {
        user: parsePermissionStatement(getStatementFor(wacAllowHeader, "user")),
        public: parsePermissionStatement(getStatementFor(wacAllowHeader, "public")),
    };
}

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * Create a new Thing with a URL added for a Predicate.
 *
 * This preserves existing values for the given Predicate. To replace them, see [[setUrl]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to add a URL value to.
 * @param predicate Predicate for which to add the given URL value.
 * @param url URL to add to `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value added for the given Predicate.
 */
const addUrl = (thing, predicate, url) => {
    const predicateNode = asNamedNode(predicate);
    const newThing = cloneThing(thing);
    newThing.add(DataFactory.quad(toNode(newThing), predicateNode, toNode(url)));
    return newThing;
};
/** @hidden Alias for [[addUrl]] for those who prefer IRI terminology. */
const addIri = addUrl;
/**
 * Create a new Thing with a boolean added for a Predicate.
 *
 * This preserves existing values for the given Predicate. To replace them, see [[setBoolean]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to add a boolean value to.
 * @param predicate Predicate for which to add the given boolean value.
 * @param value Boolean to add to `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value added for the given Predicate.
 */
const addBoolean = (thing, predicate, value) => {
    return addLiteralOfType(thing, predicate, serializeBoolean(value), xmlSchemaTypes.boolean);
};
/**
 * Create a new Thing with a datetime added for a Predicate.
 *
 * This preserves existing values for the given Predicate. To replace them, see [[setDatetime]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to add a datetime value to.
 * @param predicate Predicate for which to add the given datetime value.
 * @param value Datetime to add to `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value added for the given Predicate.
 */
const addDatetime = (thing, predicate, value) => {
    return addLiteralOfType(thing, predicate, serializeDatetime(value), xmlSchemaTypes.dateTime);
};
/**
 * Create a new Thing with a decimal added for a Predicate.
 *
 * This preserves existing values for the given Predicate. To replace them, see [[setDecimal]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to add a decimal value to.
 * @param predicate Predicate for which to add the given decimal value.
 * @param value Decimal to add to `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value added for the given Predicate.
 */
const addDecimal = (thing, predicate, value) => {
    return addLiteralOfType(thing, predicate, serializeDecimal(value), xmlSchemaTypes.decimal);
};
/**
 * Create a new Thing with an integer added for a Predicate.
 *
 * This preserves existing values for the given Predicate. To replace them, see [[setInteger]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to add an integer value to.
 * @param predicate Predicate for which to add the given integer value.
 * @param value Integer to add to `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value added for the given Predicate.
 */
const addInteger = (thing, predicate, value) => {
    return addLiteralOfType(thing, predicate, serializeInteger(value), xmlSchemaTypes.integer);
};
function addStringInLocale(thing, predicate, value, locale) {
    const literal = DataFactory.literal(value, normalizeLocale(locale));
    return addLiteral(thing, predicate, literal);
}
/**
 * Create a new Thing with an unlocalised string added for a Predicate.
 *
 * This preserves existing values for the given Predicate. To replace them, see [[setStringUnlocalized]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to add an unlocalised string value to.
 * @param predicate Predicate for which to add the given string value.
 * @param value String to add to `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value added for the given Predicate.
 */
const addStringUnlocalized = (thing, predicate, value) => {
    return addLiteralOfType(thing, predicate, value, xmlSchemaTypes.string);
};
function addNamedNode(thing, predicate, value) {
    const predicateNode = asNamedNode(predicate);
    const newThing = cloneThing(thing);
    newThing.add(DataFactory.quad(toNode(newThing), predicateNode, value));
    return newThing;
}
function addLiteral(thing, predicate, value) {
    const predicateNode = asNamedNode(predicate);
    const newThing = cloneThing(thing);
    newThing.add(DataFactory.quad(toNode(newThing), predicateNode, value));
    return newThing;
}
function addLiteralOfType(thing, predicate, value, type) {
    const literal = DataFactory.literal(value, type);
    return addLiteral(thing, predicate, literal);
}

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
function removeAll(thing, predicate) {
    const predicateNode = asNamedNode(predicate);
    const updatedThing = filterThing(thing, (quad) => !quad.predicate.equals(predicateNode));
    return updatedThing;
}
/**
 * Create a new Thing with the given URL removed for the given Predicate.
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to remove a URL value from.
 * @param predicate Predicate for which to remove the given URL value.
 * @param value URL to remove from `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value removed for the given Predicate.
 */
const removeUrl = (thing, predicate, value) => {
    const predicateNode = asNamedNode(predicate);
    const iriNode = isNamedNode(value)
        ? value
        : typeof value === "string"
            ? asNamedNode(value)
            : asNamedNode(asIri(value));
    const updatedThing = filterThing(thing, (quad) => {
        return (!quad.predicate.equals(predicateNode) ||
            !isNamedNode(quad.object) ||
            !quad.object.equals(iriNode));
    });
    return updatedThing;
};
/** @hidden Alias of [[removeUrl]] for those who prefer IRI terminology. */
const removeIri = removeUrl;
/**
 * Create a new Thing with the given boolean removed for the given Predicate.
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to remove a boolean value from.
 * @param predicate Predicate for which to remove the given boolean value.
 * @param value Boolean to remove from `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value removed for the given Predicate.
 */
const removeBoolean = (thing, predicate, value) => {
    return removeLiteralOfType(thing, predicate, serializeBoolean(value), xmlSchemaTypes.boolean);
};
/**
 * Create a new Thing with the given datetime removed for the given Predicate.
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to remove a datetime value from.
 * @param predicate Predicate for which to remove the given datetime value.
 * @param value Datetime to remove from `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value removed for the given Predicate.
 */
const removeDatetime = (thing, predicate, value) => {
    return removeLiteralOfType(thing, predicate, serializeDatetime(value), xmlSchemaTypes.dateTime);
};
/**
 * Create a new Thing with the given decimal removed for the given Predicate.
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to remove a decimal value from.
 * @param predicate Predicate for which to remove the given decimal value.
 * @param value Decimal to remove from `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value removed for the given Predicate.
 */
const removeDecimal = (thing, predicate, value) => {
    return removeLiteralOfType(thing, predicate, serializeDecimal(value), xmlSchemaTypes.decimal);
};
/**
 * Create a new Thing with the given integer removed for the given Predicate.
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to remove an integer value from.
 * @param predicate Predicate for which to remove the given integer value.
 * @param value Integer to remove from `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value removed for the given Predicate.
 */
const removeInteger = (thing, predicate, value) => {
    return removeLiteralOfType(thing, predicate, serializeInteger(value), xmlSchemaTypes.integer);
};
function removeStringInLocale(thing, predicate, value, locale) {
    // Note: Due to how the `DataFactory.literal` constructor behaves, this function
    // must call directly `removeLiteral` directly, with the locale as the data
    // type of the Literal (which is not a valid NamedNode).
    return removeLiteral(thing, predicate, DataFactory.literal(value, normalizeLocale(locale)));
}
/**
 * Create a new Thing with the given unlocalised string removed for the given Predicate.
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to remove an unlocalised string value from.
 * @param predicate Predicate for which to remove the given string value.
 * @param value String to remove from `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with the given value removed for the given Predicate.
 */
const removeStringUnlocalized = (thing, predicate, value) => {
    return removeLiteralOfType(thing, predicate, value, xmlSchemaTypes.string);
};
function removeNamedNode(thing, predicate, value) {
    const predicateNode = asNamedNode(predicate);
    const updatedThing = filterThing(thing, (quad) => {
        return (!quad.predicate.equals(predicateNode) ||
            !isNamedNode(quad.object) ||
            !quad.object.equals(value));
    });
    return updatedThing;
}
function removeLiteral(thing, predicate, value) {
    const predicateNode = asNamedNode(predicate);
    const updatedThing = filterThing(thing, (quad) => {
        return (!quad.predicate.equals(predicateNode) ||
            !isLiteral(quad.object) ||
            !quad.object.equals(value));
    });
    return updatedThing;
}
function removeLiteralOfType(thing, predicate, value, type) {
    const updatedThing = removeLiteral(thing, predicate, DataFactory.literal(value, DataFactory.namedNode(type)));
    return updatedThing;
}

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * Create a new Thing with existing values replaced by the given URL for the given Predicate.
 *
 * To preserve existing values, see [[addUrl]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to set a URL value on.
 * @param predicate Predicate for which to set the given URL value.
 * @param url URL to set on `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with existing values replaced by the given value for the given Predicate.
 */
const setUrl = (thing, predicate, url) => {
    const newThing = removeAll(thing, predicate);
    const predicateNode = asNamedNode(predicate);
    newThing.add(DataFactory.quad(toNode(newThing), predicateNode, toNode(url)));
    return newThing;
};
/** @hidden Alias of [[setUrl]] for those who prefer IRI terminology. */
const setIri = setUrl;
/**
 * Create a new Thing with existing values replaced by the given boolean for the given Predicate.
 *
 * To preserve existing values, see [[addBoolean]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to set a boolean value on.
 * @param predicate Predicate for which to set the given boolean value.
 * @param value Boolean to set on `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with existing values replaced by the given value for the given Predicate.
 */
const setBoolean = (thing, predicate, value) => {
    return setLiteralOfType(thing, predicate, serializeBoolean(value), xmlSchemaTypes.boolean);
};
/**
 * Create a new Thing with existing values replaced by the given datetime for the given Predicate.
 *
 * To preserve existing values, see [[addDatetime]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to set an datetime value on.
 * @param predicate Predicate for which to set the given datetime value.
 * @param value Datetime to set on `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with existing values replaced by the given value for the given Predicate.
 */
const setDatetime = (thing, predicate, value) => {
    return setLiteralOfType(thing, predicate, serializeDatetime(value), xmlSchemaTypes.dateTime);
};
/**
 * Create a new Thing with existing values replaced by the given decimal for the given Predicate.
 *
 * To preserve existing values, see [[addDecimal]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to set a decimal value on.
 * @param predicate Predicate for which to set the given decimal value.
 * @param value Decimal to set on `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with existing values replaced by the given value for the given Predicate.
 */
const setDecimal = (thing, predicate, value) => {
    return setLiteralOfType(thing, predicate, serializeDecimal(value), xmlSchemaTypes.decimal);
};
/**
 * Create a new Thing with existing values replaced by the given integer for the given Predicate.
 *
 * To preserve existing values, see [[addInteger]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to set an integer value on.
 * @param predicate Predicate for which to set the given integer value.
 * @param value Integer to set on `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with existing values replaced by the given value for the given Predicate.
 */
const setInteger = (thing, predicate, value) => {
    return setLiteralOfType(thing, predicate, serializeInteger(value), xmlSchemaTypes.integer);
};
function setStringInLocale(thing, predicate, value, locale) {
    const literal = DataFactory.literal(value, normalizeLocale(locale));
    return setLiteral(thing, predicate, literal);
}
/**
 * Create a new Thing with existing values replaced by the given unlocalised string for the given Predicate.
 *
 * To preserve existing values, see [[addStringUnlocalized]].
 *
 * The original `thing` is not modified; this function returns a cloned Thing with updated values.
 *
 * @param thing Thing to set an unlocalised string value on.
 * @param predicate Predicate for which to set the given unlocalised string value.
 * @param value Unlocalised string to set on `thing` for the given `predicate`.
 * @returns A new Thing equal to the input Thing with existing values replaced by the given value for the given Predicate.
 */
const setStringUnlocalized = (thing, predicate, value) => {
    return setLiteralOfType(thing, predicate, value, xmlSchemaTypes.string);
};
function setNamedNode(thing, predicate, value) {
    const newThing = removeAll(thing, predicate);
    const predicateNode = asNamedNode(predicate);
    newThing.add(DataFactory.quad(toNode(newThing), predicateNode, value));
    return newThing;
}
function setLiteral(thing, predicate, value) {
    const newThing = removeAll(thing, predicate);
    const predicateNode = asNamedNode(predicate);
    newThing.add(DataFactory.quad(toNode(newThing), predicateNode, value));
    return newThing;
}
function setLiteralOfType(thing, predicate, value, type) {
    const literal = DataFactory.literal(value, type);
    return setLiteral(thing, predicate, literal);
}

/**
 * Copyright 2020 Inrupt Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
 * Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
/**
 * Find out what Access Modes have been granted to a given Agent specifically for a given LitDataset.
 *
 * Keep in mind that this function will not tell you what access the given Agent has through other ACL rules, e.g. public or group-specific permissions.
 *
 * Also, please note that this function is still experimental: its API can change in non-major releases.
 *
 * @param dataset The LitDataset to which the given Agent may have been granted access.
 * @param agent WebID of the Agent for which to retrieve what access it has to the Resource.
 * @returns Which Access Modes have been granted to the Agent specifically for the given LitDataset, or `null` if it could not be determined (e.g. because the current user does not have Control Access to a given Resource or its Container).
 */
function unstable_getAgentAccessModesOne(dataset, agent) {
    if (unstable_hasResourceAcl(dataset)) {
        const resourceAcl = unstable_getResourceAcl(dataset);
        return unstable_getAgentResourceAccessModesOne(resourceAcl, agent);
    }
    if (unstable_hasFallbackAcl(dataset)) {
        const fallbackAcl = unstable_getFallbackAcl(dataset);
        return unstable_getAgentDefaultAccessModesOne(fallbackAcl, agent);
    }
    return null;
}
/**
 * Find out what Access Modes have been granted to specific Agents for a given LitDataset.
 *
 * Keep in mind that this function will not tell you what access arbitrary Agents might have through other ACL rules, e.g. public or group-specific permissions.
 *
 * Also, please note that this function is still experimental: its API can change in non-major releases.
 *
 * @param dataset The LitDataset to which Agents may have been granted access.
 * @returns Which Access Modes have been granted to which Agents specifically for the given LitDataset, or `null` if it could not be determined (e.g. because the current user does not have Control Access to a given Resource or its Container).
 */
function unstable_getAgentAccessModesAll(dataset) {
    if (unstable_hasResourceAcl(dataset)) {
        const resourceAcl = unstable_getResourceAcl(dataset);
        return unstable_getAgentResourceAccessModesAll(resourceAcl);
    }
    if (unstable_hasFallbackAcl(dataset)) {
        const fallbackAcl = unstable_getFallbackAcl(dataset);
        return unstable_getAgentDefaultAccessModesAll(fallbackAcl);
    }
    return null;
}
/**
 * Given an ACL LitDataset, find out which access modes it provides to an Agent for its associated Resource.
 *
 * Keep in mind that this function will not tell you:
 * - what access the given Agent has through other ACL rules, e.g. public or group-specific permissions.
 * - what access the given Agent has to child Resources, in case the associated Resource is a Container.
 *
 * Also, please note that this function is still experimental: its API can change in non-major releases.
 *
 * @param aclDataset The LitDataset that contains Access-Control List rules.
 * @param agent WebID of the Agent for which to retrieve what access it has to the Resource.
 * @returns Which Access Modes have been granted to the Agent specifically for the Resource the given ACL LitDataset is associated with.
 */
function unstable_getAgentResourceAccessModesOne(aclDataset, agent) {
    const allRules = internal_getAclRules(aclDataset);
    const resourceRules = internal_getResourceAclRulesForResource(allRules, aclDataset.accessTo);
    const agentResourceRules = getAgentAclRulesForAgent(resourceRules, agent);
    const agentAccessModes = agentResourceRules.map(internal_getAccessModes);
    return internal_combineAccessModes(agentAccessModes);
}
/**
 * Given an ACL LitDataset, find out which access modes it provides to specific Agents for the associated Resource.
 *
 * Keep in mind that this function will not tell you:
 * - what access arbitrary Agents might have been given through other ACL rules, e.g. public or group-specific permissions.
 * - what access arbitrary Agents have to child Resources, in case the associated Resource is a Container.
 *
 * Also, please note that this function is still experimental: its API can change in non-major releases.
 *
 * @param aclDataset The LitDataset that contains Access-Control List rules.
 * @returns Which Access Modes have been granted to which Agents specifically for the Resource the given ACL LitDataset is associated with.
 */
function unstable_getAgentResourceAccessModesAll(aclDataset) {
    const allRules = internal_getAclRules(aclDataset);
    const resourceRules = internal_getResourceAclRulesForResource(allRules, aclDataset.accessTo);
    const agentResourceRules = getAgentAclRules(resourceRules);
    return getAccessModesByAgent(agentResourceRules);
}
/**
 * Given an ACL LitDataset, find out which access modes it provides to an Agent for the associated Container Resource's child Resources.
 *
 * Keep in mind that this function will not tell you:
 * - what access the given Agent has through other ACL rules, e.g. public or group-specific permissions.
 * - what access the given Agent has to Container Resource itself (see [[unstable_getAgentResourceAccessModesOne]] for that).
 *
 * Also, please note that this function is still experimental: its API can change in non-major releases.
 *
 * @param aclDataset The LitDataset that contains Access-Control List rules for a certain Container.
 * @param agent WebID of the Agent for which to retrieve what access it has to the Container's children.
 * @returns Which Access Modes have been granted to the Agent specifically for the children of the Container associated with the given ACL LitDataset.
 */
function unstable_getAgentDefaultAccessModesOne(aclDataset, agent) {
    const allRules = internal_getAclRules(aclDataset);
    const resourceRules = internal_getDefaultAclRulesForResource(allRules, aclDataset.accessTo);
    const agentResourceRules = getAgentAclRulesForAgent(resourceRules, agent);
    const agentAccessModes = agentResourceRules.map(internal_getAccessModes);
    return internal_combineAccessModes(agentAccessModes);
}
/**
 * Given an ACL LitDataset, find out which access modes it provides to specific Agents for the associated Container Resource's child Resources.
 *
 * Keep in mind that this function will not tell you:
 * - what access arbitrary Agents might have been given through other ACL rules, e.g. public or group-specific permissions.
 * - what access arbitrary Agents have to the Container Resource itself (see [[unstable_getAgentResourceAccessModesAll]] for that).
 *
 * Also, please note that this function is still experimental: its API can change in non-major releases.
 *
 * @param aclDataset The LitDataset that contains Access-Control List rules.
 * @returns Which Access Modes have been granted to which Agents specifically for the children of the Container associated with the given ACL LitDataset.
 */
function unstable_getAgentDefaultAccessModesAll(aclDataset) {
    const allRules = internal_getAclRules(aclDataset);
    const resourceRules = internal_getDefaultAclRulesForResource(allRules, aclDataset.accessTo);
    const agentResourceRules = getAgentAclRules(resourceRules);
    return getAccessModesByAgent(agentResourceRules);
}
function getAgentAclRulesForAgent(aclRules, agent) {
    return aclRules.filter((rule) => appliesToAgent(rule, agent));
}
function appliesToAgent(aclRule, agent) {
    return getIriAll(aclRule, acl.agent).includes(agent);
}
function getAgentAclRules(aclRules) {
    return aclRules.filter(isAgentAclRule);
}
function isAgentAclRule(aclRule) {
    return getIriOne(aclRule, acl.agent) !== null;
}
function getAccessModesByAgent(aclRules) {
    const agentAccess = {};
    aclRules.forEach((rule) => {
        const ruleAgents = getIriAll(rule, acl.agent);
        const accessModes = internal_getAccessModes(rule);
        // A rule might apply to multiple agents. If multiple rules apply to the same agent, the Access
        // Modes granted by those rules should be combined:
        ruleAgents.forEach((agent) => {
            agentAccess[agent] =
                typeof agentAccess[agent] === "undefined"
                    ? accessModes
                    : internal_combineAccessModes([agentAccess[agent], accessModes]);
        });
    });
    return agentAccess;
}

exports.addBoolean = addBoolean;
exports.addDatetime = addDatetime;
exports.addDecimal = addDecimal;
exports.addInteger = addInteger;
exports.addIri = addIri;
exports.addLiteral = addLiteral;
exports.addNamedNode = addNamedNode;
exports.addStringInLocale = addStringInLocale;
exports.addStringUnlocalized = addStringUnlocalized;
exports.addUrl = addUrl;
exports.asIri = asIri;
exports.asUrl = asUrl;
exports.createLitDataset = createLitDataset;
exports.createThing = createThing;
exports.fetchLitDataset = fetchLitDataset;
exports.getBooleanAll = getBooleanAll;
exports.getBooleanOne = getBooleanOne;
exports.getDatetimeAll = getDatetimeAll;
exports.getDatetimeOne = getDatetimeOne;
exports.getDecimalAll = getDecimalAll;
exports.getDecimalOne = getDecimalOne;
exports.getIntegerAll = getIntegerAll;
exports.getIntegerOne = getIntegerOne;
exports.getIriAll = getIriAll;
exports.getIriOne = getIriOne;
exports.getLiteralAll = getLiteralAll;
exports.getLiteralOne = getLiteralOne;
exports.getNamedNodeAll = getNamedNodeAll;
exports.getNamedNodeOne = getNamedNodeOne;
exports.getStringInLocaleAll = getStringInLocaleAll;
exports.getStringInLocaleOne = getStringInLocaleOne;
exports.getStringUnlocalizedAll = getStringUnlocalizedAll;
exports.getStringUnlocalizedOne = getStringUnlocalizedOne;
exports.getThingAll = getThingAll;
exports.getThingOne = getThingOne;
exports.getUrlAll = getUrlAll;
exports.getUrlOne = getUrlOne;
exports.removeAll = removeAll;
exports.removeBoolean = removeBoolean;
exports.removeDatetime = removeDatetime;
exports.removeDecimal = removeDecimal;
exports.removeInteger = removeInteger;
exports.removeIri = removeIri;
exports.removeLiteral = removeLiteral;
exports.removeNamedNode = removeNamedNode;
exports.removeStringInLocale = removeStringInLocale;
exports.removeStringUnlocalized = removeStringUnlocalized;
exports.removeThing = removeThing;
exports.removeUrl = removeUrl;
exports.saveLitDatasetAt = saveLitDatasetAt;
exports.saveLitDatasetInContainer = saveLitDatasetInContainer;
exports.setBoolean = setBoolean;
exports.setDatetime = setDatetime;
exports.setDecimal = setDecimal;
exports.setInteger = setInteger;
exports.setIri = setIri;
exports.setLiteral = setLiteral;
exports.setNamedNode = setNamedNode;
exports.setStringInLocale = setStringInLocale;
exports.setStringUnlocalized = setStringUnlocalized;
exports.setThing = setThing;
exports.setUrl = setUrl;
exports.unstable_deleteFile = unstable_deleteFile;
exports.unstable_fetchFile = unstable_fetchFile;
exports.unstable_fetchLitDatasetWithAcl = unstable_fetchLitDatasetWithAcl;
exports.unstable_getAgentAccessModesAll = unstable_getAgentAccessModesAll;
exports.unstable_getAgentAccessModesOne = unstable_getAgentAccessModesOne;
exports.unstable_getAgentDefaultAccessModesAll = unstable_getAgentDefaultAccessModesAll;
exports.unstable_getAgentDefaultAccessModesOne = unstable_getAgentDefaultAccessModesOne;
exports.unstable_getAgentResourceAccessModesAll = unstable_getAgentResourceAccessModesAll;
exports.unstable_getAgentResourceAccessModesOne = unstable_getAgentResourceAccessModesOne;
exports.unstable_getFallbackAcl = unstable_getFallbackAcl;
exports.unstable_getResourceAcl = unstable_getResourceAcl;
exports.unstable_hasFallbackAcl = unstable_hasFallbackAcl;
exports.unstable_hasResourceAcl = unstable_hasResourceAcl;
exports.unstable_overwriteFile = unstable_overwriteFile;
exports.unstable_saveFileInContainer = unstable_saveFileInContainer;