JAVASCRIPT   104

annotations.js

Guest on 5th August 2021 05:14:54 PM

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

Raw Paste


Login or Register to edit or fork this paste. It's free.