@startinblox/core 0.19.0-beta.2 → 0.19.0-beta.21

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

@@ -1,836 +0,0 @@
-import { c as createCommonjsModule, a as commonjsGlobal, b as getDefaultExportFromCjs } from './common/_commonjsHelpers-0597c316.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);
-const Headers = global.Headers;
-const Request = global.Request;
-const Response = 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.
-
-var fetchNpmBrowserify = self.fetch.bind(self);
-
-var Resolve = createCommonjsModule(function (module, exports) {
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.removeDotSegmentsOfPath = exports.removeDotSegments = exports.resolve = void 0;
-/**
- * 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) {
-
-var __createBinding = commonjsGlobal && commonjsGlobal.__createBinding || (Object.create ? function (o, m, k, k2) {
-  if (k2 === undefined) k2 = k;
-  Object.defineProperty(o, k2, {
-    enumerable: true,
-    get: function () {
-      return m[k];
-    }
-  });
-} : function (o, m, k, k2) {
-  if (k2 === undefined) k2 = k;
-  o[k2] = m[k];
-});
-var __exportStar = commonjsGlobal && commonjsGlobal.__exportStar || function (m, exports) {
-  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-__exportStar(Resolve, exports);
-});
-
-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