1/******/ (() => { // webpackBootstrap
2/******/ "use strict";
3/******/ // The require scope
4/******/ var __webpack_require__ = {};
5/******/
6/************************************************************************/
7/******/ /* webpack/runtime/define property getters */
8/******/ (() => {
9/******/ // define getter functions for harmony exports
10/******/ __webpack_require__.d = (exports, definition) => {
11/******/ for(var key in definition) {
12/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
13/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
14/******/ }
15/******/ }
16/******/ };
17/******/ })();
18/******/
19/******/ /* webpack/runtime/hasOwnProperty shorthand */
20/******/ (() => {
21/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
22/******/ })();
23/******/
24/******/ /* webpack/runtime/make namespace object */
25/******/ (() => {
26/******/ // define __esModule on exports
27/******/ __webpack_require__.r = (exports) => {
28/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
29/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
30/******/ }
31/******/ Object.defineProperty(exports, '__esModule', { value: true });
32/******/ };
33/******/ })();
34/******/
35/************************************************************************/
36var __webpack_exports__ = {};
37// ESM COMPAT FLAG
38__webpack_require__.r(__webpack_exports__);
39
40// EXPORTS
41__webpack_require__.d(__webpack_exports__, {
42 store: () => (/* reexport */ store)
43});
44
45// NAMESPACE OBJECT: ./node_modules/@wordpress/annotations/build-module/store/selectors.js
46var selectors_namespaceObject = {};
47__webpack_require__.r(selectors_namespaceObject);
48__webpack_require__.d(selectors_namespaceObject, {
49 __experimentalGetAllAnnotationsForBlock: () => (__experimentalGetAllAnnotationsForBlock),
50 __experimentalGetAnnotations: () => (__experimentalGetAnnotations),
51 __experimentalGetAnnotationsForBlock: () => (__experimentalGetAnnotationsForBlock),
52 __experimentalGetAnnotationsForRichText: () => (__experimentalGetAnnotationsForRichText)
53});
54
55// NAMESPACE OBJECT: ./node_modules/@wordpress/annotations/build-module/store/actions.js
56var actions_namespaceObject = {};
57__webpack_require__.r(actions_namespaceObject);
58__webpack_require__.d(actions_namespaceObject, {
59 __experimentalAddAnnotation: () => (__experimentalAddAnnotation),
60 __experimentalRemoveAnnotation: () => (__experimentalRemoveAnnotation),
61 __experimentalRemoveAnnotationsBySource: () => (__experimentalRemoveAnnotationsBySource),
62 __experimentalUpdateAnnotationRange: () => (__experimentalUpdateAnnotationRange)
63});
64
65;// external ["wp","richText"]
66const external_wp_richText_namespaceObject = window["wp"]["richText"];
67;// external ["wp","i18n"]
68const external_wp_i18n_namespaceObject = window["wp"]["i18n"];
69;// ./node_modules/@wordpress/annotations/build-module/store/constants.js
70const STORE_NAME = "core/annotations";
71
72
73;// ./node_modules/@wordpress/annotations/build-module/format/annotation.js
74
75
76const FORMAT_NAME = "core/annotation";
77const ANNOTATION_ATTRIBUTE_PREFIX = "annotation-text-";
78
79function applyAnnotations(record, annotations = []) {
80 annotations.forEach((annotation2) => {
81 let { start, end } = annotation2;
82 if (start > record.text.length) {
83 start = record.text.length;
84 }
85 if (end > record.text.length) {
86 end = record.text.length;
87 }
88 const className = ANNOTATION_ATTRIBUTE_PREFIX + annotation2.source;
89 const id = ANNOTATION_ATTRIBUTE_PREFIX + annotation2.id;
90 record = (0,external_wp_richText_namespaceObject.applyFormat)(
91 record,
92 {
93 type: FORMAT_NAME,
94 attributes: {
95 className,
96 id
97 }
98 },
99 start,
100 end
101 );
102 });
103 return record;
104}
105function removeAnnotations(record) {
106 return removeFormat(record, "core/annotation", 0, record.text.length);
107}
108function 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}
128function updateAnnotationsWithPositions(annotations, positions, { removeAnnotation, updateAnnotationRange }) {
129 annotations.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}
145const annotation = {
146 name: FORMAT_NAME,
147 title: (0,external_wp_i18n_namespaceObject.__)("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 }) {
168 return (formats, text) => {
169 if (annotations.length === 0) {
170 return formats;
171 }
172 let record = { formats, text };
173 record = applyAnnotations(record, annotations);
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 } = props;
187 updateAnnotationsWithPositions(annotations, positions, {
188 removeAnnotation,
189 updateAnnotationRange
190 });
191 };
192 }
193};
194
195
196;// ./node_modules/@wordpress/annotations/build-module/format/index.js
197
198
199const { name: format_name, ...settings } = annotation;
200(0,external_wp_richText_namespaceObject.registerFormatType)(format_name, settings);
201
202;// external ["wp","hooks"]
203const external_wp_hooks_namespaceObject = window["wp"]["hooks"];
204;// external ["wp","data"]
205const external_wp_data_namespaceObject = window["wp"]["data"];
206;// ./node_modules/@wordpress/annotations/build-module/block/index.js
207
208
209
210const addAnnotationClassName = (OriginalComponent) => {
211 return (0,external_wp_data_namespaceObject.withSelect)((select, { clientId, className }) => {
212 const annotations = select(STORE_NAME).__experimentalGetAnnotationsForBlock(
213 clientId
214 );
215 return {
216 className: annotations.map((annotation) => {
217 return "is-annotated-by-" + annotation.source;
218 }).concat(className).filter(Boolean).join(" ")
219 };
220 })(OriginalComponent);
221};
222(0,external_wp_hooks_namespaceObject.addFilter)(
223 "editor.BlockListBlock",
224 "core/annotations",
225 addAnnotationClassName
226);
227
228;// ./node_modules/@wordpress/annotations/build-module/store/reducer.js
229function filterWithReference(collection, predicate) {
230 const filteredCollection = collection.filter(predicate);
231 return collection.length === filteredCollection.length ? collection : filteredCollection;
232}
233const mapValues = (obj, callback) => Object.entries(obj).reduce(
234 (acc, [key, value]) => ({
235 ...acc,
236 [key]: callback(value)
237 }),
238 {}
239);
240function isValidAnnotationRange(annotation) {
241 return typeof annotation.start === "number" && typeof annotation.end === "number" && annotation.start <= annotation.end;
242}
243function annotations(state = {}, action) {
244 switch (action.type) {
245 case "ANNOTATION_ADD":
246 const blockClientId = action.blockClientId;
247 const newAnnotation = {
248 id: action.id,
249 blockClientId,
250 richTextIdentifier: action.richTextIdentifier,
251 source: action.source,
252 selector: action.selector,
253 range: action.range
254 };
255 if (newAnnotation.selector === "range" && !isValidAnnotationRange(newAnnotation.range)) {
256 return state;
257 }
258 const previousAnnotationsForBlock = state?.[blockClientId] ?? [];
259 return {
260 ...state,
261 [blockClientId]: [
262 ...previousAnnotationsForBlock,
263 newAnnotation
264 ]
265 };
266 case "ANNOTATION_REMOVE":
267 return mapValues(state, (annotationsForBlock) => {
268 return filterWithReference(
269 annotationsForBlock,
270 (annotation) => {
271 return annotation.id !== action.annotationId;
272 }
273 );
274 });
275 case "ANNOTATION_UPDATE_RANGE":
276 return mapValues(state, (annotationsForBlock) => {
277 let hasChangedRange = false;
278 const newAnnotations = annotationsForBlock.map(
279 (annotation) => {
280 if (annotation.id === action.annotationId) {
281 hasChangedRange = true;
282 return {
283 ...annotation,
284 range: {
285 start: action.start,
286 end: action.end
287 }
288 };
289 }
290 return annotation;
291 }
292 );
293 return hasChangedRange ? newAnnotations : annotationsForBlock;
294 });
295 case "ANNOTATION_REMOVE_SOURCE":
296 return mapValues(state, (annotationsForBlock) => {
297 return filterWithReference(
298 annotationsForBlock,
299 (annotation) => {
300 return annotation.source !== action.source;
301 }
302 );
303 });
304 }
305 return state;
306}
307var reducer_default = annotations;
308
309
310;// ./node_modules/@wordpress/annotations/build-module/store/selectors.js
311
312const EMPTY_ARRAY = [];
313const __experimentalGetAnnotationsForBlock = (0,external_wp_data_namespaceObject.createSelector)(
314 (state, blockClientId) => {
315 return (state?.[blockClientId] ?? []).filter((annotation) => {
316 return annotation.selector === "block";
317 });
318 },
319 (state, blockClientId) => [state?.[blockClientId] ?? EMPTY_ARRAY]
320);
321function __experimentalGetAllAnnotationsForBlock(state, blockClientId) {
322 return state?.[blockClientId] ?? EMPTY_ARRAY;
323}
324const __experimentalGetAnnotationsForRichText = (0,external_wp_data_namespaceObject.createSelector)(
325 (state, blockClientId, richTextIdentifier) => {
326 return (state?.[blockClientId] ?? []).filter((annotation) => {
327 return annotation.selector === "range" && richTextIdentifier === annotation.richTextIdentifier;
328 }).map((annotation) => {
329 const { range, ...other } = annotation;
330 return {
331 ...range,
332 ...other
333 };
334 });
335 },
336 (state, blockClientId) => [state?.[blockClientId] ?? EMPTY_ARRAY]
337);
338function __experimentalGetAnnotations(state) {
339 return Object.values(state).flat();
340}
341
342
343;// ./node_modules/@wordpress/annotations/node_modules/uuid/dist/esm-browser/native.js
344const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
345/* harmony default export */ const esm_browser_native = ({
346 randomUUID
347});
348;// ./node_modules/@wordpress/annotations/node_modules/uuid/dist/esm-browser/rng.js
349// Unique ID creation requires a high quality random # generator. In the browser we therefore
350// require the crypto API and do not support built-in fallback to lower quality random number
351// generators (like Math.random()).
352let getRandomValues;
353const rnds8 = new Uint8Array(16);
354function rng() {
355 // lazy load so that environments that need to polyfill have a chance to do so
356 if (!getRandomValues) {
357 // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
358 getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
359
360 if (!getRandomValues) {
361 throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
362 }
363 }
364
365 return getRandomValues(rnds8);
366}
367;// ./node_modules/@wordpress/annotations/node_modules/uuid/dist/esm-browser/stringify.js
368
369/**
370 * Convert array of 16 byte values to UUID string format of the form:
371 * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
372 */
373
374const byteToHex = [];
375
376for (let i = 0; i < 256; ++i) {
377 byteToHex.push((i + 0x100).toString(16).slice(1));
378}
379
380function unsafeStringify(arr, offset = 0) {
381 // Note: Be careful editing this code! It's been tuned for performance
382 // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
383 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]];
384}
385
386function stringify(arr, offset = 0) {
387 const uuid = unsafeStringify(arr, offset); // Consistency check for valid UUID. If this throws, it's likely due to one
388 // of the following:
389 // - One or more input array values don't map to a hex octet (leading to
390 // "undefined" in the uuid)
391 // - Invalid input values for the RFC `version` or `variant` fields
392
393 if (!validate(uuid)) {
394 throw TypeError('Stringified UUID is invalid');
395 }
396
397 return uuid;
398}
399
400/* harmony default export */ const esm_browser_stringify = ((/* unused pure expression or super */ null && (stringify)));
401;// ./node_modules/@wordpress/annotations/node_modules/uuid/dist/esm-browser/v4.js
402
403
404
405
406function v4(options, buf, offset) {
407 if (esm_browser_native.randomUUID && !buf && !options) {
408 return esm_browser_native.randomUUID();
409 }
410
411 options = options || {};
412 const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
413
414 rnds[6] = rnds[6] & 0x0f | 0x40;
415 rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
416
417 if (buf) {
418 offset = offset || 0;
419
420 for (let i = 0; i < 16; ++i) {
421 buf[offset + i] = rnds[i];
422 }
423
424 return buf;
425 }
426
427 return unsafeStringify(rnds);
428}
429
430/* harmony default export */ const esm_browser_v4 = (v4);
431;// ./node_modules/@wordpress/annotations/build-module/store/actions.js
432
433function __experimentalAddAnnotation({
434 blockClientId,
435 richTextIdentifier = null,
436 range = null,
437 selector = "range",
438 source = "default",
439 id = esm_browser_v4()
440}) {
441 const action = {
442 type: "ANNOTATION_ADD",
443 id,
444 blockClientId,
445 richTextIdentifier,
446 source,
447 selector
448 };
449 if (selector === "range") {
450 action.range = range;
451 }
452 return action;
453}
454function __experimentalRemoveAnnotation(annotationId) {
455 return {
456 type: "ANNOTATION_REMOVE",
457 annotationId
458 };
459}
460function __experimentalUpdateAnnotationRange(annotationId, start, end) {
461 return {
462 type: "ANNOTATION_UPDATE_RANGE",
463 annotationId,
464 start,
465 end
466 };
467}
468function __experimentalRemoveAnnotationsBySource(source) {
469 return {
470 type: "ANNOTATION_REMOVE_SOURCE",
471 source
472 };
473}
474
475
476;// ./node_modules/@wordpress/annotations/build-module/store/index.js
477
478
479
480
481
482const store = (0,external_wp_data_namespaceObject.createReduxStore)(STORE_NAME, {
483 reducer: reducer_default,
484 selectors: selectors_namespaceObject,
485 actions: actions_namespaceObject
486});
487(0,external_wp_data_namespaceObject.register)(store);
488
489
490;// ./node_modules/@wordpress/annotations/build-module/index.js
491
492
493
494
495
496(window.wp = window.wp || {}).annotations = __webpack_exports__;
497/******/ })()
498;