denoland-deno/op_crates/web/11_url.js

// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.

((window) => {
  const core = window.Deno.core;

  function requiredArguments(
    name,
    length,
    required,
  ) {
    if (length < required) {
      const errMsg = `${name} requires at least ${required} argument${
        required === 1 ? "" : "s"
      }, but only ${length} present`;
      throw new TypeError(errMsg);
    }
  }

  function isIterable(
    o,
  ) {
    // checks for null and undefined
    if (o == null) {
      return false;
    }
    return (
      typeof (o)[Symbol.iterator] === "function"
    );
  }

  /** https://url.spec.whatwg.org/#idna */
  function domainToAscii(
    domain,
    { beStrict = false } = {},
  ) {
    return core.jsonOpSync("op_domain_to_ascii", { domain, beStrict });
  }

  function decodeSearchParam(p) {
    return decodeURIComponent(p.replace(/\+/g, " "));
  }

  const urls = new WeakMap();

  class URLSearchParams {
    #params = [];

    constructor(init = "") {
      if (typeof init === "string") {
        this.#handleStringInitialization(init);
        return;
      }

      if (Array.isArray(init) || isIterable(init)) {
        this.#handleArrayInitialization(init);
        return;
      }

      if (Object(init) !== init) {
        return;
      }

      if (init instanceof URLSearchParams) {
        this.#params = [...init.#params];
        return;
      }

      // Overload: record<USVString, USVString>
      for (const key of Object.keys(init)) {
        this.#append(key, init[key]);
      }

      urls.set(this, null);
    }

    #handleStringInitialization = (init) => {
      // Overload: USVString
      // If init is a string and starts with U+003F (?),
      // remove the first code point from init.
      if (init.charCodeAt(0) === 0x003f) {
        init = init.slice(1);
      }

      for (const pair of init.split("&")) {
        // Empty params are ignored
        if (pair.length === 0) {
          continue;
        }
        const position = pair.indexOf("=");
        const name = pair.slice(0, position === -1 ? pair.length : position);
        const value = pair.slice(name.length + 1);
        this.#append(decodeSearchParam(name), decodeSearchParam(value));
      }
    };

    #handleArrayInitialization = (
      init,
    ) => {
      // Overload: sequence<sequence<USVString>>
      for (const tuple of init) {
        // If pair does not contain exactly two items, then throw a TypeError.
        if (tuple.length !== 2) {
          throw new TypeError(
            "URLSearchParams.constructor tuple array argument must only contain pair elements",
          );
        }
        this.#append(tuple[0], tuple[1]);
      }
    };

    #updateSteps = () => {
      const url = urls.get(this);
      if (url == null) {
        return;
      }
      parts.get(url).query = this.toString();
    };

    #append = (name, value) => {
      this.#params.push([String(name), String(value)]);
    };

    append(name, value) {
      requiredArguments("URLSearchParams.append", arguments.length, 2);
      this.#append(name, value);
      this.#updateSteps();
    }

    delete(name) {
      requiredArguments("URLSearchParams.delete", arguments.length, 1);
      name = String(name);
      let i = 0;
      while (i < this.#params.length) {
        if (this.#params[i][0] === name) {
          this.#params.splice(i, 1);
        } else {
          i++;
        }
      }
      this.#updateSteps();
    }

    getAll(name) {
      requiredArguments("URLSearchParams.getAll", arguments.length, 1);
      name = String(name);
      const values = [];
      for (const entry of this.#params) {
        if (entry[0] === name) {
          values.push(entry[1]);
        }
      }

      return values;
    }

    get(name) {
      requiredArguments("URLSearchParams.get", arguments.length, 1);
      name = String(name);
      for (const entry of this.#params) {
        if (entry[0] === name) {
          return entry[1];
        }
      }

      return null;
    }

    has(name) {
      requiredArguments("URLSearchParams.has", arguments.length, 1);
      name = String(name);
      return this.#params.some((entry) => entry[0] === name);
    }

    set(name, value) {
      requiredArguments("URLSearchParams.set", arguments.length, 2);

      // If there are any name-value pairs whose name is name, in list,
      // set the value of the first such name-value pair to value
      // and remove the others.
      name = String(name);
      value = String(value);
      let found = false;
      let i = 0;
      while (i < this.#params.length) {
        if (this.#params[i][0] === name) {
          if (!found) {
            this.#params[i][1] = value;
            found = true;
            i++;
          } else {
            this.#params.splice(i, 1);
          }
        } else {
          i++;
        }
      }

      // Otherwise, append a new name-value pair whose name is name
      // and value is value, to list.
      if (!found) {
        this.#append(name, value);
      }

      this.#updateSteps();
    }

    sort() {
      this.#params.sort((a, b) => (a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1));
      this.#updateSteps();
    }

    forEach(
      callbackfn,
      thisArg,
    ) {
      requiredArguments("URLSearchParams.forEach", arguments.length, 1);

      if (typeof thisArg !== "undefined") {
        callbackfn = callbackfn.bind(thisArg);
      }

      for (const [key, value] of this.#params) {
        callbackfn(value, key, this);
      }
    }

    *keys() {
      for (const [key] of this.#params) {
        yield key;
      }
    }

    *values() {
      for (const [, value] of this.#params) {
        yield value;
      }
    }

    *entries() {
      yield* this.#params;
    }

    *[Symbol.iterator]() {
      yield* this.#params;
    }

    toString() {
      return this.#params
        .map(
          (tuple) =>
            `${encodeSearchParam(tuple[0])}=${encodeSearchParam(tuple[1])}`,
        )
        .join("&");
    }
  }

  const searchParamsMethods = [
    "append",
    "delete",
    "set",
  ];

  const specialSchemes = ["ftp", "file", "http", "https", "ws", "wss"];

  // https://url.spec.whatwg.org/#special-scheme
  const schemePorts = {
    ftp: "21",
    file: "",
    http: "80",
    https: "443",
    ws: "80",
    wss: "443",
  };
  const MAX_PORT = 2 ** 16 - 1;

  // Remove the part of the string that matches the pattern and return the
  // remainder (RHS) as well as the first captured group of the matched substring
  // (LHS). e.g.
  //      takePattern("https://deno.land:80", /^([a-z]+):[/]{2}/)
  //        = ["http", "deno.land:80"]
  //      takePattern("deno.land:80", /^(\[[0-9a-fA-F.:]{2,}\]|[^:]+)/)
  //        = ["deno.land", "80"]
  function takePattern(string, pattern) {
    let capture = "";
    const rest = string.replace(pattern, (_, capture_) => {
      capture = capture_;
      return "";
    });
    return [capture, rest];
  }

  function parse(url, baseParts = null) {
    const parts = {};
    let restUrl;
    let usedNonBase = false;
    [parts.protocol, restUrl] = takePattern(
      url.trim(),
      /^([A-Za-z][+-.0-9A-Za-z]*):/,
    );
    parts.protocol = parts.protocol.toLowerCase();
    if (parts.protocol == "") {
      if (baseParts == null) {
        return null;
      }
      parts.protocol = baseParts.protocol;
    } else if (
      parts.protocol != baseParts?.protocol ||
      !specialSchemes.includes(parts.protocol)
    ) {
      usedNonBase = true;
    }
    const isSpecial = specialSchemes.includes(parts.protocol);
    if (parts.protocol == "file") {
      parts.slashes = "//";
      parts.username = "";
      parts.password = "";
      if (usedNonBase || restUrl.match(/^[/\\]{2}/)) {
        [parts.hostname, restUrl] = takePattern(
          restUrl,
          /^[/\\]{2}([^/\\?#]*)/,
        );
        usedNonBase = true;
      } else {
        parts.hostname = baseParts.hostname;
      }
      parts.port = "";
    } else {
      if (usedNonBase || restUrl.match(/^[/\\]{2}/)) {
        let restAuthority;
        if (isSpecial) {
          parts.slashes = "//";
          [restAuthority, restUrl] = takePattern(
            restUrl,
            /^[/\\]*([^/\\?#]*)/,
          );
        } else {
          parts.slashes = restUrl.match(/^[/\\]{2}/) ? "//" : "";
          [restAuthority, restUrl] = takePattern(
            restUrl,
            /^[/\\]{2}([^/\\?#]*)/,
          );
        }
        let restAuthentication;
        [restAuthentication, restAuthority] = takePattern(
          restAuthority,
          /^(.*)@/,
        );
        [parts.username, restAuthentication] = takePattern(
          restAuthentication,
          /^([^:]*)/,
        );
        parts.username = encodeUserinfo(parts.username);
        [parts.password] = takePattern(restAuthentication, /^:(.*)/);
        parts.password = encodeUserinfo(parts.password);
        [parts.hostname, restAuthority] = takePattern(
          restAuthority,
          /^(\[[0-9a-fA-F.:]{2,}\]|[^:]+)/,
        );
        [parts.port] = takePattern(restAuthority, /^:(.*)/);
        if (!isValidPort(parts.port)) {
          return null;
        }
        if (parts.hostname == "" && isSpecial) {
          return null;
        }
        usedNonBase = true;
      } else {
        parts.slashes = baseParts.slashes;
        parts.username = baseParts.username;
        parts.password = baseParts.password;
        parts.hostname = baseParts.hostname;
        parts.port = baseParts.port;
      }
    }
    try {
      parts.hostname = encodeHostname(parts.hostname, isSpecial);
    } catch {
      return null;
    }
    [parts.path, restUrl] = takePattern(restUrl, /^([^?#]*)/);
    parts.path = encodePathname(parts.path);
    if (usedNonBase) {
      parts.path = normalizePath(parts.path, parts.protocol == "file");
    } else {
      if (parts.path != "") {
        usedNonBase = true;
      }
      parts.path = resolvePathFromBase(
        parts.path,
        baseParts.path || "/",
        baseParts.protocol == "file",
      );
    }
    // Drop the hostname if a drive letter is parsed.
    if (parts.protocol == "file" && parts.path.match(/^\/+[A-Za-z]:(\/|$)/)) {
      parts.hostname = "";
    }
    if (usedNonBase || restUrl.startsWith("?")) {
      [parts.query, restUrl] = takePattern(restUrl, /^(\?[^#]*)/);
      parts.query = encodeSearch(parts.query, isSpecial);
      usedNonBase = true;
    } else {
      parts.query = baseParts.query;
    }
    [parts.hash] = takePattern(restUrl, /^(#.*)/);
    parts.hash = encodeHash(parts.hash);
    return parts;
  }

  // Resolves `.`s and `..`s where possible.
  // Preserves repeating and trailing `/`s by design.
  // Assumes drive letter file paths will have a leading slash.
  function normalizePath(path, isFilePath) {
    const isAbsolute = path.startsWith("/");
    path = path.replace(/^\//, "");
    const pathSegments = path.split("/");

    let driveLetter = null;
    if (isFilePath && pathSegments[0].match(/^[A-Za-z]:$/)) {
      driveLetter = pathSegments.shift();
    }

    if (isFilePath && isAbsolute) {
      while (pathSegments.length > 1 && pathSegments[0] == "") {
        pathSegments.shift();
      }
    }

    let ensureTrailingSlash = false;
    const newPathSegments = [];
    for (let i = 0; i < pathSegments.length; i++) {
      const previous = newPathSegments[newPathSegments.length - 1];
      if (
        pathSegments[i] == ".." &&
        previous != ".." &&
        (previous != undefined || isAbsolute)
      ) {
        newPathSegments.pop();
        ensureTrailingSlash = true;
      } else if (pathSegments[i] == ".") {
        ensureTrailingSlash = true;
      } else {
        newPathSegments.push(pathSegments[i]);
        ensureTrailingSlash = false;
      }
    }
    if (driveLetter != null) {
      newPathSegments.unshift(driveLetter);
    }
    if (newPathSegments.length == 0 && !isAbsolute) {
      newPathSegments.push(".");
      ensureTrailingSlash = false;
    }

    let newPath = newPathSegments.join("/");
    if (isAbsolute) {
      newPath = `/${newPath}`;
    }
    if (ensureTrailingSlash) {
      newPath = newPath.replace(/\/*$/, "/");
    }
    return newPath;
  }

  // Standard URL basing logic, applied to paths.
  function resolvePathFromBase(path, basePath, isFilePath) {
    let basePrefix;
    let suffix;
    const baseDriveLetter = basePath.match(/^\/+[A-Za-z]:(?=\/|$)/)?.[0];
    if (isFilePath && path.match(/^\/+[A-Za-z]:(\/|$)/)) {
      basePrefix = "";
      suffix = path;
    } else if (path.startsWith("/")) {
      if (isFilePath && baseDriveLetter) {
        basePrefix = baseDriveLetter;
        suffix = path;
      } else {
        basePrefix = "";
        suffix = path;
      }
    } else if (path != "") {
      basePath = normalizePath(basePath, isFilePath);
      path = normalizePath(path, isFilePath);
      // Remove everything after the last `/` in `basePath`.
      if (baseDriveLetter && isFilePath) {
        basePrefix = `${baseDriveLetter}${
          basePath.slice(baseDriveLetter.length).replace(/[^\/]*$/, "")
        }`;
      } else {
        basePrefix = basePath.replace(/[^\/]*$/, "");
      }
      basePrefix = basePrefix.replace(/\/*$/, "/");
      // If `normalizedPath` ends with `.` or `..`, add a trailing slash.
      suffix = path.replace(/(?<=(^|\/)(\.|\.\.))$/, "/");
    } else {
      basePrefix = basePath;
      suffix = "";
    }
    return normalizePath(basePrefix + suffix, isFilePath);
  }

  function isValidPort(value) {
    // https://url.spec.whatwg.org/#port-state
    if (value === "") return true;

    const port = Number(value);
    return Number.isInteger(port) && port >= 0 && port <= MAX_PORT;
  }

  const parts = new WeakMap();

  class URL {
    #searchParams = null;

    [Symbol.for("Deno.customInspect")]() {
      const keys = [
        "href",
        "origin",
        "protocol",
        "username",
        "password",
        "host",
        "hostname",
        "port",
        "pathname",
        "hash",
        "search",
      ];
      const objectString = keys
        .map((key) => `${key}: "${this[key] || ""}"`)
        .join(", ");
      return `URL { ${objectString} }`;
    }

    #updateSearchParams = () => {
      const searchParams = new URLSearchParams(this.search);

      for (const methodName of searchParamsMethods) {
        const method = searchParams[methodName];
        searchParams[methodName] = (...args) => {
          method.apply(searchParams, args);
          this.search = searchParams.toString();
        };
      }
      this.#searchParams = searchParams;

      urls.set(searchParams, this);
    };

    get hash() {
      return parts.get(this).hash;
    }

    set hash(value) {
      value = unescape(String(value));
      if (!value) {
        parts.get(this).hash = "";
      } else {
        if (value.charAt(0) !== "#") {
          value = `#${value}`;
        }
        // hashes can contain % and # unescaped
        parts.get(this).hash = encodeHash(value);
      }
    }

    get host() {
      return `${this.hostname}${this.port ? `:${this.port}` : ""}`;
    }

    set host(value) {
      value = String(value);
      const url = new URL(`http://${value}`);
      parts.get(this).hostname = url.hostname;
      parts.get(this).port = url.port;
    }

    get hostname() {
      return parts.get(this).hostname;
    }

    set hostname(value) {
      value = String(value);
      try {
        const isSpecial = specialSchemes.includes(parts.get(this).protocol);
        parts.get(this).hostname = encodeHostname(value, isSpecial);
      } catch {}
    }

    get href() {
      const authentication = this.username || this.password
        ? `${this.username}${this.password ? ":" + this.password : ""}@`
        : "";
      const host = this.host;
      const slashes = host ? "//" : parts.get(this).slashes;
      let pathname = this.pathname;
      if (pathname.charAt(0) != "/" && pathname != "" && host != "") {
        pathname = `/${pathname}`;
      }
      return `${this.protocol}${slashes}${authentication}${host}${pathname}${this.search}${this.hash}`;
    }

    set href(value) {
      value = String(value);
      if (value !== this.href) {
        const url = new URL(value);
        parts.set(this, { ...parts.get(url) });
        this.#updateSearchParams();
      }
    }

    get origin() {
      if (this.host) {
        return `${this.protocol}//${this.host}`;
      }
      return "null";
    }

    get password() {
      return parts.get(this).password;
    }

    set password(value) {
      value = String(value);
      parts.get(this).password = encodeUserinfo(value);
    }

    get pathname() {
      let path = parts.get(this).path;
      if (specialSchemes.includes(parts.get(this).protocol)) {
        if (path.charAt(0) != "/") {
          path = `/${path}`;
        }
      }
      return path;
    }

    set pathname(value) {
      parts.get(this).path = encodePathname(String(value));
    }

    get port() {
      const port = parts.get(this).port;
      if (schemePorts[parts.get(this).protocol] === port) {
        return "";
      }

      return port;
    }

    set port(value) {
      if (!isValidPort(value)) {
        return;
      }
      parts.get(this).port = value.toString();
    }

    get protocol() {
      return `${parts.get(this).protocol}:`;
    }

    set protocol(value) {
      value = String(value);
      if (value) {
        if (value.charAt(value.length - 1) === ":") {
          value = value.slice(0, -1);
        }
        parts.get(this).protocol = encodeURIComponent(value);
      }
    }

    get search() {
      return parts.get(this).query;
    }

    set search(value) {
      value = String(value);
      const query = value == "" || value.charAt(0) == "?" ? value : `?${value}`;
      const isSpecial = specialSchemes.includes(parts.get(this).protocol);
      parts.get(this).query = encodeSearch(query, isSpecial);
      this.#updateSearchParams();
    }

    get username() {
      return parts.get(this).username;
    }

    set username(value) {
      value = String(value);
      parts.get(this).username = encodeUserinfo(value);
    }

    get searchParams() {
      return this.#searchParams;
    }

    constructor(url, base) {
      let baseParts = null;
      new.target;
      if (base) {
        baseParts = base instanceof URL ? parts.get(base) : parse(base);
        if (baseParts == null) {
          throw new TypeError("Invalid base URL.");
        }
      }

      const urlParts = url instanceof URL
        ? parts.get(url)
        : parse(url, baseParts);
      if (urlParts == null) {
        throw new TypeError("Invalid URL.");
      }
      parts.set(this, urlParts);

      this.#updateSearchParams();
    }

    toString() {
      return this.href;
    }

    toJSON() {
      return this.href;
    }

    static createObjectURL() {
      throw new Error("Not implemented");
    }

    static revokeObjectURL() {
      throw new Error("Not implemented");
    }
  }

  function parseIpv4Number(s) {
    if (s.match(/^(0[Xx])[0-9A-Za-z]+$/)) {
      return Number(s);
    }
    if (s.match(/^[0-9]+$/)) {
      return Number(s.startsWith("0") ? `0o${s}` : s);
    }
    return NaN;
  }

  function parseIpv4(s) {
    const parts = s.split(".");
    if (parts[parts.length - 1] == "" && parts.length > 1) {
      parts.pop();
    }
    if (parts.includes("") || parts.length > 4) {
      return s;
    }
    const numbers = parts.map(parseIpv4Number);
    if (numbers.includes(NaN)) {
      return s;
    }
    const last = numbers.pop();
    if (last >= 256 ** (4 - numbers.length) || numbers.find((n) => n >= 256)) {
      throw new TypeError("Invalid hostname.");
    }
    const ipv4 = numbers.reduce((sum, n, i) => sum + n * 256 ** (3 - i), last);
    const ipv4Hex = ipv4.toString(16).padStart(8, "0");
    const ipv4HexParts = ipv4Hex.match(/(..)(..)(..)(..)$/).slice(1);
    return ipv4HexParts.map((s) => String(Number(`0x${s}`))).join(".");
  }

  function charInC0ControlSet(c) {
    return (c >= "\u0000" && c <= "\u001F") || c > "\u007E";
  }

  function charInSearchSet(c, isSpecial) {
    // deno-fmt-ignore
    return charInC0ControlSet(c) || ["\u0020", "\u0022", "\u0023", "\u003C", "\u003E"].includes(c) || isSpecial && c == "\u0027" || c > "\u007E";
  }

  function charInFragmentSet(c) {
    // deno-fmt-ignore
    return charInC0ControlSet(c) || ["\u0020", "\u0022", "\u003C", "\u003E", "\u0060"].includes(c);
  }

  function charInPathSet(c) {
    // deno-fmt-ignore
    return charInFragmentSet(c) || ["\u0023", "\u003F", "\u007B", "\u007D"].includes(c);
  }

  function charInUserinfoSet(c) {
    // "\u0027" ("'") seemingly isn't in the spec, but matches Chrome and Firefox.
    // deno-fmt-ignore
    return charInPathSet(c) || ["\u0027", "\u002F", "\u003A", "\u003B", "\u003D", "\u0040", "\u005B", "\u005C", "\u005D", "\u005E", "\u007C"].includes(c);
  }

  function charIsForbiddenInHost(c) {
    // deno-fmt-ignore
    return ["\u0000", "\u0009", "\u000A", "\u000D", "\u0020", "\u0023", "\u0025", "\u002F", "\u003A", "\u003C", "\u003E", "\u003F", "\u0040", "\u005B", "\u005C", "\u005D", "\u005E"].includes(c);
  }

  function charInFormUrlencodedSet(c) {
    // deno-fmt-ignore
    return charInUserinfoSet(c) || ["\u0021", "\u0024", "\u0025", "\u0026", "\u0027", "\u0028", "\u0029", "\u002B", "\u002C", "\u007E"].includes(c);
  }

  const encoder = new TextEncoder();

  function encodeChar(c) {
    return [...encoder.encode(c)]
      .map((n) => `%${n.toString(16).padStart(2, "0")}`)
      .join("")
      .toUpperCase();
  }

  function encodeUserinfo(s) {
    return [...s].map((c) => (charInUserinfoSet(c) ? encodeChar(c) : c)).join(
      "",
    );
  }

  function encodeHostname(s, isSpecial = true) {
    // IPv6 parsing.
    if (s.startsWith("[") && s.endsWith("]")) {
      if (!s.match(/^\[[0-9A-Fa-f.:]{2,}\]$/)) {
        throw new TypeError("Invalid hostname.");
      }
      // IPv6 address compress
      return s.toLowerCase().replace(/\b:?(?:0+:?){2,}/, "::");
    }

    let result = s;

    if (!isSpecial) {
      // Check against forbidden host code points except for "%".
      for (const c of result) {
        if (charIsForbiddenInHost(c) && c != "\u0025") {
          throw new TypeError("Invalid hostname.");
        }
      }

      // Percent-encode C0 control set.
      result = [...result]
        .map((c) => (charInC0ControlSet(c) ? encodeChar(c) : c))
        .join("");

      return result;
    }

    // Percent-decode.
    if (result.match(/%(?![0-9A-Fa-f]{2})/) != null) {
      throw new TypeError("Invalid hostname.");
    }
    result = result.replace(
      /%(.{2})/g,
      (_, hex) => String.fromCodePoint(Number(`0x${hex}`)),
    );

    // IDNA domain to ASCII.
    result = domainToAscii(result);

    // Check against forbidden host code points.
    for (const c of result) {
      if (charIsForbiddenInHost(c)) {
        throw new TypeError("Invalid hostname.");
      }
    }

    // IPv4 parsing.
    if (isSpecial) {
      result = parseIpv4(result);
    }

    return result;
  }

  function encodePathname(s) {
    return [...s.replace(/\\/g, "/")].map((
      c,
    ) => (charInPathSet(c) ? encodeChar(c) : c)).join("");
  }

  function encodeSearch(s, isSpecial) {
    return [...s].map((
      c,
    ) => (charInSearchSet(c, isSpecial) ? encodeChar(c) : c)).join("");
  }

  function encodeHash(s) {
    return [...s].map((c) => (charInFragmentSet(c) ? encodeChar(c) : c)).join(
      "",
    );
  }

  function encodeSearchParam(s) {
    return [...s].map((c) => (charInFormUrlencodedSet(c) ? encodeChar(c) : c))
      .join("").replace(/%20/g, "+");
  }

  window.__bootstrap.url = {
    URL,
    URLSearchParams,
  };
})(this);