BaseIRI.js

import { escapeRegex } from './Util';

const BASE_UNSUPPORTED = /^:?[^:?#]*(?:[?#]|$)|^file:|^[^:]*:\/*[^?#]+?\/(?:\.\.?(?:\/|$)|\/)/i;
const SUFFIX_SUPPORTED = /^(?:(?:[^/?#]{3,}|\.?[^/?#.]\.?)(?:\/[^/?#]{3,}|\.?[^/?#.]\.?)*\/?)?(?:[?#]|$)/;
const CURRENT = './';
const PARENT = '../';
const QUERY = '?';
const FRAGMENT = '#';

export default class BaseIRI {
  constructor(base) {
    this.base = base;
    this._baseLength = 0;
    this._baseMatcher = null;
    this._pathReplacements = new Array(base.length + 1);
  }

  static supports(base) {
    return !BASE_UNSUPPORTED.test(base);
  }

  _getBaseMatcher() {
    if (this._baseMatcher)
      return this._baseMatcher;
    if (!BaseIRI.supports(this.base))
      return this._baseMatcher = /.^/;

    const scheme = /^[^:]*:\/*/.exec(this.base)[0];
    const regexHead = ['^', escapeRegex(scheme)];
    const regexTail = [];

    const segments = [], segmenter = /[^/?#]*([/?#])/y;
    let segment, query = 0, fragment = 0, last = segmenter.lastIndex = scheme.length;
    while (!query && !fragment && (segment = segmenter.exec(this.base))) {

      if (segment[1] === FRAGMENT)
        fragment = segmenter.lastIndex - 1;
      else {

        regexHead.push(escapeRegex(segment[0]), '(?:');
        regexTail.push(')?');

        if (segment[1] !== QUERY)
          segments.push(last = segmenter.lastIndex);
        else {
          query = last = segmenter.lastIndex;
          fragment = this.base.indexOf(FRAGMENT, query);
          this._pathReplacements[query] = QUERY;
        }
      }
    }

    for (let i = 0; i < segments.length; i++)
      this._pathReplacements[segments[i]] = PARENT.repeat(segments.length - i - 1);
    this._pathReplacements[segments[segments.length - 1]] = CURRENT;

    this._baseLength = fragment > 0 ? fragment : this.base.length;
    regexHead.push(
      escapeRegex(this.base.substring(last, this._baseLength)),
      query ? '(?:#|$)' : '(?:[?#]|$)',
    );
    return this._baseMatcher = new RegExp([...regexHead, ...regexTail].join(''));
  }

  toRelative(iri) {

    const match = this._getBaseMatcher().exec(iri);
    if (!match)
      return iri;

    const length = match[0].length;
    if (length === this._baseLength && length === iri.length)
      return '';

    const parentPath = this._pathReplacements[length];
    if (parentPath) {
      const suffix = iri.substring(length);

      if (parentPath !== QUERY && !SUFFIX_SUPPORTED.test(suffix))
        return iri;

      if (parentPath === CURRENT && /^[^?#]/.test(suffix))
        return suffix;

      return parentPath + suffix;
    }

    return iri.substring(length - 1);
  }
}