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