@startinblox/core 0.17.21-beta.9 → 0.17.22

package/dist/_snowpack/pkg/jsonld-context-parser.js

@@ -1,804 +0,0 @@
-import { c as createCommonjsModule, a as commonjsGlobal, g as getDefaultExportFromCjs } from './common/_commonjsHelpers-8c19dec8.js';
-
-// native patch for: node-fetch, whatwg-fetch
-// ref: https://github.com/tc39/proposal-global
-var getGlobal = function () {
-  if (typeof self !== 'undefined') { return self; }
-  if (typeof window !== 'undefined') { return window; }
-  if (typeof global !== 'undefined') { return global; }
-  throw new Error('unable to locate global object');
-};
-var global = getGlobal();
-global.fetch.bind(global);
-global.Headers;
-global.Request;
-global.Response;
-
-// the whatwg-fetch polyfill installs the fetch() function
-// on the global object (window or self)
-//
-// Return that as the export for use in Webpack, Browserify etc.
-
-self.fetch.bind(self);
-
-var Resolve = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Convert the given relative IRI to an absolute IRI
- * by taking into account the given optional baseIRI.
- *
- * @param {string} relativeIRI The relative IRI to convert to an absolute IRI.
- * @param {string} baseIRI The optional base IRI.
- * @return {string} an absolute IRI.
- */
-function resolve(relativeIRI, baseIRI) {
-    baseIRI = baseIRI || '';
-    const baseFragmentPos = baseIRI.indexOf('#');
-    // Ignore any fragments in the base IRI
-    if (baseFragmentPos > 0) {
-        baseIRI = baseIRI.substr(0, baseFragmentPos);
-    }
-    // Convert empty value directly to base IRI
-    if (!relativeIRI.length) {
-        // At this point, the baseIRI MUST be absolute, otherwise we error
-        if (baseIRI.indexOf(':') < 0) {
-            throw new Error(`Found invalid baseIRI '${baseIRI}' for value '${relativeIRI}'`);
-        }
-        return baseIRI;
-    }
-    // If the value starts with a query character, concat directly (but strip the existing query)
-    if (relativeIRI.startsWith('?')) {
-        const baseQueryPos = baseIRI.indexOf('?');
-        if (baseQueryPos > 0) {
-            baseIRI = baseIRI.substr(0, baseQueryPos);
-        }
-        return baseIRI + relativeIRI;
-    }
-    // If the value starts with a fragment character, concat directly
-    if (relativeIRI.startsWith('#')) {
-        return baseIRI + relativeIRI;
-    }
-    // Ignore baseIRI if it is empty
-    if (!baseIRI.length) {
-        const relativeColonPos = relativeIRI.indexOf(':');
-        if (relativeColonPos < 0) {
-            throw new Error(`Found invalid relative IRI '${relativeIRI}' for a missing baseIRI`);
-        }
-        return removeDotSegmentsOfPath(relativeIRI, relativeColonPos);
-    }
-    // Ignore baseIRI if the value is absolute
-    const valueColonPos = relativeIRI.indexOf(':');
-    if (valueColonPos >= 0) {
-        return removeDotSegmentsOfPath(relativeIRI, valueColonPos);
-    }
-    // At this point, the baseIRI MUST be absolute, otherwise we error
-    const baseColonPos = baseIRI.indexOf(':');
-    if (baseColonPos < 0) {
-        throw new Error(`Found invalid baseIRI '${baseIRI}' for value '${relativeIRI}'`);
-    }
-    const baseIRIScheme = baseIRI.substr(0, baseColonPos + 1);
-    // Inherit the baseIRI scheme if the value starts with '//'
-    if (relativeIRI.indexOf('//') === 0) {
-        return baseIRIScheme + removeDotSegmentsOfPath(relativeIRI, valueColonPos);
-    }
-    // Check cases where '://' occurs in the baseIRI, and where there is no '/' after a ':' anymore.
-    let baseSlashAfterColonPos;
-    if (baseIRI.indexOf('//', baseColonPos) === baseColonPos + 1) {
-        // If there is no additional '/' after the '//'.
-        baseSlashAfterColonPos = baseIRI.indexOf('/', baseColonPos + 3);
-        if (baseSlashAfterColonPos < 0) {
-            // If something other than a '/' follows the '://', append the value after a '/',
-            // otherwise, prefix the value with only the baseIRI scheme.
-            if (baseIRI.length > baseColonPos + 3) {
-                return baseIRI + '/' + removeDotSegmentsOfPath(relativeIRI, valueColonPos);
-            }
-            else {
-                return baseIRIScheme + removeDotSegmentsOfPath(relativeIRI, valueColonPos);
-            }
-        }
-    }
-    else {
-        // If there is not even a single '/' after the ':'
-        baseSlashAfterColonPos = baseIRI.indexOf('/', baseColonPos + 1);
-        if (baseSlashAfterColonPos < 0) {
-            // If we don't have a '/' after the ':',
-            // prefix the value with only the baseIRI scheme.
-            return baseIRIScheme + removeDotSegmentsOfPath(relativeIRI, valueColonPos);
-        }
-    }
-    // If the value starts with a '/', then prefix it with everything before the first effective slash of the base IRI.
-    if (relativeIRI.indexOf('/') === 0) {
-        return baseIRI.substr(0, baseSlashAfterColonPos) + removeDotSegments(relativeIRI);
-    }
-    let baseIRIPath = baseIRI.substr(baseSlashAfterColonPos);
-    const baseIRILastSlashPos = baseIRIPath.lastIndexOf('/');
-    // Ignore everything after the last '/' in the baseIRI path
-    if (baseIRILastSlashPos >= 0 && baseIRILastSlashPos < baseIRIPath.length - 1) {
-        baseIRIPath = baseIRIPath.substr(0, baseIRILastSlashPos + 1);
-        // Also remove the first character of the relative path if it starts with '.' (and not '..' or './')
-        // This change is only allowed if there is something else following the path
-        if (relativeIRI[0] === '.' && relativeIRI[1] !== '.' && relativeIRI[1] !== '/' && relativeIRI[2]) {
-            relativeIRI = relativeIRI.substr(1);
-        }
-    }
-    // Prefix the value with the baseIRI path where
-    relativeIRI = baseIRIPath + relativeIRI;
-    // Remove dot segment from the IRI
-    relativeIRI = removeDotSegments(relativeIRI);
-    // Prefix our transformed value with the part of the baseIRI until the first '/' after the first ':'.
-    return baseIRI.substr(0, baseSlashAfterColonPos) + relativeIRI;
-}
-exports.resolve = resolve;
-/**
- * Remove dot segments from the given path,
- * as described in https://www.ietf.org/rfc/rfc3986.txt (page 32).
- * @param {string} path An IRI path.
- * @return {string} A path, will always start with a '/'.
- */
-function removeDotSegments(path) {
-    // Prepare a buffer with segments between each '/.
-    // Each segment represents an array of characters.
-    const segmentBuffers = [];
-    let i = 0;
-    while (i < path.length) {
-        // Remove '/.' or '/..'
-        switch (path[i]) {
-            case '/':
-                if (path[i + 1] === '.') {
-                    if (path[i + 2] === '.') {
-                        // Start a new segment if we find an invalid character after the '.'
-                        if (!isCharacterAllowedAfterRelativePathSegment(path[i + 3])) {
-                            segmentBuffers.push([]);
-                            i++;
-                            break;
-                        }
-                        // Go to parent directory,
-                        // so we remove a parent segment
-                        segmentBuffers.pop();
-                        // Ensure that we end with a slash if there is a trailing '/..'
-                        if (!path[i + 3]) {
-                            segmentBuffers.push([]);
-                        }
-                        i += 3;
-                    }
-                    else {
-                        // Start a new segment if we find an invalid character after the '.'
-                        if (!isCharacterAllowedAfterRelativePathSegment(path[i + 2])) {
-                            segmentBuffers.push([]);
-                            i++;
-                            break;
-                        }
-                        // Ensure that we end with a slash if there is a trailing '/.'
-                        if (!path[i + 2]) {
-                            segmentBuffers.push([]);
-                        }
-                        // Go to the current directory,
-                        // so we do nothing
-                        i += 2;
-                    }
-                }
-                else {
-                    // Start a new segment
-                    segmentBuffers.push([]);
-                    i++;
-                }
-                break;
-            case '#':
-            case '?':
-                // Query and fragment string should be appended unchanged
-                if (!segmentBuffers.length) {
-                    segmentBuffers.push([]);
-                }
-                segmentBuffers[segmentBuffers.length - 1].push(path.substr(i));
-                // Break the while loop
-                i = path.length;
-                break;
-            default:
-                // Not a special character, just append it to our buffer
-                if (!segmentBuffers.length) {
-                    segmentBuffers.push([]);
-                }
-                segmentBuffers[segmentBuffers.length - 1].push(path[i]);
-                i++;
-                break;
-        }
-    }
-    return '/' + segmentBuffers.map((buffer) => buffer.join('')).join('/');
-}
-exports.removeDotSegments = removeDotSegments;
-/**
- * Removes dot segments of the given IRI.
- * @param {string} iri An IRI (or part of IRI).
- * @param {number} colonPosition The position of the first ':' in the IRI.
- * @return {string} The IRI where dot segments were removed.
- */
-function removeDotSegmentsOfPath(iri, colonPosition) {
-    // Determine where we should start looking for the first '/' that indicates the start of the path
-    let searchOffset = colonPosition + 1;
-    if (colonPosition >= 0) {
-        if (iri[colonPosition + 1] === '/' && iri[colonPosition + 2] === '/') {
-            searchOffset = colonPosition + 3;
-        }
-    }
-    else {
-        if (iri[0] === '/' && iri[1] === '/') {
-            searchOffset = 2;
-        }
-    }
-    // Determine the path
-    const pathSeparator = iri.indexOf('/', searchOffset);
-    if (pathSeparator < 0) {
-        return iri;
-    }
-    const base = iri.substr(0, pathSeparator);
-    const path = iri.substr(pathSeparator);
-    // Remove dot segments from the path
-    return base + removeDotSegments(path);
-}
-exports.removeDotSegmentsOfPath = removeDotSegmentsOfPath;
-function isCharacterAllowedAfterRelativePathSegment(character) {
-    return !character || character === '#' || character === '?' || character === '/';
-}
-
-});
-
-var relativeToAbsoluteIri = createCommonjsModule(function (module, exports) {
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(Resolve);
-
-});
-
-var FetchDocumentLoader_1 = createCommonjsModule(function (module, exports) {
-var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
-    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-
-/**
- * Loads documents via the fetch API.
- */
-class FetchDocumentLoader {
-    load(url) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield fetch(url, { headers: { accept: 'application/ld+json' } });
-            if (response.ok) {
-                return (yield response.json());
-            }
-            else {
-                throw new Error(`No valid context was found at ${url}: ${response.statusText}`);
-            }
-        });
-    }
-}
-exports.FetchDocumentLoader = FetchDocumentLoader;
-
-});
-
-var ContextParser_1 = createCommonjsModule(function (module, exports) {
-var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
-    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-
-
-
-/**
- * Parses JSON-LD contexts.
- */
-class ContextParser {
-    constructor(options) {
-        options = options || {};
-        this.documentLoader = options.documentLoader || new FetchDocumentLoader_1.FetchDocumentLoader();
-        this.documentCache = {};
-        this.validate = !options.skipValidation;
-        this.expandContentTypeToBase = options.expandContentTypeToBase;
-    }
-    /**
-     * Check if the given term is a valid compact IRI.
-     * Otherwise, it may be an IRI.
-     * @param {string} term A term.
-     * @return {boolean} If it is a compact IRI.
-     */
-    static isCompactIri(term) {
-        return term.indexOf(':') >= 0 && !(term && term[0] === '#');
-    }
-    /**
-     * Get the prefix from the given term.
-     * @see https://json-ld.org/spec/latest/json-ld/#compact-iris
-     * @param {string} term A term that is an URL or a prefixed URL.
-     * @param {IJsonLdContextNormalized} context A context.
-     * @return {string} The prefix or null.
-     */
-    static getPrefix(term, context) {
-        // Do not consider relative IRIs starting with a hash as compact IRIs
-        if (term && term[0] === '#') {
-            return null;
-        }
-        const separatorPos = term.indexOf(':');
-        if (separatorPos >= 0) {
-            // Suffix can not begin with two slashes
-            if (term.length > separatorPos + 1
-                && term.charAt(separatorPos + 1) === '/'
-                && term.charAt(separatorPos + 2) === '/') {
-                return null;
-            }
-            const prefix = term.substr(0, separatorPos);
-            // Prefix can not be an underscore (this is a blank node)
-            if (prefix === '_') {
-                return null;
-            }
-            // Prefix must match a term in the active context
-            if (context[prefix]) {
-                return prefix;
-            }
-        }
-        return null;
-    }
-    /**
-     * From a given context entry value, get the string value, or the @id field.
-     * @param contextValue A value for a term in a context.
-     * @return {string} The id value, or null.
-     */
-    static getContextValueId(contextValue) {
-        if (contextValue === null || typeof contextValue === 'string') {
-            return contextValue;
-        }
-        const id = contextValue['@id'];
-        return id ? id : null;
-    }
-    /**
-     * Expand the term or prefix of the given term if it has one,
-     * otherwise return the term as-is.
-     *
-     * This will try to expand the IRI as much as possible.
-     *
-     * Iff in vocab-mode, then other references to other terms in the context can be used,
-     * such as to `myTerm`:
-     * ```
-     * {
-     *   "myTerm": "http://example.org/myLongTerm"
-     * }
-     * ```
-     *
-     * @param {string} term A term that is an URL or a prefixed URL.
-     * @param {IJsonLdContextNormalized} context A context.
-     * @param {boolean} vocab If the term is a predicate or type and should be expanded based on @vocab,
-     *                        otherwise it is considered a regular term that is expanded based on @base.
-     * @return {string} The expanded term, the term as-is, or null if it was explicitly disabled in the context.
-     */
-    static expandTerm(term, context, vocab) {
-        ContextParser.assertNormalized(context);
-        const contextValue = context[term];
-        // Immediately return if the term was disabled in the context
-        if (contextValue === null || (contextValue && contextValue['@id'] === null)) {
-            return null;
-        }
-        // Check the @id
-        if (contextValue && vocab) {
-            const value = this.getContextValueId(contextValue);
-            if (value && value !== term) {
-                return value;
-            }
-        }
-        // Check if the term is prefixed
-        const prefix = ContextParser.getPrefix(term, context);
-        if (prefix) {
-            const value = this.getContextValueId(context[prefix]);
-            if (value) {
-                return value + term.substr(prefix.length + 1);
-            }
-        }
-        else if (vocab && context['@vocab'] && term.charAt(0) !== '@' && !ContextParser.isCompactIri(term)) {
-            return context['@vocab'] + term;
-        }
-        else if (!vocab && context['@base'] && term.charAt(0) !== '@' && !ContextParser.isCompactIri(term)) {
-            return relativeToAbsoluteIri.resolve(term, context['@base']);
-        }
-        return term;
-    }
-    /**
-     * Compact the given term using @base, @vocab, an aliased term, or a prefixed term.
-     *
-     * This will try to compact the IRI as much as possible.
-     *
-     * @param {string} iri An IRI to compact.
-     * @param {IJsonLdContextNormalized} context The context to compact with.
-     * @param {boolean} vocab If the term is a predicate or type and should be compacted based on @vocab,
-     *                        otherwise it is considered a regular term that is compacted based on @base.
-     * @return {string} The compacted term or the IRI as-is.
-     */
-    static compactIri(iri, context, vocab) {
-        ContextParser.assertNormalized(context);
-        // Try @vocab compacting
-        if (vocab && context['@vocab'] && iri.startsWith(context['@vocab'])) {
-            return iri.substr(context['@vocab'].length);
-        }
-        // Try @base compacting
-        if (!vocab && context['@base'] && iri.startsWith(context['@base'])) {
-            return iri.substr(context['@base'].length);
-        }
-        // Loop over all terms in the context
-        // This will try to prefix as short as possible.
-        // Once a fully compacted alias is found, return immediately, as we can not go any shorter.
-        const shortestPrefixing = { prefix: '', suffix: iri };
-        for (const key in context) {
-            const value = context[key];
-            if (value && !key.startsWith('@')) {
-                const contextIri = this.getContextValueId(value);
-                if (iri.startsWith(contextIri)) {
-                    const suffix = iri.substr(contextIri.length);
-                    if (!suffix) {
-                        if (vocab) {
-                            // Immediately return on compacted alias
-                            return key;
-                        }
-                    }
-                    else if (suffix.length < shortestPrefixing.suffix.length) {
-                        // Overwrite the shortest prefix
-                        shortestPrefixing.prefix = key;
-                        shortestPrefixing.suffix = suffix;
-                    }
-                }
-            }
-        }
-        // Return the shortest prefix
-        if (shortestPrefixing.prefix) {
-            return shortestPrefixing.prefix + ':' + shortestPrefixing.suffix;
-        }
-        return iri;
-    }
-    /**
-     * An an assert to check if the given context has been normalized.
-     * An error will be thrown otherwise.
-     * @param {JsonLdContext} context A context.
-     */
-    static assertNormalized(context) {
-        if (typeof context === 'string' || Array.isArray(context) || context['@context']) {
-            throw new Error('The given context is not normalized. Make sure to call ContextParser.parse() first.');
-        }
-    }
-    /**
-     * Check if the given context value can be a prefix value.
-     * @param value A context value.
-     * @return {boolean} If it can be a prefix value.
-     */
-    static isPrefixValue(value) {
-        return value && (typeof value === 'string' || value['@id'] || value['@type']);
-    }
-    /**
-     * Check if the given IRI is valid.
-     * @param {string} iri A potential IRI.
-     * @return {boolean} If the given IRI is valid.
-     */
-    static isValidIri(iri) {
-        return ContextParser.IRI_REGEX.test(iri);
-    }
-    /**
-     * Add an @id term for all @reverse terms.
-     * @param {IJsonLdContextNormalized} context A context.
-     * @return {IJsonLdContextNormalized} The mutated input context.
-     */
-    static idifyReverseTerms(context) {
-        for (const key of Object.keys(context)) {
-            const value = context[key];
-            if (value && typeof value === 'object') {
-                if (value['@reverse'] && !value['@id']) {
-                    if (typeof value['@reverse'] !== 'string') {
-                        throw new Error(`Invalid @reverse value: '${value['@reverse']}'`);
-                    }
-                    value['@id'] = value['@reverse'];
-                    value['@reverse'] = true;
-                }
-            }
-        }
-        return context;
-    }
-    /**
-     * Expand all prefixed terms in the given context.
-     * @param {IJsonLdContextNormalized} context A context.
-     * @param {boolean} expandContentTypeToBase If @type inside the context may be expanded
-     *                                          via @base if @vocab is set to null.
-     * @return {IJsonLdContextNormalized} The mutated input context.
-     */
-    static expandPrefixedTerms(context, expandContentTypeToBase) {
-        for (const key of Object.keys(context)) {
-            // Only expand allowed keys
-            if (ContextParser.EXPAND_KEYS_BLACKLIST.indexOf(key) < 0) {
-                // Error if we try to alias a keyword to something else.
-                if (key[0] === '@' && ContextParser.ALIAS_KEYS_BLACKLIST.indexOf(key) >= 0) {
-                    throw new Error(`Keywords can not be aliased to something else.
-Tried mapping ${key} to ${context[key]}`);
-                }
-                // Loop because prefixes might be nested
-                while (ContextParser.isPrefixValue(context[key])) {
-                    const value = context[key];
-                    let changed = false;
-                    if (typeof value === 'string') {
-                        context[key] = ContextParser.expandTerm(value, context, true);
-                        changed = changed || value !== context[key];
-                    }
-                    else {
-                        const id = value['@id'];
-                        const type = value['@type'];
-                        if (id) {
-                            context[key]['@id'] = ContextParser.expandTerm(id, context, true);
-                            changed = changed || id !== context[key]['@id'];
-                        }
-                        if (type && type !== '@vocab') {
-                            // First check @vocab, then fallback to @base
-                            context[key]['@type'] = ContextParser.expandTerm(type, context, true);
-                            if (expandContentTypeToBase && type === context[key]['@type']) {
-                                context[key]['@type'] = ContextParser.expandTerm(type, context, false);
-                            }
-                            changed = changed || type !== context[key]['@type'];
-                        }
-                    }
-                    if (!changed) {
-                        break;
-                    }
-                }
-            }
-        }
-        return context;
-    }
-    /**
-     * Normalize the @language entries in the given context to lowercase.
-     * @param {IJsonLdContextNormalized} context A context.
-     * @return {IJsonLdContextNormalized} The mutated input context.
-     */
-    static normalize(context) {
-        for (const key of Object.keys(context)) {
-            if (key === '@language' && typeof context[key] === 'string') {
-                context[key] = context[key].toLowerCase();
-            }
-            else {
-                const value = context[key];
-                if (value && typeof value === 'object') {
-                    if (typeof value['@language'] === 'string') {
-                        value['@language'] = value['@language'].toLowerCase();
-                    }
-                }
-            }
-        }
-        return context;
-    }
-    /**
-     * Validate the entries of the given context.
-     * @param {IJsonLdContextNormalized} context A context.
-     */
-    static validate(context) {
-        for (const key of Object.keys(context)) {
-            const value = context[key];
-            const valueType = typeof value;
-            // First check if the key is a keyword
-            if (key[0] === '@') {
-                switch (key.substr(1)) {
-                    case 'vocab':
-                        if (value !== null && valueType !== 'string') {
-                            throw new Error(`Found an invalid @vocab IRI: ${value}`);
-                        }
-                        break;
-                    case 'base':
-                        if (value !== null && valueType !== 'string') {
-                            throw new Error(`Found an invalid @base IRI: ${context[key]}`);
-                        }
-                        break;
-                    case 'language':
-                        if (value !== null && valueType !== 'string') {
-                            throw new Error(`Found an invalid @language string: ${value}`);
-                        }
-                        break;
-                }
-            }
-            // Otherwise, consider the key a term
-            if (value !== null) {
-                switch (valueType) {
-                    case 'string':
-                        // Always valid
-                        break;
-                    case 'object':
-                        if (!ContextParser.isCompactIri(key) && !('@id' in value)
-                            && (value['@type'] === '@id' ? !context['@base'] : !context['@vocab'])) {
-                            throw new Error(`Missing @id in context entry: '${key}': '${JSON.stringify(value)}'`);
-                        }
-                        for (const objectKey of Object.keys(value)) {
-                            const objectValue = value[objectKey];
-                            if (!objectValue) {
-                                continue;
-                            }
-                            switch (objectKey) {
-                                case '@id':
-                                    if (objectValue[0] === '@' && objectValue !== '@type' && objectValue !== '@id') {
-                                        throw new Error(`Illegal keyword alias in term value, found: '${key}': '${JSON.stringify(value)}'`);
-                                    }
-                                    break;
-                                case '@type':
-                                    if (objectValue !== '@id' && objectValue !== '@vocab'
-                                        && (objectValue[0] === '_' || !ContextParser.isValidIri(objectValue))) {
-                                        throw new Error(`A context @type must be an absolute IRI, found: '${key}': '${objectValue}'`);
-                                    }
-                                    break;
-                                case '@reverse':
-                                    if (typeof objectValue === 'string' && value['@id'] && value['@id'] !== objectValue) {
-                                        throw new Error(`Found non-matching @id and @reverse term values in '${key}':\
-'${objectValue}' and '${value['@id']}'`);
-                                    }
-                                    break;
-                                case '@container':
-                                    if (objectValue === '@list' && value['@reverse']) {
-                                        throw new Error(`Term value can not be @container: @list and @reverse at the same time on '${key}'`);
-                                    }
-                                    if (ContextParser.CONTAINERS.indexOf(objectValue) < 0) {
-                                        throw new Error(`Invalid term @container for '${key}' ('${objectValue}'), \
-must be one of ${ContextParser.CONTAINERS.join(', ')}`);
-                                    }
-                                    break;
-                                case '@language':
-                                    if (objectValue !== null && typeof objectValue !== 'string') {
-                                        throw new Error(`Found an invalid term @language string in: '${key}': '${JSON.stringify(value)}'`);
-                                    }
-                                    break;
-                            }
-                        }
-                        break;
-                    default:
-                        throw new Error(`Found an invalid term value: '${key}': '${value}'`);
-                }
-            }
-        }
-    }
-    /**
-     * Resolve relative context IRIs, or return full IRIs as-is.
-     * @param {string} contextIri A context IRI.
-     * @param {string} baseIri A base IRI.
-     * @return {string} The normalized context IRI.
-     */
-    static normalizeContextIri(contextIri, baseIri) {
-        if (!ContextParser.isValidIri(contextIri)) {
-            contextIri = relativeToAbsoluteIri.resolve(contextIri, baseIri);
-            if (!ContextParser.isValidIri(contextIri)) {
-                throw new Error(`Invalid context IRI: ${contextIri}`);
-            }
-        }
-        return contextIri;
-    }
-    /**
-     * Parse a JSON-LD context in any form.
-     * @param {JsonLdContext} context A context, URL to a context, or an array of contexts/URLs.
-     * @param {IParseOptions} options Optional parsing options.
-     * @return {Promise<IJsonLdContextNormalized>} A promise resolving to the context.
-     */
-    parse(context, { baseIri, parentContext, external } = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (context === null || context === undefined) {
-                // Context that are explicitly set to null are empty.
-                return baseIri ? { '@base': baseIri } : {};
-            }
-            else if (typeof context === 'string') {
-                return this.parse(yield this.load(ContextParser.normalizeContextIri(context, baseIri)), { baseIri, parentContext, external: true });
-            }
-            else if (Array.isArray(context)) {
-                // As a performance consideration, first load all external contexts in parallel.
-                const contexts = yield Promise.all(context.map((subContext) => {
-                    if (typeof subContext === 'string') {
-                        return this.load(ContextParser.normalizeContextIri(subContext, baseIri));
-                    }
-                    else {
-                        return subContext;
-                    }
-                }));
-                return contexts.reduce((accContextPromise, contextEntry) => accContextPromise
-                    .then((accContext) => this.parse(contextEntry, {
-                    baseIri: accContext && accContext['@base'] || baseIri,
-                    external,
-                    parentContext: accContext,
-                })), Promise.resolve(parentContext));
-            }
-            else if (typeof context === 'object') {
-                if (context['@context']) {
-                    return yield this.parse(context['@context'], { baseIri, parentContext, external });
-                }
-                // Make a deep clone of the given context, to avoid modifying it.
-                context = JSON.parse(JSON.stringify(context)); // No better way in JS at the moment...
-                // We have an actual context object.
-                let newContext = {};
-                // According to the JSON-LD spec, @base must be ignored from external contexts.
-                if (external) {
-                    delete context['@base'];
-                }
-                // Override the base IRI if provided.
-                if (baseIri) {
-                    if (!('@base' in context)) {
-                        // The context base is the document base
-                        context['@base'] = baseIri;
-                    }
-                    else if (context['@base'] !== null && !ContextParser.isValidIri(context['@base'])) {
-                        // The context base is relative to the document base
-                        context['@base'] = relativeToAbsoluteIri.resolve(context['@base'], baseIri);
-                    }
-                }
-                newContext = Object.assign({}, newContext, parentContext, context);
-                ContextParser.idifyReverseTerms(newContext);
-                ContextParser.expandPrefixedTerms(newContext, this.expandContentTypeToBase);
-                ContextParser.normalize(newContext);
-                if (this.validate) {
-                    ContextParser.validate(newContext);
-                }
-                return newContext;
-            }
-            else {
-                throw new Error(`Tried parsing a context that is not a string, array or object, but got ${context}`);
-            }
-        });
-    }
-    load(url) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cached = this.documentCache[url];
-            if (cached) {
-                return Array.isArray(cached) ? cached.slice() : Object.assign({}, cached);
-            }
-            return this.documentCache[url] = (yield this.documentLoader.load(url))['@context'];
-        });
-    }
-}
-// Regex for valid IRIs
-ContextParser.IRI_REGEX = /^([A-Za-z][A-Za-z0-9+-.]*|_):[^ "<>{}|\\\[\]`]*$/;
-// Keys in the contexts that will not be expanded based on the base IRI
-ContextParser.EXPAND_KEYS_BLACKLIST = [
-    '@base',
-    '@vocab',
-    '@language',
-];
-// Keys in the contexts that may not be aliased
-ContextParser.ALIAS_KEYS_BLACKLIST = [
-    '@container',
-    '@graph',
-    '@id',
-    '@index',
-    '@list',
-    '@nest',
-    '@none',
-    '@prefix',
-    '@reverse',
-    '@set',
-    '@type',
-    '@value',
-];
-// All valid @container values
-ContextParser.CONTAINERS = [
-    '@list',
-    '@set',
-    '@index',
-    '@language',
-];
-exports.ContextParser = ContextParser;
-
-});
-
-var jsonldContextParser = createCommonjsModule(function (module, exports) {
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(ContextParser_1);
-__export(FetchDocumentLoader_1);
-
-});
-
-var __pika_web_default_export_for_treeshaking__ = /*@__PURE__*/getDefaultExportFromCjs(jsonldContextParser);
-
-export default __pika_web_default_export_for_treeshaking__;
-//# sourceMappingURL=jsonld-context-parser.js.map