[Summary view] [Print] [Text view]

   1  (function() {
   2  "use strict";
   3  var wp;
   4  (wp ||= {}).url = (() => {
   5    var __defProp = Object.defineProperty;
   6    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   7    var __getOwnPropNames = Object.getOwnPropertyNames;
   8    var __hasOwnProp = Object.prototype.hasOwnProperty;
   9    var __export = (target, all) => {
  10      for (var name in all)
  11        __defProp(target, name, { get: all[name], enumerable: true });
  12    };
  13    var __copyProps = (to, from, except, desc) => {
  14      if (from && typeof from === "object" || typeof from === "function") {
  15        for (let key of __getOwnPropNames(from))
  16          if (!__hasOwnProp.call(to, key) && key !== except)
  17            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  18      }
  19      return to;
  20    };
  21    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  22  
  23    // packages/url/build-module/index.mjs
  24    var index_exports = {};
  25    __export(index_exports, {
  26      addQueryArgs: () => addQueryArgs,
  27      buildQueryString: () => buildQueryString,
  28      cleanForSlug: () => cleanForSlug,
  29      filterURLForDisplay: () => filterURLForDisplay,
  30      getAuthority: () => getAuthority,
  31      getFilename: () => getFilename,
  32      getFragment: () => getFragment,
  33      getPath: () => getPath,
  34      getPathAndQueryString: () => getPathAndQueryString,
  35      getProtocol: () => getProtocol,
  36      getQueryArg: () => getQueryArg,
  37      getQueryArgs: () => getQueryArgs,
  38      getQueryString: () => getQueryString,
  39      hasQueryArg: () => hasQueryArg,
  40      isEmail: () => isEmail,
  41      isPhoneNumber: () => isPhoneNumber,
  42      isURL: () => isURL,
  43      isValidAuthority: () => isValidAuthority,
  44      isValidFragment: () => isValidFragment,
  45      isValidPath: () => isValidPath,
  46      isValidProtocol: () => isValidProtocol,
  47      isValidQueryString: () => isValidQueryString,
  48      normalizePath: () => normalizePath,
  49      prependHTTP: () => prependHTTP,
  50      prependHTTPS: () => prependHTTPS,
  51      removeQueryArgs: () => removeQueryArgs,
  52      safeDecodeURI: () => safeDecodeURI,
  53      safeDecodeURIComponent: () => safeDecodeURIComponent
  54    });
  55  
  56    // packages/url/build-module/is-url.mjs
  57    function isURL(url) {
  58      try {
  59        new URL(url);
  60        return true;
  61      } catch {
  62        return false;
  63      }
  64    }
  65  
  66    // packages/url/build-module/is-email.mjs
  67    var EMAIL_REGEXP = /^(mailto:)?[a-z0-9._%+-]+@[a-z0-9][a-z0-9.-]*\.[a-z]{2,63}$/i;
  68    function isEmail(email) {
  69      return EMAIL_REGEXP.test(email);
  70    }
  71  
  72    // packages/url/build-module/is-phone-number.mjs
  73    var PHONE_REGEXP = /^(tel:)?(\+)?\d{6,15}$/;
  74    function isPhoneNumber(phoneNumber) {
  75      phoneNumber = phoneNumber.replace(/[-.() ]/g, "");
  76      return PHONE_REGEXP.test(phoneNumber);
  77    }
  78  
  79    // packages/url/build-module/get-protocol.mjs
  80    function getProtocol(url) {
  81      const matches = /^([^\s:]+:)/.exec(url);
  82      if (matches) {
  83        return matches[1];
  84      }
  85    }
  86  
  87    // packages/url/build-module/is-valid-protocol.mjs
  88    function isValidProtocol(protocol) {
  89      if (!protocol) {
  90        return false;
  91      }
  92      return /^[a-z\-.\+]+[0-9]*:$/i.test(protocol);
  93    }
  94  
  95    // packages/url/build-module/get-authority.mjs
  96    function getAuthority(url) {
  97      const matches = /^[^\/\s:]+:(?:\/\/)?\/?([^\/\s#?]+)[\/#?]{0,1}\S*$/.exec(
  98        url
  99      );
 100      if (matches) {
 101        return matches[1];
 102      }
 103    }
 104  
 105    // packages/url/build-module/is-valid-authority.mjs
 106    function isValidAuthority(authority) {
 107      if (!authority) {
 108        return false;
 109      }
 110      return /^[^\s#?]+$/.test(authority);
 111    }
 112  
 113    // packages/url/build-module/get-path.mjs
 114    function getPath(url) {
 115      const matches = /^[^\/\s:]+:(?:\/\/)?[^\/\s#?]+[\/]([^\s#?]+)[#?]{0,1}\S*$/.exec(url);
 116      if (matches) {
 117        return matches[1];
 118      }
 119    }
 120  
 121    // packages/url/build-module/is-valid-path.mjs
 122    function isValidPath(path) {
 123      if (!path) {
 124        return false;
 125      }
 126      return /^[^\s#?]+$/.test(path);
 127    }
 128  
 129    // packages/url/build-module/get-query-string.mjs
 130    function getQueryString(url) {
 131      let query;
 132      try {
 133        query = new URL(url, "http://example.com").search.substring(1);
 134      } catch {
 135      }
 136      if (query) {
 137        return query;
 138      }
 139    }
 140  
 141    // packages/url/build-module/build-query-string.mjs
 142    function buildQueryString(data) {
 143      let string = "";
 144      const stack = Object.entries(data);
 145      let pair;
 146      while (pair = stack.shift()) {
 147        let [key, value] = pair;
 148        const hasNestedData = Array.isArray(value) || value && value.constructor === Object;
 149        if (hasNestedData) {
 150          const valuePairs = Object.entries(value).reverse();
 151          for (const [member, memberValue] of valuePairs) {
 152            stack.unshift([`$key}[$member}]`, memberValue]);
 153          }
 154        } else if (value !== void 0) {
 155          if (value === null) {
 156            value = "";
 157          }
 158          string += "&" + [key, String(value)].map(encodeURIComponent).join("=");
 159        }
 160      }
 161      return string.substr(1);
 162    }
 163  
 164    // packages/url/build-module/is-valid-query-string.mjs
 165    function isValidQueryString(queryString) {
 166      if (!queryString) {
 167        return false;
 168      }
 169      return /^[^\s#?\/]+$/.test(queryString);
 170    }
 171  
 172    // packages/url/build-module/get-path-and-query-string.mjs
 173    function getPathAndQueryString(url) {
 174      const path = getPath(url);
 175      const queryString = getQueryString(url);
 176      let value = "/";
 177      if (path) {
 178        value += path;
 179      }
 180      if (queryString) {
 181        value += `?$queryString}`;
 182      }
 183      return value;
 184    }
 185  
 186    // packages/url/build-module/get-fragment.mjs
 187    function getFragment(url) {
 188      const matches = /^\S+?(#[^\s\?]*)/.exec(url);
 189      if (matches) {
 190        return matches[1];
 191      }
 192    }
 193  
 194    // packages/url/build-module/is-valid-fragment.mjs
 195    function isValidFragment(fragment) {
 196      if (!fragment) {
 197        return false;
 198      }
 199      return /^#[^\s#?\/]*$/.test(fragment);
 200    }
 201  
 202    // packages/url/build-module/safe-decode-uri-component.mjs
 203    function safeDecodeURIComponent(uriComponent) {
 204      try {
 205        return decodeURIComponent(uriComponent);
 206      } catch {
 207        return uriComponent;
 208      }
 209    }
 210  
 211    // packages/url/build-module/get-query-args.mjs
 212    function setPath(object, path, value) {
 213      const length = path.length;
 214      const lastIndex = length - 1;
 215      for (let i = 0; i < length; i++) {
 216        let key = path[i];
 217        if (!key && Array.isArray(object)) {
 218          key = object.length.toString();
 219        }
 220        key = ["__proto__", "constructor", "prototype"].includes(key) ? key.toUpperCase() : key;
 221        const isNextKeyArrayIndex = !isNaN(Number(path[i + 1]));
 222        object[key] = i === lastIndex ? (
 223          // If at end of path, assign the intended value.
 224          value
 225        ) : (
 226          // Otherwise, advance to the next object in the path, creating
 227          // it if it does not yet exist.
 228          object[key] || (isNextKeyArrayIndex ? [] : {})
 229        );
 230        if (Array.isArray(object[key]) && !isNextKeyArrayIndex) {
 231          object[key] = { ...object[key] };
 232        }
 233        object = object[key];
 234      }
 235    }
 236    function getQueryArgs(url) {
 237      return (getQueryString(url) || "").replace(/\+/g, "%20").split("&").reduce((accumulator, keyValue) => {
 238        const separatorIndex = keyValue.indexOf("=");
 239        const hasValue = separatorIndex !== -1;
 240        const key = safeDecodeURIComponent(
 241          hasValue ? keyValue.slice(0, separatorIndex) : keyValue
 242        );
 243        if (key) {
 244          const value = hasValue ? safeDecodeURIComponent(
 245            keyValue.slice(separatorIndex + 1)
 246          ) : "";
 247          const segments = key.replace(/\]/g, "").split("[");
 248          setPath(accumulator, segments, value);
 249        }
 250        return accumulator;
 251      }, /* @__PURE__ */ Object.create(null));
 252    }
 253  
 254    // packages/url/build-module/add-query-args.mjs
 255    function addQueryArgs(url = "", args) {
 256      if (!args || !Object.keys(args).length) {
 257        return url;
 258      }
 259      const fragment = getFragment(url) || "";
 260      let baseUrl = url.replace(fragment, "");
 261      const queryStringIndex = url.indexOf("?");
 262      if (queryStringIndex !== -1) {
 263        args = Object.assign(getQueryArgs(url), args);
 264        baseUrl = baseUrl.substr(0, queryStringIndex);
 265      }
 266      return baseUrl + "?" + buildQueryString(args) + fragment;
 267    }
 268  
 269    // packages/url/build-module/get-query-arg.mjs
 270    function getQueryArg(url, arg) {
 271      return getQueryArgs(url)[arg];
 272    }
 273  
 274    // packages/url/build-module/has-query-arg.mjs
 275    function hasQueryArg(url, arg) {
 276      return getQueryArg(url, arg) !== void 0;
 277    }
 278  
 279    // packages/url/build-module/remove-query-args.mjs
 280    function removeQueryArgs(url, ...args) {
 281      const fragment = url.replace(/^[^#]*/, "");
 282      url = url.replace(/#.*/, "");
 283      const queryStringIndex = url.indexOf("?");
 284      if (queryStringIndex === -1) {
 285        return url + fragment;
 286      }
 287      const query = getQueryArgs(url);
 288      const baseURL = url.substr(0, queryStringIndex);
 289      args.forEach((arg) => delete query[arg]);
 290      const queryString = buildQueryString(query);
 291      const updatedUrl = queryString ? baseURL + "?" + queryString : baseURL;
 292      return updatedUrl + fragment;
 293    }
 294  
 295    // packages/url/build-module/prepend-http.mjs
 296    var USABLE_HREF_REGEXP = /^(?:[a-z]+:|#|\?|\.|\/)/i;
 297    function prependHTTP(url) {
 298      if (!url) {
 299        return url;
 300      }
 301      url = url.trim();
 302      if (!USABLE_HREF_REGEXP.test(url) && !isEmail(url)) {
 303        return "http://" + url;
 304      }
 305      return url;
 306    }
 307  
 308    // packages/url/build-module/safe-decode-uri.mjs
 309    function safeDecodeURI(uri) {
 310      try {
 311        return decodeURI(uri);
 312      } catch {
 313        return uri;
 314      }
 315    }
 316  
 317    // packages/url/build-module/filter-url-for-display.mjs
 318    function filterURLForDisplay(url, maxLength = null) {
 319      if (!url) {
 320        return "";
 321      }
 322      let filteredURL = url.replace(/^[a-z\-.\+]+[0-9]*:(\/\/)?/i, "").replace(/^www\./i, "");
 323      if (filteredURL.match(/^[^\/]+\/$/)) {
 324        filteredURL = filteredURL.replace("/", "");
 325      }
 326      const fileRegexp = /\/([^\/?]+)\.(?:[\w]+)(?=\?|$)/;
 327      if (!maxLength || filteredURL.length <= maxLength || !filteredURL.match(fileRegexp)) {
 328        return filteredURL;
 329      }
 330      filteredURL = filteredURL.split("?")[0];
 331      const urlPieces = filteredURL.split("/");
 332      const file = urlPieces[urlPieces.length - 1];
 333      if (file.length <= maxLength) {
 334        return "\u2026" + filteredURL.slice(-maxLength);
 335      }
 336      const index = file.lastIndexOf(".");
 337      const [fileName, extension] = [
 338        file.slice(0, index),
 339        file.slice(index + 1)
 340      ];
 341      const truncatedFile = fileName.slice(-3) + "." + extension;
 342      return (
 343        // A negative end would be read as an offset from the end of the string,
 344        // keeping most of the file name and returning more than `maxLength`.
 345        file.slice(0, Math.max(0, maxLength - truncatedFile.length - 1)) + "\u2026" + truncatedFile
 346      );
 347    }
 348  
 349    // packages/url/build-module/remove-accents.mjs
 350    var CHARS = {
 351      // Decompositions for Latin-1 Supplement.
 352      "\xAA": "a",
 353      "\xBA": "o",
 354      "\xC0": "A",
 355      "\xC1": "A",
 356      "\xC2": "A",
 357      "\xC3": "A",
 358      "\xC4": "A",
 359      "\xC5": "A",
 360      "\xC6": "AE",
 361      "\xC7": "C",
 362      "\xC8": "E",
 363      "\xC9": "E",
 364      "\xCA": "E",
 365      "\xCB": "E",
 366      "\xCC": "I",
 367      "\xCD": "I",
 368      "\xCE": "I",
 369      "\xCF": "I",
 370      "\xD0": "D",
 371      "\xD1": "N",
 372      "\xD2": "O",
 373      "\xD3": "O",
 374      "\xD4": "O",
 375      "\xD5": "O",
 376      "\xD6": "O",
 377      "\xD9": "U",
 378      "\xDA": "U",
 379      "\xDB": "U",
 380      "\xDC": "U",
 381      "\xDD": "Y",
 382      "\xDE": "TH",
 383      "\xDF": "s",
 384      "\xE0": "a",
 385      "\xE1": "a",
 386      "\xE2": "a",
 387      "\xE3": "a",
 388      "\xE4": "a",
 389      "\xE5": "a",
 390      "\xE6": "ae",
 391      "\xE7": "c",
 392      "\xE8": "e",
 393      "\xE9": "e",
 394      "\xEA": "e",
 395      "\xEB": "e",
 396      "\xEC": "i",
 397      "\xED": "i",
 398      "\xEE": "i",
 399      "\xEF": "i",
 400      "\xF0": "d",
 401      "\xF1": "n",
 402      "\xF2": "o",
 403      "\xF3": "o",
 404      "\xF4": "o",
 405      "\xF5": "o",
 406      "\xF6": "o",
 407      "\xF8": "o",
 408      "\xF9": "u",
 409      "\xFA": "u",
 410      "\xFB": "u",
 411      "\xFC": "u",
 412      "\xFD": "y",
 413      "\xFE": "th",
 414      "\xFF": "y",
 415      "\xD8": "O",
 416      // Decompositions for Latin Extended-A.
 417      "\u0100": "A",
 418      "\u0101": "a",
 419      "\u0102": "A",
 420      "\u0103": "a",
 421      "\u0104": "A",
 422      "\u0105": "a",
 423      "\u0106": "C",
 424      "\u0107": "c",
 425      "\u0108": "C",
 426      "\u0109": "c",
 427      "\u010A": "C",
 428      "\u010B": "c",
 429      "\u010C": "C",
 430      "\u010D": "c",
 431      "\u010E": "D",
 432      "\u010F": "d",
 433      "\u0110": "D",
 434      "\u0111": "d",
 435      "\u0112": "E",
 436      "\u0113": "e",
 437      "\u0114": "E",
 438      "\u0115": "e",
 439      "\u0116": "E",
 440      "\u0117": "e",
 441      "\u0118": "E",
 442      "\u0119": "e",
 443      "\u011A": "E",
 444      "\u011B": "e",
 445      "\u011C": "G",
 446      "\u011D": "g",
 447      "\u011E": "G",
 448      "\u011F": "g",
 449      "\u0120": "G",
 450      "\u0121": "g",
 451      "\u0122": "G",
 452      "\u0123": "g",
 453      "\u0124": "H",
 454      "\u0125": "h",
 455      "\u0126": "H",
 456      "\u0127": "h",
 457      "\u0128": "I",
 458      "\u0129": "i",
 459      "\u012A": "I",
 460      "\u012B": "i",
 461      "\u012C": "I",
 462      "\u012D": "i",
 463      "\u012E": "I",
 464      "\u012F": "i",
 465      "\u0130": "I",
 466      "\u0131": "i",
 467      "\u0132": "IJ",
 468      "\u0133": "ij",
 469      "\u0134": "J",
 470      "\u0135": "j",
 471      "\u0136": "K",
 472      "\u0137": "k",
 473      "\u0138": "k",
 474      "\u0139": "L",
 475      "\u013A": "l",
 476      "\u013B": "L",
 477      "\u013C": "l",
 478      "\u013D": "L",
 479      "\u013E": "l",
 480      "\u013F": "L",
 481      "\u0140": "l",
 482      "\u0141": "L",
 483      "\u0142": "l",
 484      "\u0143": "N",
 485      "\u0144": "n",
 486      "\u0145": "N",
 487      "\u0146": "n",
 488      "\u0147": "N",
 489      "\u0148": "n",
 490      "\u0149": "n",
 491      "\u014A": "N",
 492      "\u014B": "n",
 493      "\u014C": "O",
 494      "\u014D": "o",
 495      "\u014E": "O",
 496      "\u014F": "o",
 497      "\u0150": "O",
 498      "\u0151": "o",
 499      "\u0152": "OE",
 500      "\u0153": "oe",
 501      "\u0154": "R",
 502      "\u0155": "r",
 503      "\u0156": "R",
 504      "\u0157": "r",
 505      "\u0158": "R",
 506      "\u0159": "r",
 507      "\u015A": "S",
 508      "\u015B": "s",
 509      "\u015C": "S",
 510      "\u015D": "s",
 511      "\u015E": "S",
 512      "\u015F": "s",
 513      "\u0160": "S",
 514      "\u0161": "s",
 515      "\u0162": "T",
 516      "\u0163": "t",
 517      "\u0164": "T",
 518      "\u0165": "t",
 519      "\u0166": "T",
 520      "\u0167": "t",
 521      "\u0168": "U",
 522      "\u0169": "u",
 523      "\u016A": "U",
 524      "\u016B": "u",
 525      "\u016C": "U",
 526      "\u016D": "u",
 527      "\u016E": "U",
 528      "\u016F": "u",
 529      "\u0170": "U",
 530      "\u0171": "u",
 531      "\u0172": "U",
 532      "\u0173": "u",
 533      "\u0174": "W",
 534      "\u0175": "w",
 535      "\u0176": "Y",
 536      "\u0177": "y",
 537      "\u0178": "Y",
 538      "\u0179": "Z",
 539      "\u017A": "z",
 540      "\u017B": "Z",
 541      "\u017C": "z",
 542      "\u017D": "Z",
 543      "\u017E": "z",
 544      "\u017F": "s",
 545      // Decompositions for Latin Extended-B.
 546      "\u018F": "E",
 547      "\u01DD": "e",
 548      "\u0218": "S",
 549      "\u0219": "s",
 550      "\u021A": "T",
 551      "\u021B": "t",
 552      // Euro sign.
 553      "\u20AC": "E",
 554      // GBP (Pound) sign.
 555      "\xA3": "",
 556      // Vowels with diacritic (Vietnamese). Unmarked.
 557      "\u01A0": "O",
 558      "\u01A1": "o",
 559      "\u01AF": "U",
 560      "\u01B0": "u",
 561      // Grave accent.
 562      "\u1EA6": "A",
 563      "\u1EA7": "a",
 564      "\u1EB0": "A",
 565      "\u1EB1": "a",
 566      "\u1EC0": "E",
 567      "\u1EC1": "e",
 568      "\u1ED2": "O",
 569      "\u1ED3": "o",
 570      "\u1EDC": "O",
 571      "\u1EDD": "o",
 572      "\u1EEA": "U",
 573      "\u1EEB": "u",
 574      "\u1EF2": "Y",
 575      "\u1EF3": "y",
 576      // Hook.
 577      "\u1EA2": "A",
 578      "\u1EA3": "a",
 579      "\u1EA8": "A",
 580      "\u1EA9": "a",
 581      "\u1EB2": "A",
 582      "\u1EB3": "a",
 583      "\u1EBA": "E",
 584      "\u1EBB": "e",
 585      "\u1EC2": "E",
 586      "\u1EC3": "e",
 587      "\u1EC8": "I",
 588      "\u1EC9": "i",
 589      "\u1ECE": "O",
 590      "\u1ECF": "o",
 591      "\u1ED4": "O",
 592      "\u1ED5": "o",
 593      "\u1EDE": "O",
 594      "\u1EDF": "o",
 595      "\u1EE6": "U",
 596      "\u1EE7": "u",
 597      "\u1EEC": "U",
 598      "\u1EED": "u",
 599      "\u1EF6": "Y",
 600      "\u1EF7": "y",
 601      // Tilde.
 602      "\u1EAA": "A",
 603      "\u1EAB": "a",
 604      "\u1EB4": "A",
 605      "\u1EB5": "a",
 606      "\u1EBC": "E",
 607      "\u1EBD": "e",
 608      "\u1EC4": "E",
 609      "\u1EC5": "e",
 610      "\u1ED6": "O",
 611      "\u1ED7": "o",
 612      "\u1EE0": "O",
 613      "\u1EE1": "o",
 614      "\u1EEE": "U",
 615      "\u1EEF": "u",
 616      "\u1EF8": "Y",
 617      "\u1EF9": "y",
 618      // Acute accent.
 619      "\u1EA4": "A",
 620      "\u1EA5": "a",
 621      "\u1EAE": "A",
 622      "\u1EAF": "a",
 623      "\u1EBE": "E",
 624      "\u1EBF": "e",
 625      "\u1ED0": "O",
 626      "\u1ED1": "o",
 627      "\u1EDA": "O",
 628      "\u1EDB": "o",
 629      "\u1EE8": "U",
 630      "\u1EE9": "u",
 631      // Dot below.
 632      "\u1EA0": "A",
 633      "\u1EA1": "a",
 634      "\u1EAC": "A",
 635      "\u1EAD": "a",
 636      "\u1EB6": "A",
 637      "\u1EB7": "a",
 638      "\u1EB8": "E",
 639      "\u1EB9": "e",
 640      "\u1EC6": "E",
 641      "\u1EC7": "e",
 642      "\u1ECA": "I",
 643      "\u1ECB": "i",
 644      "\u1ECC": "O",
 645      "\u1ECD": "o",
 646      "\u1ED8": "O",
 647      "\u1ED9": "o",
 648      "\u1EE2": "O",
 649      "\u1EE3": "o",
 650      "\u1EE4": "U",
 651      "\u1EE5": "u",
 652      "\u1EF0": "U",
 653      "\u1EF1": "u",
 654      "\u1EF4": "Y",
 655      "\u1EF5": "y",
 656      // Vowels with diacritic (Chinese, Hanyu Pinyin).
 657      "\u0251": "a",
 658      // Macron.
 659      "\u01D5": "U",
 660      "\u01D6": "u",
 661      // Acute accent.
 662      "\u01D7": "U",
 663      "\u01D8": "u",
 664      // Caron.
 665      "\u01CD": "A",
 666      "\u01CE": "a",
 667      "\u01CF": "I",
 668      "\u01D0": "i",
 669      "\u01D1": "O",
 670      "\u01D2": "o",
 671      "\u01D3": "U",
 672      "\u01D4": "u",
 673      "\u01D9": "U",
 674      "\u01DA": "u",
 675      // Grave accent.
 676      "\u01DB": "U",
 677      "\u01DC": "u"
 678    };
 679    var CHARS_REGEXP = new RegExp(
 680      `[$Object.keys(CHARS).join("")}]`,
 681      "g"
 682    );
 683    function removeAccents(string) {
 684      return string.normalize("NFC").replace(CHARS_REGEXP, (char) => CHARS[char]);
 685    }
 686  
 687    // packages/url/build-module/clean-for-slug.mjs
 688    function stripTags(string) {
 689      let result = "";
 690      let depth = 0;
 691      let quote = "";
 692      for (let i = 0; i < string.length; i++) {
 693        const char = string[i];
 694        if (depth === 0) {
 695          if (char === "<" && !/[ \t\n\v\f\r]/.test(string[i + 1] ?? "")) {
 696            if (string.startsWith("<!--", i)) {
 697              const end = string.indexOf("-->", i + 2);
 698              if (end === -1) {
 699                break;
 700              }
 701              i = end + 2;
 702            } else {
 703              depth = 1;
 704            }
 705          } else {
 706            result += char;
 707          }
 708        } else if (quote) {
 709          if (char === quote) {
 710            quote = "";
 711          }
 712        } else if (char === '"' || char === "'") {
 713          quote = char;
 714        } else if (char === "<") {
 715          depth++;
 716        } else if (char === ">") {
 717          depth--;
 718        }
 719      }
 720      return result;
 721    }
 722    function truncateEncoded(string, length) {
 723      let result = "";
 724      let encodedLength = 0;
 725      for (const char of string) {
 726        const codePoint = char.codePointAt(0) ?? 0;
 727        let charLength = 12;
 728        if (codePoint < 128) {
 729          charLength = 1;
 730        } else if (codePoint < 2048) {
 731          charLength = 6;
 732        } else if (codePoint < 65536) {
 733          charLength = 9;
 734        }
 735        if (encodedLength + charLength > length) {
 736          break;
 737        }
 738        result += char;
 739        encodedLength += charLength;
 740      }
 741      return result;
 742    }
 743    function cleanForSlug(string) {
 744      if (!string) {
 745        return "";
 746      }
 747      const lowercase = stripTags(removeAccents(string)).replace(/%(?![0-9a-fA-F]{2})/g, "").toLowerCase();
 748      return (
 749        // Like WordPress, keep what fits in 200 percent-encoded characters,
 750        // the length of the slug column.
 751        truncateEncoded(lowercase, 200).replace(/[\u00a0\u2011\u2013\u2014/]/g, "-").replace(
 752          /&nbsp;|&#8209;|&#160;|&ndash;|&#8211;|&mdash;|&#8212;/g,
 753          "-"
 754        ).replace(
 755          /[\u00ad\u00a1\u00bf\u00ab\u00bb\u2039\u203a\u2018-\u201f\u2022\u00a9\u00ae\u00b0\u2026\u2122\u00b4\u02ca\u0301\u0341\u0300\u0304\u030c\u200b-\u200f\u202a-\u202e\ufeff\ufffc]/g,
 756          ""
 757        ).replace(/[\u2000-\u200a\u2028\u2029\u202f]/g, "-").replace(/\u00d7/g, "x").replace(/&.+?;/g, "").replace(/\./g, "-").replace(/[^%a-z0-9 _\-\u0080-\uffff]/g, "").replace(/ +/g, "-").replace(/-+/g, "-").replace(/(^-+)|(-+$)/g, "")
 758      );
 759    }
 760  
 761    // packages/url/build-module/get-filename.mjs
 762    function getFilename(url) {
 763      let filename;
 764      if (!url) {
 765        return;
 766      }
 767      try {
 768        filename = new URL(url, "http://example.com").pathname.split("/").pop();
 769      } catch {
 770      }
 771      if (filename) {
 772        return filename;
 773      }
 774    }
 775  
 776    // packages/url/build-module/normalize-path.mjs
 777    function normalizePath(path) {
 778      const separatorIndex = path.indexOf("?");
 779      if (separatorIndex === -1) {
 780        return path;
 781      }
 782      const base = path.slice(0, separatorIndex);
 783      const query = path.slice(separatorIndex + 1);
 784      if (!query) {
 785        return base;
 786      }
 787      return base + "?" + query.split("&").map((entry) => entry.split("=")).map((pair) => pair.map(safeDecodeURIComponent)).sort((a, b) => a[0].localeCompare(b[0])).map((pair) => pair.map(encodeURIComponent)).map((pair) => pair.join("=")).join("&");
 788    }
 789  
 790    // packages/url/build-module/prepend-https.mjs
 791    function prependHTTPS(url) {
 792      if (!url) {
 793        return url;
 794      }
 795      if (url.startsWith("http://")) {
 796        return url;
 797      }
 798      url = prependHTTP(url);
 799      return url.replace(/^http:/, "https:");
 800    }
 801    return __toCommonJS(index_exports);
 802  })();
 803  (window.wp ||= {}).url = wp.url;
 804  })();