| [ Index ] |
PHP Cross Reference of WordPress |
[Summary view] [Print] [Text view]
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 /******/ });
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Tue Apr 7 01:00:07 2020 | Cross-referenced by PHPXref 0.7.1 |