/******/ 		};

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

// ESM COMPAT FLAG

__webpack_require__.r(__webpack_exports__);

// EXPORTS

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

var selectors_namespaceObject = {};

__webpack_require__.r(selectors_namespaceObject);

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

var actions_namespaceObject = {};

__webpack_require__.r(actions_namespaceObject);

/**

 * 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.

 *

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

 */

  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;

      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) {

}

/**

 * 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.

 */

  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);

    }

  });

}

  name: FORMAT_NAME,

  tagName: 'mark',

  className: 'annotation-text',

  attributes: {

    className: 'class',

    id: 'id'

  },

  edit() {

    return null;

  },

    return {

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

    };

  },

    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

/**

 * 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 => {

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

    return {

      className: annotations.map(annotation => {

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

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

    };

  })(OriginalComponent);

};

/**

 * External dependencies

 */

/**

 * 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;

}

/**

 * 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) {

}

/**

 * Reducer managing annotations.

 *

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

 * @param {Object} action Dispatched action.

 *

 * @return {Array} Updated state.

 */

  var _state$blockClientId;

  switch (action.type) {