[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

/wp-includes/js/dist/ -> url.js (source)

   1  /******/ (() => { // webpackBootstrap
   2  /******/     var __webpack_modules__ = ({
   3  
   4  /***/ 9681:
   5  /***/ ((module) => {
   6  
   7  var characterMap = {
   8      "À": "A",
   9      "Á": "A",
  10      "Â": "A",
  11      "Ã": "A",
  12      "Ä": "A",
  13      "Å": "A",
  14      "Ấ": "A",
  15      "Ắ": "A",
  16      "Ẳ": "A",
  17      "Ẵ": "A",
  18      "Ặ": "A",
  19      "Æ": "AE",
  20      "Ầ": "A",
  21      "Ằ": "A",
  22      "Ȃ": "A",
  23      "Ả": "A",
  24      "Ạ": "A",
  25      "Ẩ": "A",
  26      "Ẫ": "A",
  27      "Ậ": "A",
  28      "Ç": "C",
  29      "Ḉ": "C",
  30      "È": "E",
  31      "É": "E",
  32      "Ê": "E",
  33      "Ë": "E",
  34      "Ế": "E",
  35      "Ḗ": "E",
  36      "Ề": "E",
  37      "Ḕ": "E",
  38      "Ḝ": "E",
  39      "Ȇ": "E",
  40      "Ẻ": "E",
  41      "Ẽ": "E",
  42      "Ẹ": "E",
  43      "Ể": "E",
  44      "Ễ": "E",
  45      "Ệ": "E",
  46      "Ì": "I",
  47      "Í": "I",
  48      "Î": "I",
  49      "Ï": "I",
  50      "Ḯ": "I",
  51      "Ȋ": "I",
  52      "Ỉ": "I",
  53      "Ị": "I",
  54      "Ð": "D",
  55      "Ñ": "N",
  56      "Ò": "O",
  57      "Ó": "O",
  58      "Ô": "O",
  59      "Õ": "O",
  60      "Ö": "O",
  61      "Ø": "O",
  62      "Ố": "O",
  63      "Ṍ": "O",
  64      "Ṓ": "O",
  65      "Ȏ": "O",
  66      "Ỏ": "O",
  67      "Ọ": "O",
  68      "Ổ": "O",
  69      "Ỗ": "O",
  70      "Ộ": "O",
  71      "Ờ": "O",
  72      "Ở": "O",
  73      "Ỡ": "O",
  74      "Ớ": "O",
  75      "Ợ": "O",
  76      "Ù": "U",
  77      "Ú": "U",
  78      "Û": "U",
  79      "Ü": "U",
  80      "Ủ": "U",
  81      "Ụ": "U",
  82      "Ử": "U",
  83      "Ữ": "U",
  84      "Ự": "U",
  85      "Ý": "Y",
  86      "à": "a",
  87      "á": "a",
  88      "â": "a",
  89      "ã": "a",
  90      "ä": "a",
  91      "å": "a",
  92      "ấ": "a",
  93      "ắ": "a",
  94      "ẳ": "a",
  95      "ẵ": "a",
  96      "ặ": "a",
  97      "æ": "ae",
  98      "ầ": "a",
  99      "ằ": "a",
 100      "ȃ": "a",
 101      "ả": "a",
 102      "ạ": "a",
 103      "ẩ": "a",
 104      "ẫ": "a",
 105      "ậ": "a",
 106      "ç": "c",
 107      "ḉ": "c",
 108      "è": "e",
 109      "é": "e",
 110      "ê": "e",
 111      "ë": "e",
 112      "ế": "e",
 113      "ḗ": "e",
 114      "ề": "e",
 115      "ḕ": "e",
 116      "ḝ": "e",
 117      "ȇ": "e",
 118      "ẻ": "e",
 119      "ẽ": "e",
 120      "ẹ": "e",
 121      "ể": "e",
 122      "ễ": "e",
 123      "ệ": "e",
 124      "ì": "i",
 125      "í": "i",
 126      "î": "i",
 127      "ï": "i",
 128      "ḯ": "i",
 129      "ȋ": "i",
 130      "ỉ": "i",
 131      "ị": "i",
 132      "ð": "d",
 133      "ñ": "n",
 134      "ò": "o",
 135      "ó": "o",
 136      "ô": "o",
 137      "õ": "o",
 138      "ö": "o",
 139      "ø": "o",
 140      "ố": "o",
 141      "ṍ": "o",
 142      "ṓ": "o",
 143      "ȏ": "o",
 144      "ỏ": "o",
 145      "ọ": "o",
 146      "ổ": "o",
 147      "ỗ": "o",
 148      "ộ": "o",
 149      "ờ": "o",
 150      "ở": "o",
 151      "ỡ": "o",
 152      "ớ": "o",
 153      "ợ": "o",
 154      "ù": "u",
 155      "ú": "u",
 156      "û": "u",
 157      "ü": "u",
 158      "ủ": "u",
 159      "ụ": "u",
 160      "ử": "u",
 161      "ữ": "u",
 162      "ự": "u",
 163      "ý": "y",
 164      "ÿ": "y",
 165      "Ā": "A",
 166      "ā": "a",
 167      "Ă": "A",
 168      "ă": "a",
 169      "Ą": "A",
 170      "ą": "a",
 171      "Ć": "C",
 172      "ć": "c",
 173      "Ĉ": "C",
 174      "ĉ": "c",
 175      "Ċ": "C",
 176      "ċ": "c",
 177      "Č": "C",
 178      "č": "c",
 179      "C̆": "C",
 180      "c̆": "c",
 181      "Ď": "D",
 182      "ď": "d",
 183      "Đ": "D",
 184      "đ": "d",
 185      "Ē": "E",
 186      "ē": "e",
 187      "Ĕ": "E",
 188      "ĕ": "e",
 189      "Ė": "E",
 190      "ė": "e",
 191      "Ę": "E",
 192      "ę": "e",
 193      "Ě": "E",
 194      "ě": "e",
 195      "Ĝ": "G",
 196      "Ǵ": "G",
 197      "ĝ": "g",
 198      "ǵ": "g",
 199      "Ğ": "G",
 200      "ğ": "g",
 201      "Ġ": "G",
 202      "ġ": "g",
 203      "Ģ": "G",
 204      "ģ": "g",
 205      "Ĥ": "H",
 206      "ĥ": "h",
 207      "Ħ": "H",
 208      "ħ": "h",
 209      "Ḫ": "H",
 210      "ḫ": "h",
 211      "Ĩ": "I",
 212      "ĩ": "i",
 213      "Ī": "I",
 214      "ī": "i",
 215      "Ĭ": "I",
 216      "ĭ": "i",
 217      "Į": "I",
 218      "į": "i",
 219      "İ": "I",
 220      "ı": "i",
 221      "IJ": "IJ",
 222      "ij": "ij",
 223      "Ĵ": "J",
 224      "ĵ": "j",
 225      "Ķ": "K",
 226      "ķ": "k",
 227      "Ḱ": "K",
 228      "ḱ": "k",
 229      "K̆": "K",
 230      "k̆": "k",
 231      "Ĺ": "L",
 232      "ĺ": "l",
 233      "Ļ": "L",
 234      "ļ": "l",
 235      "Ľ": "L",
 236      "ľ": "l",
 237      "Ŀ": "L",
 238      "ŀ": "l",
 239      "Ł": "l",
 240      "ł": "l",
 241      "Ḿ": "M",
 242      "ḿ": "m",
 243      "M̆": "M",
 244      "m̆": "m",
 245      "Ń": "N",
 246      "ń": "n",
 247      "Ņ": "N",
 248      "ņ": "n",
 249      "Ň": "N",
 250      "ň": "n",
 251      "ʼn": "n",
 252      "N̆": "N",
 253      "n̆": "n",
 254      "Ō": "O",
 255      "ō": "o",
 256      "Ŏ": "O",
 257      "ŏ": "o",
 258      "Ő": "O",
 259      "ő": "o",
 260      "Œ": "OE",
 261      "œ": "oe",
 262      "P̆": "P",
 263      "p̆": "p",
 264      "Ŕ": "R",
 265      "ŕ": "r",
 266      "Ŗ": "R",
 267      "ŗ": "r",
 268      "Ř": "R",
 269      "ř": "r",
 270      "R̆": "R",
 271      "r̆": "r",
 272      "Ȓ": "R",
 273      "ȓ": "r",
 274      "Ś": "S",
 275      "ś": "s",
 276      "Ŝ": "S",
 277      "ŝ": "s",
 278      "Ş": "S",
 279      "Ș": "S",
 280      "ș": "s",
 281      "ş": "s",
 282      "Š": "S",
 283      "š": "s",
 284      "Ţ": "T",
 285      "ţ": "t",
 286      "ț": "t",
 287      "Ț": "T",
 288      "Ť": "T",
 289      "ť": "t",
 290      "Ŧ": "T",
 291      "ŧ": "t",
 292      "T̆": "T",
 293      "t̆": "t",
 294      "Ũ": "U",
 295      "ũ": "u",
 296      "Ū": "U",
 297      "ū": "u",
 298      "Ŭ": "U",
 299      "ŭ": "u",
 300      "Ů": "U",
 301      "ů": "u",
 302      "Ű": "U",
 303      "ű": "u",
 304      "Ų": "U",
 305      "ų": "u",
 306      "Ȗ": "U",
 307      "ȗ": "u",
 308      "V̆": "V",
 309      "v̆": "v",
 310      "Ŵ": "W",
 311      "ŵ": "w",
 312      "Ẃ": "W",
 313      "ẃ": "w",
 314      "X̆": "X",
 315      "x̆": "x",
 316      "Ŷ": "Y",
 317      "ŷ": "y",
 318      "Ÿ": "Y",
 319      "Y̆": "Y",
 320      "y̆": "y",
 321      "Ź": "Z",
 322      "ź": "z",
 323      "Ż": "Z",
 324      "ż": "z",
 325      "Ž": "Z",
 326      "ž": "z",
 327      "ſ": "s",
 328      "ƒ": "f",
 329      "Ơ": "O",
 330      "ơ": "o",
 331      "Ư": "U",
 332      "ư": "u",
 333      "Ǎ": "A",
 334      "ǎ": "a",
 335      "Ǐ": "I",
 336      "ǐ": "i",
 337      "Ǒ": "O",
 338      "ǒ": "o",
 339      "Ǔ": "U",
 340      "ǔ": "u",
 341      "Ǖ": "U",
 342      "ǖ": "u",
 343      "Ǘ": "U",
 344      "ǘ": "u",
 345      "Ǚ": "U",
 346      "ǚ": "u",
 347      "Ǜ": "U",
 348      "ǜ": "u",
 349      "Ứ": "U",
 350      "ứ": "u",
 351      "Ṹ": "U",
 352      "ṹ": "u",
 353      "Ǻ": "A",
 354      "ǻ": "a",
 355      "Ǽ": "AE",
 356      "ǽ": "ae",
 357      "Ǿ": "O",
 358      "ǿ": "o",
 359      "Þ": "TH",
 360      "þ": "th",
 361      "Ṕ": "P",
 362      "ṕ": "p",
 363      "Ṥ": "S",
 364      "ṥ": "s",
 365      "X́": "X",
 366      "x́": "x",
 367      "Ѓ": "Г",
 368      "ѓ": "г",
 369      "Ќ": "К",
 370      "ќ": "к",
 371      "A̋": "A",
 372      "a̋": "a",
 373      "E̋": "E",
 374      "e̋": "e",
 375      "I̋": "I",
 376      "i̋": "i",
 377      "Ǹ": "N",
 378      "ǹ": "n",
 379      "Ồ": "O",
 380      "ồ": "o",
 381      "Ṑ": "O",
 382      "ṑ": "o",
 383      "Ừ": "U",
 384      "ừ": "u",
 385      "Ẁ": "W",
 386      "ẁ": "w",
 387      "Ỳ": "Y",
 388      "ỳ": "y",
 389      "Ȁ": "A",
 390      "ȁ": "a",
 391      "Ȅ": "E",
 392      "ȅ": "e",
 393      "Ȉ": "I",
 394      "ȉ": "i",
 395      "Ȍ": "O",
 396      "ȍ": "o",
 397      "Ȑ": "R",
 398      "ȑ": "r",
 399      "Ȕ": "U",
 400      "ȕ": "u",
 401      "B̌": "B",
 402      "b̌": "b",
 403      "Č̣": "C",
 404      "č̣": "c",
 405      "Ê̌": "E",
 406      "ê̌": "e",
 407      "F̌": "F",
 408      "f̌": "f",
 409      "Ǧ": "G",
 410      "ǧ": "g",
 411      "Ȟ": "H",
 412      "ȟ": "h",
 413      "J̌": "J",
 414      "ǰ": "j",
 415      "Ǩ": "K",
 416      "ǩ": "k",
 417      "M̌": "M",
 418      "m̌": "m",
 419      "P̌": "P",
 420      "p̌": "p",
 421      "Q̌": "Q",
 422      "q̌": "q",
 423      "Ř̩": "R",
 424      "ř̩": "r",
 425      "Ṧ": "S",
 426      "ṧ": "s",
 427      "V̌": "V",
 428      "v̌": "v",
 429      "W̌": "W",
 430      "w̌": "w",
 431      "X̌": "X",
 432      "x̌": "x",
 433      "Y̌": "Y",
 434      "y̌": "y",
 435      "A̧": "A",
 436      "a̧": "a",
 437      "B̧": "B",
 438      "b̧": "b",
 439      "Ḑ": "D",
 440      "ḑ": "d",
 441      "Ȩ": "E",
 442      "ȩ": "e",
 443      "Ɛ̧": "E",
 444      "ɛ̧": "e",
 445      "Ḩ": "H",
 446      "ḩ": "h",
 447      "I̧": "I",
 448      "i̧": "i",
 449      "Ɨ̧": "I",
 450      "ɨ̧": "i",
 451      "M̧": "M",
 452      "m̧": "m",
 453      "O̧": "O",
 454      "o̧": "o",
 455      "Q̧": "Q",
 456      "q̧": "q",
 457      "U̧": "U",
 458      "u̧": "u",
 459      "X̧": "X",
 460      "x̧": "x",
 461      "Z̧": "Z",
 462      "z̧": "z",
 463      "й":"и",
 464      "Й":"И",
 465      "ё":"е",
 466      "Ё":"Е",
 467  };
 468  
 469  var chars = Object.keys(characterMap).join('|');
 470  var allAccents = new RegExp(chars, 'g');
 471  var firstAccent = new RegExp(chars, '');
 472  
 473  function matcher(match) {
 474      return characterMap[match];
 475  }
 476  
 477  var removeAccents = function(string) {
 478      return string.replace(allAccents, matcher);
 479  };
 480  
 481  var hasAccents = function(string) {
 482      return !!string.match(firstAccent);
 483  };
 484  
 485  module.exports = removeAccents;
 486  module.exports.has = hasAccents;
 487  module.exports.remove = removeAccents;
 488  
 489  
 490  /***/ })
 491  
 492  /******/     });
 493  /************************************************************************/
 494  /******/     // The module cache
 495  /******/     var __webpack_module_cache__ = {};
 496  /******/     
 497  /******/     // The require function
 498  /******/ 	function __webpack_require__(moduleId) {
 499  /******/         // Check if module is in cache
 500  /******/         var cachedModule = __webpack_module_cache__[moduleId];
 501  /******/         if (cachedModule !== undefined) {
 502  /******/             return cachedModule.exports;
 503  /******/         }
 504  /******/         // Create a new module (and put it into the cache)
 505  /******/         var module = __webpack_module_cache__[moduleId] = {
 506  /******/             // no module.id needed
 507  /******/             // no module.loaded needed
 508  /******/             exports: {}
 509  /******/         };
 510  /******/     
 511  /******/         // Execute the module function
 512  /******/         __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
 513  /******/     
 514  /******/         // Return the exports of the module
 515  /******/         return module.exports;
 516  /******/     }
 517  /******/     
 518  /************************************************************************/
 519  /******/     /* webpack/runtime/compat get default export */
 520  /******/     (() => {
 521  /******/         // getDefaultExport function for compatibility with non-harmony modules
 522  /******/         __webpack_require__.n = (module) => {
 523  /******/             var getter = module && module.__esModule ?
 524  /******/                 () => (module['default']) :
 525  /******/                 () => (module);
 526  /******/             __webpack_require__.d(getter, { a: getter });
 527  /******/             return getter;
 528  /******/         };
 529  /******/     })();
 530  /******/     
 531  /******/     /* webpack/runtime/define property getters */
 532  /******/     (() => {
 533  /******/         // define getter functions for harmony exports
 534  /******/         __webpack_require__.d = (exports, definition) => {
 535  /******/             for(var key in definition) {
 536  /******/                 if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
 537  /******/                     Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
 538  /******/                 }
 539  /******/             }
 540  /******/         };
 541  /******/     })();
 542  /******/     
 543  /******/     /* webpack/runtime/hasOwnProperty shorthand */
 544  /******/     (() => {
 545  /******/         __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 546  /******/     })();
 547  /******/     
 548  /******/     /* webpack/runtime/make namespace object */
 549  /******/     (() => {
 550  /******/         // define __esModule on exports
 551  /******/         __webpack_require__.r = (exports) => {
 552  /******/             if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
 553  /******/                 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 554  /******/             }
 555  /******/             Object.defineProperty(exports, '__esModule', { value: true });
 556  /******/         };
 557  /******/     })();
 558  /******/     
 559  /************************************************************************/
 560  var __webpack_exports__ = {};
 561  // This entry need to be wrapped in an IIFE because it need to be in strict mode.
 562  (() => {
 563  "use strict";
 564  // ESM COMPAT FLAG
 565  __webpack_require__.r(__webpack_exports__);
 566  
 567  // EXPORTS
 568  __webpack_require__.d(__webpack_exports__, {
 569    addQueryArgs: () => (/* reexport */ addQueryArgs),
 570    buildQueryString: () => (/* reexport */ buildQueryString),
 571    cleanForSlug: () => (/* reexport */ cleanForSlug),
 572    filterURLForDisplay: () => (/* reexport */ filterURLForDisplay),
 573    getAuthority: () => (/* reexport */ getAuthority),
 574    getFilename: () => (/* reexport */ getFilename),
 575    getFragment: () => (/* reexport */ getFragment),
 576    getPath: () => (/* reexport */ getPath),
 577    getPathAndQueryString: () => (/* reexport */ getPathAndQueryString),
 578    getProtocol: () => (/* reexport */ getProtocol),
 579    getQueryArg: () => (/* reexport */ getQueryArg),
 580    getQueryArgs: () => (/* reexport */ getQueryArgs),
 581    getQueryString: () => (/* reexport */ getQueryString),
 582    hasQueryArg: () => (/* reexport */ hasQueryArg),
 583    isEmail: () => (/* reexport */ isEmail),
 584    isURL: () => (/* reexport */ isURL),
 585    isValidAuthority: () => (/* reexport */ isValidAuthority),
 586    isValidFragment: () => (/* reexport */ isValidFragment),
 587    isValidPath: () => (/* reexport */ isValidPath),
 588    isValidProtocol: () => (/* reexport */ isValidProtocol),
 589    isValidQueryString: () => (/* reexport */ isValidQueryString),
 590    normalizePath: () => (/* reexport */ normalizePath),
 591    prependHTTP: () => (/* reexport */ prependHTTP),
 592    prependHTTPS: () => (/* reexport */ prependHTTPS),
 593    removeQueryArgs: () => (/* reexport */ removeQueryArgs),
 594    safeDecodeURI: () => (/* reexport */ safeDecodeURI),
 595    safeDecodeURIComponent: () => (/* reexport */ safeDecodeURIComponent)
 596  });
 597  
 598  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/is-url.js
 599  /**
 600   * Determines whether the given string looks like a URL.
 601   *
 602   * @param {string} url The string to scrutinise.
 603   *
 604   * @example
 605   * ```js
 606   * const isURL = isURL( 'https://wordpress.org' ); // true
 607   * ```
 608   *
 609   * @see https://url.spec.whatwg.org/
 610   * @see https://url.spec.whatwg.org/#valid-url-string
 611   *
 612   * @return {boolean} Whether or not it looks like a URL.
 613   */
 614  function isURL(url) {
 615    // A URL can be considered value if the `URL` constructor is able to parse
 616    // it. The constructor throws an error for an invalid URL.
 617    try {
 618      new URL(url);
 619      return true;
 620    } catch {
 621      return false;
 622    }
 623  }
 624  
 625  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/is-email.js
 626  const EMAIL_REGEXP = /^(mailto:)?[a-z0-9._%+-]+@[a-z0-9][a-z0-9.-]*\.[a-z]{2,63}$/i;
 627  
 628  /**
 629   * Determines whether the given string looks like an email.
 630   *
 631   * @param {string} email The string to scrutinise.
 632   *
 633   * @example
 634   * ```js
 635   * const isEmail = isEmail( 'hello@wordpress.org' ); // true
 636   * ```
 637   *
 638   * @return {boolean} Whether or not it looks like an email.
 639   */
 640  function isEmail(email) {
 641    return EMAIL_REGEXP.test(email);
 642  }
 643  
 644  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/get-protocol.js
 645  /**
 646   * Returns the protocol part of the URL.
 647   *
 648   * @param {string} url The full URL.
 649   *
 650   * @example
 651   * ```js
 652   * const protocol1 = getProtocol( 'tel:012345678' ); // 'tel:'
 653   * const protocol2 = getProtocol( 'https://wordpress.org' ); // 'https:'
 654   * ```
 655   *
 656   * @return {string|void} The protocol part of the URL.
 657   */
 658  function getProtocol(url) {
 659    const matches = /^([^\s:]+:)/.exec(url);
 660    if (matches) {
 661      return matches[1];
 662    }
 663  }
 664  
 665  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/is-valid-protocol.js
 666  /**
 667   * Tests if a url protocol is valid.
 668   *
 669   * @param {string} protocol The url protocol.
 670   *
 671   * @example
 672   * ```js
 673   * const isValid = isValidProtocol( 'https:' ); // true
 674   * const isNotValid = isValidProtocol( 'https :' ); // false
 675   * ```
 676   *
 677   * @return {boolean} True if the argument is a valid protocol (e.g. http:, tel:).
 678   */
 679  function isValidProtocol(protocol) {
 680    if (!protocol) {
 681      return false;
 682    }
 683    return /^[a-z\-.\+]+[0-9]*:$/i.test(protocol);
 684  }
 685  
 686  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/get-authority.js
 687  /**
 688   * Returns the authority part of the URL.
 689   *
 690   * @param {string} url The full URL.
 691   *
 692   * @example
 693   * ```js
 694   * const authority1 = getAuthority( 'https://wordpress.org/help/' ); // 'wordpress.org'
 695   * const authority2 = getAuthority( 'https://localhost:8080/test/' ); // 'localhost:8080'
 696   * ```
 697   *
 698   * @return {string|void} The authority part of the URL.
 699   */
 700  function getAuthority(url) {
 701    const matches = /^[^\/\s:]+:(?:\/\/)?\/?([^\/\s#?]+)[\/#?]{0,1}\S*$/.exec(url);
 702    if (matches) {
 703      return matches[1];
 704    }
 705  }
 706  
 707  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/is-valid-authority.js
 708  /**
 709   * Checks for invalid characters within the provided authority.
 710   *
 711   * @param {string} authority A string containing the URL authority.
 712   *
 713   * @example
 714   * ```js
 715   * const isValid = isValidAuthority( 'wordpress.org' ); // true
 716   * const isNotValid = isValidAuthority( 'wordpress#org' ); // false
 717   * ```
 718   *
 719   * @return {boolean} True if the argument contains a valid authority.
 720   */
 721  function isValidAuthority(authority) {
 722    if (!authority) {
 723      return false;
 724    }
 725    return /^[^\s#?]+$/.test(authority);
 726  }
 727  
 728  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/get-path.js
 729  /**
 730   * Returns the path part of the URL.
 731   *
 732   * @param {string} url The full URL.
 733   *
 734   * @example
 735   * ```js
 736   * const path1 = getPath( 'http://localhost:8080/this/is/a/test?query=true' ); // 'this/is/a/test'
 737   * const path2 = getPath( 'https://wordpress.org/help/faq/' ); // 'help/faq'
 738   * ```
 739   *
 740   * @return {string|void} The path part of the URL.
 741   */
 742  function getPath(url) {
 743    const matches = /^[^\/\s:]+:(?:\/\/)?[^\/\s#?]+[\/]([^\s#?]+)[#?]{0,1}\S*$/.exec(url);
 744    if (matches) {
 745      return matches[1];
 746    }
 747  }
 748  
 749  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/is-valid-path.js
 750  /**
 751   * Checks for invalid characters within the provided path.
 752   *
 753   * @param {string} path The URL path.
 754   *
 755   * @example
 756   * ```js
 757   * const isValid = isValidPath( 'test/path/' ); // true
 758   * const isNotValid = isValidPath( '/invalid?test/path/' ); // false
 759   * ```
 760   *
 761   * @return {boolean} True if the argument contains a valid path
 762   */
 763  function isValidPath(path) {
 764    if (!path) {
 765      return false;
 766    }
 767    return /^[^\s#?]+$/.test(path);
 768  }
 769  
 770  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/get-query-string.js
 771  /**
 772   * Returns the query string part of the URL.
 773   *
 774   * @param {string} url The full URL.
 775   *
 776   * @example
 777   * ```js
 778   * const queryString = getQueryString( 'http://localhost:8080/this/is/a/test?query=true#fragment' ); // 'query=true'
 779   * ```
 780   *
 781   * @return {string|void} The query string part of the URL.
 782   */
 783  function getQueryString(url) {
 784    let query;
 785    try {
 786      query = new URL(url, 'http://example.com').search.substring(1);
 787    } catch (error) {}
 788    if (query) {
 789      return query;
 790    }
 791  }
 792  
 793  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/build-query-string.js
 794  /**
 795   * Generates URL-encoded query string using input query data.
 796   *
 797   * It is intended to behave equivalent as PHP's `http_build_query`, configured
 798   * with encoding type PHP_QUERY_RFC3986 (spaces as `%20`).
 799   *
 800   * @example
 801   * ```js
 802   * const queryString = buildQueryString( {
 803   *    simple: 'is ok',
 804   *    arrays: [ 'are', 'fine', 'too' ],
 805   *    objects: {
 806   *       evenNested: {
 807   *          ok: 'yes',
 808   *       },
 809   *    },
 810   * } );
 811   * // "simple=is%20ok&arrays%5B0%5D=are&arrays%5B1%5D=fine&arrays%5B2%5D=too&objects%5BevenNested%5D%5Bok%5D=yes"
 812   * ```
 813   *
 814   * @param {Record<string,*>} data Data to encode.
 815   *
 816   * @return {string} Query string.
 817   */
 818  function buildQueryString(data) {
 819    let string = '';
 820    const stack = Object.entries(data);
 821    let pair;
 822    while (pair = stack.shift()) {
 823      let [key, value] = pair;
 824  
 825      // Support building deeply nested data, from array or object values.
 826      const hasNestedData = Array.isArray(value) || value && value.constructor === Object;
 827      if (hasNestedData) {
 828        // Push array or object values onto the stack as composed of their
 829        // original key and nested index or key, retaining order by a
 830        // combination of Array#reverse and Array#unshift onto the stack.
 831        const valuePairs = Object.entries(value).reverse();
 832        for (const [member, memberValue] of valuePairs) {
 833          stack.unshift([`$key}[$member}]`, memberValue]);
 834        }
 835      } else if (value !== undefined) {
 836        // Null is treated as special case, equivalent to empty string.
 837        if (value === null) {
 838          value = '';
 839        }
 840        string += '&' + [key, value].map(encodeURIComponent).join('=');
 841      }
 842    }
 843  
 844    // Loop will concatenate with leading `&`, but it's only expected for all
 845    // but the first query parameter. This strips the leading `&`, while still
 846    // accounting for the case that the string may in-fact be empty.
 847    return string.substr(1);
 848  }
 849  
 850  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/is-valid-query-string.js
 851  /**
 852   * Checks for invalid characters within the provided query string.
 853   *
 854   * @param {string} queryString The query string.
 855   *
 856   * @example
 857   * ```js
 858   * const isValid = isValidQueryString( 'query=true&another=false' ); // true
 859   * const isNotValid = isValidQueryString( 'query=true?another=false' ); // false
 860   * ```
 861   *
 862   * @return {boolean} True if the argument contains a valid query string.
 863   */
 864  function isValidQueryString(queryString) {
 865    if (!queryString) {
 866      return false;
 867    }
 868    return /^[^\s#?\/]+$/.test(queryString);
 869  }
 870  
 871  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/get-path-and-query-string.js
 872  /**
 873   * Internal dependencies
 874   */
 875  
 876  
 877  /**
 878   * Returns the path part and query string part of the URL.
 879   *
 880   * @param {string} url The full URL.
 881   *
 882   * @example
 883   * ```js
 884   * const pathAndQueryString1 = getPathAndQueryString( 'http://localhost:8080/this/is/a/test?query=true' ); // '/this/is/a/test?query=true'
 885   * const pathAndQueryString2 = getPathAndQueryString( 'https://wordpress.org/help/faq/' ); // '/help/faq'
 886   * ```
 887   *
 888   * @return {string} The path part and query string part of the URL.
 889   */
 890  function getPathAndQueryString(url) {
 891    const path = getPath(url);
 892    const queryString = getQueryString(url);
 893    let value = '/';
 894    if (path) value += path;
 895    if (queryString) value += `?$queryString}`;
 896    return value;
 897  }
 898  
 899  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/get-fragment.js
 900  /**
 901   * Returns the fragment part of the URL.
 902   *
 903   * @param {string} url The full URL
 904   *
 905   * @example
 906   * ```js
 907   * const fragment1 = getFragment( 'http://localhost:8080/this/is/a/test?query=true#fragment' ); // '#fragment'
 908   * const fragment2 = getFragment( 'https://wordpress.org#another-fragment?query=true' ); // '#another-fragment'
 909   * ```
 910   *
 911   * @return {string|void} The fragment part of the URL.
 912   */
 913  function getFragment(url) {
 914    const matches = /^\S+?(#[^\s\?]*)/.exec(url);
 915    if (matches) {
 916      return matches[1];
 917    }
 918  }
 919  
 920  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/is-valid-fragment.js
 921  /**
 922   * Checks for invalid characters within the provided fragment.
 923   *
 924   * @param {string} fragment The url fragment.
 925   *
 926   * @example
 927   * ```js
 928   * const isValid = isValidFragment( '#valid-fragment' ); // true
 929   * const isNotValid = isValidFragment( '#invalid-#fragment' ); // false
 930   * ```
 931   *
 932   * @return {boolean} True if the argument contains a valid fragment.
 933   */
 934  function isValidFragment(fragment) {
 935    if (!fragment) {
 936      return false;
 937    }
 938    return /^#[^\s#?\/]*$/.test(fragment);
 939  }
 940  
 941  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/safe-decode-uri-component.js
 942  /**
 943   * Safely decodes a URI component with `decodeURIComponent`. Returns the URI component unmodified if
 944   * `decodeURIComponent` throws an error.
 945   *
 946   * @param {string} uriComponent URI component to decode.
 947   *
 948   * @return {string} Decoded URI component if possible.
 949   */
 950  function safeDecodeURIComponent(uriComponent) {
 951    try {
 952      return decodeURIComponent(uriComponent);
 953    } catch (uriComponentError) {
 954      return uriComponent;
 955    }
 956  }
 957  
 958  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/get-query-args.js
 959  /**
 960   * Internal dependencies
 961   */
 962  
 963  
 964  
 965  /** @typedef {import('./get-query-arg').QueryArgParsed} QueryArgParsed */
 966  
 967  /**
 968   * @typedef {Record<string,QueryArgParsed>} QueryArgs
 969   */
 970  
 971  /**
 972   * Sets a value in object deeply by a given array of path segments. Mutates the
 973   * object reference.
 974   *
 975   * @param {Record<string,*>} object Object in which to assign.
 976   * @param {string[]}         path   Path segment at which to set value.
 977   * @param {*}                value  Value to set.
 978   */
 979  function setPath(object, path, value) {
 980    const length = path.length;
 981    const lastIndex = length - 1;
 982    for (let i = 0; i < length; i++) {
 983      let key = path[i];
 984      if (!key && Array.isArray(object)) {
 985        // If key is empty string and next value is array, derive key from
 986        // the current length of the array.
 987        key = object.length.toString();
 988      }
 989      key = ['__proto__', 'constructor', 'prototype'].includes(key) ? key.toUpperCase() : key;
 990  
 991      // If the next key in the path is numeric (or empty string), it will be
 992      // created as an array. Otherwise, it will be created as an object.
 993      const isNextKeyArrayIndex = !isNaN(Number(path[i + 1]));
 994      object[key] = i === lastIndex ?
 995      // If at end of path, assign the intended value.
 996      value :
 997      // Otherwise, advance to the next object in the path, creating
 998      // it if it does not yet exist.
 999      object[key] || (isNextKeyArrayIndex ? [] : {});
1000      if (Array.isArray(object[key]) && !isNextKeyArrayIndex) {
1001        // If we current key is non-numeric, but the next value is an
1002        // array, coerce the value to an object.
1003        object[key] = {
1004          ...object[key]
1005        };
1006      }
1007  
1008      // Update working reference object to the next in the path.
1009      object = object[key];
1010    }
1011  }
1012  
1013  /**
1014   * Returns an object of query arguments of the given URL. If the given URL is
1015   * invalid or has no querystring, an empty object is returned.
1016   *
1017   * @param {string} url URL.
1018   *
1019   * @example
1020   * ```js
1021   * const foo = getQueryArgs( 'https://wordpress.org?foo=bar&bar=baz' );
1022   * // { "foo": "bar", "bar": "baz" }
1023   * ```
1024   *
1025   * @return {QueryArgs} Query args object.
1026   */
1027  function getQueryArgs(url) {
1028    return (getQueryString(url) || ''
1029    // Normalize space encoding, accounting for PHP URL encoding
1030    // corresponding to `application/x-www-form-urlencoded`.
1031    //
1032    // See: https://tools.ietf.org/html/rfc1866#section-8.2.1
1033    ).replace(/\+/g, '%20').split('&').reduce((accumulator, keyValue) => {
1034      const [key, value = ''] = keyValue.split('=')
1035      // Filtering avoids decoding as `undefined` for value, where
1036      // default is restored in destructuring assignment.
1037      .filter(Boolean).map(safeDecodeURIComponent);
1038      if (key) {
1039        const segments = key.replace(/\]/g, '').split('[');
1040        setPath(accumulator, segments, value);
1041      }
1042      return accumulator;
1043    }, Object.create(null));
1044  }
1045  
1046  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/add-query-args.js
1047  /**
1048   * Internal dependencies
1049   */
1050  
1051  
1052  
1053  /**
1054   * Appends arguments as querystring to the provided URL. If the URL already
1055   * includes query arguments, the arguments are merged with (and take precedent
1056   * over) the existing set.
1057   *
1058   * @param {string} [url=''] URL to which arguments should be appended. If omitted,
1059   *                          only the resulting querystring is returned.
1060   * @param {Object} [args]   Query arguments to apply to URL.
1061   *
1062   * @example
1063   * ```js
1064   * const newURL = addQueryArgs( 'https://google.com', { q: 'test' } ); // https://google.com/?q=test
1065   * ```
1066   *
1067   * @return {string} URL with arguments applied.
1068   */
1069  function addQueryArgs(url = '', args) {
1070    // If no arguments are to be appended, return original URL.
1071    if (!args || !Object.keys(args).length) {
1072      return url;
1073    }
1074    let baseUrl = url;
1075  
1076    // Determine whether URL already had query arguments.
1077    const queryStringIndex = url.indexOf('?');
1078    if (queryStringIndex !== -1) {
1079      // Merge into existing query arguments.
1080      args = Object.assign(getQueryArgs(url), args);
1081  
1082      // Change working base URL to omit previous query arguments.
1083      baseUrl = baseUrl.substr(0, queryStringIndex);
1084    }
1085    return baseUrl + '?' + buildQueryString(args);
1086  }
1087  
1088  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/get-query-arg.js
1089  /**
1090   * Internal dependencies
1091   */
1092  
1093  
1094  /**
1095   * @typedef {{[key: string]: QueryArgParsed}} QueryArgObject
1096   */
1097  
1098  /**
1099   * @typedef {string|string[]|QueryArgObject} QueryArgParsed
1100   */
1101  
1102  /**
1103   * Returns a single query argument of the url
1104   *
1105   * @param {string} url URL.
1106   * @param {string} arg Query arg name.
1107   *
1108   * @example
1109   * ```js
1110   * const foo = getQueryArg( 'https://wordpress.org?foo=bar&bar=baz', 'foo' ); // bar
1111   * ```
1112   *
1113   * @return {QueryArgParsed|void} Query arg value.
1114   */
1115  function getQueryArg(url, arg) {
1116    return getQueryArgs(url)[arg];
1117  }
1118  
1119  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/has-query-arg.js
1120  /**
1121   * Internal dependencies
1122   */
1123  
1124  
1125  /**
1126   * Determines whether the URL contains a given query arg.
1127   *
1128   * @param {string} url URL.
1129   * @param {string} arg Query arg name.
1130   *
1131   * @example
1132   * ```js
1133   * const hasBar = hasQueryArg( 'https://wordpress.org?foo=bar&bar=baz', 'bar' ); // true
1134   * ```
1135   *
1136   * @return {boolean} Whether or not the URL contains the query arg.
1137   */
1138  function hasQueryArg(url, arg) {
1139    return getQueryArg(url, arg) !== undefined;
1140  }
1141  
1142  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/remove-query-args.js
1143  /**
1144   * Internal dependencies
1145   */
1146  
1147  
1148  
1149  /**
1150   * Removes arguments from the query string of the url
1151   *
1152   * @param {string}    url  URL.
1153   * @param {...string} args Query Args.
1154   *
1155   * @example
1156   * ```js
1157   * const newUrl = removeQueryArgs( 'https://wordpress.org?foo=bar&bar=baz&baz=foobar', 'foo', 'bar' ); // https://wordpress.org?baz=foobar
1158   * ```
1159   *
1160   * @return {string} Updated URL.
1161   */
1162  function removeQueryArgs(url, ...args) {
1163    const queryStringIndex = url.indexOf('?');
1164    if (queryStringIndex === -1) {
1165      return url;
1166    }
1167    const query = getQueryArgs(url);
1168    const baseURL = url.substr(0, queryStringIndex);
1169    args.forEach(arg => delete query[arg]);
1170    const queryString = buildQueryString(query);
1171    return queryString ? baseURL + '?' + queryString : baseURL;
1172  }
1173  
1174  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/prepend-http.js
1175  /**
1176   * Internal dependencies
1177   */
1178  
1179  const USABLE_HREF_REGEXP = /^(?:[a-z]+:|#|\?|\.|\/)/i;
1180  
1181  /**
1182   * Prepends "http://" to a url, if it looks like something that is meant to be a TLD.
1183   *
1184   * @param {string} url The URL to test.
1185   *
1186   * @example
1187   * ```js
1188   * const actualURL = prependHTTP( 'wordpress.org' ); // http://wordpress.org
1189   * ```
1190   *
1191   * @return {string} The updated URL.
1192   */
1193  function prependHTTP(url) {
1194    if (!url) {
1195      return url;
1196    }
1197    url = url.trim();
1198    if (!USABLE_HREF_REGEXP.test(url) && !isEmail(url)) {
1199      return 'http://' + url;
1200    }
1201    return url;
1202  }
1203  
1204  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/safe-decode-uri.js
1205  /**
1206   * Safely decodes a URI with `decodeURI`. Returns the URI unmodified if
1207   * `decodeURI` throws an error.
1208   *
1209   * @param {string} uri URI to decode.
1210   *
1211   * @example
1212   * ```js
1213   * const badUri = safeDecodeURI( '%z' ); // does not throw an Error, simply returns '%z'
1214   * ```
1215   *
1216   * @return {string} Decoded URI if possible.
1217   */
1218  function safeDecodeURI(uri) {
1219    try {
1220      return decodeURI(uri);
1221    } catch (uriError) {
1222      return uri;
1223    }
1224  }
1225  
1226  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/filter-url-for-display.js
1227  /**
1228   * Returns a URL for display.
1229   *
1230   * @param {string}      url       Original URL.
1231   * @param {number|null} maxLength URL length.
1232   *
1233   * @example
1234   * ```js
1235   * const displayUrl = filterURLForDisplay( 'https://www.wordpress.org/gutenberg/' ); // wordpress.org/gutenberg
1236   * const imageUrl = filterURLForDisplay( 'https://www.wordpress.org/wp-content/uploads/img.png', 20 ); // …ent/uploads/img.png
1237   * ```
1238   *
1239   * @return {string} Displayed URL.
1240   */
1241  function filterURLForDisplay(url, maxLength = null) {
1242    // Remove protocol and www prefixes.
1243    let filteredURL = url.replace(/^(?:https?:)\/\/(?:www\.)?/, '');
1244  
1245    // Ends with / and only has that single slash, strip it.
1246    if (filteredURL.match(/^[^\/]+\/$/)) {
1247      filteredURL = filteredURL.replace('/', '');
1248    }
1249  
1250    // capture file name from URL
1251    const fileRegexp = /\/([^\/?]+)\.(?:[\w]+)(?=\?|$)/;
1252    if (!maxLength || filteredURL.length <= maxLength || !filteredURL.match(fileRegexp)) {
1253      return filteredURL;
1254    }
1255  
1256    // If the file is not greater than max length, return last portion of URL.
1257    filteredURL = filteredURL.split('?')[0];
1258    const urlPieces = filteredURL.split('/');
1259    const file = urlPieces[urlPieces.length - 1];
1260    if (file.length <= maxLength) {
1261      return '…' + filteredURL.slice(-maxLength);
1262    }
1263  
1264    // If the file is greater than max length, truncate the file.
1265    const index = file.lastIndexOf('.');
1266    const [fileName, extension] = [file.slice(0, index), file.slice(index + 1)];
1267    const truncatedFile = fileName.slice(-3) + '.' + extension;
1268    return file.slice(0, maxLength - truncatedFile.length - 1) + '…' + truncatedFile;
1269  }
1270  
1271  // EXTERNAL MODULE: ./node_modules/remove-accents/index.js
1272  var remove_accents = __webpack_require__(9681);
1273  var remove_accents_default = /*#__PURE__*/__webpack_require__.n(remove_accents);
1274  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/clean-for-slug.js
1275  /**
1276   * External dependencies
1277   */
1278  
1279  
1280  /**
1281   * Performs some basic cleanup of a string for use as a post slug.
1282   *
1283   * This replicates some of what `sanitize_title()` does in WordPress core, but
1284   * is only designed to approximate what the slug will be.
1285   *
1286   * Converts Latin-1 Supplement and Latin Extended-A letters to basic Latin
1287   * letters. Removes combining diacritical marks. Converts whitespace, periods,
1288   * and forward slashes to hyphens. Removes any remaining non-word characters
1289   * except hyphens. Converts remaining string to lowercase. It does not account
1290   * for octets, HTML entities, or other encoded characters.
1291   *
1292   * @param {string} string Title or slug to be processed.
1293   *
1294   * @return {string} Processed string.
1295   */
1296  function cleanForSlug(string) {
1297    if (!string) {
1298      return '';
1299    }
1300    return remove_accents_default()(string)
1301    // Convert each group of whitespace, periods, and forward slashes to a hyphen.
1302    .replace(/[\s\./]+/g, '-')
1303    // Remove anything that's not a letter, number, underscore or hyphen.
1304    .replace(/[^\p{L}\p{N}_-]+/gu, '')
1305    // Convert to lowercase
1306    .toLowerCase()
1307    // Replace multiple hyphens with a single one.
1308    .replace(/-+/g, '-')
1309    // Remove any remaining leading or trailing hyphens.
1310    .replace(/(^-+)|(-+$)/g, '');
1311  }
1312  
1313  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/get-filename.js
1314  /**
1315   * Returns the filename part of the URL.
1316   *
1317   * @param {string} url The full URL.
1318   *
1319   * @example
1320   * ```js
1321   * const filename1 = getFilename( 'http://localhost:8080/this/is/a/test.jpg' ); // 'test.jpg'
1322   * const filename2 = getFilename( '/this/is/a/test.png' ); // 'test.png'
1323   * ```
1324   *
1325   * @return {string|void} The filename part of the URL.
1326   */
1327  function getFilename(url) {
1328    let filename;
1329    try {
1330      filename = new URL(url, 'http://example.com').pathname.split('/').pop();
1331    } catch (error) {}
1332    if (filename) {
1333      return filename;
1334    }
1335  }
1336  
1337  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/normalize-path.js
1338  /**
1339   * Given a path, returns a normalized path where equal query parameter values
1340   * will be treated as identical, regardless of order they appear in the original
1341   * text.
1342   *
1343   * @param {string} path Original path.
1344   *
1345   * @return {string} Normalized path.
1346   */
1347  function normalizePath(path) {
1348    const splitted = path.split('?');
1349    const query = splitted[1];
1350    const base = splitted[0];
1351    if (!query) {
1352      return base;
1353    }
1354  
1355    // 'b=1%2C2&c=2&a=5'
1356    return base + '?' + query
1357    // [ 'b=1%2C2', 'c=2', 'a=5' ]
1358    .split('&')
1359    // [ [ 'b, '1%2C2' ], [ 'c', '2' ], [ 'a', '5' ] ]
1360    .map(entry => entry.split('='))
1361    // [ [ 'b', '1,2' ], [ 'c', '2' ], [ 'a', '5' ] ]
1362    .map(pair => pair.map(decodeURIComponent))
1363    // [ [ 'a', '5' ], [ 'b, '1,2' ], [ 'c', '2' ] ]
1364    .sort((a, b) => a[0].localeCompare(b[0]))
1365    // [ [ 'a', '5' ], [ 'b, '1%2C2' ], [ 'c', '2' ] ]
1366    .map(pair => pair.map(encodeURIComponent))
1367    // [ 'a=5', 'b=1%2C2', 'c=2' ]
1368    .map(pair => pair.join('='))
1369    // 'a=5&b=1%2C2&c=2'
1370    .join('&');
1371  }
1372  
1373  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/prepend-https.js
1374  /**
1375   * Internal dependencies
1376   */
1377  
1378  
1379  /**
1380   * Prepends "https://" to a url, if it looks like something that is meant to be a TLD.
1381   *
1382   * Note: this will not replace "http://" with "https://".
1383   *
1384   * @param {string} url The URL to test.
1385   *
1386   * @example
1387   * ```js
1388   * const actualURL = prependHTTPS( 'wordpress.org' ); // https://wordpress.org
1389   * ```
1390   *
1391   * @return {string} The updated URL.
1392   */
1393  function prependHTTPS(url) {
1394    if (!url) {
1395      return url;
1396    }
1397  
1398    // If url starts with http://, return it as is.
1399    if (url.startsWith('http://')) {
1400      return url;
1401    }
1402    url = prependHTTP(url);
1403    return url.replace(/^http:/, 'https:');
1404  }
1405  
1406  ;// CONCATENATED MODULE: ./node_modules/@wordpress/url/build-module/index.js
1407  
1408  
1409  
1410  
1411  
1412  
1413  
1414  
1415  
1416  
1417  
1418  
1419  
1420  
1421  
1422  
1423  
1424  
1425  
1426  
1427  
1428  
1429  
1430  
1431  
1432  
1433  
1434  
1435  })();
1436  
1437  (window.wp = window.wp || {}).url = __webpack_exports__;
1438  /******/ })()
1439  ;


Generated : Mon Mar 18 08:20:01 2024 Cross-referenced by PHPXref