/******/ (() => { // webpackBootstrap

/******/ 	"use strict";

/******/ 	// The require scope

/******/ 	var __webpack_require__ = {};

/******/ 	

/************************************************************************/

/******/ 	/* webpack/runtime/define property getters */

/******/ 	(() => {

/******/ 		// define getter functions for harmony exports

/******/ 		__webpack_require__.d = (exports, definition) => {

/******/ 			for(var key in definition) {

/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {

/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });

/******/ 				}

/******/ 			}

/******/ 		};

/******/ 	})();

/******/ 	

/******/ 	/* webpack/runtime/hasOwnProperty shorthand */

/******/ 	(() => {

/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))

/******/ 	})();

/******/ 	

/******/ 	/* webpack/runtime/make namespace object */

/******/ 	(() => {

/******/ 		// define __esModule on exports

/******/ 		__webpack_require__.r = (exports) => {

/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {

/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

/******/ 			}

/******/ 			Object.defineProperty(exports, '__esModule', { value: true });

/******/ 		};

/******/ 	})();

/******/ 	

/************************************************************************/

var __webpack_exports__ = {};

// ESM COMPAT FLAG

__webpack_require__.r(__webpack_exports__);

// EXPORTS

__webpack_require__.d(__webpack_exports__, {

  store: () => (/* reexport */ store)

});

// NAMESPACE OBJECT: ./node_modules/@wordpress/annotations/build-module/store/selectors.js

var selectors_namespaceObject = {};

__webpack_require__.r(selectors_namespaceObject);

__webpack_require__.d(selectors_namespaceObject, {

  __experimentalGetAllAnnotationsForBlock: () => (__experimentalGetAllAnnotationsForBlock),

  __experimentalGetAnnotations: () => (__experimentalGetAnnotations),

  __experimentalGetAnnotationsForBlock: () => (__experimentalGetAnnotationsForBlock),

  __experimentalGetAnnotationsForRichText: () => (__experimentalGetAnnotationsForRichText)

});

// NAMESPACE OBJECT: ./node_modules/@wordpress/annotations/build-module/store/actions.js

var actions_namespaceObject = {};

__webpack_require__.r(actions_namespaceObject);

__webpack_require__.d(actions_namespaceObject, {

  __experimentalAddAnnotation: () => (__experimentalAddAnnotation),

  __experimentalRemoveAnnotation: () => (__experimentalRemoveAnnotation),

  __experimentalRemoveAnnotationsBySource: () => (__experimentalRemoveAnnotationsBySource),

  __experimentalUpdateAnnotationRange: () => (__experimentalUpdateAnnotationRange)

});

const external_wp_richText_namespaceObject = window["wp"]["richText"];

const external_wp_i18n_namespaceObject = window["wp"]["i18n"];

/**

 * The identifier for the data store.

 *

 * @type {string}

 */

const STORE_NAME = 'core/annotations';

/**

 * WordPress dependencies

 */

const FORMAT_NAME = 'core/annotation';

const ANNOTATION_ATTRIBUTE_PREFIX = 'annotation-text-';

/**

 * Internal dependencies

 */

/**

 * Applies given annotations to the given record.

 *

 * @param {Object} record      The record to apply annotations to.

 * @param {Array}  annotations The annotation to apply.

 * @return {Object} A record with the annotations applied.

 */

function applyAnnotations(record, annotations = []) {

  annotations.forEach(annotation => {

    let {

      start,

      end

    } = annotation;

    if (start > record.text.length) {

      start = record.text.length;

    }

    if (end > record.text.length) {

      end = record.text.length;

    }

    const className = ANNOTATION_ATTRIBUTE_PREFIX + annotation.source;

    const id = ANNOTATION_ATTRIBUTE_PREFIX + annotation.id;

    record = (0,external_wp_richText_namespaceObject.applyFormat)(record, {

      type: FORMAT_NAME,

      attributes: {

        className,

        id

      }

    }, start, end);

  });

  return record;

}

/**

 * Removes annotations from the given record.

 *

 * @param {Object} record Record to remove annotations from.

 * @return {Object} The cleaned record.

 */

function removeAnnotations(record) {

  return removeFormat(record, 'core/annotation', 0, record.text.length);

}

/**

 * Retrieves the positions of annotations inside an array of formats.

 *

 * @param {Array} formats Formats with annotations in there.

 * @return {Object} ID keyed positions of annotations.

 */

function retrieveAnnotationPositions(formats) {

  const positions = {};

  formats.forEach((characterFormats, i) => {

    characterFormats = characterFormats || [];

    characterFormats = characterFormats.filter(format => format.type === FORMAT_NAME);

    characterFormats.forEach(format => {

      let {

        id

      } = format.attributes;

      id = id.replace(ANNOTATION_ATTRIBUTE_PREFIX, '');

      if (!positions.hasOwnProperty(id)) {

        positions[id] = {

          start: i

        };

      }

      // Annotations refer to positions between characters.

      // Formats refer to the character themselves.

      // So we need to adjust for that here.

      positions[id].end = i + 1;

    });

  });

  return positions;

}

/**

 * Updates annotations in the state based on positions retrieved from RichText.

 *

 * @param {Array}    annotations                   The annotations that are currently applied.

 * @param {Array}    positions                     The current positions of the given annotations.

 * @param {Object}   actions

 * @param {Function} actions.removeAnnotation      Function to remove an annotation from the state.

 * @param {Function} actions.updateAnnotationRange Function to update an annotation range in the state.

 */

