@availity/resolve-url/dist/index.js

Resolve absolute url from relative urls

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.js
var index_exports = {};
__export(index_exports, {
  default: () => index_default,
  isAbsoluteUrl: () => is_absolute_url_default,
  relativeToAbsolute: () => resolve
});
module.exports = __toCommonJS(index_exports);

// src/is-absolute-url.js
var isAbsoluteUrl = (url) => {
  if (typeof url !== "string") {
    throw new TypeError(`Expected a \`string\`, got \`${typeof url}\``);
  }
  return /^[a-z][a-z\d+.-]*:/.test(url);
};
var is_absolute_url_default = isAbsoluteUrl;

// src/relative-to-absolute.js
function isCharacterAllowedAfterRelativePathSegment(character) {
  return !character || character === "#" || character === "?" || character === "/";
}
function removeDotSegments(path) {
  const segmentBuffers = [];
  let i = 0;
  while (i < path.length) {
    switch (path[i]) {
      case "/": {
        if (path[i + 1] === ".") {
          if (path[i + 2] === ".") {
            if (!isCharacterAllowedAfterRelativePathSegment(path[i + 3])) {
              segmentBuffers.at(-1).push(path.substr(i));
              i = path.length;
              break;
            }
            segmentBuffers.pop();
            if (!path[i + 3]) {
              segmentBuffers.push([]);
            }
            i += 3;
          } else {
            if (!isCharacterAllowedAfterRelativePathSegment(path[i + 2])) {
              segmentBuffers.at(-1).push(path.substr(i));
              i = path.length;
              break;
            }
            if (!path[i + 2]) {
              segmentBuffers.push([]);
            }
            i += 2;
          }
        } else {
          segmentBuffers.push([]);
          i += 1;
        }
        break;
      }
      case "#":
      case "?": {
        if (segmentBuffers.length === 0) {
          segmentBuffers.push([]);
        }
        segmentBuffers.at(-1).push(path.substr(i));
        i = path.length;
        break;
      }
      default: {
        if (segmentBuffers.length === 0) {
          segmentBuffers.push([]);
        }
        segmentBuffers.at(-1).push(path[i]);
        i += 1;
        break;
      }
    }
  }
  return `/${segmentBuffers.map((buffer) => buffer.join("")).join("/")}`;
}
function removeDotSegmentsOfPath(iri, colonPosition) {
  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;
  }
  const pathSeparator = iri.indexOf("/", searchOffset);
  if (pathSeparator < 0) {
    return iri;
  }
  const base = iri.substr(0, pathSeparator);
  const path = iri.substr(pathSeparator);
  return base + removeDotSegments(path);
}
function resolve(relativeIRI, baseIRI = "") {
  const baseFragmentPos = baseIRI.indexOf("#");
  if (baseFragmentPos > 0) {
    baseIRI = baseIRI.substr(0, baseFragmentPos);
  }
  if (relativeIRI.length === 0) {
    return baseIRI;
  }
  if (relativeIRI.indexOf("?") === 0) {
    const baseQueryPos = baseIRI.indexOf("?");
    if (baseQueryPos > 0) {
      baseIRI = baseIRI.substr(0, baseQueryPos);
    }
    return baseIRI + relativeIRI;
  }
  if (relativeIRI.indexOf("#") === 0) {
    return baseIRI + relativeIRI;
  }
  if (baseIRI.length === 0) {
    return removeDotSegmentsOfPath(relativeIRI, relativeIRI.indexOf(":"));
  }
  const valueColonPos = relativeIRI.indexOf(":");
  if (valueColonPos >= 0) {
    return removeDotSegmentsOfPath(relativeIRI, valueColonPos);
  }
  const baseColonPos = baseIRI.indexOf(":");
  if (baseColonPos < 0) {
    throw new Error(`Found invalid baseIRI '${baseIRI}' for value '${relativeIRI}'`);
  }
  const baseIRIScheme = baseIRI.substr(0, baseColonPos + 1);
  if (relativeIRI.indexOf("//") === 0) {
    return baseIRIScheme + removeDotSegmentsOfPath(relativeIRI, valueColonPos);
  }
  let baseSlashAfterColonPos;
  if (baseIRI.indexOf("//", baseColonPos) === baseColonPos + 1) {
    baseSlashAfterColonPos = baseIRI.indexOf("/", baseColonPos + 3);
    if (baseSlashAfterColonPos < 0) {
      if (baseIRI.length > baseColonPos + 3) {
        return `${baseIRI}/${removeDotSegmentsOfPath(relativeIRI, valueColonPos)}`;
      }
      return baseIRIScheme + removeDotSegmentsOfPath(relativeIRI, valueColonPos);
    }
  } else {
    baseSlashAfterColonPos = baseIRI.indexOf("/", baseColonPos + 1);
    if (baseIRI.length > baseColonPos + 1) {
      return `${baseIRI}/${removeDotSegmentsOfPath(relativeIRI, valueColonPos)}`;
    }
    return baseIRIScheme + removeDotSegmentsOfPath(relativeIRI, valueColonPos);
  }
  if (relativeIRI.indexOf("/") === 0) {
    return baseIRI.substr(0, baseSlashAfterColonPos) + removeDotSegments(relativeIRI);
  }
  let baseIRIPath = baseIRI.substr(baseSlashAfterColonPos);
  const baseIRILastSlashPos = baseIRIPath.lastIndexOf("/");
  if (baseIRILastSlashPos >= 0 && baseIRILastSlashPos < baseIRIPath.length - 1) {
    baseIRIPath = baseIRIPath.substr(0, baseIRILastSlashPos + 1);
    if (relativeIRI[0] === "." && relativeIRI[1] !== "." && relativeIRI[1] !== "/" && relativeIRI[2]) {
      relativeIRI = relativeIRI.substr(1);
    }
  }
  relativeIRI = baseIRIPath + relativeIRI;
  relativeIRI = removeDotSegments(relativeIRI);
  return baseIRI.substr(0, baseSlashAfterColonPos) + relativeIRI;
}

// src/resolve-url.js
var resolveUrl = ({ relative = "", base }) => {
  if (is_absolute_url_default(relative)) {
    return relative;
  }
  if (!base) {
    const { origin } = window.location;
    base = `${origin}/`;
  }
  return resolve(relative, base);
};
var resolve_url_default = resolveUrl;

// src/index.js
var index_default = resolve_url_default;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  isAbsoluteUrl,
  relativeToAbsolute
});