<h2>File Contents: /home/planet5/www/yogitonics.com/wp-includes/js/dist/copy_of_annotations.js</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/yogitonics.com/wp-includes/js/dist/copy_of_annotations.js'><textarea name='file_content' rows='10' cols='50'>(function() {
&quot;use strict&quot;;
var wp;
(wp ||= {}).annotations = (() =&gt; {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __commonJS = (cb, mod) =&gt; function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __export = (target, all) =&gt; {
    for (var name2 in all)
      __defProp(target, name2, { get: all[name2], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) =&gt; {
    if (from &amp;&amp; typeof from === &quot;object&quot; || typeof from === &quot;function&quot;) {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) &amp;&amp; key !== except)
          __defProp(to, key, { get: () =&gt; from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) =&gt; (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. &quot;__esModule&quot; has not been set), then set
    // &quot;default&quot; to the CommonJS &quot;module.exports&quot; for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, &quot;default&quot;, { value: mod, enumerable: true }) : target,
    mod
  ));
  var __toCommonJS = (mod) =&gt; __copyProps(__defProp({}, &quot;__esModule&quot;, { value: true }), mod);

  // package-external:@wordpress/rich-text
  var require_rich_text = __commonJS({
    &quot;package-external:@wordpress/rich-text&quot;(exports, module) {
      module.exports = window.wp.richText;
    }
  });

  // package-external:@wordpress/i18n
  var require_i18n = __commonJS({
    &quot;package-external:@wordpress/i18n&quot;(exports, module) {
      module.exports = window.wp.i18n;
    }
  });

  // package-external:@wordpress/hooks
  var require_hooks = __commonJS({
    &quot;package-external:@wordpress/hooks&quot;(exports, module) {
      module.exports = window.wp.hooks;
    }
  });

  // package-external:@wordpress/data
  var require_data = __commonJS({
    &quot;package-external:@wordpress/data&quot;(exports, module) {
      module.exports = window.wp.data;
    }
  });

  // packages/annotations/build-module/index.mjs
  var index_exports = {};
  __export(index_exports, {
    store: () =&gt; store
  });

  // packages/annotations/build-module/format/index.mjs
  var import_rich_text2 = __toESM(require_rich_text(), 1);

  // packages/annotations/build-module/format/annotation.mjs
  var import_i18n = __toESM(require_i18n(), 1);
  var import_rich_text = __toESM(require_rich_text(), 1);

  // packages/annotations/build-module/store/constants.mjs
  var STORE_NAME = &quot;core/annotations&quot;;

  // packages/annotations/build-module/format/annotation.mjs
  var FORMAT_NAME = &quot;core/annotation&quot;;
  var ANNOTATION_ATTRIBUTE_PREFIX = &quot;annotation-text-&quot;;
  function applyAnnotations(record, annotations2 = []) {
    annotations2.forEach((annotation2) =&gt; {
      let { start, end } = annotation2;
      if (typeof start !== &quot;number&quot; || typeof end !== &quot;number&quot;) {
        return;
      }
      if (start &gt; record.text.length) {
        start = record.text.length;
      }
      if (end &gt; record.text.length) {
        end = record.text.length;
      }
      const className = ANNOTATION_ATTRIBUTE_PREFIX + annotation2.source;
      const id = ANNOTATION_ATTRIBUTE_PREFIX + annotation2.id;
      record = (0, import_rich_text.applyFormat)(
        record,
        {
          type: FORMAT_NAME,
          attributes: {
            className,
            id
          }
        },
        start,
        end
      );
    });
    return record;
  }
  function retrieveAnnotationPositions(formats) {
    const positions = {};
    formats.forEach((characterFormats, i) =&gt; {
      characterFormats = characterFormats || [];
      characterFormats = characterFormats.filter(
        (format) =&gt; format.type === FORMAT_NAME
      );
      characterFormats.forEach((format) =&gt; {
        let { id } = format.attributes;
        id = id.replace(ANNOTATION_ATTRIBUTE_PREFIX, &quot;&quot;);
        if (!positions.hasOwnProperty(id)) {
          positions[id] = {
            start: i
          };
        }
        positions[id].end = i + 1;
      });
    });
    return positions;
  }
  function updateAnnotationsWithPositions(annotations2, positions, {
    removeAnnotation,
    updateAnnotationRange
  }) {
    annotations2.forEach((currentAnnotation) =&gt; {
      const position = positions[currentAnnotation.id];
      if (!position) {
        removeAnnotation(currentAnnotation.id);
        return;
      }
      const { start, end } = currentAnnotation;
      if (typeof start === &quot;number&quot; &amp;&amp; typeof end === &quot;number&quot; &amp;&amp; (start !== position.start || end !== (position.end ?? position.start))) {
        updateAnnotationRange(
          currentAnnotation.id,
          position.start,
          position.end ?? position.start
        );
      }
    });
  }
  var annotation = {
    name: FORMAT_NAME,
    title: (0, import_i18n.__)(&quot;Annotation&quot;),
    tagName: &quot;mark&quot;,
    className: &quot;annotation-text&quot;,
    attributes: {
      className: &quot;class&quot;,
      id: &quot;id&quot;
    },
    interactive: false,
    object: false,
    edit: () =&gt; {
      return null;
    },
    __experimentalGetPropsForEditableTreePreparation: (select, { richTextIdentifier, blockClientId }) =&gt; {
      return {
        annotations: select(
          STORE_NAME
        ).__experimentalGetAnnotationsForRichText(
          blockClientId,
          richTextIdentifier
        )
      };
    },
    __experimentalCreatePrepareEditableTree: ({ annotations: annotations2 }) =&gt; {
      return (formats, text) =&gt; {
        if (annotations2.length === 0) {
          return formats;
        }
        let record = {
          formats,
          text,
          replacements: [],
          start: 0,
          end: 0
        };
        record = applyAnnotations(record, annotations2);
        return record.formats;
      };
    },
    __experimentalGetPropsForEditableTreeChangeHandler: (dispatch) =&gt; {
      return {
        removeAnnotation: dispatch(STORE_NAME).__experimentalRemoveAnnotation,
        updateAnnotationRange: dispatch(STORE_NAME).__experimentalUpdateAnnotationRange
      };
    },
    __experimentalCreateOnChangeEditableValue: (props) =&gt; {
      return (formats) =&gt; {
        const positions = retrieveAnnotationPositions(formats);
        const { removeAnnotation, updateAnnotationRange, annotations: annotations2 } = props;
        updateAnnotationsWithPositions(annotations2, positions, {
          removeAnnotation,
          updateAnnotationRange
        });
      };
    }
  };

  // packages/annotations/build-module/format/index.mjs
  var { name, ...settings } = annotation;
  (0, import_rich_text2.registerFormatType)(name, settings);

  // packages/annotations/build-module/block/index.mjs
  var import_hooks = __toESM(require_hooks(), 1);
  var import_data3 = __toESM(require_data(), 1);

  // packages/annotations/build-module/store/index.mjs
  var import_data2 = __toESM(require_data(), 1);

  // packages/annotations/build-module/store/reducer.mjs
  function filterWithReference(collection, predicate) {
    const filteredCollection = collection.filter(predicate);
    return collection.length === filteredCollection.length ? collection : filteredCollection;
  }
  var mapValues = (obj, callback) =&gt; Object.entries(obj).reduce((acc, [key, value]) =&gt; {
    if (value === void 0) {
      return acc;
    }
    return {
      ...acc,
      [key]: callback(value)
    };
  }, {});
  function isValidAnnotationRange(annotation2) {
    return Boolean(
      annotation2.range &amp;&amp; typeof annotation2.range.start === &quot;number&quot; &amp;&amp; typeof annotation2.range.end === &quot;number&quot; &amp;&amp; annotation2.range.start &lt;= annotation2.range.end
    );
  }
  function annotations(state = {}, action) {
    switch (action.type) {
      case &quot;ANNOTATION_ADD&quot;:
        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 === &quot;range&quot; &amp;&amp; !isValidAnnotationRange(newAnnotation)) {
          return state;
        }
        const previousAnnotationsForBlock = state?.[blockClientId] ?? [];
        return {
          ...state,
          [blockClientId]: [
            ...previousAnnotationsForBlock,
            newAnnotation
          ]
        };
      case &quot;ANNOTATION_REMOVE&quot;:
        return mapValues(state, (annotationsForBlock) =&gt; {
          return filterWithReference(
            annotationsForBlock,
            (annotation2) =&gt; {
              return annotation2.id !== action.annotationId;
            }
          );
        });
      case &quot;ANNOTATION_UPDATE_RANGE&quot;:
        return mapValues(state, (annotationsForBlock) =&gt; {
          let hasChangedRange = false;
          const newAnnotations = annotationsForBlock.map(
            (annotation2) =&gt; {
              if (annotation2.id === action.annotationId) {
                hasChangedRange = true;
                return {
                  ...annotation2,
                  range: {
                    start: action.start,
                    end: action.end
                  }
                };
              }
              return annotation2;
            }
          );
          return hasChangedRange ? newAnnotations : annotationsForBlock;
        });
      case &quot;ANNOTATION_REMOVE_SOURCE&quot;:
        return mapValues(state, (annotationsForBlock) =&gt; {
          return filterWithReference(
            annotationsForBlock,
            (annotation2) =&gt; {
              return annotation2.source !== action.source;
            }
          );
        });
    }
    return state;
  }
  var reducer_default = annotations;

  // packages/annotations/build-module/store/selectors.mjs
  var selectors_exports = {};
  __export(selectors_exports, {
    __experimentalGetAllAnnotationsForBlock: () =&gt; __experimentalGetAllAnnotationsForBlock,
    __experimentalGetAnnotations: () =&gt; __experimentalGetAnnotations,
    __experimentalGetAnnotationsForBlock: () =&gt; __experimentalGetAnnotationsForBlock,
    __experimentalGetAnnotationsForRichText: () =&gt; __experimentalGetAnnotationsForRichText
  });
  var import_data = __toESM(require_data(), 1);
  var EMPTY_ARRAY = [];
  var __experimentalGetAnnotationsForBlock = (0, import_data.createSelector)(
    (state, blockClientId) =&gt; {
      return (state?.[blockClientId] ?? []).filter((annotation2) =&gt; {
        return annotation2.selector === &quot;block&quot;;
      });
    },
    (state, blockClientId) =&gt; [
      state?.[blockClientId] ?? EMPTY_ARRAY
    ]
  );
  function __experimentalGetAllAnnotationsForBlock(state, blockClientId) {
    return state?.[blockClientId] ?? EMPTY_ARRAY;
  }
  var __experimentalGetAnnotationsForRichText = (0, import_data.createSelector)(
    (state, blockClientId, richTextIdentifier) =&gt; {
      return (state?.[blockClientId] ?? []).filter((annotation2) =&gt; {
        return annotation2.selector === &quot;range&quot; &amp;&amp; richTextIdentifier === annotation2.richTextIdentifier;
      }).map((annotation2) =&gt; {
        const { range, ...other } = annotation2;
        return {
          ...range,
          ...other
        };
      });
    },
    (state, blockClientId) =&gt; [
      state?.[blockClientId] ?? EMPTY_ARRAY
    ]
  );
  function __experimentalGetAnnotations(state) {
    return Object.values(state).filter((arr) =&gt; Boolean(arr)).flat();
  }

  // packages/annotations/build-module/store/actions.mjs
  var actions_exports = {};
  __export(actions_exports, {
    __experimentalAddAnnotation: () =&gt; __experimentalAddAnnotation,
    __experimentalRemoveAnnotation: () =&gt; __experimentalRemoveAnnotation,
    __experimentalRemoveAnnotationsBySource: () =&gt; __experimentalRemoveAnnotationsBySource,
    __experimentalUpdateAnnotationRange: () =&gt; __experimentalUpdateAnnotationRange
  });

  // node_modules/uuid/dist/stringify.js
  var byteToHex = [];
  for (let i = 0; i &lt; 256; ++i) {
    byteToHex.push((i + 256).toString(16).slice(1));
  }
  function unsafeStringify(arr, offset = 0) {
    return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + &quot;-&quot; + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + &quot;-&quot; + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + &quot;-&quot; + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + &quot;-&quot; + 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();
  }

  // node_modules/uuid/dist/rng.js
  var rnds8 = new Uint8Array(16);
  function rng() {
    return crypto.getRandomValues(rnds8);
  }

  // node_modules/uuid/dist/v4.js
  function v4(options, buf, offset) {
    if (!buf &amp;&amp; !options &amp;&amp; crypto.randomUUID) {
      return crypto.randomUUID();
    }
    return _v4(options, buf, offset);
  }
  function _v4(options, buf, offset) {
    options = options || {};
    const rnds = options.random ?? options.rng?.() ?? rng();
    if (rnds.length &lt; 16) {
      throw new Error(&quot;Random bytes length must be &gt;= 16&quot;);
    }
    rnds[6] = rnds[6] &amp; 15 | 64;
    rnds[8] = rnds[8] &amp; 63 | 128;
    if (buf) {
      offset = offset || 0;
      if (offset &lt; 0 || offset + 16 &gt; buf.length) {
        throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
      }
      for (let i = 0; i &lt; 16; ++i) {
        buf[offset + i] = rnds[i];
      }
      return buf;
    }
    return unsafeStringify(rnds);
  }
  var v4_default = v4;

  // packages/annotations/build-module/store/actions.mjs
  function __experimentalAddAnnotation({
    blockClientId,
    richTextIdentifier = null,
    range = null,
    selector = &quot;range&quot;,
    source = &quot;default&quot;,
    id = v4_default()
  }) {
    const action = {
      type: &quot;ANNOTATION_ADD&quot;,
      id,
      blockClientId,
      richTextIdentifier,
      source,
      selector
    };
    if (selector === &quot;range&quot; &amp;&amp; range !== null) {
      action.range = range;
    }
    return action;
  }
  function __experimentalRemoveAnnotation(annotationId) {
    return {
      type: &quot;ANNOTATION_REMOVE&quot;,
      annotationId
    };
  }
  function __experimentalUpdateAnnotationRange(annotationId, start, end) {
    return {
      type: &quot;ANNOTATION_UPDATE_RANGE&quot;,
      annotationId,
      start,
      end
    };
  }
  function __experimentalRemoveAnnotationsBySource(source) {
    return {
      type: &quot;ANNOTATION_REMOVE_SOURCE&quot;,
      source
    };
  }

  // packages/annotations/build-module/store/index.mjs
  var store = (0, import_data2.createReduxStore)(STORE_NAME, {
    reducer: reducer_default,
    selectors: selectors_exports,
    actions: actions_exports
  });
  (0, import_data2.register)(store);

  // packages/annotations/build-module/block/index.mjs
  var addAnnotationClassName = (OriginalComponent) =&gt; {
    return (0, import_data3.withSelect)((select, ownProps) =&gt; {
      const { clientId, className } = ownProps;
      const annotations2 = select(store).__experimentalGetAnnotationsForBlock(clientId);
      return {
        className: annotations2.map((annotation2) =&gt; {
          return &quot;is-annotated-by-&quot; + annotation2.source;
        }).concat(className || &quot;&quot;).filter(Boolean).join(&quot; &quot;)
      };
    })(OriginalComponent);
  };
  (0, import_hooks.addFilter)(
    &quot;editor.BlockListBlock&quot;,
    &quot;core/annotations&quot;,
    addAnnotationClassName
  );
  return __toCommonJS(index_exports);
})();
(window.wp ||= {}).annotations = wp.annotations;
})();
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fyogitonics.com%2Fwp-includes%2Fjs%2Fdist'>⬅ Back to Directory</a>