function updateAnnotationsWithPositions(annotations, positions, {

  removeAnnotation,

  updateAnnotationRange

}) {

  annotations.forEach(currentAnnotation => {

    const position = positions[currentAnnotation.id];

    // If we cannot find an annotation, delete it.

    if (!position) {

      // Apparently the annotation has been removed, so remove it from the state:

      // Remove...

      removeAnnotation(currentAnnotation.id);

      return;

    }

    const {

      start,

      end

    } = currentAnnotation;

    if (start !== position.start || end !== position.end) {

      updateAnnotationRange(currentAnnotation.id, position.start, position.end);

    }

  });

}

const annotation = {

  name: FORMAT_NAME,

  title: (0,external_wp_i18n_namespaceObject.__)('Annotation'),

  tagName: 'mark',

  className: 'annotation-text',

  attributes: {

    className: 'class',

    id: 'id'

  },

  edit() {

    return null;

  },

  __experimentalGetPropsForEditableTreePreparation(select, {

    richTextIdentifier,

    blockClientId

  }) {

    return {

      annotations: select(STORE_NAME).__experimentalGetAnnotationsForRichText(blockClientId, richTextIdentifier)

    };

  },

  __experimentalCreatePrepareEditableTree({

    annotations

  }) {

    return (formats, text) => {

      if (annotations.length === 0) {

        return formats;

      }

      let record = {

        formats,

        text

      };

      record = applyAnnotations(record, annotations);

      return record.formats;

    };

  },

  __experimentalGetPropsForEditableTreeChangeHandler(dispatch) {

    return {

      removeAnnotation: dispatch(STORE_NAME).__experimentalRemoveAnnotation,

      updateAnnotationRange: dispatch(STORE_NAME).__experimentalUpdateAnnotationRange

    };

  },

  __experimentalCreateOnChangeEditableValue(props) {

    return formats => {

      const positions = retrieveAnnotationPositions(formats);

      const {

        removeAnnotation,

        updateAnnotationRange,

        annotations

      } = props;

      updateAnnotationsWithPositions(annotations, positions, {

        removeAnnotation,

        updateAnnotationRange

      });

    };

  }

};

/**

 * WordPress dependencies

 */

/**

 * Internal dependencies

 */

const {

  name: format_name,

  ...settings

} = annotation;

(0,external_wp_richText_namespaceObject.registerFormatType)(format_name, settings);

const external_wp_hooks_namespaceObject = window["wp"]["hooks"];

const external_wp_data_namespaceObject = window["wp"]["data"];

/**

 * WordPress dependencies

 */

/**

 * Internal dependencies

 */

/**

 * Adds annotation className to the block-list-block component.

 *

 * @param {Object} OriginalComponent The original BlockListBlock component.

 * @return {Object} The enhanced component.

 */

const addAnnotationClassName = OriginalComponent => {

  return (0,external_wp_data_namespaceObject.withSelect)((select, {

    clientId,

    className

  }) => {

    const annotations = select(STORE_NAME).__experimentalGetAnnotationsForBlock(clientId);

    return {

      className: annotations.map(annotation => {

        return 'is-annotated-by-' + annotation.source;

      }).concat(className).filter(Boolean).join(' ')

    };

  })(OriginalComponent);

};

(0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockListBlock', 'core/annotations', addAnnotationClassName);

/**

 * Filters an array based on the predicate, but keeps the reference the same if

 * the array hasn't changed.

 *

 * @param {Array}    collection The collection to filter.

 * @param {Function} predicate  Function that determines if the item should stay

 *                              in the array.

 * @return {Array} Filtered array.

 */

function filterWithReference(collection, predicate) {

  const filteredCollection = collection.filter(predicate);

  return collection.length === filteredCollection.length ? collection : filteredCollection;

}

/**

 * Creates a new object with the same keys, but with `callback()` called as

 * a transformer function on each of the values.

 *

 * @param {Object}   obj      The object to transform.

 * @param {Function} callback The function to transform each object value.

 * @return {Array} Transformed object.

 */

const mapValues = (obj, callback) => Object.entries(obj).reduce((acc, [key, value]) => ({

  ...acc,

  [key]: callback(value)

}), {});

/**

 * Verifies whether the given annotations is a valid annotation.

 *

 * @param {Object} annotation The annotation to verify.

 * @return {boolean} Whether the given annotation is valid.

 */

function isValidAnnotationRange(annotation) {

  return typeof annotation.start === 'number' && typeof annotation.end === 'number' && annotation.start <= annotation.end;

}

/**

 * Reducer managing annotations.

 *

 * @param {Object} state  The annotations currently shown in the editor.

 * @param {Object} action Dispatched action.

 *

 * @return {Array} Updated state.

 */

function annotations(state = {}, action) {

  var _state$blockClientId;

  switch (action.type) {

    case 'ANNOTATION_ADD':

      const blockClientId = action.blockClientId;

      const newAnnotation = {

        id: action.id,

        blockClientId,

        richTextIdentifier: action.richTextIdentifier,

        source: action.source,

        selector: action.selector,

        range: action.range

      };

      if (newAnnotation.selector === 'range' && !isValidAnnotationRange(newAnnotation.range)) {

        return state;

      }

      const previousAnnotationsForBlock = (_state$blockClientId = state?.[blockClientId]) !== null && _state$blockClientId !== void 0 ? _state$blockClientId : [];

      return {

        ...state,

        [blockClientId]: [...previousAnnotationsForBlock, newAnnotation]

      };

    case 'ANNOTATION_REMOVE':