[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

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

   1  this["wp"] = this["wp"] || {}; this["wp"]["annotations"] =
   2  /******/ (function(modules) { // webpackBootstrap
   3  /******/     // The module cache
   4  /******/     var installedModules = {};
   5  /******/
   6  /******/     // The require function
   7  /******/ 	function __webpack_require__(moduleId) {
   8  /******/
   9  /******/         // Check if module is in cache
  10  /******/         if(installedModules[moduleId]) {
  11  /******/             return installedModules[moduleId].exports;
  12  /******/         }
  13  /******/         // Create a new module (and put it into the cache)
  14  /******/         var module = installedModules[moduleId] = {
  15  /******/             i: moduleId,
  16  /******/             l: false,
  17  /******/             exports: {}
  18  /******/         };
  19  /******/
  20  /******/         // Execute the module function
  21  /******/         modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  22  /******/
  23  /******/         // Flag the module as loaded
  24  /******/         module.l = true;
  25  /******/
  26  /******/         // Return the exports of the module
  27  /******/         return module.exports;
  28  /******/     }
  29  /******/
  30  /******/
  31  /******/     // expose the modules object (__webpack_modules__)
  32  /******/     __webpack_require__.m = modules;
  33  /******/
  34  /******/     // expose the module cache
  35  /******/     __webpack_require__.c = installedModules;
  36  /******/
  37  /******/     // define getter function for harmony exports
  38  /******/     __webpack_require__.d = function(exports, name, getter) {
  39  /******/         if(!__webpack_require__.o(exports, name)) {
  40  /******/             Object.defineProperty(exports, name, { enumerable: true, get: getter });
  41  /******/         }
  42  /******/     };
  43  /******/
  44  /******/     // define __esModule on exports
  45  /******/     __webpack_require__.r = function(exports) {
  46  /******/         if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  47  /******/             Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  48  /******/         }
  49  /******/         Object.defineProperty(exports, '__esModule', { value: true });
  50  /******/     };
  51  /******/
  52  /******/     // create a fake namespace object
  53  /******/     // mode & 1: value is a module id, require it
  54  /******/     // mode & 2: merge all properties of value into the ns
  55  /******/     // mode & 4: return value when already ns object
  56  /******/     // mode & 8|1: behave like require
  57  /******/     __webpack_require__.t = function(value, mode) {
  58  /******/         if(mode & 1) value = __webpack_require__(value);
  59  /******/         if(mode & 8) return value;
  60  /******/         if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  61  /******/         var ns = Object.create(null);
  62  /******/         __webpack_require__.r(ns);
  63  /******/         Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  64  /******/         if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  65  /******/         return ns;
  66  /******/     };
  67  /******/
  68  /******/     // getDefaultExport function for compatibility with non-harmony modules
  69  /******/     __webpack_require__.n = function(module) {
  70  /******/         var getter = module && module.__esModule ?
  71  /******/ 			function getDefault() { return module['default']; } :
  72  /******/ 			function getModuleExports() { return module; };
  73  /******/         __webpack_require__.d(getter, 'a', getter);
  74  /******/         return getter;
  75  /******/     };
  76  /******/
  77  /******/     // Object.prototype.hasOwnProperty.call
  78  /******/     __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  79  /******/
  80  /******/     // __webpack_public_path__
  81  /******/     __webpack_require__.p = "";
  82  /******/
  83  /******/
  84  /******/     // Load entry module and return exports
  85  /******/     return __webpack_require__(__webpack_require__.s = 435);
  86  /******/ })
  87  /************************************************************************/
  88  /******/ ({
  89  
  90  /***/ 1:
  91  /***/ (function(module, exports) {
  92  
  93  (function() { module.exports = this["wp"]["i18n"]; }());
  94  
  95  /***/ }),
  96  
  97  /***/ 116:
  98  /***/ (function(module, exports) {
  99  
 100  // Unique ID creation requires a high quality random # generator.  In the
 101  // browser this is a little complicated due to unknown quality of Math.random()
 102  // and inconsistent support for the `crypto` API.  We do the best we can via
 103  // feature-detection
 104  
 105  // getRandomValues needs to be invoked in a context where "this" is a Crypto
 106  // implementation. Also, find the complete implementation of crypto on IE11.
 107  var getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) ||
 108                        (typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto));
 109  
 110  if (getRandomValues) {
 111    // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto
 112    var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef
 113  
 114    module.exports = function whatwgRNG() {
 115      getRandomValues(rnds8);
 116      return rnds8;
 117    };
 118  } else {
 119    // Math.random()-based (RNG)
 120    //
 121    // If all else fails, use Math.random().  It's fast, but is of unspecified
 122    // quality.
 123    var rnds = new Array(16);
 124  
 125    module.exports = function mathRNG() {
 126      for (var i = 0, r; i < 16; i++) {
 127        if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
 128        rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
 129      }
 130  
 131      return rnds;
 132    };
 133  }
 134  
 135  
 136  /***/ }),
 137  
 138  /***/ 117:
 139  /***/ (function(module, exports) {
 140  
 141  /**
 142   * Convert array of 16 byte values to UUID string format of the form:
 143   * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
 144   */
 145  var byteToHex = [];
 146  for (var i = 0; i < 256; ++i) {
 147    byteToHex[i] = (i + 0x100).toString(16).substr(1);
 148  }
 149  
 150  function bytesToUuid(buf, offset) {
 151    var i = offset || 0;
 152    var bth = byteToHex;
 153    // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
 154    return ([bth[buf[i++]], bth[buf[i++]], 
 155      bth[buf[i++]], bth[buf[i++]], '-',
 156      bth[buf[i++]], bth[buf[i++]], '-',
 157      bth[buf[i++]], bth[buf[i++]], '-',
 158      bth[buf[i++]], bth[buf[i++]], '-',
 159      bth[buf[i++]], bth[buf[i++]],
 160      bth[buf[i++]], bth[buf[i++]],
 161      bth[buf[i++]], bth[buf[i++]]]).join('');
 162  }
 163  
 164  module.exports = bytesToUuid;
 165  
 166  
 167  /***/ }),
 168  
 169  /***/ 18:
 170  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 171  
 172  "use strict";
 173  
 174  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
 175  var arrayLikeToArray = __webpack_require__(25);
 176  
 177  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
 178  
 179  function _arrayWithoutHoles(arr) {
 180    if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr);
 181  }
 182  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
 183  var iterableToArray = __webpack_require__(35);
 184  
 185  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
 186  var unsupportedIterableToArray = __webpack_require__(27);
 187  
 188  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
 189  function _nonIterableSpread() {
 190    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 191  }
 192  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
 193  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _toConsumableArray; });
 194  
 195  
 196  
 197  
 198  function _toConsumableArray(arr) {
 199    return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread();
 200  }
 201  
 202  /***/ }),
 203  
 204  /***/ 19:
 205  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 206  
 207  "use strict";
 208  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutProperties; });
 209  /* harmony import */ var _objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(43);
 210  
 211  function _objectWithoutProperties(source, excluded) {
 212    if (source == null) return {};
 213    var target = Object(_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(source, excluded);
 214    var key, i;
 215  
 216    if (Object.getOwnPropertySymbols) {
 217      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
 218  
 219      for (i = 0; i < sourceSymbolKeys.length; i++) {
 220        key = sourceSymbolKeys[i];
 221        if (excluded.indexOf(key) >= 0) continue;
 222        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
 223        target[key] = source[key];
 224      }
 225    }
 226  
 227    return target;
 228  }
 229  
 230  /***/ }),
 231  
 232  /***/ 2:
 233  /***/ (function(module, exports) {
 234  
 235  (function() { module.exports = this["lodash"]; }());
 236  
 237  /***/ }),
 238  
 239  /***/ 24:
 240  /***/ (function(module, exports) {
 241  
 242  (function() { module.exports = this["wp"]["richText"]; }());
 243  
 244  /***/ }),
 245  
 246  /***/ 25:
 247  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 248  
 249  "use strict";
 250  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; });
 251  function _arrayLikeToArray(arr, len) {
 252    if (len == null || len > arr.length) len = arr.length;
 253  
 254    for (var i = 0, arr2 = new Array(len); i < len; i++) {
 255      arr2[i] = arr[i];
 256    }
 257  
 258    return arr2;
 259  }
 260  
 261  /***/ }),
 262  
 263  /***/ 27:
 264  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 265  
 266  "use strict";
 267  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; });
 268  /* harmony import */ var _arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(25);
 269  
 270  function _unsupportedIterableToArray(o, minLen) {
 271    if (!o) return;
 272    if (typeof o === "string") return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
 273    var n = Object.prototype.toString.call(o).slice(8, -1);
 274    if (n === "Object" && o.constructor) n = o.constructor.name;
 275    if (n === "Map" || n === "Set") return Array.from(n);
 276    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
 277  }
 278  
 279  /***/ }),
 280  
 281  /***/ 32:
 282  /***/ (function(module, exports) {
 283  
 284  (function() { module.exports = this["wp"]["hooks"]; }());
 285  
 286  /***/ }),
 287  
 288  /***/ 35:
 289  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 290  
 291  "use strict";
 292  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; });
 293  function _iterableToArray(iter) {
 294    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
 295  }
 296  
 297  /***/ }),
 298  
 299  /***/ 4:
 300  /***/ (function(module, exports) {
 301  
 302  (function() { module.exports = this["wp"]["data"]; }());
 303  
 304  /***/ }),
 305  
 306  /***/ 40:
 307  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 308  
 309  "use strict";
 310  
 311  
 312  var LEAF_KEY, hasWeakMap;
 313  
 314  /**
 315   * Arbitrary value used as key for referencing cache object in WeakMap tree.
 316   *
 317   * @type {Object}
 318   */
 319  LEAF_KEY = {};
 320  
 321  /**
 322   * Whether environment supports WeakMap.
 323   *
 324   * @type {boolean}
 325   */
 326  hasWeakMap = typeof WeakMap !== 'undefined';
 327  
 328  /**
 329   * Returns the first argument as the sole entry in an array.
 330   *
 331   * @param {*} value Value to return.
 332   *
 333   * @return {Array} Value returned as entry in array.
 334   */
 335  function arrayOf( value ) {
 336      return [ value ];
 337  }
 338  
 339  /**
 340   * Returns true if the value passed is object-like, or false otherwise. A value
 341   * is object-like if it can support property assignment, e.g. object or array.
 342   *
 343   * @param {*} value Value to test.
 344   *
 345   * @return {boolean} Whether value is object-like.
 346   */
 347  function isObjectLike( value ) {
 348      return !! value && 'object' === typeof value;
 349  }
 350  
 351  /**
 352   * Creates and returns a new cache object.
 353   *
 354   * @return {Object} Cache object.
 355   */
 356  function createCache() {
 357      var cache = {
 358          clear: function() {
 359              cache.head = null;
 360          },
 361      };
 362  
 363      return cache;
 364  }
 365  
 366  /**
 367   * Returns true if entries within the two arrays are strictly equal by
 368   * reference from a starting index.
 369   *
 370   * @param {Array}  a         First array.
 371   * @param {Array}  b         Second array.
 372   * @param {number} fromIndex Index from which to start comparison.
 373   *
 374   * @return {boolean} Whether arrays are shallowly equal.
 375   */
 376  function isShallowEqual( a, b, fromIndex ) {
 377      var i;
 378  
 379      if ( a.length !== b.length ) {
 380          return false;
 381      }
 382  
 383      for ( i = fromIndex; i < a.length; i++ ) {
 384          if ( a[ i ] !== b[ i ] ) {
 385              return false;
 386          }
 387      }
 388  
 389      return true;
 390  }
 391  
 392  /**
 393   * Returns a memoized selector function. The getDependants function argument is
 394   * called before the memoized selector and is expected to return an immutable
 395   * reference or array of references on which the selector depends for computing
 396   * its own return value. The memoize cache is preserved only as long as those
 397   * dependant references remain the same. If getDependants returns a different
 398   * reference(s), the cache is cleared and the selector value regenerated.
 399   *
 400   * @param {Function} selector      Selector function.
 401   * @param {Function} getDependants Dependant getter returning an immutable
 402   *                                 reference or array of reference used in
 403   *                                 cache bust consideration.
 404   *
 405   * @return {Function} Memoized selector.
 406   */
 407  /* harmony default export */ __webpack_exports__["a"] = (function( selector, getDependants ) {
 408      var rootCache, getCache;
 409  
 410      // Use object source as dependant if getter not provided
 411      if ( ! getDependants ) {
 412          getDependants = arrayOf;
 413      }
 414  
 415      /**
 416       * Returns the root cache. If WeakMap is supported, this is assigned to the
 417       * root WeakMap cache set, otherwise it is a shared instance of the default
 418       * cache object.
 419       *
 420       * @return {(WeakMap|Object)} Root cache object.
 421       */
 422  	function getRootCache() {
 423          return rootCache;
 424      }
 425  
 426      /**
 427       * Returns the cache for a given dependants array. When possible, a WeakMap
 428       * will be used to create a unique cache for each set of dependants. This
 429       * is feasible due to the nature of WeakMap in allowing garbage collection
 430       * to occur on entries where the key object is no longer referenced. Since
 431       * WeakMap requires the key to be an object, this is only possible when the
 432       * dependant is object-like. The root cache is created as a hierarchy where
 433       * each top-level key is the first entry in a dependants set, the value a
 434       * WeakMap where each key is the next dependant, and so on. This continues
 435       * so long as the dependants are object-like. If no dependants are object-
 436       * like, then the cache is shared across all invocations.
 437       *
 438       * @see isObjectLike
 439       *
 440       * @param {Array} dependants Selector dependants.
 441       *
 442       * @return {Object} Cache object.
 443       */
 444  	function getWeakMapCache( dependants ) {
 445          var caches = rootCache,
 446              isUniqueByDependants = true,
 447              i, dependant, map, cache;
 448  
 449          for ( i = 0; i < dependants.length; i++ ) {
 450              dependant = dependants[ i ];
 451  
 452              // Can only compose WeakMap from object-like key.
 453              if ( ! isObjectLike( dependant ) ) {
 454                  isUniqueByDependants = false;
 455                  break;
 456              }
 457  
 458              // Does current segment of cache already have a WeakMap?
 459              if ( caches.has( dependant ) ) {
 460                  // Traverse into nested WeakMap.
 461                  caches = caches.get( dependant );
 462              } else {
 463                  // Create, set, and traverse into a new one.
 464                  map = new WeakMap();
 465                  caches.set( dependant, map );
 466                  caches = map;
 467              }
 468          }
 469  
 470          // We use an arbitrary (but consistent) object as key for the last item
 471          // in the WeakMap to serve as our running cache.
 472          if ( ! caches.has( LEAF_KEY ) ) {
 473              cache = createCache();
 474              cache.isUniqueByDependants = isUniqueByDependants;
 475              caches.set( LEAF_KEY, cache );
 476          }
 477  
 478          return caches.get( LEAF_KEY );
 479      }
 480  
 481      // Assign cache handler by availability of WeakMap
 482      getCache = hasWeakMap ? getWeakMapCache : getRootCache;
 483  
 484      /**
 485       * Resets root memoization cache.
 486       */
 487  	function clear() {
 488          rootCache = hasWeakMap ? new WeakMap() : createCache();
 489      }
 490  
 491      // eslint-disable-next-line jsdoc/check-param-names
 492      /**
 493       * The augmented selector call, considering first whether dependants have
 494       * changed before passing it to underlying memoize function.
 495       *
 496       * @param {Object} source    Source object for derivation.
 497       * @param {...*}   extraArgs Additional arguments to pass to selector.
 498       *
 499       * @return {*} Selector result.
 500       */
 501  	function callSelector( /* source, ...extraArgs */ ) {
 502          var len = arguments.length,
 503              cache, node, i, args, dependants;
 504  
 505          // Create copy of arguments (avoid leaking deoptimization).
 506          args = new Array( len );
 507          for ( i = 0; i < len; i++ ) {
 508              args[ i ] = arguments[ i ];
 509          }
 510  
 511          dependants = getDependants.apply( null, args );
 512          cache = getCache( dependants );
 513  
 514          // If not guaranteed uniqueness by dependants (primitive type or lack
 515          // of WeakMap support), shallow compare against last dependants and, if
 516          // references have changed, destroy cache to recalculate result.
 517          if ( ! cache.isUniqueByDependants ) {
 518              if ( cache.lastDependants && ! isShallowEqual( dependants, cache.lastDependants, 0 ) ) {
 519                  cache.clear();
 520              }
 521  
 522              cache.lastDependants = dependants;
 523          }
 524  
 525          node = cache.head;
 526          while ( node ) {
 527              // Check whether node arguments match arguments
 528              if ( ! isShallowEqual( node.args, args, 1 ) ) {
 529                  node = node.next;
 530                  continue;
 531              }
 532  
 533              // At this point we can assume we've found a match
 534  
 535              // Surface matched node to head if not already
 536              if ( node !== cache.head ) {
 537                  // Adjust siblings to point to each other.
 538                  node.prev.next = node.next;
 539                  if ( node.next ) {
 540                      node.next.prev = node.prev;
 541                  }
 542  
 543                  node.next = cache.head;
 544                  node.prev = null;
 545                  cache.head.prev = node;
 546                  cache.head = node;
 547              }
 548  
 549              // Return immediately
 550              return node.val;
 551          }
 552  
 553          // No cached value found. Continue to insertion phase:
 554  
 555          node = {
 556              // Generate the result from original function
 557              val: selector.apply( null, args ),
 558          };
 559  
 560          // Avoid including the source object in the cache.
 561          args[ 0 ] = null;
 562          node.args = args;
 563  
 564          // Don't need to check whether node is already head, since it would
 565          // have been returned above already if it was
 566  
 567          // Shift existing head down list
 568          if ( cache.head ) {
 569              cache.head.prev = node;
 570              node.next = cache.head;
 571          }
 572  
 573          cache.head = node;
 574  
 575          return node.val;
 576      }
 577  
 578      callSelector.getDependants = getDependants;
 579      callSelector.clear = clear;
 580      clear();
 581  
 582      return callSelector;
 583  });
 584  
 585  
 586  /***/ }),
 587  
 588  /***/ 43:
 589  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 590  
 591  "use strict";
 592  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutPropertiesLoose; });
 593  function _objectWithoutPropertiesLoose(source, excluded) {
 594    if (source == null) return {};
 595    var target = {};
 596    var sourceKeys = Object.keys(source);
 597    var key, i;
 598  
 599    for (i = 0; i < sourceKeys.length; i++) {
 600      key = sourceKeys[i];
 601      if (excluded.indexOf(key) >= 0) continue;
 602      target[key] = source[key];
 603    }
 604  
 605    return target;
 606  }
 607  
 608  /***/ }),
 609  
 610  /***/ 435:
 611  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 612  
 613  "use strict";
 614  __webpack_require__.r(__webpack_exports__);
 615  var selectors_namespaceObject = {};
 616  __webpack_require__.r(selectors_namespaceObject);
 617  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetAnnotationsForBlock", function() { return __experimentalGetAnnotationsForBlock; });
 618  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetAllAnnotationsForBlock", function() { return selectors_experimentalGetAllAnnotationsForBlock; });
 619  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetAnnotationsForRichText", function() { return __experimentalGetAnnotationsForRichText; });
 620  __webpack_require__.d(selectors_namespaceObject, "__experimentalGetAnnotations", function() { return __experimentalGetAnnotations; });
 621  var actions_namespaceObject = {};
 622  __webpack_require__.r(actions_namespaceObject);
 623  __webpack_require__.d(actions_namespaceObject, "__experimentalAddAnnotation", function() { return __experimentalAddAnnotation; });
 624  __webpack_require__.d(actions_namespaceObject, "__experimentalRemoveAnnotation", function() { return __experimentalRemoveAnnotation; });
 625  __webpack_require__.d(actions_namespaceObject, "__experimentalUpdateAnnotationRange", function() { return __experimentalUpdateAnnotationRange; });
 626  __webpack_require__.d(actions_namespaceObject, "__experimentalRemoveAnnotationsBySource", function() { return __experimentalRemoveAnnotationsBySource; });
 627  
 628  // EXTERNAL MODULE: external {"this":["wp","data"]}
 629  var external_this_wp_data_ = __webpack_require__(4);
 630  
 631  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
 632  var toConsumableArray = __webpack_require__(18);
 633  
 634  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
 635  var defineProperty = __webpack_require__(5);
 636  
 637  // EXTERNAL MODULE: external {"this":"lodash"}
 638  var external_this_lodash_ = __webpack_require__(2);
 639  
 640  // CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/store/reducer.js
 641  
 642  
 643  
 644  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 645  
 646  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 647  
 648  /**
 649   * External dependencies
 650   */
 651  
 652  /**
 653   * Filters an array based on the predicate, but keeps the reference the same if
 654   * the array hasn't changed.
 655   *
 656   * @param {Array}    collection The collection to filter.
 657   * @param {Function} predicate  Function that determines if the item should stay
 658   *                              in the array.
 659   * @return {Array} Filtered array.
 660   */
 661  
 662  function filterWithReference(collection, predicate) {
 663    var filteredCollection = collection.filter(predicate);
 664    return collection.length === filteredCollection.length ? collection : filteredCollection;
 665  }
 666  /**
 667   * Verifies whether the given annotations is a valid annotation.
 668   *
 669   * @param {Object} annotation The annotation to verify.
 670   * @return {boolean} Whether the given annotation is valid.
 671   */
 672  
 673  
 674  function isValidAnnotationRange(annotation) {
 675    return Object(external_this_lodash_["isNumber"])(annotation.start) && Object(external_this_lodash_["isNumber"])(annotation.end) && annotation.start <= annotation.end;
 676  }
 677  /**
 678   * Reducer managing annotations.
 679   *
 680   * @param {Array} state The annotations currently shown in the editor.
 681   * @param {Object} action Dispatched action.
 682   *
 683   * @return {Array} Updated state.
 684   */
 685  
 686  
 687  function reducer_annotations() {
 688    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 689    var action = arguments.length > 1 ? arguments[1] : undefined;
 690  
 691    switch (action.type) {
 692      case 'ANNOTATION_ADD':
 693        var blockClientId = action.blockClientId;
 694        var newAnnotation = {
 695          id: action.id,
 696          blockClientId: blockClientId,
 697          richTextIdentifier: action.richTextIdentifier,
 698          source: action.source,
 699          selector: action.selector,
 700          range: action.range
 701        };
 702  
 703        if (newAnnotation.selector === 'range' && !isValidAnnotationRange(newAnnotation.range)) {
 704          return state;
 705        }
 706  
 707        var previousAnnotationsForBlock = Object(external_this_lodash_["get"])(state, blockClientId, []);
 708        return _objectSpread({}, state, Object(defineProperty["a" /* default */])({}, blockClientId, [].concat(Object(toConsumableArray["a" /* default */])(previousAnnotationsForBlock), [newAnnotation])));
 709  
 710      case 'ANNOTATION_REMOVE':
 711        return Object(external_this_lodash_["mapValues"])(state, function (annotationsForBlock) {
 712          return filterWithReference(annotationsForBlock, function (annotation) {
 713            return annotation.id !== action.annotationId;
 714          });
 715        });
 716  
 717      case 'ANNOTATION_UPDATE_RANGE':
 718        return Object(external_this_lodash_["mapValues"])(state, function (annotationsForBlock) {
 719          var hasChangedRange = false;
 720          var newAnnotations = annotationsForBlock.map(function (annotation) {
 721            if (annotation.id === action.annotationId) {
 722              hasChangedRange = true;
 723              return _objectSpread({}, annotation, {
 724                range: {
 725                  start: action.start,
 726                  end: action.end
 727                }
 728              });
 729            }
 730  
 731            return annotation;
 732          });
 733          return hasChangedRange ? newAnnotations : annotationsForBlock;
 734        });
 735  
 736      case 'ANNOTATION_REMOVE_SOURCE':
 737        return Object(external_this_lodash_["mapValues"])(state, function (annotationsForBlock) {
 738          return filterWithReference(annotationsForBlock, function (annotation) {
 739            return annotation.source !== action.source;
 740          });
 741        });
 742    }
 743  
 744    return state;
 745  }
 746  /* harmony default export */ var reducer = (reducer_annotations);
 747  
 748  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
 749  var objectWithoutProperties = __webpack_require__(19);
 750  
 751  // EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js
 752  var rememo = __webpack_require__(40);
 753  
 754  // CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/store/selectors.js
 755  
 756  
 757  
 758  function selectors_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 759  
 760  function selectors_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { selectors_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { selectors_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 761  
 762  /**
 763   * External dependencies
 764   */
 765  
 766  
 767  /**
 768   * Shared reference to an empty array for cases where it is important to avoid
 769   * returning a new array reference on every invocation, as in a connected or
 770   * other pure component which performs `shouldComponentUpdate` check on props.
 771   * This should be used as a last resort, since the normalized data should be
 772   * maintained by the reducer result in state.
 773   *
 774   * @type {Array}
 775   */
 776  
 777  var EMPTY_ARRAY = [];
 778  /**
 779   * Returns the annotations for a specific client ID.
 780   *
 781   * @param {Object} state Editor state.
 782   * @param {string} clientId The ID of the block to get the annotations for.
 783   *
 784   * @return {Array} The annotations applicable to this block.
 785   */
 786  
 787  var __experimentalGetAnnotationsForBlock = Object(rememo["a" /* default */])(function (state, blockClientId) {
 788    return Object(external_this_lodash_["get"])(state, blockClientId, []).filter(function (annotation) {
 789      return annotation.selector === 'block';
 790    });
 791  }, function (state, blockClientId) {
 792    return [Object(external_this_lodash_["get"])(state, blockClientId, EMPTY_ARRAY)];
 793  });
 794  var selectors_experimentalGetAllAnnotationsForBlock = function __experimentalGetAllAnnotationsForBlock(state, blockClientId) {
 795    return Object(external_this_lodash_["get"])(state, blockClientId, EMPTY_ARRAY);
 796  };
 797  /**
 798   * Returns the annotations that apply to the given RichText instance.
 799   *
 800   * Both a blockClientId and a richTextIdentifier are required. This is because
 801   * a block might have multiple `RichText` components. This does mean that every
 802   * block needs to implement annotations itself.
 803   *
 804   * @param {Object} state              Editor state.
 805   * @param {string} blockClientId      The client ID for the block.
 806   * @param {string} richTextIdentifier Unique identifier that identifies the given RichText.
 807   * @return {Array} All the annotations relevant for the `RichText`.
 808   */
 809  
 810  var __experimentalGetAnnotationsForRichText = Object(rememo["a" /* default */])(function (state, blockClientId, richTextIdentifier) {
 811    return Object(external_this_lodash_["get"])(state, blockClientId, []).filter(function (annotation) {
 812      return annotation.selector === 'range' && richTextIdentifier === annotation.richTextIdentifier;
 813    }).map(function (annotation) {
 814      var range = annotation.range,
 815          other = Object(objectWithoutProperties["a" /* default */])(annotation, ["range"]);
 816  
 817      return selectors_objectSpread({}, range, {}, other);
 818    });
 819  }, function (state, blockClientId) {
 820    return [Object(external_this_lodash_["get"])(state, blockClientId, EMPTY_ARRAY)];
 821  });
 822  /**
 823   * Returns all annotations in the editor state.
 824   *
 825   * @param {Object} state Editor state.
 826   * @return {Array} All annotations currently applied.
 827   */
 828  
 829  function __experimentalGetAnnotations(state) {
 830    return Object(external_this_lodash_["flatMap"])(state, function (annotations) {
 831      return annotations;
 832    });
 833  }
 834  
 835  // EXTERNAL MODULE: ./node_modules/uuid/v4.js
 836  var v4 = __webpack_require__(83);
 837  var v4_default = /*#__PURE__*/__webpack_require__.n(v4);
 838  
 839  // CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/store/actions.js
 840  /**
 841   * External dependencies
 842   */
 843  
 844  /**
 845   * Adds an annotation to a block.
 846   *
 847   * The `block` attribute refers to a block ID that needs to be annotated.
 848   * `isBlockAnnotation` controls whether or not the annotation is a block
 849   * annotation. The `source` is the source of the annotation, this will be used
 850   * to identity groups of annotations.
 851   *
 852   * The `range` property is only relevant if the selector is 'range'.
 853   *
 854   * @param {Object} annotation                    The annotation to add.
 855   * @param {string} annotation.blockClientId      The blockClientId to add the annotation to.
 856   * @param {string} annotation.richTextIdentifier Identifier for the RichText instance the annotation applies to.
 857   * @param {Object} annotation.range              The range at which to apply this annotation.
 858   * @param {number} annotation.range.start        The offset where the annotation should start.
 859   * @param {number} annotation.range.end          The offset where the annotation should end.
 860   * @param {string} annotation.[selector="range"] The way to apply this annotation.
 861   * @param {string} annotation.[source="default"] The source that added the annotation.
 862   * @param {string} annotation.[id]               The ID the annotation should have. Generates a UUID by default.
 863   *
 864   * @return {Object} Action object.
 865   */
 866  
 867  function __experimentalAddAnnotation(_ref) {
 868    var blockClientId = _ref.blockClientId,
 869        _ref$richTextIdentifi = _ref.richTextIdentifier,
 870        richTextIdentifier = _ref$richTextIdentifi === void 0 ? null : _ref$richTextIdentifi,
 871        _ref$range = _ref.range,
 872        range = _ref$range === void 0 ? null : _ref$range,
 873        _ref$selector = _ref.selector,
 874        selector = _ref$selector === void 0 ? 'range' : _ref$selector,
 875        _ref$source = _ref.source,
 876        source = _ref$source === void 0 ? 'default' : _ref$source,
 877        _ref$id = _ref.id,
 878        id = _ref$id === void 0 ? v4_default()() : _ref$id;
 879    var action = {
 880      type: 'ANNOTATION_ADD',
 881      id: id,
 882      blockClientId: blockClientId,
 883      richTextIdentifier: richTextIdentifier,
 884      source: source,
 885      selector: selector
 886    };
 887  
 888    if (selector === 'range') {
 889      action.range = range;
 890    }
 891  
 892    return action;
 893  }
 894  /**
 895   * Removes an annotation with a specific ID.
 896   *
 897   * @param {string} annotationId The annotation to remove.
 898   *
 899   * @return {Object} Action object.
 900   */
 901  
 902  function __experimentalRemoveAnnotation(annotationId) {
 903    return {
 904      type: 'ANNOTATION_REMOVE',
 905      annotationId: annotationId
 906    };
 907  }
 908  /**
 909   * Updates the range of an annotation.
 910   *
 911   * @param {string} annotationId ID of the annotation to update.
 912   * @param {number} start The start of the new range.
 913   * @param {number} end The end of the new range.
 914   *
 915   * @return {Object} Action object.
 916   */
 917  
 918  function __experimentalUpdateAnnotationRange(annotationId, start, end) {
 919    return {
 920      type: 'ANNOTATION_UPDATE_RANGE',
 921      annotationId: annotationId,
 922      start: start,
 923      end: end
 924    };
 925  }
 926  /**
 927   * Removes all annotations of a specific source.
 928   *
 929   * @param {string} source The source to remove.
 930   *
 931   * @return {Object} Action object.
 932   */
 933  
 934  function __experimentalRemoveAnnotationsBySource(source) {
 935    return {
 936      type: 'ANNOTATION_REMOVE_SOURCE',
 937      source: source
 938    };
 939  }
 940  
 941  // CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/store/index.js
 942  /**
 943   * WordPress dependencies
 944   */
 945  
 946  /**
 947   * Internal dependencies
 948   */
 949  
 950  
 951  
 952  
 953  /**
 954   * Module Constants
 955   */
 956  
 957  var MODULE_KEY = 'core/annotations';
 958  var store = Object(external_this_wp_data_["registerStore"])(MODULE_KEY, {
 959    reducer: reducer,
 960    selectors: selectors_namespaceObject,
 961    actions: actions_namespaceObject
 962  });
 963  /* harmony default export */ var build_module_store = (store);
 964  
 965  // EXTERNAL MODULE: external {"this":["wp","richText"]}
 966  var external_this_wp_richText_ = __webpack_require__(24);
 967  
 968  // EXTERNAL MODULE: external {"this":["wp","i18n"]}
 969  var external_this_wp_i18n_ = __webpack_require__(1);
 970  
 971  // CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/format/annotation.js
 972  /**
 973   * WordPress dependencies
 974   */
 975  
 976  
 977  var FORMAT_NAME = 'core/annotation';
 978  var ANNOTATION_ATTRIBUTE_PREFIX = 'annotation-text-';
 979  var STORE_KEY = 'core/annotations';
 980  /**
 981   * Applies given annotations to the given record.
 982   *
 983   * @param {Object} record The record to apply annotations to.
 984   * @param {Array} annotations The annotation to apply.
 985   * @return {Object} A record with the annotations applied.
 986   */
 987  
 988  function applyAnnotations(record) {
 989    var annotations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
 990    annotations.forEach(function (annotation) {
 991      var start = annotation.start,
 992          end = annotation.end;
 993  
 994      if (start > record.text.length) {
 995        start = record.text.length;
 996      }
 997  
 998      if (end > record.text.length) {
 999        end = record.text.length;
1000      }
1001  
1002      var className = ANNOTATION_ATTRIBUTE_PREFIX + annotation.source;
1003      var id = ANNOTATION_ATTRIBUTE_PREFIX + annotation.id;
1004      record = Object(external_this_wp_richText_["applyFormat"])(record, {
1005        type: FORMAT_NAME,
1006        attributes: {
1007          className: className,
1008          id: id
1009        }
1010      }, start, end);
1011    });
1012    return record;
1013  }
1014  /**
1015   * Removes annotations from the given record.
1016   *
1017   * @param {Object} record Record to remove annotations from.
1018   * @return {Object} The cleaned record.
1019   */
1020  
1021  function removeAnnotations(record) {
1022    return Object(external_this_wp_richText_["removeFormat"])(record, 'core/annotation', 0, record.text.length);
1023  }
1024  /**
1025   * Retrieves the positions of annotations inside an array of formats.
1026   *
1027   * @param {Array} formats Formats with annotations in there.
1028   * @return {Object} ID keyed positions of annotations.
1029   */
1030  
1031  function retrieveAnnotationPositions(formats) {
1032    var positions = {};
1033    formats.forEach(function (characterFormats, i) {
1034      characterFormats = characterFormats || [];
1035      characterFormats = characterFormats.filter(function (format) {
1036        return format.type === FORMAT_NAME;
1037      });
1038      characterFormats.forEach(function (format) {
1039        var id = format.attributes.id;
1040        id = id.replace(ANNOTATION_ATTRIBUTE_PREFIX, '');
1041  
1042        if (!positions.hasOwnProperty(id)) {
1043          positions[id] = {
1044            start: i
1045          };
1046        } // Annotations refer to positions between characters.
1047        // Formats refer to the character themselves.
1048        // So we need to adjust for that here.
1049  
1050  
1051        positions[id].end = i + 1;
1052      });
1053    });
1054    return positions;
1055  }
1056  /**
1057   * Updates annotations in the state based on positions retrieved from RichText.
1058   *
1059   * @param {Array}    annotations                   The annotations that are currently applied.
1060   * @param {Array}    positions                     The current positions of the given annotations.
1061   * @param {Object}   actions
1062   * @param {Function} actions.removeAnnotation      Function to remove an annotation from the state.
1063   * @param {Function} actions.updateAnnotationRange Function to update an annotation range in the state.
1064   */
1065  
1066  
1067  function updateAnnotationsWithPositions(annotations, positions, _ref) {
1068    var removeAnnotation = _ref.removeAnnotation,
1069        updateAnnotationRange = _ref.updateAnnotationRange;
1070    annotations.forEach(function (currentAnnotation) {
1071      var position = positions[currentAnnotation.id]; // If we cannot find an annotation, delete it.
1072  
1073      if (!position) {
1074        // Apparently the annotation has been removed, so remove it from the state:
1075        // Remove...
1076        removeAnnotation(currentAnnotation.id);
1077        return;
1078      }
1079  
1080      var start = currentAnnotation.start,
1081          end = currentAnnotation.end;
1082  
1083      if (start !== position.start || end !== position.end) {
1084        updateAnnotationRange(currentAnnotation.id, position.start, position.end);
1085      }
1086    });
1087  }
1088  
1089  var annotation_annotation = {
1090    name: FORMAT_NAME,
1091    title: Object(external_this_wp_i18n_["__"])('Annotation'),
1092    tagName: 'mark',
1093    className: 'annotation-text',
1094    attributes: {
1095      className: 'class',
1096      id: 'id'
1097    },
1098    edit: function edit() {
1099      return null;
1100    },
1101    __experimentalGetPropsForEditableTreePreparation: function __experimentalGetPropsForEditableTreePreparation(select, _ref2) {
1102      var richTextIdentifier = _ref2.richTextIdentifier,
1103          blockClientId = _ref2.blockClientId;
1104      return {
1105        annotations: select(STORE_KEY).__experimentalGetAnnotationsForRichText(blockClientId, richTextIdentifier)
1106      };
1107    },
1108    __experimentalCreatePrepareEditableTree: function __experimentalCreatePrepareEditableTree(_ref3) {
1109      var annotations = _ref3.annotations;
1110      return function (formats, text) {
1111        if (annotations.length === 0) {
1112          return formats;
1113        }
1114  
1115        var record = {
1116          formats: formats,
1117          text: text
1118        };
1119        record = applyAnnotations(record, annotations);
1120        return record.formats;
1121      };
1122    },
1123    __experimentalGetPropsForEditableTreeChangeHandler: function __experimentalGetPropsForEditableTreeChangeHandler(dispatch) {
1124      return {
1125        removeAnnotation: dispatch(STORE_KEY).__experimentalRemoveAnnotation,
1126        updateAnnotationRange: dispatch(STORE_KEY).__experimentalUpdateAnnotationRange
1127      };
1128    },
1129    __experimentalCreateOnChangeEditableValue: function __experimentalCreateOnChangeEditableValue(props) {
1130      return function (formats) {
1131        var positions = retrieveAnnotationPositions(formats);
1132        var removeAnnotation = props.removeAnnotation,
1133            updateAnnotationRange = props.updateAnnotationRange,
1134            annotations = props.annotations;
1135        updateAnnotationsWithPositions(annotations, positions, {
1136          removeAnnotation: removeAnnotation,
1137          updateAnnotationRange: updateAnnotationRange
1138        });
1139      };
1140    }
1141  };
1142  
1143  // CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/format/index.js
1144  
1145  
1146  /**
1147   * WordPress dependencies
1148   */
1149  
1150  /**
1151   * Internal dependencies
1152   */
1153  
1154  
1155  
1156  var format_name = annotation_annotation.name,
1157      settings = Object(objectWithoutProperties["a" /* default */])(annotation_annotation, ["name"]);
1158  
1159  Object(external_this_wp_richText_["registerFormatType"])(format_name, settings);
1160  
1161  // EXTERNAL MODULE: external {"this":["wp","hooks"]}
1162  var external_this_wp_hooks_ = __webpack_require__(32);
1163  
1164  // CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/block/index.js
1165  /**
1166   * WordPress dependencies
1167   */
1168  
1169  
1170  /**
1171   * Adds annotation className to the block-list-block component.
1172   *
1173   * @param {Object} OriginalComponent The original BlockListBlock component.
1174   * @return {Object} The enhanced component.
1175   */
1176  
1177  var block_addAnnotationClassName = function addAnnotationClassName(OriginalComponent) {
1178    return Object(external_this_wp_data_["withSelect"])(function (select, _ref) {
1179      var clientId = _ref.clientId,
1180          className = _ref.className;
1181  
1182      var annotations = select('core/annotations').__experimentalGetAnnotationsForBlock(clientId);
1183  
1184      return {
1185        className: annotations.map(function (annotation) {
1186          return 'is-annotated-by-' + annotation.source;
1187        }).concat(className).filter(Boolean).join(' ')
1188      };
1189    })(OriginalComponent);
1190  };
1191  
1192  Object(external_this_wp_hooks_["addFilter"])('editor.BlockListBlock', 'core/annotations', block_addAnnotationClassName);
1193  
1194  // CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/index.js
1195  /**
1196   * Internal dependencies
1197   */
1198  
1199  
1200  
1201  
1202  
1203  /***/ }),
1204  
1205  /***/ 5:
1206  /***/ (function(module, __webpack_exports__, __webpack_require__) {
1207  
1208  "use strict";
1209  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; });
1210  function _defineProperty(obj, key, value) {
1211    if (key in obj) {
1212      Object.defineProperty(obj, key, {
1213        value: value,
1214        enumerable: true,
1215        configurable: true,
1216        writable: true
1217      });
1218    } else {
1219      obj[key] = value;
1220    }
1221  
1222    return obj;
1223  }
1224  
1225  /***/ }),
1226  
1227  /***/ 83:
1228  /***/ (function(module, exports, __webpack_require__) {
1229  
1230  var rng = __webpack_require__(116);
1231  var bytesToUuid = __webpack_require__(117);
1232  
1233  function v4(options, buf, offset) {
1234    var i = buf && offset || 0;
1235  
1236    if (typeof(options) == 'string') {
1237      buf = options === 'binary' ? new Array(16) : null;
1238      options = null;
1239    }
1240    options = options || {};
1241  
1242    var rnds = options.random || (options.rng || rng)();
1243  
1244    // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
1245    rnds[6] = (rnds[6] & 0x0f) | 0x40;
1246    rnds[8] = (rnds[8] & 0x3f) | 0x80;
1247  
1248    // Copy bytes to buffer, if provided
1249    if (buf) {
1250      for (var ii = 0; ii < 16; ++ii) {
1251        buf[i + ii] = rnds[ii];
1252      }
1253    }
1254  
1255    return buf || bytesToUuid(rnds);
1256  }
1257  
1258  module.exports = v4;
1259  
1260  
1261  /***/ })
1262  
1263  /******/ });


Generated: Tue Apr 7 01:00:07 2020 Cross-referenced by PHPXref 0.7.1