[Summary view] [Print] [Text view]

   1  (function() {
   2  "use strict";
   3  var wp;
   4  (wp ||= {}).coreData = (() => {
   5    var __create = Object.create;
   6    var __defProp = Object.defineProperty;
   7    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   8    var __getOwnPropNames = Object.getOwnPropertyNames;
   9    var __getProtoOf = Object.getPrototypeOf;
  10    var __hasOwnProp = Object.prototype.hasOwnProperty;
  11    var __commonJS = (cb, mod) => function __require() {
  12      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  13    };
  14    var __export = (target, all) => {
  15      for (var name in all)
  16        __defProp(target, name, { get: all[name], enumerable: true });
  17    };
  18    var __copyProps = (to, from, except, desc) => {
  19      if (from && typeof from === "object" || typeof from === "function") {
  20        for (let key of __getOwnPropNames(from))
  21          if (!__hasOwnProp.call(to, key) && key !== except)
  22            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  23      }
  24      return to;
  25    };
  26    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  27      // If the importer is in node compatibility mode or this is not an ESM
  28      // file that has been converted to a CommonJS file using a Babel-
  29      // compatible transform (i.e. "__esModule" has not been set), then set
  30      // "default" to the CommonJS "module.exports" for node compatibility.
  31      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  32      mod
  33    ));
  34    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  35  
  36    // package-external:@wordpress/data
  37    var require_data = __commonJS({
  38      "package-external:@wordpress/data"(exports, module) {
  39        module.exports = window.wp.data;
  40      }
  41    });
  42  
  43    // node_modules/fast-deep-equal/es6/index.js
  44    var require_es6 = __commonJS({
  45      "node_modules/fast-deep-equal/es6/index.js"(exports, module) {
  46        "use strict";
  47        module.exports = function equal(a, b) {
  48          if (a === b) return true;
  49          if (a && b && typeof a == "object" && typeof b == "object") {
  50            if (a.constructor !== b.constructor) return false;
  51            var length, i, keys;
  52            if (Array.isArray(a)) {
  53              length = a.length;
  54              if (length != b.length) return false;
  55              for (i = length; i-- !== 0; )
  56                if (!equal(a[i], b[i])) return false;
  57              return true;
  58            }
  59            if (a instanceof Map && b instanceof Map) {
  60              if (a.size !== b.size) return false;
  61              for (i of a.entries())
  62                if (!b.has(i[0])) return false;
  63              for (i of a.entries())
  64                if (!equal(i[1], b.get(i[0]))) return false;
  65              return true;
  66            }
  67            if (a instanceof Set && b instanceof Set) {
  68              if (a.size !== b.size) return false;
  69              for (i of a.entries())
  70                if (!b.has(i[0])) return false;
  71              return true;
  72            }
  73            if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
  74              length = a.length;
  75              if (length != b.length) return false;
  76              for (i = length; i-- !== 0; )
  77                if (a[i] !== b[i]) return false;
  78              return true;
  79            }
  80            if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
  81            if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
  82            if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
  83            keys = Object.keys(a);
  84            length = keys.length;
  85            if (length !== Object.keys(b).length) return false;
  86            for (i = length; i-- !== 0; )
  87              if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
  88            for (i = length; i-- !== 0; ) {
  89              var key = keys[i];
  90              if (!equal(a[key], b[key])) return false;
  91            }
  92            return true;
  93          }
  94          return a !== a && b !== b;
  95        };
  96      }
  97    });
  98  
  99    // package-external:@wordpress/compose
 100    var require_compose = __commonJS({
 101      "package-external:@wordpress/compose"(exports, module) {
 102        module.exports = window.wp.compose;
 103      }
 104    });
 105  
 106    // package-external:@wordpress/undo-manager
 107    var require_undo_manager = __commonJS({
 108      "package-external:@wordpress/undo-manager"(exports, module) {
 109        module.exports = window.wp.undoManager;
 110      }
 111    });
 112  
 113    // package-external:@wordpress/api-fetch
 114    var require_api_fetch = __commonJS({
 115      "package-external:@wordpress/api-fetch"(exports, module) {
 116        module.exports = window.wp.apiFetch;
 117      }
 118    });
 119  
 120    // package-external:@wordpress/sync
 121    var require_sync = __commonJS({
 122      "package-external:@wordpress/sync"(exports, module) {
 123        module.exports = window.wp.sync;
 124      }
 125    });
 126  
 127    // package-external:@wordpress/private-apis
 128    var require_private_apis = __commonJS({
 129      "package-external:@wordpress/private-apis"(exports, module) {
 130        module.exports = window.wp.privateApis;
 131      }
 132    });
 133  
 134    // node_modules/equivalent-key-map/equivalent-key-map.js
 135    var require_equivalent_key_map = __commonJS({
 136      "node_modules/equivalent-key-map/equivalent-key-map.js"(exports, module) {
 137        "use strict";
 138        function _typeof(obj) {
 139          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
 140            _typeof = function(obj2) {
 141              return typeof obj2;
 142            };
 143          } else {
 144            _typeof = function(obj2) {
 145              return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
 146            };
 147          }
 148          return _typeof(obj);
 149        }
 150        function _classCallCheck(instance, Constructor) {
 151          if (!(instance instanceof Constructor)) {
 152            throw new TypeError("Cannot call a class as a function");
 153          }
 154        }
 155        function _defineProperties(target, props) {
 156          for (var i = 0; i < props.length; i++) {
 157            var descriptor = props[i];
 158            descriptor.enumerable = descriptor.enumerable || false;
 159            descriptor.configurable = true;
 160            if ("value" in descriptor) descriptor.writable = true;
 161            Object.defineProperty(target, descriptor.key, descriptor);
 162          }
 163        }
 164        function _createClass(Constructor, protoProps, staticProps) {
 165          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
 166          if (staticProps) _defineProperties(Constructor, staticProps);
 167          return Constructor;
 168        }
 169        function getValuePair(instance, key) {
 170          var _map = instance._map, _arrayTreeMap = instance._arrayTreeMap, _objectTreeMap = instance._objectTreeMap;
 171          if (_map.has(key)) {
 172            return _map.get(key);
 173          }
 174          var properties = Object.keys(key).sort();
 175          var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap;
 176          for (var i = 0; i < properties.length; i++) {
 177            var property = properties[i];
 178            map = map.get(property);
 179            if (map === void 0) {
 180              return;
 181            }
 182            var propertyValue = key[property];
 183            map = map.get(propertyValue);
 184            if (map === void 0) {
 185              return;
 186            }
 187          }
 188          var valuePair = map.get("_ekm_value");
 189          if (!valuePair) {
 190            return;
 191          }
 192          _map.delete(valuePair[0]);
 193          valuePair[0] = key;
 194          map.set("_ekm_value", valuePair);
 195          _map.set(key, valuePair);
 196          return valuePair;
 197        }
 198        var EquivalentKeyMap2 = /* @__PURE__ */ (function() {
 199          function EquivalentKeyMap3(iterable) {
 200            _classCallCheck(this, EquivalentKeyMap3);
 201            this.clear();
 202            if (iterable instanceof EquivalentKeyMap3) {
 203              var iterablePairs = [];
 204              iterable.forEach(function(value, key) {
 205                iterablePairs.push([key, value]);
 206              });
 207              iterable = iterablePairs;
 208            }
 209            if (iterable != null) {
 210              for (var i = 0; i < iterable.length; i++) {
 211                this.set(iterable[i][0], iterable[i][1]);
 212              }
 213            }
 214          }
 215          _createClass(EquivalentKeyMap3, [{
 216            key: "set",
 217            /**
 218             * Add or update an element with a specified key and value.
 219             *
 220             * @param {*} key   The key of the element to add.
 221             * @param {*} value The value of the element to add.
 222             *
 223             * @return {EquivalentKeyMap} Map instance.
 224             */
 225            value: function set(key, value) {
 226              if (key === null || _typeof(key) !== "object") {
 227                this._map.set(key, value);
 228                return this;
 229              }
 230              var properties = Object.keys(key).sort();
 231              var valuePair = [key, value];
 232              var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap;
 233              for (var i = 0; i < properties.length; i++) {
 234                var property = properties[i];
 235                if (!map.has(property)) {
 236                  map.set(property, new EquivalentKeyMap3());
 237                }
 238                map = map.get(property);
 239                var propertyValue = key[property];
 240                if (!map.has(propertyValue)) {
 241                  map.set(propertyValue, new EquivalentKeyMap3());
 242                }
 243                map = map.get(propertyValue);
 244              }
 245              var previousValuePair = map.get("_ekm_value");
 246              if (previousValuePair) {
 247                this._map.delete(previousValuePair[0]);
 248              }
 249              map.set("_ekm_value", valuePair);
 250              this._map.set(key, valuePair);
 251              return this;
 252            }
 253            /**
 254             * Returns a specified element.
 255             *
 256             * @param {*} key The key of the element to return.
 257             *
 258             * @return {?*} The element associated with the specified key or undefined
 259             *              if the key can't be found.
 260             */
 261          }, {
 262            key: "get",
 263            value: function get(key) {
 264              if (key === null || _typeof(key) !== "object") {
 265                return this._map.get(key);
 266              }
 267              var valuePair = getValuePair(this, key);
 268              if (valuePair) {
 269                return valuePair[1];
 270              }
 271            }
 272            /**
 273             * Returns a boolean indicating whether an element with the specified key
 274             * exists or not.
 275             *
 276             * @param {*} key The key of the element to test for presence.
 277             *
 278             * @return {boolean} Whether an element with the specified key exists.
 279             */
 280          }, {
 281            key: "has",
 282            value: function has(key) {
 283              if (key === null || _typeof(key) !== "object") {
 284                return this._map.has(key);
 285              }
 286              return getValuePair(this, key) !== void 0;
 287            }
 288            /**
 289             * Removes the specified element.
 290             *
 291             * @param {*} key The key of the element to remove.
 292             *
 293             * @return {boolean} Returns true if an element existed and has been
 294             *                   removed, or false if the element does not exist.
 295             */
 296          }, {
 297            key: "delete",
 298            value: function _delete(key) {
 299              if (!this.has(key)) {
 300                return false;
 301              }
 302              this.set(key, void 0);
 303              return true;
 304            }
 305            /**
 306             * Executes a provided function once per each key/value pair, in insertion
 307             * order.
 308             *
 309             * @param {Function} callback Function to execute for each element.
 310             * @param {*}        thisArg  Value to use as `this` when executing
 311             *                            `callback`.
 312             */
 313          }, {
 314            key: "forEach",
 315            value: function forEach(callback) {
 316              var _this = this;
 317              var thisArg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this;
 318              this._map.forEach(function(value, key) {
 319                if (key !== null && _typeof(key) === "object") {
 320                  value = value[1];
 321                }
 322                callback.call(thisArg, value, key, _this);
 323              });
 324            }
 325            /**
 326             * Removes all elements.
 327             */
 328          }, {
 329            key: "clear",
 330            value: function clear() {
 331              this._map = /* @__PURE__ */ new Map();
 332              this._arrayTreeMap = /* @__PURE__ */ new Map();
 333              this._objectTreeMap = /* @__PURE__ */ new Map();
 334            }
 335          }, {
 336            key: "size",
 337            get: function get() {
 338              return this._map.size;
 339            }
 340          }]);
 341          return EquivalentKeyMap3;
 342        })();
 343        module.exports = EquivalentKeyMap2;
 344      }
 345    });
 346  
 347    // package-external:@wordpress/url
 348    var require_url = __commonJS({
 349      "package-external:@wordpress/url"(exports, module) {
 350        module.exports = window.wp.url;
 351      }
 352    });
 353  
 354    // package-external:@wordpress/blocks
 355    var require_blocks = __commonJS({
 356      "package-external:@wordpress/blocks"(exports, module) {
 357        module.exports = window.wp.blocks;
 358      }
 359    });
 360  
 361    // package-external:@wordpress/i18n
 362    var require_i18n = __commonJS({
 363      "package-external:@wordpress/i18n"(exports, module) {
 364        module.exports = window.wp.i18n;
 365      }
 366    });
 367  
 368    // package-external:@wordpress/block-editor
 369    var require_block_editor = __commonJS({
 370      "package-external:@wordpress/block-editor"(exports, module) {
 371        module.exports = window.wp.blockEditor;
 372      }
 373    });
 374  
 375    // package-external:@wordpress/rich-text
 376    var require_rich_text = __commonJS({
 377      "package-external:@wordpress/rich-text"(exports, module) {
 378        module.exports = window.wp.richText;
 379      }
 380    });
 381  
 382    // package-external:@wordpress/deprecated
 383    var require_deprecated = __commonJS({
 384      "package-external:@wordpress/deprecated"(exports, module) {
 385        module.exports = window.wp.deprecated;
 386      }
 387    });
 388  
 389    // package-external:@wordpress/notices
 390    var require_notices = __commonJS({
 391      "package-external:@wordpress/notices"(exports, module) {
 392        module.exports = window.wp.notices;
 393      }
 394    });
 395  
 396    // package-external:@wordpress/html-entities
 397    var require_html_entities = __commonJS({
 398      "package-external:@wordpress/html-entities"(exports, module) {
 399        module.exports = window.wp.htmlEntities;
 400      }
 401    });
 402  
 403    // package-external:@wordpress/element
 404    var require_element = __commonJS({
 405      "package-external:@wordpress/element"(exports, module) {
 406        module.exports = window.wp.element;
 407      }
 408    });
 409  
 410    // vendor-external:react/jsx-runtime
 411    var require_jsx_runtime = __commonJS({
 412      "vendor-external:react/jsx-runtime"(exports, module) {
 413        module.exports = window.ReactJSXRuntime;
 414      }
 415    });
 416  
 417    // package-external:@wordpress/warning
 418    var require_warning = __commonJS({
 419      "package-external:@wordpress/warning"(exports, module) {
 420        module.exports = window.wp.warning;
 421      }
 422    });
 423  
 424    // package-external:@wordpress/primitives
 425    var require_primitives = __commonJS({
 426      "package-external:@wordpress/primitives"(exports, module) {
 427        module.exports = window.wp.primitives;
 428      }
 429    });
 430  
 431    // package-external:@wordpress/components
 432    var require_components = __commonJS({
 433      "package-external:@wordpress/components"(exports, module) {
 434        module.exports = window.wp.components;
 435      }
 436    });
 437  
 438    // packages/core-data/build-module/index.mjs
 439    var index_exports = {};
 440    __export(index_exports, {
 441      EntityProvider: () => EntityProvider,
 442      __experimentalFetchLinkSuggestions: () => fetchLinkSuggestions,
 443      __experimentalFetchUrlData: () => experimental_fetch_url_data_default,
 444      __experimentalUseEntityRecord: () => useDeprecatedEntityRecord,
 445      __experimentalUseEntityRecords: () => useDeprecatedEntityRecords,
 446      __experimentalUseResourcePermissions: () => useDeprecatedResourcePermissions,
 447      fetchBlockPatterns: () => fetchBlockPatterns,
 448      privateApis: () => privateApis,
 449      store: () => store,
 450      useEntityBlockEditor: () => useEntityBlockEditor,
 451      useEntityId: () => useEntityId,
 452      useEntityProp: () => useEntityProp,
 453      useEntityRecord: () => useEntityRecord,
 454      useEntityRecords: () => useEntityRecords,
 455      useResourcePermissions: () => use_resource_permissions_default
 456    });
 457    var import_data20 = __toESM(require_data(), 1);
 458  
 459    // packages/core-data/build-module/reducer.mjs
 460    var import_es65 = __toESM(require_es6(), 1);
 461    var import_compose2 = __toESM(require_compose(), 1);
 462    var import_data7 = __toESM(require_data(), 1);
 463    var import_undo_manager = __toESM(require_undo_manager(), 1);
 464  
 465    // packages/core-data/build-module/utils/clear-unchanged-edits.mjs
 466    var import_es6 = __toESM(require_es6(), 1);
 467    function clearUnchangedEdits(edits, persistedRecord) {
 468      if (!persistedRecord) {
 469        return edits;
 470      }
 471      return Object.fromEntries(
 472        Object.entries(edits).map(([key, value]) => {
 473          const persisted = persistedRecord[key]?.raw ?? persistedRecord[key];
 474          return [
 475            key,
 476            (0, import_es6.default)(value, persisted) ? void 0 : value
 477          ];
 478        })
 479      );
 480    }
 481  
 482    // packages/core-data/build-module/utils/conservative-map-item.mjs
 483    var import_es62 = __toESM(require_es6(), 1);
 484    function conservativeMapItem(item, nextItem) {
 485      if (!item) {
 486        return nextItem;
 487      }
 488      let hasChanges = false;
 489      const result = {};
 490      for (const key in nextItem) {
 491        if ((0, import_es62.default)(item[key], nextItem[key])) {
 492          result[key] = item[key];
 493        } else {
 494          hasChanges = true;
 495          result[key] = nextItem[key];
 496        }
 497      }
 498      if (!hasChanges) {
 499        return item;
 500      }
 501      for (const key in item) {
 502        if (!result.hasOwnProperty(key)) {
 503          result[key] = item[key];
 504        }
 505      }
 506      return result;
 507    }
 508  
 509    // packages/core-data/build-module/utils/get-normalized-comma-separable.mjs
 510    function getNormalizedCommaSeparable(value) {
 511      if (typeof value === "string") {
 512        return value.split(",");
 513      } else if (Array.isArray(value)) {
 514        return value;
 515      }
 516      return null;
 517    }
 518    var get_normalized_comma_separable_default = getNormalizedCommaSeparable;
 519  
 520    // packages/core-data/build-module/utils/set-nested-value.mjs
 521    function setNestedValue(object, path, value) {
 522      if (!object || typeof object !== "object") {
 523        return object;
 524      }
 525      const normalizedPath = Array.isArray(path) ? path : path.split(".");
 526      normalizedPath.reduce((acc, key, idx) => {
 527        if (acc[key] === void 0) {
 528          if (Number.isInteger(normalizedPath[idx + 1])) {
 529            acc[key] = [];
 530          } else {
 531            acc[key] = {};
 532          }
 533        }
 534        if (idx === normalizedPath.length - 1) {
 535          acc[key] = value;
 536        }
 537        return acc[key];
 538      }, object);
 539      return object;
 540    }
 541  
 542    // packages/core-data/build-module/utils/get-filtered-item.mjs
 543    var filteredItemCache = /* @__PURE__ */ new WeakMap();
 544    function getFilteredItem(item, _fields) {
 545      const fields = get_normalized_comma_separable_default(_fields) ?? [];
 546      const fieldsKey = fields.join(",");
 547      let itemCache = filteredItemCache.get(item);
 548      if (itemCache) {
 549        const filtered = itemCache.get(fieldsKey);
 550        if (filtered !== void 0) {
 551          return filtered;
 552        }
 553      } else if (item !== null && typeof item === "object") {
 554        itemCache = /* @__PURE__ */ new Map();
 555        filteredItemCache.set(item, itemCache);
 556      }
 557      const filteredItem = {};
 558      for (let f = 0; f < fields.length; f++) {
 559        const field = fields[f].split(".");
 560        let value = item;
 561        field.forEach((fieldName) => {
 562          value = value?.[fieldName];
 563        });
 564        setNestedValue(filteredItem, field, value);
 565      }
 566      itemCache?.set(fieldsKey, filteredItem);
 567      return filteredItem;
 568    }
 569  
 570    // packages/core-data/build-module/utils/if-matching-action.mjs
 571    var ifMatchingAction = (isMatch) => (reducer) => (state, action) => {
 572      if (state === void 0 || isMatch(action)) {
 573        return reducer(state, action);
 574      }
 575      return state;
 576    };
 577    var if_matching_action_default = ifMatchingAction;
 578  
 579    // packages/core-data/build-module/utils/forward-resolver.mjs
 580    var forwardResolver = (resolverName) => (...args) => async ({ resolveSelect: resolveSelect2 }) => {
 581      await resolveSelect2[resolverName](...args);
 582    };
 583    var forward_resolver_default = forwardResolver;
 584  
 585    // packages/core-data/build-module/utils/replace-action.mjs
 586    var replaceAction = (replacer) => (reducer) => (state, action) => {
 587      return reducer(state, replacer(action));
 588    };
 589    var replace_action_default = replaceAction;
 590  
 591    // packages/core-data/build-module/utils/with-weak-map-cache.mjs
 592    function withWeakMapCache(fn) {
 593      const cache3 = /* @__PURE__ */ new WeakMap();
 594      return (key) => {
 595        let value;
 596        if (cache3.has(key)) {
 597          value = cache3.get(key);
 598        } else {
 599          value = fn(key);
 600          if (key !== null && typeof key === "object") {
 601            cache3.set(key, value);
 602          }
 603        }
 604        return value;
 605      };
 606    }
 607    var with_weak_map_cache_default = withWeakMapCache;
 608  
 609    // packages/core-data/build-module/utils/get-nested-value.mjs
 610    function getNestedValue(object, path, defaultValue) {
 611      if (!object || typeof object !== "object" || typeof path !== "string" && !Array.isArray(path)) {
 612        return object;
 613      }
 614      const normalizedPath = Array.isArray(path) ? path : path.split(".");
 615      let value = object;
 616      normalizedPath.forEach((fieldName) => {
 617        value = value?.[fieldName];
 618      });
 619      return value !== void 0 ? value : defaultValue;
 620    }
 621  
 622    // packages/core-data/build-module/utils/is-numeric-id.mjs
 623    function isNumericID(id) {
 624      return /^\s*\d+\s*$/.test(id);
 625    }
 626  
 627    // packages/core-data/build-module/utils/user-permissions.mjs
 628    var ALLOWED_RESOURCE_ACTIONS = [
 629      "create",
 630      "read",
 631      "update",
 632      "delete"
 633    ];
 634    function getUserPermissionsFromAllowHeader(allowedMethods) {
 635      const permissions = {};
 636      const methods = {
 637        create: "POST",
 638        read: "GET",
 639        update: "PUT",
 640        delete: "DELETE"
 641      };
 642      for (const [actionName, methodName] of Object.entries(methods)) {
 643        permissions[actionName] = allowedMethods ? allowedMethods.includes(methodName) : false;
 644      }
 645      return permissions;
 646    }
 647    function getUserPermissionCacheKey(action, resource, id) {
 648      const key = (typeof resource === "object" ? [action, resource.kind, resource.name, resource.id] : [action, resource, id]).filter(Boolean).join("/");
 649      return key;
 650    }
 651  
 652    // packages/core-data/build-module/utils/receive-intermediate-results.mjs
 653    var RECEIVE_INTERMEDIATE_RESULTS = /* @__PURE__ */ Symbol(
 654      "RECEIVE_INTERMEDIATE_RESULTS"
 655    );
 656  
 657    // packages/core-data/build-module/utils/normalize-query-for-resolution.mjs
 658    function normalizeQueryForResolution(query) {
 659      if (!query) {
 660        return void 0;
 661      }
 662      const entries = Object.entries(query).filter(
 663        ([k, v]) => (k === "context" || k === "_fields") && v !== void 0 && v !== null
 664      );
 665      return entries.length > 0 ? Object.fromEntries(entries) : void 0;
 666    }
 667  
 668    // packages/core-data/build-module/utils/save-crdt-doc.mjs
 669    var import_api_fetch = __toESM(require_api_fetch(), 1);
 670  
 671    // packages/core-data/build-module/sync.mjs
 672    var import_sync = __toESM(require_sync(), 1);
 673  
 674    // packages/core-data/build-module/lock-unlock.mjs
 675    var import_private_apis = __toESM(require_private_apis(), 1);
 676    var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
 677      "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
 678      "@wordpress/core-data"
 679    );
 680  
 681    // packages/core-data/build-module/sync.mjs
 682    var {
 683      ConnectionErrorCode,
 684      createSyncManager,
 685      Delta,
 686      CRDT_DOC_META_PERSISTENCE_KEY,
 687      CRDT_RECORD_MAP_KEY,
 688      LOCAL_EDITOR_ORIGIN,
 689      LOCAL_UNDO_IGNORED_ORIGIN,
 690      retrySyncConnection
 691    } = unlock(import_sync.privateApis);
 692    var CRDT_AUTOSAVE_SNAPSHOT_KEY = "crdt_snapshot";
 693    var syncManager;
 694    function getSyncManager() {
 695      if (syncManager) {
 696        return syncManager;
 697      }
 698      if (!globalThis.window?.__experimentalEnableRealTimeCollaboration) {
 699        return void 0;
 700      }
 701      syncManager = createSyncManager();
 702      return syncManager;
 703    }
 704    function hasSyncManager() {
 705      return Boolean(syncManager);
 706    }
 707    function getEntitySnapshot(kind, name, recordId) {
 708      if (!hasSyncManager()) {
 709        return void 0;
 710      }
 711      return getSyncManager()?.getEntitySnapshot(
 712        `$kind}/$name}`,
 713        `$recordId}`
 714      );
 715    }
 716    function entityContainsSnapshot(kind, name, recordId, encodedSnapshot) {
 717      if (!hasSyncManager()) {
 718        return false;
 719      }
 720      return getSyncManager()?.entityContainsSnapshot(
 721        `$kind}/$name}`,
 722        `$recordId}`,
 723        encodedSnapshot
 724      ) ?? false;
 725    }
 726  
 727    // packages/core-data/build-module/utils/save-crdt-doc.mjs
 728    var SYNC_SAVE_API_PATH = "/wp-sync/v1/save";
 729    var saveCRDTDocQueues = /* @__PURE__ */ new Map();
 730    async function serializeAndSaveCRDTDoc(objectType, objectId, room) {
 731      const serializedDoc = await getSyncManager()?.createPersistedCRDTDoc(
 732        objectType,
 733        objectId
 734      );
 735      if (!serializedDoc) {
 736        return;
 737      }
 738      await (0, import_api_fetch.default)({
 739        path: SYNC_SAVE_API_PATH,
 740        method: "POST",
 741        data: {
 742          room,
 743          doc: serializedDoc
 744        }
 745      });
 746    }
 747    async function saveCRDTDoc(objectType, objectId) {
 748      const room = `$objectType}:$objectId}`;
 749      const previousSave = saveCRDTDocQueues.get(room) || Promise.resolve();
 750      const currentSave = previousSave.catch(() => {
 751      }).then(() => serializeAndSaveCRDTDoc(objectType, objectId, room));
 752      saveCRDTDocQueues.set(room, currentSave);
 753      try {
 754        await currentSave;
 755      } finally {
 756        if (saveCRDTDocQueues.get(room) === currentSave) {
 757          saveCRDTDocQueues.delete(room);
 758        }
 759      }
 760    }
 761  
 762    // packages/core-data/build-module/utils/get-pagination-meta.mjs
 763    function getPaginationMeta(headers) {
 764      const totalItems = parseInt(headers.get("X-WP-Total") ?? "");
 765      const totalPages = parseInt(headers.get("X-WP-TotalPages") ?? "");
 766      return {
 767        totalItems: Number.isFinite(totalItems) ? totalItems : null,
 768        totalPages: Number.isFinite(totalPages) ? totalPages : null
 769      };
 770    }
 771  
 772    // packages/core-data/build-module/queried-data/actions.mjs
 773    function receiveItems(items2, edits, meta) {
 774      return {
 775        type: "RECEIVE_ITEMS",
 776        items: items2,
 777        persistedEdits: edits,
 778        meta
 779      };
 780    }
 781    function removeItems(kind, name, records, invalidateCache = false) {
 782      return {
 783        type: "REMOVE_ITEMS",
 784        itemIds: Array.isArray(records) ? records : [records],
 785        kind,
 786        name,
 787        invalidateCache
 788      };
 789    }
 790    function receiveQueriedItems(items2, query = {}, edits, meta) {
 791      return {
 792        ...receiveItems(items2, edits, meta),
 793        query
 794      };
 795    }
 796  
 797    // packages/core-data/build-module/queried-data/selectors.mjs
 798    var import_equivalent_key_map = __toESM(require_equivalent_key_map(), 1);
 799  
 800    // packages/core-data/build-module/queried-data/get-query-parts.mjs
 801    var import_url = __toESM(require_url(), 1);
 802    function getQueryParts(query) {
 803      const parts = {
 804        stableKey: "",
 805        page: 1,
 806        perPage: 10,
 807        offset: null,
 808        fields: null,
 809        include: null,
 810        context: "default"
 811      };
 812      const keys = Object.keys(query).sort();
 813      for (let i = 0; i < keys.length; i++) {
 814        const key = keys[i];
 815        let value = query[key];
 816        switch (key) {
 817          case "page":
 818            parts[key] = Number(value);
 819            break;
 820          case "per_page":
 821            parts.perPage = Number(value);
 822            break;
 823          case "offset": {
 824            const numericOffset = Number(value);
 825            if (Number.isFinite(numericOffset)) {
 826              parts.offset = numericOffset;
 827            }
 828            break;
 829          }
 830          case "context":
 831            parts.context = value;
 832            break;
 833          default:
 834            if (key === "_fields") {
 835              parts.fields = get_normalized_comma_separable_default(value) ?? [];
 836              value = parts.fields.join();
 837            }
 838            if (key === "include") {
 839              if (typeof value === "number") {
 840                value = value.toString();
 841              }
 842              parts.include = (get_normalized_comma_separable_default(value) ?? []).map(Number);
 843              value = parts.include.join();
 844            }
 845            parts.stableKey += (parts.stableKey ? "&" : "") + (0, import_url.addQueryArgs)("", { [key]: value }).slice(1);
 846        }
 847      }
 848      return parts;
 849    }
 850    var get_query_parts_default = with_weak_map_cache_default(getQueryParts);
 851  
 852    // packages/core-data/build-module/queried-data/selectors.mjs
 853    var queriedItemsCacheByState = /* @__PURE__ */ new WeakMap();
 854    function getQueriedItemsUncached(state, query, options = {}) {
 855      const { supportsPagination = true } = options;
 856      const {
 857        stableKey,
 858        page,
 859        perPage,
 860        offset: queryOffset,
 861        include,
 862        fields,
 863        context
 864      } = get_query_parts_default(query);
 865      const itemIds = state.queries?.[context]?.[stableKey]?.itemIds;
 866      if (!itemIds) {
 867        return null;
 868      }
 869      const isPaginated = supportsPagination && perPage !== -1;
 870      const startOffset = isPaginated ? queryOffset ?? (page - 1) * perPage : 0;
 871      const endOffset = isPaginated ? Math.min(startOffset + perPage, itemIds.length) : itemIds.length;
 872      if (isPaginated && itemIds.length < startOffset + perPage) {
 873        const totalItems = state.queries[context][stableKey].meta?.totalItems;
 874        if (Number.isFinite(totalItems) && itemIds.length < totalItems) {
 875          return null;
 876        }
 877      }
 878      const items2 = [];
 879      for (let i = startOffset; i < endOffset; i++) {
 880        const itemId = itemIds[i];
 881        if (Array.isArray(include) && !include.includes(itemId)) {
 882          continue;
 883        }
 884        if (itemId === void 0) {
 885          continue;
 886        }
 887        if (!state.items[context]?.hasOwnProperty(itemId)) {
 888          return null;
 889        }
 890        const item = state.items[context][itemId];
 891        let filteredItem;
 892        if (Array.isArray(fields)) {
 893          filteredItem = {};
 894          for (let f = 0; f < fields.length; f++) {
 895            const field = fields[f].split(".");
 896            let value = item;
 897            field.forEach((fieldName) => {
 898              value = value?.[fieldName];
 899            });
 900            setNestedValue(filteredItem, field, value);
 901          }
 902        } else {
 903          if (!state.itemIsComplete[context]?.[itemId]) {
 904            return null;
 905          }
 906          filteredItem = item;
 907        }
 908        items2.push(filteredItem);
 909      }
 910      return items2;
 911    }
 912    function getQueriedItems(state, query = {}, options = {}) {
 913      let queriedItemsCache = queriedItemsCacheByState.get(state);
 914      if (queriedItemsCache) {
 915        const queriedItems = queriedItemsCache.get(query);
 916        if (queriedItems !== void 0) {
 917          return queriedItems;
 918        }
 919      } else {
 920        queriedItemsCache = new import_equivalent_key_map.default();
 921        queriedItemsCacheByState.set(state, queriedItemsCache);
 922      }
 923      const items2 = getQueriedItemsUncached(state, query, options);
 924      queriedItemsCache.set(query, items2);
 925      return items2;
 926    }
 927    function getQueriedTotalItems(state, query = {}) {
 928      const { stableKey, context } = get_query_parts_default(query);
 929      return state.queries?.[context]?.[stableKey]?.meta?.totalItems ?? null;
 930    }
 931    function getQueriedTotalPages(state, query = {}) {
 932      const { stableKey, context } = get_query_parts_default(query);
 933      return state.queries?.[context]?.[stableKey]?.meta?.totalPages ?? null;
 934    }
 935  
 936    // packages/core-data/build-module/queried-data/reducer.mjs
 937    var import_data6 = __toESM(require_data(), 1);
 938    var import_compose = __toESM(require_compose(), 1);
 939  
 940    // node_modules/tslib/tslib.es6.mjs
 941    var __assign = function() {
 942      __assign = Object.assign || function __assign2(t) {
 943        for (var s, i = 1, n = arguments.length; i < n; i++) {
 944          s = arguments[i];
 945          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
 946        }
 947        return t;
 948      };
 949      return __assign.apply(this, arguments);
 950    };
 951  
 952    // node_modules/lower-case/dist.es2015/index.js
 953    function lowerCase(str) {
 954      return str.toLowerCase();
 955    }
 956  
 957    // node_modules/no-case/dist.es2015/index.js
 958    var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
 959    var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
 960    function noCase(input, options) {
 961      if (options === void 0) {
 962        options = {};
 963      }
 964      var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
 965      var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
 966      var start = 0;
 967      var end = result.length;
 968      while (result.charAt(start) === "\0")
 969        start++;
 970      while (result.charAt(end - 1) === "\0")
 971        end--;
 972      return result.slice(start, end).split("\0").map(transform).join(delimiter);
 973    }
 974    function replace(input, re, value) {
 975      if (re instanceof RegExp)
 976        return input.replace(re, value);
 977      return re.reduce(function(input2, re2) {
 978        return input2.replace(re2, value);
 979      }, input);
 980    }
 981  
 982    // node_modules/pascal-case/dist.es2015/index.js
 983    function pascalCaseTransform(input, index) {
 984      var firstChar = input.charAt(0);
 985      var lowerChars = input.substr(1).toLowerCase();
 986      if (index > 0 && firstChar >= "0" && firstChar <= "9") {
 987        return "_" + firstChar + lowerChars;
 988      }
 989      return "" + firstChar.toUpperCase() + lowerChars;
 990    }
 991    function pascalCase(input, options) {
 992      if (options === void 0) {
 993        options = {};
 994      }
 995      return noCase(input, __assign({ delimiter: "", transform: pascalCaseTransform }, options));
 996    }
 997  
 998    // node_modules/camel-case/dist.es2015/index.js
 999    function camelCaseTransform(input, index) {
1000      if (index === 0)
1001        return input.toLowerCase();
1002      return pascalCaseTransform(input, index);
1003    }
1004    function camelCase(input, options) {
1005      if (options === void 0) {
1006        options = {};
1007      }
1008      return pascalCase(input, __assign({ transform: camelCaseTransform }, options));
1009    }
1010  
1011    // node_modules/upper-case-first/dist.es2015/index.js
1012    function upperCaseFirst(input) {
1013      return input.charAt(0).toUpperCase() + input.substr(1);
1014    }
1015  
1016    // node_modules/capital-case/dist.es2015/index.js
1017    function capitalCaseTransform(input) {
1018      return upperCaseFirst(input.toLowerCase());
1019    }
1020    function capitalCase(input, options) {
1021      if (options === void 0) {
1022        options = {};
1023      }
1024      return noCase(input, __assign({ delimiter: " ", transform: capitalCaseTransform }, options));
1025    }
1026  
1027    // packages/core-data/build-module/entities.mjs
1028    var import_api_fetch2 = __toESM(require_api_fetch(), 1);
1029    var import_blocks4 = __toESM(require_blocks(), 1);
1030    var import_i18n = __toESM(require_i18n(), 1);
1031  
1032    // packages/core-data/build-module/awareness/post-editor-awareness.mjs
1033    var import_data4 = __toESM(require_data(), 1);
1034    var import_sync9 = __toESM(require_sync(), 1);
1035    var import_block_editor3 = __toESM(require_block_editor(), 1);
1036  
1037    // packages/core-data/build-module/awareness/base-awareness.mjs
1038    var import_data = __toESM(require_data(), 1);
1039  
1040    // packages/core-data/build-module/awareness/config.mjs
1041    var AWARENESS_CURSOR_UPDATE_THROTTLE_IN_MS = 100;
1042    var LOCAL_CURSOR_UPDATE_DEBOUNCE_IN_MS = 5;
1043    var REMOVAL_DELAY_IN_MS = 5e3;
1044  
1045    // packages/core-data/build-module/awareness/typed-awareness.mjs
1046    var import_sync3 = __toESM(require_sync(), 1);
1047  
1048    // packages/core-data/build-module/awareness/utils.mjs
1049    function getBrowserName() {
1050      const userAgent = window.navigator.userAgent;
1051      let browserName = "Unknown";
1052      if (userAgent.includes("Firefox")) {
1053        browserName = "Firefox";
1054      } else if (userAgent.includes("Edg")) {
1055        browserName = "Microsoft Edge";
1056      } else if (userAgent.includes("Chrome") && !userAgent.includes("Edg")) {
1057        browserName = "Chrome";
1058      } else if (userAgent.includes("Safari") && !userAgent.includes("Chrome")) {
1059        browserName = "Safari";
1060      } else if (userAgent.includes("MSIE") || userAgent.includes("Trident")) {
1061        browserName = "Internet Explorer";
1062      } else if (userAgent.includes("Opera") || userAgent.includes("OPR")) {
1063        browserName = "Opera";
1064      }
1065      return browserName;
1066    }
1067    function areMapsEqual(map1, map2, comparatorFn) {
1068      if (map1.size !== map2.size) {
1069        return false;
1070      }
1071      for (const [key, value1] of map1.entries()) {
1072        if (!map2.has(key)) {
1073          return false;
1074        }
1075        if (!comparatorFn(value1, map2.get(key))) {
1076          return false;
1077        }
1078      }
1079      return true;
1080    }
1081    function areCollaboratorInfosEqual(collaboratorInfo1, collaboratorInfo2) {
1082      if (!collaboratorInfo1 || !collaboratorInfo2) {
1083        return collaboratorInfo1 === collaboratorInfo2;
1084      }
1085      if (Object.keys(collaboratorInfo1).length !== Object.keys(collaboratorInfo2).length) {
1086        return false;
1087      }
1088      return Object.entries(collaboratorInfo1).every(([key, value]) => {
1089        return value === collaboratorInfo2[key];
1090      });
1091    }
1092    function hasValidAvatarUrls(value) {
1093      if ("object" !== typeof value || null === value || Array.isArray(value)) {
1094        return false;
1095      }
1096      return ["24", "48", "96"].every(
1097        (size) => !(size in value) || "string" === typeof value[size]
1098      );
1099    }
1100    function isCollaboratorInfo(value) {
1101      if ("object" !== typeof value || null === value) {
1102        return false;
1103      }
1104      return "id" in value && "name" in value && "slug" in value && "browserType" in value && "enteredAt" in value && (null === value.id || "number" === typeof value.id && Number.isInteger(value.id) && value.id > 0) && "string" === typeof value.name && "" !== value.name.trim() && "string" === typeof value.slug && (!("avatar_urls" in value) || hasValidAvatarUrls(value.avatar_urls)) && "string" === typeof value.browserType && "number" === typeof value.enteredAt && Number.isFinite(value.enteredAt);
1105    }
1106    function generateCollaboratorInfo(currentCollaborator, clientId) {
1107      const presentationInfo = {
1108        browserType: getBrowserName(),
1109        enteredAt: Date.now()
1110      };
1111      if ("object" === typeof currentCollaborator && currentCollaborator) {
1112        const user = currentCollaborator;
1113        if ("id" in user && "name" in user) {
1114          const collaboratorInfo = {
1115            ...presentationInfo,
1116            ..."avatar_urls" in user && hasValidAvatarUrls(user.avatar_urls) ? { avatar_urls: user.avatar_urls } : {},
1117            id: user.id,
1118            name: user.name,
1119            slug: "slug" in user && "string" === typeof user.slug ? user.slug : ""
1120          };
1121          if (isCollaboratorInfo(collaboratorInfo) && null !== collaboratorInfo.id) {
1122            return collaboratorInfo;
1123          }
1124        }
1125      }
1126      return {
1127        ...presentationInfo,
1128        id: null,
1129        // Keep shared awareness data language-neutral. The editor localizes this
1130        // fallback name for the viewer when it is displayed.
1131        name: "Anonymous User",
1132        slug: `anonymous-$clientId}`
1133      };
1134    }
1135    function getRecordValue(obj, key) {
1136      if ("object" === typeof obj && null !== obj && key in obj) {
1137        return obj[key];
1138      }
1139      return null;
1140    }
1141    function getTypedKeys(obj) {
1142      return Object.keys(obj);
1143    }
1144  
1145    // packages/core-data/build-module/awareness/typed-awareness.mjs
1146    var TypedAwareness = class extends import_sync3.Awareness {
1147      /**
1148       * Get the states from an awareness document.
1149       */
1150      getStates() {
1151        return super.getStates();
1152      }
1153      /**
1154       * Get a local state field from an awareness document.
1155       * @param field
1156       */
1157      getLocalStateField(field) {
1158        const state = this.getLocalState();
1159        return getRecordValue(state, field);
1160      }
1161      /**
1162       * Set a local state field on an awareness document.
1163       * @param field
1164       * @param value
1165       */
1166      setLocalStateField(field, value) {
1167        super.setLocalStateField(field, value);
1168      }
1169    };
1170  
1171    // packages/core-data/build-module/awareness/awareness-state.mjs
1172    var AwarenessWithEqualityChecks = class extends TypedAwareness {
1173      /** OVERRIDDEN METHODS */
1174      /**
1175       * Set a local state field on an awareness document. Calling this method may
1176       * trigger rerenders of any subscribed components.
1177       *
1178       * Equality checks are provided by the abstract `equalityFieldChecks` property.
1179       * @param field - The field to set.
1180       * @param value - The value to set.
1181       */
1182      setLocalStateField(field, value) {
1183        if (this.isFieldEqual(
1184          field,
1185          value,
1186          this.getLocalStateField(field) ?? void 0
1187        )) {
1188          return;
1189        }
1190        super.setLocalStateField(field, value);
1191      }
1192      /** CUSTOM METHODS */
1193      /**
1194       * Determine if a field value has changed using the provided equality checks.
1195       * @param field  - The field to check.
1196       * @param value1 - The first value to compare.
1197       * @param value2 - The second value to compare.
1198       */
1199      isFieldEqual(field, value1, value2) {
1200        if (["clientId", "isConnected", "isMe"].includes(field)) {
1201          return value1 === value2;
1202        }
1203        if (field in this.equalityFieldChecks) {
1204          const fn = this.equalityFieldChecks[field];
1205          return fn(value1, value2);
1206        }
1207        throw new Error(
1208          `No equality check implemented for awareness state field "$field.toString()}".`
1209        );
1210      }
1211      /**
1212       * Determine if two states are equal by comparing each field using the
1213       * provided equality checks.
1214       * @param state1 - The first state to compare.
1215       * @param state2 - The second state to compare.
1216       */
1217      isStateEqual(state1, state2) {
1218        return [
1219          .../* @__PURE__ */ new Set([
1220            ...getTypedKeys(state1),
1221            ...getTypedKeys(state2)
1222          ])
1223        ].every((field) => {
1224          const value1 = state1[field];
1225          const value2 = state2[field];
1226          return this.isFieldEqual(field, value1, value2);
1227        });
1228      }
1229    };
1230    var AwarenessState = class extends AwarenessWithEqualityChecks {
1231      /** CUSTOM PROPERTIES */
1232      /**
1233       * Whether the setUp method has been called, to avoid running it multiple
1234       * times.
1235       */
1236      hasSetupRun = false;
1237      /**
1238       * We keep track of all seen states during the current session for two reasons:
1239       *
1240       * 1. So that we can represent recently disconnected collaborators in our UI, even
1241       *    after they have been removed from the awareness document.
1242       * 2. So that we can provide debug information about all collaborators seen during
1243       *    the session.
1244       */
1245      disconnectedCollaborators = /* @__PURE__ */ new Set();
1246      seenStates = /* @__PURE__ */ new Map();
1247      /**
1248       * Hold a snapshot of the previous awareness state allows us to compare the
1249       * state values and avoid unnecessary updates to subscribers.
1250       */
1251      previousSnapshot = /* @__PURE__ */ new Map();
1252      stateSubscriptions = [];
1253      /**
1254       * In some cases, we may want to throttle setting local state fields to avoid
1255       * overwhelming the awareness document with rapid updates. At the same time, we
1256       * want to ensure that when we read our own state locally, we get the latest
1257       * value -- even if it hasn't yet been set on the awareness instance.
1258       */
1259      myThrottledState = {};
1260      throttleTimeouts = /* @__PURE__ */ new Map();
1261      /** CUSTOM METHODS */
1262      /**
1263       * Set up the awareness state. This method is idempotent and will only run
1264       * once. Subclasses should override `onSetUp()` instead of this method to
1265       * add their own setup logic.
1266       *
1267       * This is defined as a readonly arrow function property to prevent
1268       * subclasses from overriding it.
1269       */
1270      setUp = () => {
1271        if (this.hasSetupRun) {
1272          return;
1273        }
1274        this.hasSetupRun = true;
1275        this.onSetUp();
1276        this.on(
1277          "change",
1278          ({ added, removed, updated }) => {
1279            [...added, ...updated].forEach((id) => {
1280              this.disconnectedCollaborators.delete(id);
1281            });
1282            removed.forEach((id) => {
1283              this.disconnectedCollaborators.add(id);
1284              setTimeout(() => {
1285                this.disconnectedCollaborators.delete(id);
1286                this.updateSubscribers(
1287                  true
1288                  /* force update */
1289                );
1290              }, REMOVAL_DELAY_IN_MS);
1291            });
1292            this.updateSubscribers();
1293          }
1294        );
1295      };
1296      /**
1297       * Get the most recent state from the last processed change event.
1298       *
1299       * @return An array of EnhancedState< State >.
1300       */
1301      getCurrentState() {
1302        return Array.from(this.previousSnapshot.values());
1303      }
1304      /**
1305       * Get all seen states in this session to enable debug reporting.
1306       */
1307      getSeenStates() {
1308        return this.seenStates;
1309      }
1310      /**
1311       * Allow external code to subscribe to awareness state changes.
1312       * @param callback - The callback to subscribe to.
1313       */
1314      onStateChange(callback) {
1315        this.stateSubscriptions.push(callback);
1316        return () => {
1317          this.stateSubscriptions = this.stateSubscriptions.filter(
1318            (cb) => cb !== callback
1319          );
1320        };
1321      }
1322      /**
1323       * Set a local state field on an awareness document with throttle. See caveats
1324       * of this.setLocalStateField.
1325       * @param field - The field to set.
1326       * @param value - The value to set.
1327       * @param wait  - The wait time in milliseconds.
1328       */
1329      setThrottledLocalStateField(field, value, wait) {
1330        this.setLocalStateField(field, value);
1331        this.throttleTimeouts.set(
1332          field,
1333          setTimeout(() => {
1334            this.throttleTimeouts.delete(field);
1335            if (this.myThrottledState[field]) {
1336              this.setLocalStateField(
1337                field,
1338                this.myThrottledState[field]
1339              );
1340              delete this.myThrottledState[field];
1341            }
1342          }, wait)
1343        );
1344      }
1345      /**
1346       * Set the current collaborator's connection status as awareness state.
1347       * @param isConnected - The connection status.
1348       */
1349      setConnectionStatus(isConnected) {
1350        if (isConnected) {
1351          this.disconnectedCollaborators.delete(this.clientID);
1352        } else {
1353          this.disconnectedCollaborators.add(this.clientID);
1354        }
1355        this.updateSubscribers(
1356          true
1357          /* force update */
1358        );
1359      }
1360      /**
1361       * Update all subscribed listeners with the latest awareness state.
1362       * @param forceUpdate - Whether to force an update.
1363       */
1364      updateSubscribers(forceUpdate = false) {
1365        if (!this.stateSubscriptions.length) {
1366          return;
1367        }
1368        const states = this.getStates();
1369        this.seenStates = new Map([
1370          ...this.seenStates.entries(),
1371          ...states.entries()
1372        ]);
1373        const updatedStates = new Map(
1374          [...this.disconnectedCollaborators, ...states.keys()].filter((clientId) => {
1375            return Object.keys(this.seenStates.get(clientId) ?? {}).length > 0;
1376          }).map((clientId) => {
1377            const rawState = this.seenStates.get(clientId);
1378            const isConnected = !this.disconnectedCollaborators.has(clientId);
1379            const isMe = clientId === this.clientID;
1380            const myState = isMe ? this.myThrottledState : {};
1381            const state = {
1382              ...rawState,
1383              ...myState,
1384              clientId,
1385              isConnected,
1386              isMe
1387            };
1388            return [clientId, state];
1389          })
1390        );
1391        if (!forceUpdate) {
1392          if (areMapsEqual(
1393            this.previousSnapshot,
1394            updatedStates,
1395            this.isStateEqual.bind(this)
1396          )) {
1397            return;
1398          }
1399        }
1400        this.previousSnapshot = updatedStates;
1401        this.stateSubscriptions.forEach((callback) => {
1402          callback(Array.from(updatedStates.values()));
1403        });
1404      }
1405    };
1406  
1407    // packages/core-data/build-module/name.mjs
1408    var STORE_NAME = "core";
1409  
1410    // packages/core-data/build-module/awareness/base-awareness.mjs
1411    var BaseAwarenessState = class extends AwarenessState {
1412      onSetUp() {
1413        void this.setCurrentCollaboratorInfo();
1414      }
1415      /**
1416       * Set the current collaborator info in the local state.
1417       */
1418      async setCurrentCollaboratorInfo() {
1419        let currentUser2;
1420        try {
1421          currentUser2 = await (0, import_data.resolveSelect)(STORE_NAME).getCurrentUser();
1422        } catch {
1423        }
1424        this.setLocalStateField(
1425          "collaboratorInfo",
1426          generateCollaboratorInfo(currentUser2, this.clientID)
1427        );
1428      }
1429    };
1430    var baseEqualityFieldChecks = {
1431      collaboratorInfo: areCollaboratorInfosEqual
1432    };
1433    var BaseAwareness = class extends BaseAwarenessState {
1434      equalityFieldChecks = baseEqualityFieldChecks;
1435    };
1436  
1437    // packages/core-data/build-module/awareness/block-lookup.mjs
1438    var import_data2 = __toESM(require_data(), 1);
1439    var import_sync4 = __toESM(require_sync(), 1);
1440    var import_block_editor = __toESM(require_block_editor(), 1);
1441    function getContainingBlockYMap(yType) {
1442      let current = yType;
1443      while (current) {
1444        const parent = current.parent;
1445        if (parent instanceof import_sync4.Y.Map && parent.parent instanceof import_sync4.Y.Array && parent.get("clientId") !== void 0 && parent.get("innerBlocks") instanceof import_sync4.Y.Array) {
1446          return parent;
1447        }
1448        current = parent instanceof import_sync4.Y.AbstractType ? parent : null;
1449      }
1450      return null;
1451    }
1452    function getBlockPathInYdoc(yType) {
1453      const path = [];
1454      let current = yType;
1455      while (current) {
1456        const parentArray = current.parent;
1457        if (!parentArray || !(parentArray instanceof import_sync4.Y.Array)) {
1458          return null;
1459        }
1460        let index = -1;
1461        for (let i = 0; i < parentArray.length; i++) {
1462          if (parentArray.get(i) === current) {
1463            index = i;
1464            break;
1465          }
1466        }
1467        if (index === -1) {
1468          return null;
1469        }
1470        path.unshift(index);
1471        const grandparent = parentArray.parent;
1472        if (grandparent instanceof import_sync4.Y.Map && grandparent.get("clientId") !== void 0) {
1473          current = grandparent;
1474        } else {
1475          break;
1476        }
1477      }
1478      return path;
1479    }
1480    function resolveBlockClientIdByPath(path, blocks) {
1481      if (path.length === 0) {
1482        return null;
1483      }
1484      for (let i = 0; i < path.length; i++) {
1485        const block = blocks[path[i]];
1486        if (!block) {
1487          return null;
1488        }
1489        if (i === path.length - 1) {
1490          return block.clientId;
1491        }
1492        blocks = block.innerBlocks;
1493      }
1494      return null;
1495    }
1496    function usePostContentBlocks() {
1497      return (0, import_data2.useSelect)((select5) => {
1498        const { getBlocksByName, getClientIdsTree } = unlock(
1499          select5(import_block_editor.store)
1500        );
1501        const [postContentClientId] = getBlocksByName("core/post-content");
1502        return getClientIdsTree(postContentClientId ?? "");
1503      }, []);
1504    }
1505  
1506    // packages/core-data/build-module/utils/crdt-utils.mjs
1507    var import_sync5 = __toESM(require_sync(), 1);
1508    var import_rich_text = __toESM(require_rich_text(), 1);
1509    function getRootMap(doc, key) {
1510      return doc.getMap(key);
1511    }
1512    function createYMap(partial = {}) {
1513      return new import_sync5.Y.Map(Object.entries(partial));
1514    }
1515    function isYMap(value) {
1516      return value instanceof import_sync5.Y.Map;
1517    }
1518    function asRichTextOffset(offset) {
1519      return offset;
1520    }
1521    function asHtmlStringIndex(index) {
1522      return index;
1523    }
1524    function getYTextByAttributeKey(attributes, attributeKey) {
1525      const directValue = attributes.get(attributeKey);
1526      if (directValue instanceof import_sync5.Y.Text) {
1527        return directValue;
1528      }
1529      let value = attributes;
1530      for (const pathPart of attributeKey.split(".")) {
1531        if (value instanceof import_sync5.Y.Map) {
1532          value = value.get(pathPart);
1533        } else if (value instanceof import_sync5.Y.Array) {
1534          const index = Number.parseInt(pathPart, 10);
1535          if (!Number.isSafeInteger(index) || index < 0 || index.toString() !== pathPart) {
1536            return null;
1537          }
1538          value = value.get(index);
1539        } else {
1540          return null;
1541        }
1542      }
1543      return value instanceof import_sync5.Y.Text ? value : null;
1544    }
1545    function findBlockByClientIdInDoc(blockId, ydoc) {
1546      const ymap = getRootMap(ydoc, CRDT_RECORD_MAP_KEY);
1547      const blocks = ymap.get("blocks");
1548      if (!(blocks instanceof import_sync5.Y.Array)) {
1549        return null;
1550      }
1551      return findBlockByClientIdInBlocks(blockId, blocks);
1552    }
1553    var MARKER_START = 57344;
1554    function pickMarker(text) {
1555      const tryCount = 16;
1556      for (let code = MARKER_START; code < MARKER_START + tryCount; code++) {
1557        const candidate = String.fromCharCode(code);
1558        if (!text.includes(candidate)) {
1559          return candidate;
1560        }
1561      }
1562      return null;
1563    }
1564    function htmlIndexToRichTextOffset(html, htmlIndex) {
1565      if (!html.includes("<") && !html.includes("&")) {
1566        return asRichTextOffset(htmlIndex);
1567      }
1568      const marker = pickMarker(html);
1569      if (!marker) {
1570        return asRichTextOffset(htmlIndex);
1571      }
1572      const withMarker = html.slice(0, htmlIndex) + marker + html.slice(htmlIndex);
1573      const value = (0, import_rich_text.create)({ html: withMarker });
1574      const markerPos = value.text.indexOf(marker);
1575      return asRichTextOffset(markerPos === -1 ? htmlIndex : markerPos);
1576    }
1577    function richTextOffsetToHtmlIndex(html, richTextOffset) {
1578      if (!html.includes("<") && !html.includes("&")) {
1579        return asHtmlStringIndex(richTextOffset);
1580      }
1581      const marker = pickMarker(html);
1582      if (!marker) {
1583        return asHtmlStringIndex(richTextOffset);
1584      }
1585      const value = (0, import_rich_text.create)({ html });
1586      const markerValue = (0, import_rich_text.create)({ text: marker });
1587      if (value.formats[richTextOffset]) {
1588        markerValue.formats[0] = value.formats[richTextOffset];
1589      }
1590      const withMarker = (0, import_rich_text.insert)(
1591        value,
1592        markerValue,
1593        richTextOffset,
1594        richTextOffset
1595      );
1596      const htmlWithMarker = (0, import_rich_text.toHTMLString)({ value: withMarker });
1597      const markerIndex = htmlWithMarker.indexOf(marker);
1598      return asHtmlStringIndex(
1599        markerIndex === -1 ? richTextOffset : markerIndex
1600      );
1601    }
1602    function findBlockByClientIdInBlocks(blockId, blocks) {
1603      for (const block of blocks) {
1604        if (block.get("clientId") === blockId) {
1605          return block;
1606        }
1607        const innerBlocks = block.get("innerBlocks");
1608        if (innerBlocks && innerBlocks.length > 0) {
1609          const innerBlock = findBlockByClientIdInBlocks(
1610            blockId,
1611            innerBlocks
1612          );
1613          if (innerBlock) {
1614            return innerBlock;
1615          }
1616        }
1617      }
1618      return null;
1619    }
1620  
1621    // packages/core-data/build-module/utils/crdt-user-selections.mjs
1622    var import_data3 = __toESM(require_data(), 1);
1623    var import_sync7 = __toESM(require_sync(), 1);
1624    var import_block_editor2 = __toESM(require_block_editor(), 1);
1625    var SelectionType = /* @__PURE__ */ ((SelectionType2) => {
1626      SelectionType2["None"] = "none";
1627      SelectionType2["Cursor"] = "cursor";
1628      SelectionType2["SelectionInOneBlock"] = "selection-in-one-block";
1629      SelectionType2["SelectionInMultipleBlocks"] = "selection-in-multiple-blocks";
1630      SelectionType2["WholeBlock"] = "whole-block";
1631      return SelectionType2;
1632    })(SelectionType || {});
1633    var SelectionDirection = /* @__PURE__ */ ((SelectionDirection2) => {
1634      SelectionDirection2["Forward"] = "f";
1635      SelectionDirection2["Backward"] = "b";
1636      return SelectionDirection2;
1637    })(SelectionDirection || {});
1638    function getSelectionState(selectionStart, selectionEnd, yDoc, options) {
1639      const { selectionDirection } = options ?? {};
1640      const ymap = getRootMap(yDoc, CRDT_RECORD_MAP_KEY);
1641      const yBlocks = ymap.get("blocks");
1642      const isSelectionEmpty = Object.keys(selectionStart).length === 0;
1643      const noSelection = {
1644        type: "none"
1645        /* None */
1646      };
1647      if (isSelectionEmpty || !yBlocks) {
1648        return noSelection;
1649      }
1650      const isSelectionInOneBlock = selectionStart.clientId === selectionEnd.clientId;
1651      const isCursorOnly = isSelectionInOneBlock && selectionStart.offset === selectionEnd.offset;
1652      const isSelectionAWholeBlock = isSelectionInOneBlock && selectionStart.offset === void 0 && selectionEnd.offset === void 0;
1653      if (isSelectionAWholeBlock) {
1654        const path = getBlockPathForLocalClientId(selectionStart.clientId);
1655        const blockPosition = path ? createRelativePositionForBlockPath(path, yBlocks) : null;
1656        if (!blockPosition) {
1657          return noSelection;
1658        }
1659        return {
1660          type: "whole-block",
1661          blockPosition
1662        };
1663      } else if (isCursorOnly) {
1664        const cursorPosition = getCursorPosition(selectionStart, yBlocks);
1665        if (!cursorPosition) {
1666          return noSelection;
1667        }
1668        return {
1669          type: "cursor",
1670          cursorPosition
1671        };
1672      } else if (isSelectionInOneBlock) {
1673        const cursorStartPosition = getCursorPosition(
1674          selectionStart,
1675          yBlocks
1676        );
1677        const cursorEndPosition = getCursorPosition(selectionEnd, yBlocks);
1678        if (!cursorStartPosition || !cursorEndPosition) {
1679          return noSelection;
1680        }
1681        return {
1682          type: "selection-in-one-block",
1683          cursorStartPosition,
1684          cursorEndPosition,
1685          selectionDirection
1686        };
1687      }
1688      const startEndpoint = getSelectionEndpoint(selectionStart, yBlocks);
1689      const endEndpoint = getSelectionEndpoint(selectionEnd, yBlocks);
1690      if (!startEndpoint || !endEndpoint) {
1691        return noSelection;
1692      }
1693      return {
1694        type: "selection-in-multiple-blocks",
1695        startEndpoint,
1696        endEndpoint,
1697        selectionDirection
1698      };
1699    }
1700    function getCursorPosition(selection, blocks) {
1701      const path = getBlockPathForLocalClientId(selection.clientId);
1702      const block = path ? findBlockByPath(path, blocks) : null;
1703      if (!block || !selection.attributeKey || void 0 === selection.offset) {
1704        return null;
1705      }
1706      const attributes = block.get("attributes");
1707      const currentYText = attributes ? getYTextByAttributeKey(attributes, selection.attributeKey) : null;
1708      if (!(currentYText instanceof import_sync7.Y.Text)) {
1709        return null;
1710      }
1711      const relativePosition = import_sync7.Y.createRelativePositionFromTypeIndex(
1712        currentYText,
1713        richTextOffsetToHtmlIndex(
1714          currentYText.toString(),
1715          asRichTextOffset(selection.offset)
1716        )
1717      );
1718      return {
1719        relativePosition,
1720        absoluteOffset: selection.offset,
1721        attributeKey: selection.attributeKey
1722      };
1723    }
1724    function getSelectionEndpoint(selection, blocks) {
1725      const cursorPosition = getCursorPosition(selection, blocks);
1726      if (cursorPosition) {
1727        return { type: "cursor", cursorPosition };
1728      }
1729      const path = getBlockPathForLocalClientId(selection.clientId);
1730      const blockPosition = path ? createRelativePositionForBlockPath(path, blocks) : null;
1731      if (blockPosition) {
1732        return { type: "whole-block", blockPosition };
1733      }
1734      return null;
1735    }
1736    function getBlockPathForLocalClientId(clientId) {
1737      const { getBlockIndex, getBlockRootClientId, getBlockName } = (0, import_data3.select)(import_block_editor2.store);
1738      const path = [];
1739      let current = clientId;
1740      while (current) {
1741        const index = getBlockIndex(current);
1742        if (index === -1) {
1743          return null;
1744        }
1745        path.unshift(index);
1746        const parent = getBlockRootClientId(current);
1747        if (!parent) {
1748          break;
1749        }
1750        const parentName = getBlockName(parent);
1751        if (parentName === "core/post-content") {
1752          break;
1753        }
1754        current = parent;
1755      }
1756      return path.length > 0 ? path : null;
1757    }
1758    function findBlockByPath(path, blocks) {
1759      let currentBlocks = blocks;
1760      for (let i = 0; i < path.length; i++) {
1761        if (path[i] >= currentBlocks.length) {
1762          return null;
1763        }
1764        const block = currentBlocks.get(path[i]);
1765        if (!block) {
1766          return null;
1767        }
1768        if (i === path.length - 1) {
1769          return block;
1770        }
1771        currentBlocks = block.get("innerBlocks") ?? new import_sync7.Y.Array();
1772      }
1773      return null;
1774    }
1775    function createRelativePositionForBlockPath(path, blocks) {
1776      let currentBlocks = blocks;
1777      for (let i = 0; i < path.length; i++) {
1778        if (path[i] >= currentBlocks.length) {
1779          return null;
1780        }
1781        if (i === path.length - 1) {
1782          return import_sync7.Y.createRelativePositionFromTypeIndex(
1783            currentBlocks,
1784            path[i]
1785          );
1786        }
1787        const block = currentBlocks.get(path[i]);
1788        currentBlocks = block?.get("innerBlocks") ?? new import_sync7.Y.Array();
1789      }
1790      return null;
1791    }
1792    function areSelectionsStatesEqual(selection1, selection2) {
1793      if (selection1.type !== selection2.type) {
1794        return false;
1795      }
1796      switch (selection1.type) {
1797        case "none":
1798          return true;
1799        case "cursor":
1800          return areCursorPositionsEqual(
1801            selection1.cursorPosition,
1802            selection2.cursorPosition
1803          );
1804        case "selection-in-one-block":
1805          return areCursorPositionsEqual(
1806            selection1.cursorStartPosition,
1807            selection2.cursorStartPosition
1808          ) && areCursorPositionsEqual(
1809            selection1.cursorEndPosition,
1810            selection2.cursorEndPosition
1811          ) && selection1.selectionDirection === selection2.selectionDirection;
1812        case "selection-in-multiple-blocks":
1813          return areEndpointsEqual(
1814            selection1.startEndpoint,
1815            selection2.startEndpoint
1816          ) && areEndpointsEqual(
1817            selection1.endEndpoint,
1818            selection2.endEndpoint
1819          ) && selection1.selectionDirection === selection2.selectionDirection;
1820        case "whole-block":
1821          return import_sync7.Y.compareRelativePositions(
1822            selection1.blockPosition,
1823            selection2.blockPosition
1824          );
1825        default:
1826          return false;
1827      }
1828    }
1829    function areEndpointsEqual(ep1, ep2) {
1830      if (ep1.type !== ep2.type) {
1831        return false;
1832      }
1833      if (ep1.type === "cursor" && ep2.type === "cursor") {
1834        return areCursorPositionsEqual(
1835          ep1.cursorPosition,
1836          ep2.cursorPosition
1837        );
1838      }
1839      return import_sync7.Y.compareRelativePositions(
1840        ep1.blockPosition,
1841        ep2.blockPosition
1842      );
1843    }
1844    function areCursorPositionsEqual(cursorPosition1, cursorPosition2) {
1845      const isRelativePositionEqual = import_sync7.Y.compareRelativePositions(
1846        cursorPosition1.relativePosition,
1847        cursorPosition2.relativePosition
1848      );
1849      const isAbsoluteOffsetEqual = cursorPosition1.absoluteOffset === cursorPosition2.absoluteOffset;
1850      return isRelativePositionEqual && isAbsoluteOffsetEqual;
1851    }
1852  
1853    // packages/core-data/build-module/awareness/post-editor-awareness.mjs
1854    var PostEditorAwareness = class extends BaseAwarenessState {
1855      constructor(doc, kind, name, postId) {
1856        super(doc);
1857        this.kind = kind;
1858        this.name = name;
1859        this.postId = postId;
1860      }
1861      equalityFieldChecks = {
1862        ...baseEqualityFieldChecks,
1863        editorState: this.areEditorStatesEqual
1864      };
1865      onSetUp() {
1866        super.onSetUp();
1867        this.subscribeToCollaboratorSelectionChanges();
1868      }
1869      /**
1870       * Subscribe to collaborator selection changes and update the selection state.
1871       */
1872      subscribeToCollaboratorSelectionChanges() {
1873        const {
1874          getSelectionStart,
1875          getSelectionEnd,
1876          getSelectedBlocksInitialCaretPosition
1877        } = (0, import_data4.select)(import_block_editor3.store);
1878        let selectionStart = getSelectionStart();
1879        let selectionEnd = getSelectionEnd();
1880        let localCursorTimeout = null;
1881        let selectionBeforeDebounce = null;
1882        (0, import_data4.subscribe)(() => {
1883          const newSelectionStart = getSelectionStart();
1884          const newSelectionEnd = getSelectionEnd();
1885          if (newSelectionStart === selectionStart && newSelectionEnd === selectionEnd) {
1886            return;
1887          }
1888          if (!selectionBeforeDebounce) {
1889            selectionBeforeDebounce = {
1890              start: selectionStart,
1891              end: selectionEnd
1892            };
1893          }
1894          selectionStart = newSelectionStart;
1895          selectionEnd = newSelectionEnd;
1896          const initialPosition = getSelectedBlocksInitialCaretPosition();
1897          void this.updateSelectionInEntityRecord(
1898            selectionStart,
1899            selectionEnd,
1900            initialPosition
1901          );
1902          if (localCursorTimeout) {
1903            clearTimeout(localCursorTimeout);
1904          }
1905          localCursorTimeout = setTimeout(() => {
1906            const selectionStateOptions = {};
1907            if (selectionBeforeDebounce) {
1908              selectionStateOptions.selectionDirection = detectSelectionDirection(
1909                selectionBeforeDebounce.start,
1910                selectionBeforeDebounce.end,
1911                selectionStart,
1912                selectionEnd
1913              );
1914              selectionBeforeDebounce = null;
1915            }
1916            const selectionState = getSelectionState(
1917              selectionStart,
1918              selectionEnd,
1919              this.doc,
1920              selectionStateOptions
1921            );
1922            this.setThrottledLocalStateField(
1923              "editorState",
1924              { selection: selectionState },
1925              AWARENESS_CURSOR_UPDATE_THROTTLE_IN_MS
1926            );
1927          }, LOCAL_CURSOR_UPDATE_DEBOUNCE_IN_MS);
1928        });
1929      }
1930      /**
1931       * Update the entity record with the current collaborator's selection.
1932       *
1933       * @param selectionStart  - The start position of the selection.
1934       * @param selectionEnd    - The end position of the selection.
1935       * @param initialPosition - The initial position of the selection.
1936       */
1937      async updateSelectionInEntityRecord(selectionStart, selectionEnd, initialPosition) {
1938        const edits = {
1939          selection: { selectionStart, selectionEnd, initialPosition }
1940        };
1941        const options = {
1942          undoIgnore: true
1943        };
1944        (0, import_data4.dispatch)(STORE_NAME).editEntityRecord(
1945          this.kind,
1946          this.name,
1947          this.postId,
1948          edits,
1949          options
1950        );
1951      }
1952      /**
1953       * Check if two editor states are equal.
1954       *
1955       * @param state1 - The first editor state.
1956       * @param state2 - The second editor state.
1957       * @return True if the editor states are equal, false otherwise.
1958       */
1959      areEditorStatesEqual(state1, state2) {
1960        if (!state1 || !state2) {
1961          return state1 === state2;
1962        }
1963        if (!state1.selection || !state2.selection) {
1964          return state1.selection === state2.selection;
1965        }
1966        return areSelectionsStatesEqual(state1.selection, state2.selection);
1967      }
1968      /**
1969       * Resolve a selection state to a text index and block client ID.
1970       *
1971       * For text-based selections, navigates up from the resolved Y.Text via
1972       * AbstractType.parent to find the containing block, then resolves the
1973       * local clientId via the block's tree path.
1974       * For WholeBlock selections, resolves the block's relative position and
1975       * then finds the local clientId via tree path.
1976       *
1977       * Tree-path resolution is used instead of reading the clientId directly
1978       * from the Yjs block because the local block-editor store may use different
1979       * clientIds (e.g. in "Show Template" mode where blocks are cloned).
1980       *
1981       * @param selection - The selection state.
1982       * @param blocks    - The tree of block-editor store post content blocks.
1983       * @return The rich-text offset and block client ID, or nulls if not resolvable.
1984       */
1985      convertSelectionStateToAbsolute(selection, blocks) {
1986        if (selection.type === SelectionType.None) {
1987          return {
1988            richTextOffset: null,
1989            localClientId: null,
1990            attributeKey: null
1991          };
1992        }
1993        if (selection.type === SelectionType.WholeBlock) {
1994          const absolutePos = import_sync9.Y.createAbsolutePositionFromRelativePosition(
1995            selection.blockPosition,
1996            this.doc
1997          );
1998          let localClientId2 = null;
1999          if (absolutePos && absolutePos.type instanceof import_sync9.Y.Array) {
2000            const parentArray = absolutePos.type;
2001            const block = parentArray.get(absolutePos.index);
2002            if (block instanceof import_sync9.Y.Map) {
2003              const path2 = getBlockPathInYdoc(block);
2004              localClientId2 = path2 ? resolveBlockClientIdByPath(path2, blocks) : null;
2005            }
2006          }
2007          return {
2008            richTextOffset: null,
2009            localClientId: localClientId2,
2010            attributeKey: null
2011          };
2012        }
2013        if (selection.type === SelectionType.SelectionInMultipleBlocks) {
2014          return {
2015            richTextOffset: null,
2016            localClientId: null,
2017            attributeKey: null
2018          };
2019        }
2020        const cursorPos = "cursorPosition" in selection ? selection.cursorPosition : selection.cursorStartPosition;
2021        const absolutePosition = import_sync9.Y.createAbsolutePositionFromRelativePosition(
2022          cursorPos.relativePosition,
2023          this.doc
2024        );
2025        if (!absolutePosition) {
2026          return {
2027            richTextOffset: null,
2028            localClientId: null,
2029            attributeKey: null
2030          };
2031        }
2032        const yType = getContainingBlockYMap(absolutePosition.type);
2033        const path = yType ? getBlockPathInYdoc(yType) : null;
2034        const localClientId = path ? resolveBlockClientIdByPath(path, blocks) : null;
2035        return {
2036          richTextOffset: htmlIndexToRichTextOffset(
2037            absolutePosition.type.toString(),
2038            asHtmlStringIndex(absolutePosition.index)
2039          ),
2040          localClientId,
2041          attributeKey: cursorPos.attributeKey ?? null
2042        };
2043      }
2044      /**
2045       * Type guard to check if a struct is a Y.Item (not Y.GC)
2046       * @param struct - The struct to check.
2047       * @return True if the struct is a Y.Item, false otherwise.
2048       */
2049      isYItem(struct) {
2050        return "content" in struct;
2051      }
2052      /**
2053       * Get data for debugging, using the awareness state.
2054       *
2055       * @return {YDocDebugData} The debug data.
2056       */
2057      getDebugData() {
2058        const ydoc = this.doc;
2059        const docData = Object.fromEntries(
2060          Array.from(ydoc.share, ([key, value]) => [
2061            key,
2062            value.toJSON()
2063          ])
2064        );
2065        const collaboratorMapData = new Map(
2066          Array.from(this.getSeenStates().entries()).filter(
2067            ([, collaboratorState]) => isCollaboratorInfo(collaboratorState.collaboratorInfo)
2068          ).map(([clientId, collaboratorState]) => [
2069            String(clientId),
2070            {
2071              name: collaboratorState.collaboratorInfo.name,
2072              wpUserId: collaboratorState.collaboratorInfo.id
2073            }
2074          ])
2075        );
2076        const serializableClientItems = {};
2077        ydoc.store.clients.forEach((structs, clientId) => {
2078          const items2 = structs.filter(this.isYItem);
2079          serializableClientItems[clientId] = items2.map((item) => {
2080            const { left, right, ...rest } = item;
2081            return {
2082              ...rest,
2083              left: left ? {
2084                id: left.id,
2085                length: left.length,
2086                origin: left.origin,
2087                content: left.content
2088              } : null,
2089              right: right ? {
2090                id: right.id,
2091                length: right.length,
2092                origin: right.origin,
2093                content: right.content
2094              } : null
2095            };
2096          });
2097        });
2098        return {
2099          doc: docData,
2100          clients: serializableClientItems,
2101          collaboratorMap: Object.fromEntries(collaboratorMapData)
2102        };
2103      }
2104    };
2105    function detectSelectionDirection(prevStart, prevEnd, newStart, newEnd) {
2106      const startMoved = !areBlockSelectionsEqual(prevStart, newStart);
2107      const endMoved = !areBlockSelectionsEqual(prevEnd, newEnd);
2108      if (startMoved && !endMoved) {
2109        return SelectionDirection.Backward;
2110      }
2111      return SelectionDirection.Forward;
2112    }
2113    function areBlockSelectionsEqual(a, b) {
2114      return a.clientId === b.clientId && a.attributeKey === b.attributeKey && a.offset === b.offset;
2115    }
2116  
2117    // packages/core-data/build-module/utils/crdt.mjs
2118    var import_es64 = __toESM(require_es6(), 1);
2119    var import_blocks3 = __toESM(require_blocks(), 1);
2120    var import_sync14 = __toESM(require_sync(), 1);
2121  
2122    // node_modules/uuid/dist/stringify.js
2123    var byteToHex = [];
2124    for (let i = 0; i < 256; ++i) {
2125      byteToHex.push((i + 256).toString(16).slice(1));
2126    }
2127    function unsafeStringify(arr, offset = 0) {
2128      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]]).toLowerCase();
2129    }
2130  
2131    // node_modules/uuid/dist/rng.js
2132    var rnds8 = new Uint8Array(16);
2133    function rng() {
2134      return crypto.getRandomValues(rnds8);
2135    }
2136  
2137    // node_modules/uuid/dist/v4.js
2138    function v4(options, buf, offset) {
2139      if (!buf && !options && crypto.randomUUID) {
2140        return crypto.randomUUID();
2141      }
2142      return _v4(options, buf, offset);
2143    }
2144    function _v4(options, buf, offset) {
2145      options = options || {};
2146      const rnds = options.random ?? options.rng?.() ?? rng();
2147      if (rnds.length < 16) {
2148        throw new Error("Random bytes length must be >= 16");
2149      }
2150      rnds[6] = rnds[6] & 15 | 64;
2151      rnds[8] = rnds[8] & 63 | 128;
2152      if (buf) {
2153        offset = offset || 0;
2154        if (offset < 0 || offset + 16 > buf.length) {
2155          throw new RangeError(`UUID byte range $offset}:$offset + 15} is out of buffer bounds`);
2156        }
2157        for (let i = 0; i < 16; ++i) {
2158          buf[offset + i] = rnds[i];
2159        }
2160        return buf;
2161      }
2162      return unsafeStringify(rnds);
2163    }
2164    var v4_default = v4;
2165  
2166    // packages/core-data/build-module/utils/crdt-blocks.mjs
2167    var import_es63 = __toESM(require_es6(), 1);
2168    var import_blocks = __toESM(require_blocks(), 1);
2169    var import_rich_text3 = __toESM(require_rich_text(), 1);
2170    var import_sync10 = __toESM(require_sync(), 1);
2171  
2172    // packages/core-data/build-module/utils/crdt-text.mjs
2173    var import_rich_text2 = __toESM(require_rich_text(), 1);
2174    var RICH_TEXT_CACHE_MAX_SIZE = 500;
2175    function createRichTextDataCache(maxSize) {
2176      const cache3 = /* @__PURE__ */ new Map();
2177      return function(value) {
2178        const cached = cache3.get(value);
2179        if (cached) {
2180          return cached;
2181        }
2182        const result = import_rich_text2.RichTextData.fromHTMLString(value);
2183        if (cache3.size >= maxSize) {
2184          cache3.delete(cache3.keys().next().value);
2185        }
2186        cache3.set(value, result);
2187        return result;
2188      };
2189    }
2190    var getCachedRichTextData = createRichTextDataCache(
2191      RICH_TEXT_CACHE_MAX_SIZE
2192    );
2193  
2194    // packages/core-data/build-module/utils/crdt-blocks.mjs
2195    var serializableBlocksCache = /* @__PURE__ */ new WeakMap();
2196    function serializeAttributeValue(value) {
2197      if (value instanceof import_rich_text3.RichTextData) {
2198        return value.valueOf();
2199      }
2200      if (Array.isArray(value)) {
2201        return value.map(serializeAttributeValue);
2202      }
2203      if (value && typeof value === "object") {
2204        const result = {};
2205        for (const [k, v] of Object.entries(value)) {
2206          result[k] = serializeAttributeValue(v);
2207        }
2208        return result;
2209      }
2210      return value;
2211    }
2212    function makeBlockAttributesSerializable(blockName, attributes) {
2213      const newAttributes = { ...attributes };
2214      for (const [key, value] of Object.entries(attributes)) {
2215        if (isLocalAttribute(blockName, key)) {
2216          delete newAttributes[key];
2217          continue;
2218        }
2219        newAttributes[key] = serializeAttributeValue(value);
2220      }
2221      return newAttributes;
2222    }
2223    function makeBlocksSerializable(blocks) {
2224      return blocks.map((block) => {
2225        const {
2226          name,
2227          innerBlocks,
2228          attributes,
2229          /*
2230           * Any validation issues discovered when loading a block are appended
2231           * to the block node with a logging function, which cannot be serialized.
2232           *
2233           * @see import("@wordpress/blocks/src/api/parser").parseRawBlock()
2234           */
2235          validationIssues,
2236          ...rest
2237        } = block;
2238        return {
2239          ...rest,
2240          name,
2241          attributes: makeBlockAttributesSerializable(name, attributes),
2242          innerBlocks: makeBlocksSerializable(innerBlocks)
2243        };
2244      });
2245    }
2246    function deserializeAttributeValue(schema, value) {
2247      if (schema?.type === "rich-text" && typeof value === "string") {
2248        return getCachedRichTextData(value);
2249      }
2250      if (Array.isArray(value)) {
2251        return value.map(
2252          (item) => deserializeAttributeValue(schema, item)
2253        );
2254      }
2255      if (value && typeof value === "object") {
2256        const result = {};
2257        for (const [key, innerValue] of Object.entries(
2258          value
2259        )) {
2260          result[key] = deserializeAttributeValue(
2261            schema?.query?.[key],
2262            innerValue
2263          );
2264        }
2265        return result;
2266      }
2267      return value;
2268    }
2269    function deserializeBlockAttributes(blocks) {
2270      return blocks.map((block) => {
2271        const { name, innerBlocks, attributes, ...rest } = block;
2272        const newAttributes = { ...attributes };
2273        for (const [key, value] of Object.entries(attributes)) {
2274          const schema = getBlockAttributeSchema(name, key);
2275          if (schema) {
2276            newAttributes[key] = deserializeAttributeValue(
2277              schema,
2278              value
2279            );
2280          }
2281        }
2282        return {
2283          ...rest,
2284          name,
2285          attributes: newAttributes,
2286          innerBlocks: deserializeBlockAttributes(innerBlocks ?? [])
2287        };
2288      });
2289    }
2290    function areBlocksEqual(gblock, yblock) {
2291      const yblockAsJson = yblock.toJSON();
2292      const overwrites = {
2293        innerBlocks: null,
2294        clientId: null
2295      };
2296      const res = (0, import_es63.default)(
2297        Object.assign({}, gblock, overwrites),
2298        Object.assign({}, yblockAsJson, overwrites)
2299      );
2300      const inners = gblock.innerBlocks || [];
2301      const yinners = yblock.get("innerBlocks");
2302      return res && inners.length === yinners?.length && inners.every(
2303        (block, i) => areBlocksEqual(block, yinners.get(i))
2304      );
2305    }
2306    function createNewYAttributeMap(blockName, attributes) {
2307      return new import_sync10.Y.Map(
2308        Object.entries(attributes).map(
2309          ([attributeName, attributeValue]) => {
2310            return [
2311              attributeName,
2312              createNewYAttributeValue(
2313                blockName,
2314                attributeName,
2315                attributeValue
2316              )
2317            ];
2318          }
2319        )
2320      );
2321    }
2322    function createNewYAttributeValue(blockName, attributeName, attributeValue) {
2323      const schema = getBlockAttributeSchema(blockName, attributeName);
2324      return createYValueFromSchema(schema, attributeValue);
2325    }
2326    function createYValueFromSchema(schema, value) {
2327      if (!schema) {
2328        return value;
2329      }
2330      if (schema.type === "rich-text") {
2331        return new import_sync10.Y.Text(value?.toString() ?? "");
2332      }
2333      if (schema.type === "array" && schema.query && Array.isArray(value)) {
2334        const query = schema.query;
2335        const yArray = new import_sync10.Y.Array();
2336        yArray.insert(
2337          0,
2338          value.map((item) => createYMapFromQuery(query, item))
2339        );
2340        return yArray;
2341      }
2342      if (schema.type === "object" && schema.query && isRecord(value)) {
2343        return createYMapFromQuery(schema.query, value);
2344      }
2345      return value;
2346    }
2347    function isRecord(value) {
2348      return !!value && typeof value === "object" && !Array.isArray(value);
2349    }
2350    function createYMapFromQuery(query, obj) {
2351      if (!isRecord(obj)) {
2352        return new import_sync10.Y.Map();
2353      }
2354      const entries = Object.entries(obj).map(
2355        ([key, val]) => {
2356          const subSchema = query[key];
2357          return [key, createYValueFromSchema(subSchema, val)];
2358        }
2359      );
2360      return new import_sync10.Y.Map(entries);
2361    }
2362    function createNewYBlock(block) {
2363      return createYMap(
2364        Object.fromEntries(
2365          Object.entries(block).map(([key, value]) => {
2366            switch (key) {
2367              case "attributes": {
2368                return [
2369                  key,
2370                  createNewYAttributeMap(block.name, value)
2371                ];
2372              }
2373              case "innerBlocks": {
2374                const innerBlocks = new import_sync10.Y.Array();
2375                if (!Array.isArray(value)) {
2376                  return [key, innerBlocks];
2377                }
2378                innerBlocks.insert(
2379                  0,
2380                  value.map(
2381                    (innerBlock) => createNewYBlock(innerBlock)
2382                  )
2383                );
2384                return [key, innerBlocks];
2385              }
2386              default:
2387                return [key, value];
2388            }
2389          })
2390        )
2391      );
2392    }
2393    function mergeCrdtBlocks(yblocks, incomingBlocks, attributeCursor, options = {}) {
2394      if (!serializableBlocksCache.has(incomingBlocks)) {
2395        serializableBlocksCache.set(
2396          incomingBlocks,
2397          makeBlocksSerializable(incomingBlocks)
2398        );
2399      }
2400      const incomingBlocksToSync = serializableBlocksCache.get(incomingBlocks) ?? [];
2401      const numOfCommonEntries = Math.min(
2402        incomingBlocksToSync.length ?? 0,
2403        yblocks.length
2404      );
2405      let left = 0;
2406      let right = 0;
2407      for (; left < numOfCommonEntries && areBlocksEqual(incomingBlocksToSync[left], yblocks.get(left)); left++) {
2408      }
2409      for (; right < numOfCommonEntries - left && areBlocksEqual(
2410        incomingBlocksToSync[incomingBlocksToSync.length - right - 1],
2411        yblocks.get(yblocks.length - right - 1)
2412      ); right++) {
2413      }
2414      const numOfUpdatesNeeded = numOfCommonEntries - left - right;
2415      const numOfInsertionsNeeded = Math.max(
2416        0,
2417        incomingBlocksToSync.length - yblocks.length
2418      );
2419      const numOfDeletionsNeeded = Math.max(
2420        0,
2421        yblocks.length - incomingBlocksToSync.length
2422      );
2423      for (let i = 0; i < numOfUpdatesNeeded; i++, left++) {
2424        const incomingYBlock = incomingBlocksToSync[left];
2425        const localYBlock = yblocks.get(left);
2426        Object.entries(incomingYBlock).forEach(
2427          ([incomingBlockProperty, incomingBlockPropertyValue]) => {
2428            switch (incomingBlockProperty) {
2429              case "attributes": {
2430                const localAttributes = localYBlock.get(
2431                  incomingBlockProperty
2432                );
2433                const incomingAttributes = incomingBlockPropertyValue;
2434                if (!localAttributes) {
2435                  localYBlock.set(
2436                    incomingBlockProperty,
2437                    createNewYAttributeMap(
2438                      incomingYBlock.name,
2439                      incomingAttributes
2440                    )
2441                  );
2442                  break;
2443                }
2444                Object.entries(incomingAttributes).forEach(
2445                  ([
2446                    incomingAttributeName,
2447                    incomingAttributeValue
2448                  ]) => {
2449                    const currentAttribute = localAttributes?.get(
2450                      incomingAttributeName
2451                    );
2452                    const isExpectedType = isExpectedAttributeType(
2453                      incomingYBlock.name,
2454                      incomingAttributeName,
2455                      currentAttribute
2456                    );
2457                    const isYType = currentAttribute instanceof import_sync10.Y.AbstractType;
2458                    const isAttributeChanged = !isExpectedType || isYType || !(0, import_es63.default)(
2459                      currentAttribute,
2460                      incomingAttributeValue
2461                    );
2462                    if (isAttributeChanged) {
2463                      updateYBlockAttribute(
2464                        incomingYBlock.name,
2465                        incomingYBlock.clientId,
2466                        incomingAttributeName,
2467                        incomingAttributeValue,
2468                        localAttributes,
2469                        attributeCursor
2470                      );
2471                    }
2472                  }
2473                );
2474                localAttributes.forEach(
2475                  (_attrValue, attrName) => {
2476                    if (!incomingBlockPropertyValue.hasOwnProperty(
2477                      attrName
2478                    )) {
2479                      localAttributes.delete(attrName);
2480                    }
2481                  }
2482                );
2483                break;
2484              }
2485              case "innerBlocks": {
2486                let yInnerBlocks = localYBlock.get(
2487                  incomingBlockProperty
2488                );
2489                if (!(yInnerBlocks instanceof import_sync10.Y.Array)) {
2490                  yInnerBlocks = new import_sync10.Y.Array();
2491                  localYBlock.set(
2492                    incomingBlockProperty,
2493                    yInnerBlocks
2494                  );
2495                }
2496                mergeCrdtBlocks(
2497                  yInnerBlocks,
2498                  incomingBlockPropertyValue ?? [],
2499                  attributeCursor,
2500                  options
2501                );
2502                break;
2503              }
2504              case "clientId": {
2505                if (options.preserveClientIds) {
2506                  break;
2507                }
2508                if (incomingBlockPropertyValue !== localYBlock.get(incomingBlockProperty)) {
2509                  localYBlock.set(
2510                    incomingBlockProperty,
2511                    incomingBlockPropertyValue
2512                  );
2513                }
2514                break;
2515              }
2516              default:
2517                if (!(0, import_es63.default)(
2518                  incomingYBlock[incomingBlockProperty],
2519                  localYBlock.get(incomingBlockProperty)
2520                )) {
2521                  localYBlock.set(
2522                    incomingBlockProperty,
2523                    incomingBlockPropertyValue
2524                  );
2525                }
2526            }
2527          }
2528        );
2529        localYBlock.forEach((_v, k) => {
2530          if (!incomingYBlock.hasOwnProperty(k)) {
2531            localYBlock.delete(k);
2532          }
2533        });
2534      }
2535      yblocks.delete(left, numOfDeletionsNeeded);
2536      for (let i = 0; i < numOfInsertionsNeeded; i++, left++) {
2537        const newBlock = [createNewYBlock(incomingBlocksToSync[left])];
2538        yblocks.insert(left, newBlock);
2539      }
2540      const knownClientIds = /* @__PURE__ */ new Set();
2541      for (let j = 0; j < yblocks.length; j++) {
2542        const yblock = yblocks.get(j);
2543        let clientId = yblock.get("clientId");
2544        if (!clientId) {
2545          continue;
2546        }
2547        if (knownClientIds.has(clientId)) {
2548          clientId = v4_default();
2549          yblock.set("clientId", clientId);
2550        }
2551        knownClientIds.add(clientId);
2552      }
2553    }
2554    function areArrayElementsEqual(newElement, yElement) {
2555      if (yElement instanceof import_sync10.Y.Map && isRecord(newElement)) {
2556        return (0, import_es63.default)(newElement, yElement.toJSON());
2557      }
2558      return (0, import_es63.default)(newElement, yElement);
2559    }
2560    function mergeYArray(yArray, newValue, schema, cursorPosition, cursorScope) {
2561      if (!schema.query) {
2562        return;
2563      }
2564      const query = schema.query;
2565      const numOfCommonEntries = Math.min(newValue.length, yArray.length);
2566      let left = 0;
2567      let right = 0;
2568      for (; left < numOfCommonEntries && areArrayElementsEqual(newValue[left], yArray.get(left)); left++) {
2569      }
2570      for (; right < numOfCommonEntries - left && areArrayElementsEqual(
2571        newValue[newValue.length - right - 1],
2572        yArray.get(yArray.length - right - 1)
2573      ); right++) {
2574      }
2575      const numOfUpdatesNeeded = numOfCommonEntries - left - right;
2576      for (let i = 0; i < numOfUpdatesNeeded; i++) {
2577        const currentElement = yArray.get(left + i);
2578        const newElement = newValue[left + i];
2579        if (currentElement instanceof import_sync10.Y.Map && isRecord(newElement)) {
2580          mergeYMapValues(
2581            currentElement,
2582            newElement,
2583            query,
2584            cursorPosition,
2585            cursorScope
2586          );
2587        } else {
2588          yArray.delete(0, yArray.length);
2589          yArray.insert(
2590            0,
2591            newValue.map((item) => createYMapFromQuery(query, item))
2592          );
2593          return;
2594        }
2595      }
2596      const numOfDeletionsNeeded = Math.max(0, yArray.length - newValue.length);
2597      if (numOfDeletionsNeeded > 0) {
2598        yArray.delete(left + numOfUpdatesNeeded, numOfDeletionsNeeded);
2599      }
2600      const numOfInsertionsNeeded = Math.max(
2601        0,
2602        newValue.length - yArray.length
2603      );
2604      if (numOfInsertionsNeeded > 0) {
2605        const insertAt = left + numOfUpdatesNeeded;
2606        const itemsToInsert = new Array(
2607          numOfInsertionsNeeded
2608        );
2609        for (let i = 0; i < numOfInsertionsNeeded; i++) {
2610          itemsToInsert[i] = createYMapFromQuery(
2611            query,
2612            newValue[insertAt + i]
2613          );
2614        }
2615        yArray.insert(insertAt, itemsToInsert);
2616      }
2617    }
2618    function mergeYValue(schema, newVal, yMap, key, cursorPosition, cursorScope) {
2619      const currentVal = yMap.get(key);
2620      if (schema?.type === "rich-text" && typeof newVal === "string" && currentVal instanceof import_sync10.Y.Text) {
2621        mergeRichTextUpdate(
2622          currentVal,
2623          newVal,
2624          resolveRichTextCursorPosition(cursorPosition, cursorScope, newVal)
2625        );
2626      } else if (schema?.type === "array" && schema.query && Array.isArray(newVal) && currentVal instanceof import_sync10.Y.Array) {
2627        mergeYArray(currentVal, newVal, schema, cursorPosition, cursorScope);
2628      } else if (schema?.type === "object" && schema.query && isRecord(newVal) && currentVal instanceof import_sync10.Y.Map) {
2629        mergeYMapValues(
2630          currentVal,
2631          newVal,
2632          schema.query,
2633          cursorPosition,
2634          cursorScope
2635        );
2636      } else {
2637        const newYValue = createYValueFromSchema(schema, newVal);
2638        if (newYValue !== newVal || !(0, import_es63.default)(currentVal, newVal)) {
2639          yMap.set(key, newYValue);
2640        }
2641      }
2642    }
2643    function mergeYMapValues(yMap, newObj, query, cursorPosition, cursorScope) {
2644      for (const [key, newVal] of Object.entries(newObj)) {
2645        mergeYValue(
2646          query[key],
2647          newVal,
2648          yMap,
2649          key,
2650          cursorPosition,
2651          cursorScope
2652        );
2653      }
2654      for (const key of yMap.keys()) {
2655        if (!Object.hasOwn(newObj, key)) {
2656          yMap.delete(key);
2657        }
2658      }
2659    }
2660    function updateYBlockAttribute(blockName, clientId, attributeName, attributeValue, currentAttributes, newCursorPosition) {
2661      const schema = getBlockAttributeSchema(blockName, attributeName);
2662      mergeYValue(
2663        schema,
2664        attributeValue,
2665        currentAttributes,
2666        attributeName,
2667        newCursorPosition,
2668        { attributeKey: attributeName, clientId }
2669      );
2670    }
2671    function resolveRichTextCursorPosition(cursorPosition, cursorScope, updatedValue) {
2672      return cursorPosition && cursorPosition.clientId === cursorScope.clientId && cursorPosition.attributeKey === cursorScope.attributeKey && "number" === typeof cursorPosition.offset && Number.isInteger(cursorPosition.offset) ? richTextOffsetToHtmlIndex(
2673        updatedValue,
2674        asRichTextOffset(cursorPosition.offset)
2675      ) : null;
2676    }
2677    var cachedBlockAttributeSchemas;
2678    function getBlockAttributeSchema(blockName, attributeName) {
2679      if (!cachedBlockAttributeSchemas) {
2680        cachedBlockAttributeSchemas = /* @__PURE__ */ new Map();
2681        for (const blockType of (0, import_blocks.getBlockTypes)()) {
2682          cachedBlockAttributeSchemas.set(
2683            blockType.name,
2684            new Map(
2685              Object.entries(blockType.attributes ?? {}).map(
2686                ([name, definition]) => {
2687                  const { role, type, query } = definition;
2688                  return [name, { role, type, query }];
2689                }
2690              )
2691            )
2692          );
2693        }
2694      }
2695      return cachedBlockAttributeSchemas.get(blockName)?.get(attributeName);
2696    }
2697    function isExpectedAttributeType(blockName, attributeName, attributeValue) {
2698      const schema = getBlockAttributeSchema(blockName, attributeName);
2699      if (schema?.type === "rich-text") {
2700        return attributeValue instanceof import_sync10.Y.Text;
2701      }
2702      if (schema?.type === "string") {
2703        return typeof attributeValue === "string";
2704      }
2705      if (schema?.type === "array" && schema.query) {
2706        return attributeValue instanceof import_sync10.Y.Array;
2707      }
2708      if (schema?.type === "object" && schema.query) {
2709        return attributeValue instanceof import_sync10.Y.Map;
2710      }
2711      return true;
2712    }
2713    function isLocalAttribute(blockName, attributeName) {
2714      return "local" === getBlockAttributeSchema(blockName, attributeName)?.role;
2715    }
2716    var localDoc;
2717    function mergeRichTextUpdate(blockYText, updatedValue, htmlCursorIndex = null) {
2718      const currentValueAsDelta = new Delta(blockYText.toDelta());
2719      const updatedValueAsDelta = new Delta([{ insert: updatedValue }]);
2720      const deltaDiff = currentValueAsDelta.diffWithCursor(
2721        updatedValueAsDelta,
2722        htmlCursorIndex
2723      );
2724      const safeDiff = htmlCursorIndex === null || isDeltaVerificationMatch(blockYText, deltaDiff, updatedValue) ? deltaDiff : currentValueAsDelta.diff(updatedValueAsDelta);
2725      blockYText.applyDelta(safeDiff.ops);
2726    }
2727    function isDeltaVerificationMatch(blockYText, delta, expectedValue) {
2728      if (!localDoc) {
2729        localDoc = new import_sync10.Y.Doc();
2730      }
2731      const verificationYText = localDoc.getText("verification-text");
2732      verificationYText.delete(0, verificationYText.length);
2733      verificationYText.insert(0, blockYText.toString());
2734      verificationYText.applyDelta(delta.ops);
2735      return verificationYText.toString() === expectedValue;
2736    }
2737  
2738    // packages/core-data/build-module/utils/crdt-selection.mjs
2739    var import_data5 = __toESM(require_data(), 1);
2740    var import_block_editor4 = __toESM(require_block_editor(), 1);
2741    var import_blocks2 = __toESM(require_blocks(), 1);
2742    var import_sync13 = __toESM(require_sync(), 1);
2743  
2744    // packages/core-data/build-module/utils/block-selection-history.mjs
2745    var import_sync12 = __toESM(require_sync(), 1);
2746    var SELECTION_HISTORY_DEFAULT_SIZE = 5;
2747    var YSelectionType = /* @__PURE__ */ ((YSelectionType2) => {
2748      YSelectionType2["RelativeSelection"] = "RelativeSelection";
2749      YSelectionType2["BlockSelection"] = "BlockSelection";
2750      return YSelectionType2;
2751    })(YSelectionType || {});
2752    function createBlockSelectionHistory(ydoc, historySize = SELECTION_HISTORY_DEFAULT_SIZE) {
2753      let history = [];
2754      const getSelectionHistory2 = () => {
2755        return history.slice(0);
2756      };
2757      const updateSelection = (newSelection) => {
2758        if (!newSelection?.selectionStart?.clientId || !newSelection?.selectionEnd?.clientId) {
2759          return;
2760        }
2761        const { selectionStart, selectionEnd } = newSelection;
2762        const start = convertWPBlockSelectionToSelection(
2763          selectionStart,
2764          ydoc
2765        );
2766        const end = convertWPBlockSelectionToSelection(selectionEnd, ydoc);
2767        addToHistory({ start, end });
2768      };
2769      const addToHistory = (yFullSelection) => {
2770        const startClientId = yFullSelection.start.clientId;
2771        const endClientId = yFullSelection.end.clientId;
2772        history = history.filter((entry) => {
2773          const isSameBlockCombination = entry.start.clientId === startClientId && entry.end.clientId === endClientId;
2774          return !isSameBlockCombination;
2775        });
2776        history.unshift(yFullSelection);
2777        if (history.length > historySize + 1) {
2778          history = history.slice(0, historySize + 1);
2779        }
2780      };
2781      return {
2782        getSelectionHistory: getSelectionHistory2,
2783        updateSelection
2784      };
2785    }
2786    function convertWPBlockSelectionToSelection(selection, ydoc) {
2787      const clientId = selection.clientId;
2788      const block = findBlockByClientIdInDoc(clientId, ydoc);
2789      const attributes = block?.get("attributes");
2790      const attributeKey = selection.attributeKey;
2791      let changedYText = null;
2792      if (attributeKey && attributes) {
2793        changedYText = getYTextByAttributeKey(attributes, attributeKey);
2794      }
2795      if (!(changedYText instanceof import_sync12.Y.Text) || !attributeKey || !clientId) {
2796        return {
2797          type: "BlockSelection",
2798          clientId
2799        };
2800      }
2801      const offset = selection.offset ?? 0;
2802      const relativePosition = import_sync12.Y.createRelativePositionFromTypeIndex(
2803        changedYText,
2804        richTextOffsetToHtmlIndex(
2805          changedYText.toString(),
2806          asRichTextOffset(offset)
2807        )
2808      );
2809      return {
2810        type: "RelativeSelection",
2811        attributeKey,
2812        relativePosition,
2813        clientId,
2814        offset
2815      };
2816    }
2817  
2818    // packages/core-data/build-module/utils/crdt-selection.mjs
2819    var selectionHistoryMap = /* @__PURE__ */ new WeakMap();
2820    function getBlockSelectionHistory(ydoc) {
2821      let history = selectionHistoryMap.get(ydoc);
2822      if (!history) {
2823        history = createBlockSelectionHistory(ydoc);
2824        selectionHistoryMap.set(ydoc, history);
2825      }
2826      return history;
2827    }
2828    function getSelectionHistory(ydoc) {
2829      return getBlockSelectionHistory(ydoc).getSelectionHistory();
2830    }
2831    function updateSelectionHistory(ydoc, wpSelection) {
2832      return getBlockSelectionHistory(ydoc).updateSelection(wpSelection);
2833    }
2834    function convertYSelectionToBlockSelection(ySelection, ydoc) {
2835      if (ySelection.type === YSelectionType.RelativeSelection) {
2836        const { relativePosition, attributeKey, clientId } = ySelection;
2837        const absolutePosition = import_sync13.Y.createAbsolutePositionFromRelativePosition(
2838          relativePosition,
2839          ydoc
2840        );
2841        if (absolutePosition) {
2842          return {
2843            clientId,
2844            attributeKey,
2845            offset: htmlIndexToRichTextOffset(
2846              absolutePosition.type.toString(),
2847              asHtmlStringIndex(absolutePosition.index)
2848            )
2849          };
2850        }
2851      } else if (ySelection.type === YSelectionType.BlockSelection) {
2852        return {
2853          clientId: ySelection.clientId,
2854          attributeKey: void 0,
2855          offset: void 0
2856        };
2857      }
2858      return null;
2859    }
2860    function convertYFullSelectionToWPSelection(yFullSelection, ydoc) {
2861      const { start, end } = yFullSelection;
2862      const startBlock = findBlockByClientIdInDoc(start.clientId, ydoc);
2863      const endBlock = findBlockByClientIdInDoc(end.clientId, ydoc);
2864      if (!startBlock || !endBlock) {
2865        return null;
2866      }
2867      const startBlockSelection = convertYSelectionToBlockSelection(
2868        start,
2869        ydoc
2870      );
2871      const endBlockSelection = convertYSelectionToBlockSelection(end, ydoc);
2872      if (startBlockSelection === null || endBlockSelection === null) {
2873        return null;
2874      }
2875      return {
2876        selectionStart: startBlockSelection,
2877        selectionEnd: endBlockSelection
2878      };
2879    }
2880    function findSelectionFromHistory(ydoc, selectionHistory) {
2881      for (const positionToTry of selectionHistory) {
2882        const result = convertYFullSelectionToWPSelection(
2883          positionToTry,
2884          ydoc
2885        );
2886        if (result !== null) {
2887          return result;
2888        }
2889      }
2890      return null;
2891    }
2892    function restoreSelection(selectionHistory, ydoc) {
2893      const selectionToRestore = findSelectionFromHistory(
2894        ydoc,
2895        selectionHistory
2896      );
2897      if (selectionToRestore === null) {
2898        return;
2899      }
2900      const { getBlock } = (0, import_data5.select)(import_block_editor4.store);
2901      const { resetSelection } = (0, import_data5.dispatch)(import_block_editor4.store);
2902      const { selectionStart, selectionEnd } = selectionToRestore;
2903      const isSelectionInSameBlock = selectionStart.clientId === selectionEnd.clientId;
2904      if (isSelectionInSameBlock) {
2905        const block = getBlock(selectionStart.clientId);
2906        const isBlockEmpty = block && (0, import_blocks2.isUnmodifiedBlock)(block);
2907        const isBeginningOfEmptyBlock = 0 === selectionStart.offset && 0 === selectionEnd.offset && isBlockEmpty && !selectionStart.attributeKey && !selectionEnd.attributeKey;
2908        if (isBeginningOfEmptyBlock) {
2909          const selectionStartWithoutOffset = {
2910            clientId: selectionStart.clientId
2911          };
2912          const selectionEndWithoutOffset = {
2913            clientId: selectionEnd.clientId
2914          };
2915          resetSelection(
2916            selectionStartWithoutOffset,
2917            selectionEndWithoutOffset,
2918            0
2919          );
2920        } else {
2921          resetSelection(selectionStart, selectionEnd, 0);
2922        }
2923      } else {
2924        resetSelection(selectionEnd, selectionEnd, 0);
2925      }
2926    }
2927    function getShiftedSelection(ydoc, selectionHistory) {
2928      if (selectionHistory.length === 0) {
2929        return null;
2930      }
2931      const { start, end } = selectionHistory[0];
2932      if (start.type === YSelectionType.BlockSelection || end.type === YSelectionType.BlockSelection) {
2933        return null;
2934      }
2935      const selectionStart = convertYSelectionToBlockSelection(start, ydoc);
2936      const selectionEnd = convertYSelectionToBlockSelection(end, ydoc);
2937      if (!selectionStart || !selectionEnd) {
2938        return null;
2939      }
2940      const startShifted = selectionStart.offset !== start.offset;
2941      const endShifted = selectionEnd.offset !== end.offset;
2942      if (!startShifted && !endShifted) {
2943        return null;
2944      }
2945      return { selectionStart, selectionEnd };
2946    }
2947  
2948    // packages/core-data/build-module/utils/crdt.mjs
2949    var POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE = "_crdt_document";
2950    var disallowedPostMetaKeys = /* @__PURE__ */ new Set([
2951      POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE
2952    ]);
2953    function defaultApplyChangesToCRDTDoc(ydoc, changes) {
2954      const ymap = getRootMap(ydoc, CRDT_RECORD_MAP_KEY);
2955      Object.entries(changes).forEach(([key, newValue]) => {
2956        if ("function" === typeof newValue) {
2957          return;
2958        }
2959        switch (key) {
2960          // Add support for additional data types here.
2961          default: {
2962            const currentValue = ymap.get(key);
2963            updateMapValue(ymap, key, currentValue, newValue);
2964          }
2965        }
2966      });
2967    }
2968    function applyPostChangesToCRDTDoc(ydoc, changes, syncedProperties) {
2969      const ymap = getRootMap(ydoc, CRDT_RECORD_MAP_KEY);
2970      Object.keys(changes).forEach((key) => {
2971        if (!syncedProperties.has(key)) {
2972          return;
2973        }
2974        const newValue = changes[key];
2975        if ("function" === typeof newValue) {
2976          return;
2977        }
2978        switch (key) {
2979          case "blocks": {
2980            const newCursorPosition = parseCursorSelection(
2981              changes.selection
2982            );
2983            const rawContent = getRawValue(changes.content);
2984            if (!newValue && typeof rawContent === "string") {
2985              mergeContentWithoutBlocks(
2986                ymap,
2987                rawContent,
2988                newCursorPosition
2989              );
2990              break;
2991            } else if (!newValue) {
2992              ymap.set(key, void 0);
2993              break;
2994            }
2995            let currentBlocks = ymap.get(key);
2996            if (!(currentBlocks instanceof import_sync14.Y.Array)) {
2997              currentBlocks = new import_sync14.Y.Array();
2998              ymap.set(key, currentBlocks);
2999            }
3000            mergeCrdtBlocks(currentBlocks, newValue, newCursorPosition);
3001            break;
3002          }
3003          case "content":
3004          case "excerpt":
3005          case "title": {
3006            const currentValue = ymap.get(key);
3007            let rawValue = getRawValue(newValue);
3008            if (key === "title" && !currentValue?.toString() && "Auto Draft" === rawValue) {
3009              rawValue = "";
3010            }
3011            if (currentValue instanceof import_sync14.Y.Text) {
3012              mergeRichTextUpdate(currentValue, rawValue ?? "");
3013            } else {
3014              const newYText = new import_sync14.Y.Text(rawValue ?? "");
3015              ymap.set(key, newYText);
3016            }
3017            break;
3018          }
3019          // "Meta" is overloaded term; here, it refers to post meta.
3020          case "meta": {
3021            let metaMap = ymap.get("meta");
3022            if (!isYMap(metaMap)) {
3023              metaMap = createYMap();
3024              ymap.set("meta", metaMap);
3025            }
3026            Object.entries(newValue ?? {}).forEach(
3027              ([metaKey, metaValue]) => {
3028                if (disallowedPostMetaKeys.has(metaKey)) {
3029                  return;
3030                }
3031                updateMapValue(
3032                  metaMap,
3033                  metaKey,
3034                  metaMap.get(metaKey),
3035                  // current value in CRDT
3036                  metaValue
3037                  // new value from changes
3038                );
3039              }
3040            );
3041            break;
3042          }
3043          case "slug": {
3044            if (!newValue) {
3045              break;
3046            }
3047            const currentValue = ymap.get(key);
3048            updateMapValue(ymap, key, currentValue, newValue);
3049            break;
3050          }
3051          // Add support for additional properties here.
3052          default: {
3053            const currentValue = ymap.get(key);
3054            updateMapValue(ymap, key, currentValue, newValue);
3055          }
3056        }
3057      });
3058      if (changes.selection) {
3059        const selection = changes.selection;
3060        setTimeout(() => {
3061          updateSelectionHistory(ydoc, selection);
3062        }, 0);
3063      }
3064    }
3065    function mergeContentWithoutBlocks(ymap, rawContent, cursorPosition) {
3066      let currentBlocks = ymap.get("blocks");
3067      if (!(currentBlocks instanceof import_sync14.Y.Array)) {
3068        currentBlocks = new import_sync14.Y.Array();
3069        ymap.set("blocks", currentBlocks);
3070      }
3071      mergeCrdtBlocks(
3072        currentBlocks,
3073        (0, import_blocks3.parse)(rawContent),
3074        cursorPosition,
3075        { preserveClientIds: true }
3076      );
3077    }
3078    function parseCursorSelection(selection) {
3079      const selectionStart = selection?.selectionStart;
3080      return selectionStart?.clientId && selectionStart.attributeKey && "number" === typeof selectionStart.offset && Number.isInteger(selectionStart.offset) ? {
3081        attributeKey: selectionStart.attributeKey,
3082        clientId: selectionStart.clientId,
3083        offset: asRichTextOffset(selectionStart.offset)
3084      } : null;
3085    }
3086    function defaultGetChangesFromCRDTDoc(crdtDoc, editedRecord) {
3087      const docRecord = getRootMap(crdtDoc, CRDT_RECORD_MAP_KEY).toJSON();
3088      return Object.fromEntries(
3089        Object.entries(docRecord).filter(
3090          ([key, newValue]) => haveValuesChanged(editedRecord?.[key], newValue)
3091        )
3092      );
3093    }
3094    function getPostChangesFromCRDTDoc(ydoc, editedRecord, syncedProperties) {
3095      const ymap = getRootMap(ydoc, CRDT_RECORD_MAP_KEY);
3096      let allowedMetaChanges = {};
3097      const changes = Object.fromEntries(
3098        Object.entries(ymap.toJSON()).filter(([key, newValue]) => {
3099          if (!syncedProperties.has(key)) {
3100            return false;
3101          }
3102          const currentValue = editedRecord[key];
3103          switch (key) {
3104            case "blocks": {
3105              if (ydoc.meta?.get(CRDT_DOC_META_PERSISTENCE_KEY) && editedRecord.content) {
3106                const blocksJson = ymap.get("blocks")?.toJSON() ?? [];
3107                return (0, import_blocks3.__unstableSerializeAndClean)(blocksJson).trim() !== getRawValue(editedRecord.content);
3108              }
3109              return true;
3110            }
3111            case "date": {
3112              const currentDateIsFloating = null === currentValue || editedRecord.modified === currentValue;
3113              if (currentDateIsFloating) {
3114                return false;
3115              }
3116              return haveValuesChanged(currentValue, newValue);
3117            }
3118            case "meta": {
3119              const currentMeta = currentValue ?? {};
3120              allowedMetaChanges = Object.fromEntries(
3121                Object.entries(newValue ?? {}).filter(
3122                  ([metaKey]) => {
3123                    if (disallowedPostMetaKeys.has(metaKey)) {
3124                      return false;
3125                    }
3126                    return metaKey in currentMeta;
3127                  }
3128                )
3129              );
3130              const mergedValue = {
3131                ...currentMeta,
3132                ...allowedMetaChanges
3133              };
3134              return haveValuesChanged(currentValue, mergedValue);
3135            }
3136            case "status": {
3137              if ("auto-draft" === newValue) {
3138                return false;
3139              }
3140              return haveValuesChanged(currentValue, newValue);
3141            }
3142            case "content":
3143            case "excerpt":
3144            case "title": {
3145              return haveValuesChanged(
3146                getRawValue(currentValue),
3147                newValue
3148              );
3149            }
3150            // Add support for additional data types here.
3151            default: {
3152              return haveValuesChanged(currentValue, newValue);
3153            }
3154          }
3155        })
3156      );
3157      if (changes.blocks) {
3158        changes.blocks = deserializeBlockAttributes(
3159          changes.blocks
3160        );
3161      }
3162      if (changes.blocks && !changes.content) {
3163        const capturedBlocks = changes.blocks;
3164        changes.content = () => (0, import_blocks3.__unstableSerializeAndClean)(capturedBlocks);
3165      }
3166      if ("object" === typeof changes.meta) {
3167        changes.meta = {
3168          ...editedRecord.meta,
3169          ...allowedMetaChanges
3170        };
3171      }
3172      const selectionHistory = getSelectionHistory(ydoc);
3173      const shiftedSelection = getShiftedSelection(ydoc, selectionHistory);
3174      if (shiftedSelection) {
3175        changes.selection = {
3176          ...shiftedSelection,
3177          initialPosition: 0
3178        };
3179      }
3180      return changes;
3181    }
3182    var defaultSyncConfig = {
3183      applyChangesToCRDTDoc: defaultApplyChangesToCRDTDoc,
3184      createAwareness: (ydoc) => new BaseAwareness(ydoc),
3185      getChangesFromCRDTDoc: defaultGetChangesFromCRDTDoc
3186    };
3187    var defaultCollectionSyncConfig = {
3188      applyChangesToCRDTDoc: () => {
3189      },
3190      getChangesFromCRDTDoc: () => ({}),
3191      shouldSync: (_, objectId) => null === objectId
3192    };
3193    function getRawValue(value) {
3194      if ("string" === typeof value) {
3195        return value;
3196      }
3197      if (value && "object" === typeof value && "raw" in value && "string" === typeof value.raw) {
3198        return value.raw;
3199      }
3200      return void 0;
3201    }
3202    function haveValuesChanged(currentValue, newValue) {
3203      return !(0, import_es64.default)(currentValue, newValue);
3204    }
3205    function updateMapValue(map, key, currentValue, newValue) {
3206      if (void 0 === newValue) {
3207        map.delete(key);
3208        return;
3209      }
3210      if (haveValuesChanged(currentValue, newValue)) {
3211        map.set(key, newValue);
3212      }
3213    }
3214  
3215    // packages/core-data/build-module/entities.mjs
3216    var DEFAULT_ENTITY_KEY = "id";
3217    var POST_RAW_ATTRIBUTES = ["title", "excerpt", "content"];
3218    var blocksTransientEdits = {
3219      blocks: {
3220        read: (record) => (0, import_blocks4.parse)(record.content?.raw ?? ""),
3221        write: (record) => ({
3222          content: (0, import_blocks4.__unstableSerializeAndClean)(record.blocks)
3223        })
3224      }
3225    };
3226    var rootEntitiesConfig = [
3227      {
3228        label: (0, import_i18n.__)("Base"),
3229        kind: "root",
3230        key: false,
3231        name: "__unstableBase",
3232        baseURL: "/",
3233        baseURLParams: {
3234          // Please also change the preload path when changing this.
3235          // @see lib/compat/wordpress-7.1/preload.php
3236          _fields: [
3237            "description",
3238            "gmt_offset",
3239            "home",
3240            "image_max_bit_depth",
3241            "image_sizes",
3242            "image_size_threshold",
3243            "image_strip_meta",
3244            "name",
3245            "site_icon",
3246            "site_icon_url",
3247            "site_logo",
3248            "timezone_string",
3249            "url",
3250            "page_for_posts",
3251            "page_on_front",
3252            "show_on_front"
3253          ].join(",")
3254        },
3255        // The entity doesn't support selecting multiple records.
3256        // The property is maintained for backward compatibility.
3257        plural: "__unstableBases",
3258        supportsPagination: false
3259      },
3260      {
3261        label: (0, import_i18n.__)("Post Type"),
3262        name: "postType",
3263        kind: "root",
3264        key: "slug",
3265        baseURL: "/wp/v2/types",
3266        baseURLParams: { context: "edit" },
3267        plural: "postTypes",
3268        supportsPagination: false
3269      },
3270      {
3271        name: "media",
3272        kind: "root",
3273        baseURL: "/wp/v2/media",
3274        baseURLParams: { context: "edit" },
3275        plural: "mediaItems",
3276        label: (0, import_i18n.__)("Media"),
3277        rawAttributes: ["caption", "title", "description"],
3278        supportsPagination: true
3279      },
3280      {
3281        name: "taxonomy",
3282        kind: "root",
3283        key: "slug",
3284        baseURL: "/wp/v2/taxonomies",
3285        baseURLParams: { context: "edit" },
3286        plural: "taxonomies",
3287        label: (0, import_i18n.__)("Taxonomy"),
3288        supportsPagination: false
3289      },
3290      {
3291        name: "sidebar",
3292        kind: "root",
3293        baseURL: "/wp/v2/sidebars",
3294        baseURLParams: { context: "edit" },
3295        plural: "sidebars",
3296        transientEdits: { blocks: true },
3297        label: (0, import_i18n.__)("Widget areas"),
3298        supportsPagination: false
3299      },
3300      {
3301        name: "widget",
3302        kind: "root",
3303        baseURL: "/wp/v2/widgets",
3304        baseURLParams: { context: "edit" },
3305        plural: "widgets",
3306        transientEdits: { blocks: true },
3307        label: (0, import_i18n.__)("Widgets"),
3308        supportsPagination: false
3309      },
3310      {
3311        name: "widgetType",
3312        kind: "root",
3313        baseURL: "/wp/v2/widget-types",
3314        baseURLParams: { context: "edit" },
3315        plural: "widgetTypes",
3316        label: (0, import_i18n.__)("Widget types"),
3317        supportsPagination: false
3318      },
3319      {
3320        label: (0, import_i18n.__)("User"),
3321        name: "user",
3322        kind: "root",
3323        baseURL: "/wp/v2/users",
3324        getTitle: (record) => record?.name || record?.slug,
3325        baseURLParams: { context: "edit" },
3326        plural: "users",
3327        supportsPagination: true
3328      },
3329      {
3330        name: "comment",
3331        kind: "root",
3332        baseURL: "/wp/v2/comments",
3333        baseURLParams: { context: "edit" },
3334        plural: "comments",
3335        label: (0, import_i18n.__)("Comment"),
3336        supportsPagination: true,
3337        ...globalThis.window?.__experimentalEnableRealTimeCollaboration ? { syncConfig: defaultCollectionSyncConfig } : {}
3338      },
3339      {
3340        name: "menu",
3341        kind: "root",
3342        baseURL: "/wp/v2/menus",
3343        baseURLParams: { context: "edit" },
3344        plural: "menus",
3345        label: (0, import_i18n.__)("Menu"),
3346        supportsPagination: true
3347      },
3348      {
3349        name: "menuItem",
3350        kind: "root",
3351        baseURL: "/wp/v2/menu-items",
3352        baseURLParams: { context: "edit" },
3353        plural: "menuItems",
3354        label: (0, import_i18n.__)("Menu Item"),
3355        rawAttributes: ["title"],
3356        supportsPagination: true
3357      },
3358      {
3359        name: "menuLocation",
3360        kind: "root",
3361        baseURL: "/wp/v2/menu-locations",
3362        baseURLParams: { context: "edit" },
3363        plural: "menuLocations",
3364        label: (0, import_i18n.__)("Menu Location"),
3365        key: "name",
3366        supportsPagination: false
3367      },
3368      {
3369        label: (0, import_i18n.__)("Global Styles"),
3370        name: "globalStyles",
3371        kind: "root",
3372        baseURL: "/wp/v2/global-styles",
3373        baseURLParams: { context: "edit" },
3374        plural: "globalStylesVariations",
3375        // Should be different from name.
3376        getTitle: () => (0, import_i18n.__)("Custom Styles"),
3377        getRevisionsUrl: (parentId, revisionId) => `/wp/v2/global-styles/$parentId}/revisions$revisionId ? "/" + revisionId : ""}`,
3378        supportsPagination: true
3379      },
3380      {
3381        label: (0, import_i18n.__)("Themes"),
3382        name: "theme",
3383        kind: "root",
3384        baseURL: "/wp/v2/themes",
3385        baseURLParams: { context: "edit" },
3386        plural: "themes",
3387        key: "stylesheet",
3388        supportsPagination: false
3389      },
3390      {
3391        label: (0, import_i18n.__)("Plugins"),
3392        name: "plugin",
3393        kind: "root",
3394        baseURL: "/wp/v2/plugins",
3395        baseURLParams: { context: "edit" },
3396        plural: "plugins",
3397        key: "plugin",
3398        supportsPagination: false
3399      },
3400      {
3401        label: (0, import_i18n.__)("Status"),
3402        name: "status",
3403        kind: "root",
3404        baseURL: "/wp/v2/statuses",
3405        baseURLParams: { context: "edit" },
3406        plural: "statuses",
3407        key: "slug",
3408        supportsPagination: false
3409      },
3410      {
3411        label: (0, import_i18n.__)("Font Collections"),
3412        name: "fontCollection",
3413        kind: "root",
3414        baseURL: "/wp/v2/font-collections",
3415        baseURLParams: { context: "view" },
3416        plural: "fontCollections",
3417        key: "slug",
3418        supportsPagination: true
3419      },
3420      {
3421        label: (0, import_i18n.__)("Icons"),
3422        name: "icon",
3423        kind: "root",
3424        baseURL: "/wp/v2/icons",
3425        baseURLParams: { context: "view" },
3426        plural: "icons",
3427        key: "name",
3428        supportsPagination: false
3429      },
3430      {
3431        label: (0, import_i18n.__)("Icon Collections"),
3432        name: "iconCollection",
3433        kind: "root",
3434        baseURL: "/wp/v2/icon-collections",
3435        baseURLParams: { context: "view" },
3436        plural: "iconCollections",
3437        key: "slug",
3438        supportsPagination: false
3439      }
3440    ];
3441    var deprecatedEntities = {
3442      root: {
3443        media: {
3444          since: "6.9",
3445          alternative: {
3446            kind: "postType",
3447            name: "attachment"
3448          }
3449        }
3450      }
3451    };
3452    var additionalEntityConfigLoaders = [
3453      { kind: "postType", loadEntities: loadPostTypeEntities },
3454      { kind: "taxonomy", loadEntities: loadTaxonomyEntities },
3455      {
3456        kind: "root",
3457        name: "site",
3458        plural: "sites",
3459        loadEntities: loadSiteEntity
3460      }
3461    ];
3462    var prePersistPostType = async (persistedRecord, edits, name, isTemplate) => {
3463      const newEdits = {};
3464      if (!isTemplate && persistedRecord?.status === "auto-draft") {
3465        if (!edits.status && !newEdits.status) {
3466          newEdits.status = "draft";
3467        }
3468        if ((!edits.title || edits.title === "Auto Draft") && !newEdits.title && (!persistedRecord?.title || persistedRecord?.title === "Auto Draft")) {
3469          newEdits.title = "";
3470        }
3471      }
3472      if (window.__experimentalEnableRealTimeCollaboration && persistedRecord) {
3473        const objectType = `postType/$name}`;
3474        const objectId = persistedRecord.id;
3475        const serializedDoc = await getSyncManager()?.createPersistedCRDTDoc(
3476          objectType,
3477          objectId
3478        );
3479        if (serializedDoc) {
3480          newEdits.meta = {
3481            ...edits.meta,
3482            [POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE]: serializedDoc
3483          };
3484        }
3485      }
3486      return newEdits;
3487    };
3488    async function loadPostTypeEntities() {
3489      const postTypesPromise = (0, import_api_fetch2.default)({ path: "/wp/v2/types?context=view" });
3490      const taxonomiesPromise = window.__experimentalEnableRealTimeCollaboration ? (0, import_api_fetch2.default)({ path: "/wp/v2/taxonomies?context=view" }) : Promise.resolve({});
3491      const [postTypes, taxonomies] = await Promise.all([
3492        postTypesPromise,
3493        taxonomiesPromise
3494      ]);
3495      return Object.entries(postTypes ?? {}).map(([name, postType]) => {
3496        const isTemplate = ["wp_template", "wp_template_part"].includes(
3497          name
3498        );
3499        const namespace = postType?.rest_namespace ?? "wp/v2";
3500        const syncedProperties = /* @__PURE__ */ new Set([
3501          "author",
3502          "blocks",
3503          "content",
3504          "comment_status",
3505          "date",
3506          "excerpt",
3507          "featured_media",
3508          "format",
3509          "meta",
3510          "ping_status",
3511          "slug",
3512          "status",
3513          "sticky",
3514          "template",
3515          "title",
3516          ...postType.taxonomies?.map((taxonomy) => taxonomies?.[taxonomy]?.rest_base)?.filter(Boolean) ?? []
3517        ]);
3518        const entity2 = {
3519          kind: "postType",
3520          baseURL: `/$namespace}/$postType.rest_base}`,
3521          baseURLParams: { context: "edit" },
3522          name,
3523          label: postType.name,
3524          transientEdits: {
3525            ...blocksTransientEdits,
3526            selection: true
3527          },
3528          mergedEdits: { meta: true },
3529          rawAttributes: POST_RAW_ATTRIBUTES,
3530          getTitle: (record) => record?.title?.rendered || record?.title || (isTemplate ? capitalCase(record.slug ?? "") : String(record.id)),
3531          __unstablePrePersist: (persistedRecord, edits) => prePersistPostType(persistedRecord, edits, name, isTemplate),
3532          __unstable_rest_base: postType.rest_base,
3533          // The templates controller returns the whole collection and never
3534          // paginates.
3535          supportsPagination: !isTemplate,
3536          getRevisionsUrl: (parentId, revisionId) => `/$namespace}/$postType.rest_base}/$parentId}/revisions$revisionId ? "/" + revisionId : ""}`,
3537          revisionKey: isTemplate ? "wp_id" : DEFAULT_ENTITY_KEY
3538        };
3539        if (!window.__experimentalEnableRealTimeCollaboration) {
3540          return entity2;
3541        }
3542        entity2.syncConfig = {
3543          // Save a CRDT document with this entity
3544          supportsPersistence: true,
3545          /**
3546           * Apply changes from the local editor to the local CRDT document so
3547           * that those changes can be synced to other peers (via the provider).
3548           *
3549           * @param {import('@wordpress/sync').CRDTDoc}               crdtDoc
3550           * @param {Partial< import('@wordpress/sync').ObjectData >} changes
3551           * @return {void}
3552           */
3553          applyChangesToCRDTDoc: (crdtDoc, changes) => applyPostChangesToCRDTDoc(crdtDoc, changes, syncedProperties),
3554          /**
3555           * Create the awareness instance for the entity's CRDT document.
3556           *
3557           * @param {import('@wordpress/sync').CRDTDoc}  ydoc
3558           * @param {import('@wordpress/sync').ObjectID} objectId
3559           * @return {import('@wordpress/sync').Awareness} Awareness instance
3560           */
3561          createAwareness: (ydoc, objectId) => {
3562            const kind = "postType";
3563            const id = parseInt(objectId, 10);
3564            return new PostEditorAwareness(ydoc, kind, name, id);
3565          },
3566          /**
3567           * Extract changes from a CRDT document that can be used to update the
3568           * local editor state.
3569           *
3570           * @param {import('@wordpress/sync').CRDTDoc}    crdtDoc
3571           * @param {import('@wordpress/sync').ObjectData} editedRecord
3572           * @return {Partial< import('@wordpress/sync').ObjectData >} Changes to record
3573           */
3574          getChangesFromCRDTDoc: (crdtDoc, editedRecord) => getPostChangesFromCRDTDoc(
3575            crdtDoc,
3576            editedRecord,
3577            syncedProperties
3578          ),
3579          /**
3580           * Extract changes from a CRDT document that can be used to update the
3581           * local editor state.
3582           *
3583           * @param {import('@wordpress/sync').ObjectData} record
3584           * @return {Partial< import('@wordpress/sync').ObjectData >} Changes to record
3585           */
3586          getPersistedCRDTDoc: (record) => {
3587            return record?.meta?.[POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE] || null;
3588          },
3589          shouldSync: () => !(Array.isArray(window._wpCollaborationDisabledPostTypes) && window._wpCollaborationDisabledPostTypes.includes(name))
3590        };
3591        return entity2;
3592      });
3593    }
3594    async function loadTaxonomyEntities() {
3595      const taxonomies = await (0, import_api_fetch2.default)({
3596        path: "/wp/v2/taxonomies?context=view"
3597      });
3598      return Object.entries(taxonomies ?? {}).map(([name, taxonomy]) => {
3599        const namespace = taxonomy?.rest_namespace ?? "wp/v2";
3600        const entity2 = {
3601          kind: "taxonomy",
3602          baseURL: `/$namespace}/$taxonomy.rest_base}`,
3603          baseURLParams: { context: "edit" },
3604          name,
3605          label: taxonomy.name,
3606          getTitle: (record) => record?.name,
3607          supportsPagination: true
3608        };
3609        if (window.__experimentalEnableRealTimeCollaboration) {
3610          entity2.syncConfig = defaultSyncConfig;
3611        }
3612        return entity2;
3613      });
3614    }
3615    async function loadSiteEntity() {
3616      const entity2 = {
3617        label: (0, import_i18n.__)("Site"),
3618        name: "site",
3619        kind: "root",
3620        key: false,
3621        baseURL: "/wp/v2/settings",
3622        supportsPagination: false,
3623        meta: {}
3624      };
3625      const site = await (0, import_api_fetch2.default)({
3626        path: entity2.baseURL,
3627        method: "OPTIONS"
3628      });
3629      const labels = {};
3630      Object.entries(site?.schema?.properties ?? {}).forEach(
3631        ([key, value]) => {
3632          if (typeof value === "object" && value.title) {
3633            labels[key] = value.title;
3634          }
3635        }
3636      );
3637      return [{ ...entity2, meta: { labels } }];
3638    }
3639    var getMethodName = (kind, name, prefix = "get") => {
3640      const kindPrefix = kind === "root" ? "" : pascalCase(kind);
3641      const suffix = pascalCase(name);
3642      return `$prefix}$kindPrefix}$suffix}`;
3643    };
3644  
3645    // packages/core-data/build-module/queried-data/reducer.mjs
3646    function getContextFromAction(action) {
3647      const { query } = action;
3648      if (!query) {
3649        return "default";
3650      }
3651      const queryParts = get_query_parts_default(query);
3652      return queryParts.context;
3653    }
3654    function getMergedItemIds(itemIds = [], nextItemIds, { page = 1, offset, perPage = 10 } = {}) {
3655      if (perPage === -1) {
3656        return nextItemIds;
3657      }
3658      const nextItemIdsStartIndex = offset ?? (page - 1) * perPage;
3659      const nextItemIdsRange = Math.max(perPage, nextItemIds.length);
3660      const size = Math.max(
3661        itemIds.length,
3662        nextItemIdsStartIndex + nextItemIds.length
3663      );
3664      const mergedItemIds = new Array(size);
3665      for (let i = 0; i < size; i++) {
3666        const isInNextItemsRange = i >= nextItemIdsStartIndex && i < nextItemIdsStartIndex + nextItemIdsRange;
3667        if (isInNextItemsRange) {
3668          mergedItemIds[i] = nextItemIds[i - nextItemIdsStartIndex];
3669        } else {
3670          mergedItemIds[i] = itemIds[i];
3671        }
3672      }
3673      return mergedItemIds;
3674    }
3675    function removeEntitiesById(entities2, ids) {
3676      return Object.fromEntries(
3677        Object.entries(entities2).filter(
3678          ([id]) => !ids.some((itemId) => {
3679            if (Number.isInteger(itemId)) {
3680              return itemId === +id;
3681            }
3682            return itemId === id;
3683          })
3684        )
3685      );
3686    }
3687    function items(state = {}, action) {
3688      switch (action.type) {
3689        case "RECEIVE_ITEMS": {
3690          const context = getContextFromAction(action);
3691          const key = action.key || DEFAULT_ENTITY_KEY;
3692          const itemsList = Array.isArray(action.items) ? action.items : [action.items];
3693          return {
3694            ...state,
3695            [context]: {
3696              ...state[context],
3697              ...Object.fromEntries(
3698                itemsList.map((item) => [
3699                  item?.[key],
3700                  conservativeMapItem(
3701                    state?.[context]?.[item?.[key]],
3702                    item
3703                  )
3704                ])
3705              )
3706            }
3707          };
3708        }
3709        case "REMOVE_ITEMS":
3710          return Object.fromEntries(
3711            Object.entries(state).map(([itemId, contextState]) => [
3712              itemId,
3713              removeEntitiesById(contextState, action.itemIds)
3714            ])
3715          );
3716      }
3717      return state;
3718    }
3719    function itemIsComplete(state = {}, action) {
3720      switch (action.type) {
3721        case "RECEIVE_ITEMS": {
3722          const context = getContextFromAction(action);
3723          const { query, key = DEFAULT_ENTITY_KEY } = action;
3724          const itemsList = Array.isArray(action.items) ? action.items : [action.items];
3725          const queryParts = query ? get_query_parts_default(query) : {};
3726          const isCompleteQuery = !query || !Array.isArray(queryParts.fields);
3727          return {
3728            ...state,
3729            [context]: {
3730              ...state[context],
3731              ...itemsList.reduce((result, item) => {
3732                const itemId = item?.[key];
3733                result[itemId] = state?.[context]?.[itemId] || isCompleteQuery;
3734                return result;
3735              }, {})
3736            }
3737          };
3738        }
3739        case "REMOVE_ITEMS":
3740          return Object.fromEntries(
3741            Object.entries(state).map(([itemId, contextState]) => [
3742              itemId,
3743              removeEntitiesById(contextState, action.itemIds)
3744            ])
3745          );
3746      }
3747      return state;
3748    }
3749    var receiveQueries = (0, import_compose.compose)([
3750      // Limit to matching action type so we don't attempt to replace action on
3751      // an unhandled action.
3752      if_matching_action_default((action) => "query" in action),
3753      // Inject query parts into action for use both in `keyedReducer` and reducer.
3754      replace_action_default((action) => {
3755        if (action.query) {
3756          return {
3757            ...action,
3758            ...get_query_parts_default(action.query)
3759          };
3760        }
3761        return action;
3762      }),
3763      (0, import_data6.keyedReducer)("context"),
3764      // Queries shape is shared, but keyed by query `stableKey` part. Original
3765      // reducer tracks only a single query object.
3766      (0, import_data6.keyedReducer)("stableKey")
3767    ])((state = {}, action) => {
3768      if (action.type !== "RECEIVE_ITEMS") {
3769        return state;
3770      }
3771      if (!Array.isArray(action.items)) {
3772        return state;
3773      }
3774      const key = action.key ?? DEFAULT_ENTITY_KEY;
3775      return {
3776        itemIds: getMergedItemIds(
3777          state.itemIds,
3778          action.items.map((item) => item?.[key]).filter(Boolean),
3779          {
3780            page: action.page,
3781            offset: action.offset,
3782            perPage: action.perPage
3783          }
3784        ),
3785        meta: action.meta
3786      };
3787    });
3788    function removeQueryItems(queryItems, removedItems) {
3789      const itemIds = queryItems.itemIds.filter(
3790        (itemId) => !removedItems[itemId]
3791      );
3792      const removedCount = queryItems.itemIds.length - itemIds.length;
3793      if (removedCount === 0) {
3794        return queryItems;
3795      }
3796      const nextQueryItems = { ...queryItems, itemIds };
3797      if (Number.isFinite(queryItems.meta?.totalItems)) {
3798        nextQueryItems.meta = {
3799          ...queryItems.meta,
3800          totalItems: Math.max(
3801            0,
3802            queryItems.meta.totalItems - removedCount
3803          ),
3804          totalPages: null
3805        };
3806      }
3807      return nextQueryItems;
3808    }
3809    var queries = (state = {}, action) => {
3810      switch (action.type) {
3811        case "RECEIVE_ITEMS":
3812          return receiveQueries(state, action);
3813        case "REMOVE_ITEMS":
3814          const removedItems = action.itemIds.reduce((result, itemId) => {
3815            result[itemId] = true;
3816            return result;
3817          }, {});
3818          return Object.fromEntries(
3819            Object.entries(state).map(
3820              ([queryGroup, contextQueries]) => [
3821                queryGroup,
3822                Object.fromEntries(
3823                  Object.entries(contextQueries).map(
3824                    ([query, queryItems]) => [
3825                      query,
3826                      removeQueryItems(
3827                        queryItems,
3828                        removedItems
3829                      )
3830                    ]
3831                  )
3832                )
3833              ]
3834            )
3835          );
3836        default:
3837          return state;
3838      }
3839    };
3840    var reducer_default = (0, import_data6.combineReducers)({
3841      items,
3842      itemIsComplete,
3843      queries
3844    });
3845  
3846    // packages/core-data/build-module/reducer.mjs
3847    function users(state = { byId: {}, queries: {} }, action) {
3848      switch (action.type) {
3849        case "RECEIVE_USER_QUERY":
3850          return {
3851            byId: {
3852              ...state.byId,
3853              // Key users by their ID.
3854              ...action.users.reduce(
3855                (newUsers, user) => ({
3856                  ...newUsers,
3857                  [user.id]: user
3858                }),
3859                {}
3860              )
3861            },
3862            queries: {
3863              ...state.queries,
3864              [action.queryID]: action.users.map((user) => user.id)
3865            }
3866          };
3867      }
3868      return state;
3869    }
3870    function currentUser(state = {}, action) {
3871      switch (action.type) {
3872        case "RECEIVE_CURRENT_USER":
3873          return action.currentUser;
3874      }
3875      return state;
3876    }
3877    function currentTheme(state = void 0, action) {
3878      switch (action.type) {
3879        case "RECEIVE_CURRENT_THEME":
3880          return action.currentTheme.stylesheet;
3881      }
3882      return state;
3883    }
3884    function currentGlobalStylesId(state = void 0, action) {
3885      switch (action.type) {
3886        case "RECEIVE_CURRENT_GLOBAL_STYLES_ID":
3887          return action.id;
3888      }
3889      return state;
3890    }
3891    function themeBaseGlobalStyles(state = {}, action) {
3892      switch (action.type) {
3893        case "RECEIVE_THEME_GLOBAL_STYLES":
3894          return {
3895            ...state,
3896            [action.stylesheet]: action.globalStyles
3897          };
3898      }
3899      return state;
3900    }
3901    function themeGlobalStyleVariations(state = {}, action) {
3902      switch (action.type) {
3903        case "RECEIVE_THEME_GLOBAL_STYLE_VARIATIONS":
3904          return {
3905            ...state,
3906            [action.stylesheet]: action.variations
3907          };
3908      }
3909      return state;
3910    }
3911    var withMultiEntityRecordEdits = (reducer) => (state, action) => {
3912      if (action.type === "UNDO" || action.type === "REDO") {
3913        const { record } = action;
3914        let newState = state;
3915        record.forEach(({ id: { kind, name, recordId }, changes }) => {
3916          const persistedRecord = state?.queriedData?.items?.default?.[recordId];
3917          const edits = Object.fromEntries(
3918            Object.entries(changes).map(([key, value]) => [
3919              key,
3920              action.type === "UNDO" ? value.from : value.to
3921            ])
3922          );
3923          newState = reducer(newState, {
3924            type: "EDIT_ENTITY_RECORD",
3925            kind,
3926            name,
3927            recordId,
3928            // Clear edits matching the persisted record so the entity is
3929            // no longer dirty after undoing back to its saved state.
3930            edits: clearUnchangedEdits(edits, persistedRecord)
3931          });
3932        });
3933        return newState;
3934      }
3935      return reducer(state, action);
3936    };
3937    function entity(entityConfig) {
3938      return (0, import_compose2.compose)([
3939        withMultiEntityRecordEdits,
3940        // Limit to matching action type so we don't attempt to replace action on
3941        // an unhandled action.
3942        if_matching_action_default(
3943          (action) => action.name && action.kind && action.name === entityConfig.name && action.kind === entityConfig.kind
3944        ),
3945        // Inject the entity config into the action.
3946        replace_action_default((action) => {
3947          return {
3948            key: entityConfig.key || DEFAULT_ENTITY_KEY,
3949            ...action
3950          };
3951        })
3952      ])(
3953        (0, import_data7.combineReducers)({
3954          queriedData: reducer_default,
3955          edits: (state = {}, action) => {
3956            switch (action.type) {
3957              case "RECEIVE_ITEMS":
3958                const context = action?.query?.context ?? "default";
3959                if (context !== "default") {
3960                  return state;
3961                }
3962                const nextState = { ...state };
3963                const itemsList = Array.isArray(action.items) ? action.items : [action.items];
3964                for (const record of itemsList) {
3965                  const recordId = record?.[action.key];
3966                  const edits = nextState[recordId];
3967                  if (!edits) {
3968                    continue;
3969                  }
3970                  const nextEdits2 = Object.keys(edits).reduce(
3971                    (acc, key) => {
3972                      if (
3973                        // Edits are the "raw" attribute values, but records may have
3974                        // objects with more properties, so we use `get` here for the
3975                        // comparison.
3976                        !(0, import_es65.default)(
3977                          edits[key],
3978                          record[key]?.raw ?? record[key]
3979                        ) && // Sometimes the server alters the sent value which means
3980                        // we need to also remove the edits before the api request.
3981                        (!action.persistedEdits || !(0, import_es65.default)(
3982                          edits[key],
3983                          action.persistedEdits[key]
3984                        ))
3985                      ) {
3986                        acc[key] = edits[key];
3987                      }
3988                      return acc;
3989                    },
3990                    {}
3991                  );
3992                  if (Object.keys(nextEdits2).length) {
3993                    nextState[recordId] = nextEdits2;
3994                  } else {
3995                    delete nextState[recordId];
3996                  }
3997                }
3998                return nextState;
3999              case "EDIT_ENTITY_RECORD":
4000                const nextEdits = {
4001                  ...state[action.recordId],
4002                  ...action.edits
4003                };
4004                Object.keys(nextEdits).forEach((key) => {
4005                  if (nextEdits[key] === void 0) {
4006                    delete nextEdits[key];
4007                  }
4008                });
4009                return {
4010                  ...state,
4011                  [action.recordId]: nextEdits
4012                };
4013            }
4014            return state;
4015          },
4016          saving: (state = {}, action) => {
4017            switch (action.type) {
4018              case "SAVE_ENTITY_RECORD_START":
4019              case "SAVE_ENTITY_RECORD_FINISH":
4020                return {
4021                  ...state,
4022                  [action.recordId]: {
4023                    pending: action.type === "SAVE_ENTITY_RECORD_START",
4024                    error: action.error,
4025                    isAutosave: action.isAutosave
4026                  }
4027                };
4028            }
4029            return state;
4030          },
4031          deleting: (state = {}, action) => {
4032            switch (action.type) {
4033              case "DELETE_ENTITY_RECORD_START":
4034              case "DELETE_ENTITY_RECORD_FINISH":
4035                return {
4036                  ...state,
4037                  [action.recordId]: {
4038                    pending: action.type === "DELETE_ENTITY_RECORD_START",
4039                    error: action.error
4040                  }
4041                };
4042            }
4043            return state;
4044          },
4045          revisions: (state = {}, action) => {
4046            if (action.type === "RECEIVE_ITEM_REVISIONS") {
4047              const recordKey = action.recordKey;
4048              delete action.recordKey;
4049              const newState = reducer_default(state[recordKey], {
4050                ...action,
4051                type: "RECEIVE_ITEMS"
4052              });
4053              return {
4054                ...state,
4055                [recordKey]: newState
4056              };
4057            }
4058            if (action.type === "REMOVE_ITEMS") {
4059              return Object.fromEntries(
4060                Object.entries(state).filter(
4061                  ([id]) => !action.itemIds.some((itemId) => {
4062                    if (Number.isInteger(itemId)) {
4063                      return itemId === +id;
4064                    }
4065                    return itemId === id;
4066                  })
4067                )
4068              );
4069            }
4070            return state;
4071          }
4072        })
4073      );
4074    }
4075    function entitiesConfig(state = rootEntitiesConfig, action) {
4076      switch (action.type) {
4077        case "ADD_ENTITIES":
4078          return [...state, ...action.entities];
4079      }
4080      return state;
4081    }
4082    var entities = (state = {}, action) => {
4083      const newConfig = entitiesConfig(state.config, action);
4084      let entitiesDataReducer = state.reducer;
4085      if (!entitiesDataReducer || newConfig !== state.config) {
4086        const entitiesByKind = newConfig.reduce((acc, record) => {
4087          const { kind } = record;
4088          if (!acc[kind]) {
4089            acc[kind] = [];
4090          }
4091          acc[kind].push(record);
4092          return acc;
4093        }, {});
4094        entitiesDataReducer = (0, import_data7.combineReducers)(
4095          Object.fromEntries(
4096            Object.entries(entitiesByKind).map(
4097              ([kind, subEntities]) => {
4098                const kindReducer = (0, import_data7.combineReducers)(
4099                  Object.fromEntries(
4100                    subEntities.map((entityConfig) => [
4101                      entityConfig.name,
4102                      entity(entityConfig)
4103                    ])
4104                  )
4105                );
4106                return [kind, kindReducer];
4107              }
4108            )
4109          )
4110        );
4111      }
4112      const newData = entitiesDataReducer(state.records, action);
4113      if (newData === state.records && newConfig === state.config && entitiesDataReducer === state.reducer) {
4114        return state;
4115      }
4116      return {
4117        reducer: entitiesDataReducer,
4118        records: newData,
4119        config: newConfig
4120      };
4121    };
4122    function undoManager(state = (0, import_undo_manager.createUndoManager)()) {
4123      return state;
4124    }
4125    function syncUndoManagerState(state = { hasRedo: false, hasUndo: false }, action) {
4126      switch (action.type) {
4127        case "SYNC_UNDO_MANAGER_CHANGE":
4128          return {
4129            hasRedo: action.hasRedo,
4130            hasUndo: action.hasUndo
4131          };
4132      }
4133      return state;
4134    }
4135    function editsReference(state = {}, action) {
4136      switch (action.type) {
4137        case "EDIT_ENTITY_RECORD":
4138        case "UNDO":
4139        case "REDO":
4140          return {};
4141      }
4142      return state;
4143    }
4144    function embedPreviews(state = {}, action) {
4145      switch (action.type) {
4146        case "RECEIVE_EMBED_PREVIEW":
4147          const { url, preview } = action;
4148          return {
4149            ...state,
4150            [url]: preview
4151          };
4152      }
4153      return state;
4154    }
4155    function userPermissions(state = {}, action) {
4156      switch (action.type) {
4157        case "RECEIVE_USER_PERMISSION":
4158          return {
4159            ...state,
4160            [action.key]: action.isAllowed
4161          };
4162        case "RECEIVE_USER_PERMISSIONS":
4163          return {
4164            ...state,
4165            ...action.permissions
4166          };
4167      }
4168      return state;
4169    }
4170    function autosaves(state = {}, action) {
4171      switch (action.type) {
4172        case "RECEIVE_AUTOSAVES":
4173          const { postId, autosaves: autosavesData } = action;
4174          return {
4175            ...state,
4176            [postId]: autosavesData
4177          };
4178      }
4179      return state;
4180    }
4181    function blockPatterns(state = [], action) {
4182      switch (action.type) {
4183        case "RECEIVE_BLOCK_PATTERNS":
4184          return action.patterns;
4185      }
4186      return state;
4187    }
4188    function blockPatternCategories(state = [], action) {
4189      switch (action.type) {
4190        case "RECEIVE_BLOCK_PATTERN_CATEGORIES":
4191          return action.categories;
4192      }
4193      return state;
4194    }
4195    function userPatternCategories(state = [], action) {
4196      switch (action.type) {
4197        case "RECEIVE_USER_PATTERN_CATEGORIES":
4198          return action.patternCategories;
4199      }
4200      return state;
4201    }
4202    function navigationFallbackId(state = null, action) {
4203      switch (action.type) {
4204        case "RECEIVE_NAVIGATION_FALLBACK_ID":
4205          return action.fallbackId;
4206      }
4207      return state;
4208    }
4209    function themeGlobalStyleRevisions(state = {}, action) {
4210      switch (action.type) {
4211        case "RECEIVE_THEME_GLOBAL_STYLE_REVISIONS":
4212          return {
4213            ...state,
4214            [action.currentId]: action.revisions
4215          };
4216      }
4217      return state;
4218    }
4219    function defaultTemplates(state = {}, action) {
4220      switch (action.type) {
4221        case "RECEIVE_DEFAULT_TEMPLATE":
4222          return {
4223            ...state,
4224            [JSON.stringify(action.query)]: action.templateId
4225          };
4226      }
4227      return state;
4228    }
4229    function registeredPostMeta(state = {}, action) {
4230      switch (action.type) {
4231        case "RECEIVE_REGISTERED_POST_META":
4232          return {
4233            ...state,
4234            [action.postType]: action.registeredPostMeta
4235          };
4236      }
4237      return state;
4238    }
4239    function editorSettings(state = null, action) {
4240      switch (action.type) {
4241        case "RECEIVE_EDITOR_SETTINGS":
4242          return action.settings;
4243      }
4244      return state;
4245    }
4246    function editorAssets(state = null, action) {
4247      switch (action.type) {
4248        case "RECEIVE_EDITOR_ASSETS":
4249          return action.assets;
4250      }
4251      return state;
4252    }
4253    function syncConnectionStatuses(state = {}, action) {
4254      switch (action.type) {
4255        case "SET_SYNC_CONNECTION_STATUS": {
4256          const key = `$action.kind}/$action.name}:$action.key}`;
4257          return {
4258            ...state,
4259            [key]: action.status
4260          };
4261        }
4262        case "CLEAR_SYNC_CONNECTION_STATUS": {
4263          const key = `$action.kind}/$action.name}:$action.key}`;
4264          const { [key]: _, ...rest } = state;
4265          return rest;
4266        }
4267      }
4268      return state;
4269    }
4270    function collaborationSupported(state = true, action) {
4271      switch (action.type) {
4272        case "SET_COLLABORATION_SUPPORTED":
4273          return action.supported;
4274        case "SET_SYNC_CONNECTION_STATUS":
4275          if (ConnectionErrorCode.DOCUMENT_SIZE_LIMIT_EXCEEDED === action.status?.error?.code) {
4276            return false;
4277          }
4278          return state;
4279      }
4280      return state;
4281    }
4282    function viewConfigs(state = {}, action) {
4283      switch (action.type) {
4284        case "RECEIVE_VIEW_CONFIG": {
4285          const key = `$action.kind}/$action.name}`;
4286          return {
4287            ...state,
4288            [key]: {
4289              ...state[key],
4290              ...action.config
4291            }
4292          };
4293        }
4294      }
4295      return state;
4296    }
4297    var reducer_default2 = (0, import_data7.combineReducers)({
4298      users,
4299      currentTheme,
4300      currentGlobalStylesId,
4301      currentUser,
4302      themeGlobalStyleVariations,
4303      themeBaseGlobalStyles,
4304      themeGlobalStyleRevisions,
4305      entities,
4306      editsReference,
4307      syncUndoManagerState,
4308      undoManager,
4309      embedPreviews,
4310      userPermissions,
4311      autosaves,
4312      blockPatterns,
4313      blockPatternCategories,
4314      userPatternCategories,
4315      navigationFallbackId,
4316      defaultTemplates,
4317      registeredPostMeta,
4318      editorSettings,
4319      editorAssets,
4320      syncConnectionStatuses,
4321      collaborationSupported,
4322      viewConfigs
4323    });
4324  
4325    // packages/core-data/build-module/selectors.mjs
4326    var selectors_exports = {};
4327    __export(selectors_exports, {
4328      __experimentalGetCurrentGlobalStylesId: () => __experimentalGetCurrentGlobalStylesId,
4329      __experimentalGetCurrentThemeBaseGlobalStyles: () => __experimentalGetCurrentThemeBaseGlobalStyles,
4330      __experimentalGetCurrentThemeGlobalStylesVariations: () => __experimentalGetCurrentThemeGlobalStylesVariations,
4331      __experimentalGetDirtyEntityRecords: () => __experimentalGetDirtyEntityRecords,
4332      __experimentalGetEntitiesBeingSaved: () => __experimentalGetEntitiesBeingSaved,
4333      __experimentalGetEntityRecordNoResolver: () => __experimentalGetEntityRecordNoResolver,
4334      canUser: () => canUser,
4335      canUserEditEntityRecord: () => canUserEditEntityRecord,
4336      getAuthors: () => getAuthors,
4337      getAutosave: () => getAutosave,
4338      getAutosaves: () => getAutosaves,
4339      getBlockPatternCategories: () => getBlockPatternCategories,
4340      getBlockPatterns: () => getBlockPatterns,
4341      getCurrentTheme: () => getCurrentTheme,
4342      getCurrentThemeGlobalStylesRevisions: () => getCurrentThemeGlobalStylesRevisions,
4343      getCurrentUser: () => getCurrentUser,
4344      getDefaultTemplateId: () => getDefaultTemplateId,
4345      getEditedEntityRecord: () => getEditedEntityRecord,
4346      getEmbedPreview: () => getEmbedPreview,
4347      getEntitiesByKind: () => getEntitiesByKind,
4348      getEntitiesConfig: () => getEntitiesConfig,
4349      getEntity: () => getEntity,
4350      getEntityConfig: () => getEntityConfig,
4351      getEntityRecord: () => getEntityRecord,
4352      getEntityRecordEdits: () => getEntityRecordEdits,
4353      getEntityRecordNonTransientEdits: () => getEntityRecordNonTransientEdits,
4354      getEntityRecords: () => getEntityRecords,
4355      getEntityRecordsTotalItems: () => getEntityRecordsTotalItems,
4356      getEntityRecordsTotalPages: () => getEntityRecordsTotalPages,
4357      getLastEntityDeleteError: () => getLastEntityDeleteError,
4358      getLastEntitySaveError: () => getLastEntitySaveError,
4359      getRawEntityRecord: () => getRawEntityRecord,
4360      getRedoEdit: () => getRedoEdit,
4361      getReferenceByDistinctEdits: () => getReferenceByDistinctEdits,
4362      getRevision: () => getRevision,
4363      getRevisions: () => getRevisions,
4364      getThemeSupports: () => getThemeSupports,
4365      getUndoEdit: () => getUndoEdit,
4366      getUserPatternCategories: () => getUserPatternCategories,
4367      getUserQueryResults: () => getUserQueryResults,
4368      hasEditsForEntityRecord: () => hasEditsForEntityRecord,
4369      hasEntityRecord: () => hasEntityRecord,
4370      hasEntityRecords: () => hasEntityRecords,
4371      hasFetchedAutosaves: () => hasFetchedAutosaves,
4372      hasRedo: () => hasRedo,
4373      hasRevision: () => hasRevision,
4374      hasUndo: () => hasUndo,
4375      isAutosavingEntityRecord: () => isAutosavingEntityRecord,
4376      isDeletingEntityRecord: () => isDeletingEntityRecord,
4377      isPreviewEmbedFallback: () => isPreviewEmbedFallback,
4378      isRequestingEmbedPreview: () => isRequestingEmbedPreview,
4379      isSavingEntityRecord: () => isSavingEntityRecord
4380    });
4381    var import_data9 = __toESM(require_data(), 1);
4382    var import_url2 = __toESM(require_url(), 1);
4383    var import_deprecated2 = __toESM(require_deprecated(), 1);
4384  
4385    // packages/core-data/build-module/private-selectors.mjs
4386    var private_selectors_exports = {};
4387    __export(private_selectors_exports, {
4388      getBlockPatternsForPostType: () => getBlockPatternsForPostType,
4389      getEditorAssets: () => getEditorAssets,
4390      getEditorSettings: () => getEditorSettings,
4391      getEntityRecordPermissions: () => getEntityRecordPermissions,
4392      getEntityRecordsPermissions: () => getEntityRecordsPermissions,
4393      getEntitySyncConnectionStatus: () => getEntitySyncConnectionStatus,
4394      getHomePage: () => getHomePage,
4395      getNavigationFallbackId: () => getNavigationFallbackId,
4396      getPostsPageId: () => getPostsPageId,
4397      getRegisteredPostMeta: () => getRegisteredPostMeta,
4398      getSyncConnectionStatus: () => getSyncConnectionStatus,
4399      getTemplateId: () => getTemplateId,
4400      getUndoManager: () => getUndoManager,
4401      getViewConfig: () => getViewConfig,
4402      isCollaborationSupported: () => isCollaborationSupported
4403    });
4404    var import_data8 = __toESM(require_data(), 1);
4405  
4406    // packages/core-data/build-module/utils/log-entity-deprecation.mjs
4407    var import_deprecated = __toESM(require_deprecated(), 1);
4408    var loggedAlready = false;
4409    function logEntityDeprecation(kind, name, functionName, {
4410      alternativeFunctionName,
4411      isShorthandSelector = false
4412    } = {}) {
4413      const deprecation = deprecatedEntities[kind]?.[name];
4414      if (!deprecation) {
4415        return;
4416      }
4417      if (!loggedAlready) {
4418        const { alternative } = deprecation;
4419        const message = isShorthandSelector ? `'$functionName}'` : `The '$kind}', '$name}' entity (used via '$functionName}')`;
4420        let alternativeMessage = `the '$alternative.kind}', '$alternative.name}' entity`;
4421        if (alternativeFunctionName) {
4422          alternativeMessage += ` via the '$alternativeFunctionName}' function`;
4423        }
4424        (0, import_deprecated.default)(message, {
4425          ...deprecation,
4426          alternative: alternativeMessage
4427        });
4428      }
4429      loggedAlready = true;
4430      setTimeout(() => {
4431        loggedAlready = false;
4432      }, 0);
4433    }
4434  
4435    // packages/core-data/build-module/private-selectors.mjs
4436    var EMPTY_OBJECT = {};
4437    function getUndoManager(state) {
4438      return getSyncManager()?.undoManager ?? state.undoManager;
4439    }
4440    function getNavigationFallbackId(state) {
4441      return state.navigationFallbackId;
4442    }
4443    var getBlockPatternsForPostType = (0, import_data8.createRegistrySelector)(
4444      (select5) => (0, import_data8.createSelector)(
4445        (state, postType) => select5(STORE_NAME).getBlockPatterns().filter(
4446          ({ postTypes }) => !postTypes || Array.isArray(postTypes) && postTypes.includes(postType)
4447        ),
4448        () => [select5(STORE_NAME).getBlockPatterns()]
4449      )
4450    );
4451    var getEntityRecordsPermissions = (0, import_data8.createRegistrySelector)(
4452      (select5) => (0, import_data8.createSelector)(
4453        (state, kind, name, ids) => {
4454          const normalizedIds = Array.isArray(ids) ? ids : [ids];
4455          return normalizedIds.map((id) => ({
4456            delete: select5(STORE_NAME).canUser("delete", {
4457              kind,
4458              name,
4459              id
4460            }),
4461            update: select5(STORE_NAME).canUser("update", {
4462              kind,
4463              name,
4464              id
4465            })
4466          }));
4467        },
4468        (state) => [state.userPermissions]
4469      )
4470    );
4471    function getEntityRecordPermissions(state, kind, name, id) {
4472      logEntityDeprecation(kind, name, "getEntityRecordPermissions");
4473      return getEntityRecordsPermissions(state, kind, name, id)[0];
4474    }
4475    function getRegisteredPostMeta(state, postType) {
4476      return state.registeredPostMeta?.[postType] ?? {};
4477    }
4478    function normalizePageId(value) {
4479      if (!value || !["number", "string"].includes(typeof value)) {
4480        return null;
4481      }
4482      if (Number(value) === 0) {
4483        return null;
4484      }
4485      return value.toString();
4486    }
4487    var getHomePage = (0, import_data8.createRegistrySelector)(
4488      (select5) => (0, import_data8.createSelector)(
4489        () => {
4490          const siteData = select5(STORE_NAME).getEntityRecord(
4491            "root",
4492            "__unstableBase"
4493          );
4494          if (!siteData) {
4495            return null;
4496          }
4497          const homepageId = siteData?.show_on_front === "page" ? normalizePageId(siteData.page_on_front) : null;
4498          if (homepageId) {
4499            return { postType: "page", postId: homepageId };
4500          }
4501          const frontPageTemplateId = select5(
4502            STORE_NAME
4503          ).getDefaultTemplateId({
4504            slug: "front-page"
4505          });
4506          if (frontPageTemplateId) {
4507            return {
4508              postType: "wp_template",
4509              postId: frontPageTemplateId
4510            };
4511          }
4512          if (frontPageTemplateId === "") {
4513            return EMPTY_OBJECT;
4514          }
4515          return null;
4516        },
4517        (state) => [
4518          // Even though getDefaultTemplateId.shouldInvalidate returns true when root/site changes,
4519          // it doesn't seem to invalidate this cache, I'm not sure why.
4520          getEntityRecord(state, "root", "site"),
4521          getEntityRecord(state, "root", "__unstableBase"),
4522          getDefaultTemplateId(state, {
4523            slug: "front-page"
4524          })
4525        ]
4526      )
4527    );
4528    var getPostsPageId = (0, import_data8.createRegistrySelector)((select5) => () => {
4529      const siteData = select5(STORE_NAME).getEntityRecord(
4530        "root",
4531        "__unstableBase"
4532      );
4533      return siteData?.show_on_front === "page" ? normalizePageId(siteData.page_for_posts) : null;
4534    });
4535    var getTemplateId = (0, import_data8.createRegistrySelector)(
4536      (select5) => (state, postType, postId) => {
4537        const homepage = unlock(select5(STORE_NAME)).getHomePage();
4538        if (!homepage) {
4539          return;
4540        }
4541        if (postType === "page" && postType === homepage?.postType && postId.toString() === homepage?.postId) {
4542          const templates = select5(STORE_NAME).getEntityRecords(
4543            "postType",
4544            "wp_template",
4545            {
4546              per_page: -1
4547            }
4548          );
4549          if (!templates) {
4550            return;
4551          }
4552          const id = templates.find(
4553            ({ slug }) => slug === "front-page"
4554          )?.id;
4555          if (id) {
4556            return id;
4557          }
4558        }
4559        const editedEntity = select5(STORE_NAME).getEditedEntityRecord(
4560          "postType",
4561          postType,
4562          postId
4563        );
4564        if (!editedEntity) {
4565          return;
4566        }
4567        const postsPageId = unlock(select5(STORE_NAME)).getPostsPageId();
4568        if (postType === "page" && postsPageId === postId.toString()) {
4569          return select5(STORE_NAME).getDefaultTemplateId({
4570            slug: "home"
4571          });
4572        }
4573        const currentTemplateSlug = editedEntity.template;
4574        if (currentTemplateSlug) {
4575          const currentTemplate = select5(STORE_NAME).getEntityRecords("postType", "wp_template", {
4576            per_page: -1
4577          })?.find(({ slug }) => slug === currentTemplateSlug);
4578          if (currentTemplate) {
4579            return currentTemplate.id;
4580          }
4581        }
4582        let slugToCheck;
4583        if (editedEntity.slug) {
4584          slugToCheck = postType === "page" ? `$postType}-$editedEntity.slug}` : `single-$postType}-$editedEntity.slug}`;
4585        } else {
4586          slugToCheck = postType === "page" ? "page" : `single-$postType}`;
4587        }
4588        return select5(STORE_NAME).getDefaultTemplateId({
4589          slug: slugToCheck
4590        });
4591      }
4592    );
4593    function getEditorSettings(state) {
4594      return state.editorSettings;
4595    }
4596    function getEditorAssets(state) {
4597      return state.editorAssets;
4598    }
4599    function isCollaborationSupported(state) {
4600      return state.collaborationSupported;
4601    }
4602    function getViewConfig(state, kind, name) {
4603      return state.viewConfigs?.[`$kind}/$name}`] ?? {
4604        default_view: void 0,
4605        default_layouts: void 0,
4606        view_list: void 0,
4607        form: void 0
4608      };
4609    }
4610    function getSyncConnectionStatus(state) {
4611      if (!state.syncConnectionStatuses) {
4612        return void 0;
4613      }
4614      const PRIORITIZED_STATUSES = ["disconnected", "connecting", "connected"];
4615      let coalesced;
4616      for (const status of Object.values(state.syncConnectionStatuses)) {
4617        if (!coalesced || PRIORITIZED_STATUSES.indexOf(status.status) < PRIORITIZED_STATUSES.indexOf(coalesced.status)) {
4618          coalesced = status;
4619        }
4620      }
4621      return coalesced;
4622    }
4623    function getEntitySyncConnectionStatus(state, kind, name, recordId) {
4624      return state.syncConnectionStatuses?.[`$kind}/$name}:$recordId}`];
4625    }
4626  
4627    // packages/core-data/build-module/selectors.mjs
4628    var EMPTY_OBJECT2 = {};
4629    var isRequestingEmbedPreview = (0, import_data9.createRegistrySelector)(
4630      (select5) => (state, url) => {
4631        return select5(STORE_NAME).isResolving("getEmbedPreview", [
4632          url
4633        ]);
4634      }
4635    );
4636    function getAuthors(state, query) {
4637      (0, import_deprecated2.default)("select( 'core' ).getAuthors()", {
4638        since: "5.9",
4639        alternative: "select( 'core' ).getUsers({ who: 'authors' })"
4640      });
4641      const path = (0, import_url2.addQueryArgs)(
4642        "/wp/v2/users/?who=authors&per_page=100",
4643        query
4644      );
4645      return getUserQueryResults(state, path);
4646    }
4647    function getCurrentUser(state) {
4648      return state.currentUser;
4649    }
4650    var getUserQueryResults = (0, import_data9.createSelector)(
4651      (state, queryID) => {
4652        const queryResults = state.users.queries[queryID] ?? [];
4653        return queryResults.map((id) => state.users.byId[id]);
4654      },
4655      (state, queryID) => [
4656        state.users.queries[queryID],
4657        state.users.byId
4658      ]
4659    );
4660    function getEntitiesByKind(state, kind) {
4661      (0, import_deprecated2.default)("wp.data.select( 'core' ).getEntitiesByKind()", {
4662        since: "6.0",
4663        alternative: "wp.data.select( 'core' ).getEntitiesConfig()"
4664      });
4665      return getEntitiesConfig(state, kind);
4666    }
4667    var getEntitiesConfig = (0, import_data9.createSelector)(
4668      (state, kind) => state.entities.config.filter((entity2) => entity2.kind === kind),
4669      /* eslint-disable @typescript-eslint/no-unused-vars */
4670      (state, kind) => state.entities.config
4671      /* eslint-enable @typescript-eslint/no-unused-vars */
4672    );
4673    function getEntity(state, kind, name) {
4674      (0, import_deprecated2.default)("wp.data.select( 'core' ).getEntity()", {
4675        since: "6.0",
4676        alternative: "wp.data.select( 'core' ).getEntityConfig()"
4677      });
4678      return getEntityConfig(state, kind, name);
4679    }
4680    function getEntityConfig(state, kind, name) {
4681      logEntityDeprecation(kind, name, "getEntityConfig");
4682      return state.entities.config?.find(
4683        (config) => config.kind === kind && config.name === name
4684      );
4685    }
4686    var getEntityRecord = ((state, kind, name, recordId, query) => {
4687      logEntityDeprecation(kind, name, "getEntityRecord");
4688      const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
4689      if (!queriedState) {
4690        return void 0;
4691      }
4692      const context = query?.context ?? "default";
4693      if (!query || !query._fields) {
4694        if (!queriedState.itemIsComplete[context]?.[recordId]) {
4695          return void 0;
4696        }
4697        return queriedState.items[context][recordId];
4698      }
4699      const item = queriedState.items[context]?.[recordId];
4700      if (!item) {
4701        return item;
4702      }
4703      return getFilteredItem(item, query._fields);
4704    });
4705    getEntityRecord.normalizeArgs = (args) => {
4706      const newArgs = [...args];
4707      const recordKey = newArgs?.[2];
4708      newArgs[2] = isNumericID(recordKey) ? Number(recordKey) : recordKey;
4709      return newArgs;
4710    };
4711    function hasEntityRecord(state, kind, name, recordId, query) {
4712      const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
4713      if (!queriedState) {
4714        return false;
4715      }
4716      const context = query?.context ?? "default";
4717      if (!query || !query._fields) {
4718        return !!queriedState.itemIsComplete[context]?.[recordId];
4719      }
4720      const item = queriedState.items[context]?.[recordId];
4721      if (!item) {
4722        return false;
4723      }
4724      const fields = get_normalized_comma_separable_default(query._fields) ?? [];
4725      for (let i = 0; i < fields.length; i++) {
4726        const path = fields[i].split(".");
4727        let value = item;
4728        for (let p = 0; p < path.length; p++) {
4729          const part = path[p];
4730          if (!value || !Object.hasOwn(value, part)) {
4731            return false;
4732          }
4733          value = value[part];
4734        }
4735      }
4736      return true;
4737    }
4738    function __experimentalGetEntityRecordNoResolver(state, kind, name, recordId) {
4739      return getEntityRecord(state, kind, name, recordId);
4740    }
4741    var getRawEntityRecord = (0, import_data9.createSelector)(
4742      (state, kind, name, recordId) => {
4743        logEntityDeprecation(kind, name, "getRawEntityRecord");
4744        const record = getEntityRecord(
4745          state,
4746          kind,
4747          name,
4748          recordId
4749        );
4750        const config = getEntityConfig(state, kind, name);
4751        if (!record || !config?.rawAttributes?.length) {
4752          return record;
4753        }
4754        return Object.fromEntries(
4755          Object.keys(record).map((key) => {
4756            if (config.rawAttributes.includes(key)) {
4757              const rawValue = record[key]?.raw;
4758              return [
4759                key,
4760                rawValue !== void 0 ? rawValue : record[key]
4761              ];
4762            }
4763            return [key, record[key]];
4764          })
4765        );
4766      },
4767      (state, kind, name, recordId, query) => {
4768        const context = query?.context ?? "default";
4769        return [
4770          state.entities.config,
4771          state.entities.records?.[kind]?.[name]?.queriedData?.items[context]?.[recordId],
4772          state.entities.records?.[kind]?.[name]?.queriedData?.itemIsComplete[context]?.[recordId]
4773        ];
4774      }
4775    );
4776    function hasEntityRecords(state, kind, name, query) {
4777      logEntityDeprecation(kind, name, "hasEntityRecords");
4778      return Array.isArray(getEntityRecords(state, kind, name, query));
4779    }
4780    var getEntityRecords = ((state, kind, name, query) => {
4781      logEntityDeprecation(kind, name, "getEntityRecords");
4782      const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
4783      if (!queriedState) {
4784        return null;
4785      }
4786      return getQueriedItems(queriedState, query, {
4787        supportsPagination: !!getEntityConfig(state, kind, name)?.supportsPagination
4788      });
4789    });
4790    var getEntityRecordsTotalItems = (state, kind, name, query) => {
4791      logEntityDeprecation(kind, name, "getEntityRecordsTotalItems");
4792      const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
4793      if (!queriedState) {
4794        return null;
4795      }
4796      return getQueriedTotalItems(queriedState, query);
4797    };
4798    var getEntityRecordsTotalPages = (state, kind, name, query) => {
4799      logEntityDeprecation(kind, name, "getEntityRecordsTotalPages");
4800      const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
4801      if (!queriedState) {
4802        return null;
4803      }
4804      if (!getEntityConfig(state, kind, name)?.supportsPagination || query?.per_page === -1) {
4805        return 1;
4806      }
4807      const totalItems = getQueriedTotalItems(queriedState, query);
4808      if (!totalItems) {
4809        return totalItems;
4810      }
4811      if (!query?.per_page) {
4812        return getQueriedTotalPages(queriedState, query);
4813      }
4814      return Math.ceil(totalItems / query.per_page);
4815    };
4816    var __experimentalGetDirtyEntityRecords = (0, import_data9.createSelector)(
4817      (state) => {
4818        const {
4819          entities: { records }
4820        } = state;
4821        const dirtyRecords = [];
4822        Object.keys(records).forEach((kind) => {
4823          Object.keys(records[kind]).forEach((name) => {
4824            const primaryKeys = Object.keys(records[kind][name].edits).filter(
4825              (primaryKey) => (
4826                // The entity record must exist (not be deleted),
4827                // and it must have edits.
4828                getEntityRecord(state, kind, name, primaryKey) && hasEditsForEntityRecord(state, kind, name, primaryKey)
4829              )
4830            );
4831            if (primaryKeys.length) {
4832              const entityConfig = getEntityConfig(state, kind, name);
4833              primaryKeys.forEach((primaryKey) => {
4834                const entityRecord = getEditedEntityRecord(
4835                  state,
4836                  kind,
4837                  name,
4838                  primaryKey
4839                );
4840                dirtyRecords.push({
4841                  // We avoid using primaryKey because it's transformed into a string
4842                  // when it's used as an object key.
4843                  key: entityRecord ? entityRecord[entityConfig.key || DEFAULT_ENTITY_KEY] : void 0,
4844                  title: entityConfig?.getTitle?.(entityRecord) || "",
4845                  name,
4846                  kind
4847                });
4848              });
4849            }
4850          });
4851        });
4852        return dirtyRecords;
4853      },
4854      (state) => [state.entities.records]
4855    );
4856    var __experimentalGetEntitiesBeingSaved = (0, import_data9.createSelector)(
4857      (state) => {
4858        const {
4859          entities: { records }
4860        } = state;
4861        const recordsBeingSaved = [];
4862        Object.keys(records).forEach((kind) => {
4863          Object.keys(records[kind]).forEach((name) => {
4864            const primaryKeys = Object.keys(records[kind][name].saving).filter(
4865              (primaryKey) => isSavingEntityRecord(state, kind, name, primaryKey)
4866            );
4867            if (primaryKeys.length) {
4868              const entityConfig = getEntityConfig(state, kind, name);
4869              primaryKeys.forEach((primaryKey) => {
4870                const entityRecord = getEditedEntityRecord(
4871                  state,
4872                  kind,
4873                  name,
4874                  primaryKey
4875                );
4876                recordsBeingSaved.push({
4877                  // We avoid using primaryKey because it's transformed into a string
4878                  // when it's used as an object key.
4879                  key: entityRecord ? entityRecord[entityConfig.key || DEFAULT_ENTITY_KEY] : void 0,
4880                  title: entityConfig?.getTitle?.(entityRecord) || "",
4881                  name,
4882                  kind
4883                });
4884              });
4885            }
4886          });
4887        });
4888        return recordsBeingSaved;
4889      },
4890      (state) => [state.entities.records]
4891    );
4892    function getEntityRecordEdits(state, kind, name, recordId) {
4893      logEntityDeprecation(kind, name, "getEntityRecordEdits");
4894      return state.entities.records?.[kind]?.[name]?.edits?.[String(recordId)];
4895    }
4896    var getEntityRecordNonTransientEdits = (0, import_data9.createSelector)(
4897      (state, kind, name, recordId) => {
4898        logEntityDeprecation(kind, name, "getEntityRecordNonTransientEdits");
4899        const { transientEdits } = getEntityConfig(state, kind, name) || {};
4900        const edits = getEntityRecordEdits(state, kind, name, recordId) || {};
4901        if (!transientEdits) {
4902          return edits;
4903        }
4904        return Object.keys(edits).reduce((acc, key) => {
4905          if (!transientEdits[key]) {
4906            acc[key] = edits[key];
4907          }
4908          return acc;
4909        }, {});
4910      },
4911      (state, kind, name, recordId) => [
4912        state.entities.config,
4913        state.entities.records?.[kind]?.[name]?.edits?.[String(recordId)]
4914      ]
4915    );
4916    function hasEditsForEntityRecord(state, kind, name, recordId) {
4917      logEntityDeprecation(kind, name, "hasEditsForEntityRecord");
4918      return isSavingEntityRecord(state, kind, name, recordId) || Object.keys(
4919        getEntityRecordNonTransientEdits(state, kind, name, recordId)
4920      ).length > 0;
4921    }
4922    var getEditedEntityRecord = (0, import_data9.createSelector)(
4923      (state, kind, name, recordId) => {
4924        logEntityDeprecation(kind, name, "getEditedEntityRecord");
4925        const raw = getRawEntityRecord(state, kind, name, recordId);
4926        const edited = getEntityRecordEdits(state, kind, name, recordId);
4927        if (!raw && !edited) {
4928          return false;
4929        }
4930        return {
4931          ...raw,
4932          ...edited
4933        };
4934      },
4935      (state, kind, name, recordId, query) => {
4936        const context = query?.context ?? "default";
4937        return [
4938          state.entities.config,
4939          state.entities.records?.[kind]?.[name]?.queriedData.items[context]?.[recordId],
4940          state.entities.records?.[kind]?.[name]?.queriedData.itemIsComplete[context]?.[recordId],
4941          state.entities.records?.[kind]?.[name]?.edits?.[String(recordId)]
4942        ];
4943      }
4944    );
4945    function isAutosavingEntityRecord(state, kind, name, recordId) {
4946      logEntityDeprecation(kind, name, "isAutosavingEntityRecord");
4947      const { pending, isAutosave } = state.entities.records?.[kind]?.[name]?.saving?.[recordId] ?? {};
4948      return Boolean(pending && isAutosave);
4949    }
4950    function isSavingEntityRecord(state, kind, name, recordId) {
4951      logEntityDeprecation(kind, name, "isSavingEntityRecord");
4952      return state.entities.records?.[kind]?.[name]?.saving?.[String(recordId)]?.pending ?? false;
4953    }
4954    function isDeletingEntityRecord(state, kind, name, recordId) {
4955      logEntityDeprecation(kind, name, "isDeletingEntityRecord");
4956      return state.entities.records?.[kind]?.[name]?.deleting?.[String(recordId)]?.pending ?? false;
4957    }
4958    function getLastEntitySaveError(state, kind, name, recordId) {
4959      logEntityDeprecation(kind, name, "getLastEntitySaveError");
4960      return state.entities.records?.[kind]?.[name]?.saving?.[String(recordId)]?.error;
4961    }
4962    function getLastEntityDeleteError(state, kind, name, recordId) {
4963      logEntityDeprecation(kind, name, "getLastEntityDeleteError");
4964      return state.entities.records?.[kind]?.[name]?.deleting?.[recordId]?.error;
4965    }
4966    function getUndoEdit(state) {
4967      (0, import_deprecated2.default)("select( 'core' ).getUndoEdit()", {
4968        since: "6.3"
4969      });
4970      return void 0;
4971    }
4972    function getRedoEdit(state) {
4973      (0, import_deprecated2.default)("select( 'core' ).getRedoEdit()", {
4974        since: "6.3"
4975      });
4976      return void 0;
4977    }
4978    function hasUndo(state) {
4979      if (getSyncManager()?.undoManager) {
4980        return state.syncUndoManagerState.hasUndo;
4981      }
4982      return getUndoManager(state).hasUndo();
4983    }
4984    function hasRedo(state) {
4985      if (getSyncManager()?.undoManager) {
4986        return state.syncUndoManagerState.hasRedo;
4987      }
4988      return getUndoManager(state).hasRedo();
4989    }
4990    function getCurrentTheme(state) {
4991      if (!state.currentTheme) {
4992        return null;
4993      }
4994      return getEntityRecord(state, "root", "theme", state.currentTheme);
4995    }
4996    function __experimentalGetCurrentGlobalStylesId(state) {
4997      return state.currentGlobalStylesId;
4998    }
4999    function getThemeSupports(state) {
5000      return getCurrentTheme(state)?.theme_supports ?? EMPTY_OBJECT2;
5001    }
5002    function getEmbedPreview(state, url) {
5003      return state.embedPreviews[url];
5004    }
5005    function isPreviewEmbedFallback(state, url) {
5006      const preview = state.embedPreviews[url];
5007      const oEmbedLinkCheck = '<a href="' + url + '">' + url + "</a>";
5008      if (!preview) {
5009        return false;
5010      }
5011      return preview.html === oEmbedLinkCheck;
5012    }
5013    function canUser(state, action, resource, id) {
5014      const isEntity = typeof resource === "object";
5015      if (isEntity && (!resource.kind || !resource.name)) {
5016        return false;
5017      }
5018      if (isEntity) {
5019        logEntityDeprecation(resource.kind, resource.name, "canUser");
5020      }
5021      const key = getUserPermissionCacheKey(action, resource, id);
5022      return state.userPermissions[key];
5023    }
5024    function canUserEditEntityRecord(state, kind, name, recordId) {
5025      (0, import_deprecated2.default)(`wp.data.select( 'core' ).canUserEditEntityRecord()`, {
5026        since: "6.7",
5027        alternative: `wp.data.select( 'core' ).canUser( 'update', { kind, name, id } )`
5028      });
5029      return canUser(state, "update", { kind, name, id: recordId });
5030    }
5031    function getAutosaves(state, postType, postId) {
5032      return state.autosaves[postId];
5033    }
5034    function getAutosave(state, postType, postId, authorId) {
5035      if (authorId === void 0) {
5036        return;
5037      }
5038      const autosaves2 = state.autosaves[postId];
5039      return autosaves2?.find(
5040        (autosave) => autosave.author === authorId
5041      );
5042    }
5043    var hasFetchedAutosaves = (0, import_data9.createRegistrySelector)(
5044      (select5) => (state, postType, postId) => {
5045        return select5(STORE_NAME).hasFinishedResolution("getAutosaves", [
5046          postType,
5047          postId
5048        ]);
5049      }
5050    );
5051    function getReferenceByDistinctEdits(state) {
5052      return state.editsReference;
5053    }
5054    function __experimentalGetCurrentThemeBaseGlobalStyles(state) {
5055      const currentTheme2 = getCurrentTheme(state);
5056      if (!currentTheme2) {
5057        return null;
5058      }
5059      return state.themeBaseGlobalStyles[currentTheme2.stylesheet];
5060    }
5061    function __experimentalGetCurrentThemeGlobalStylesVariations(state) {
5062      const currentTheme2 = getCurrentTheme(state);
5063      if (!currentTheme2) {
5064        return null;
5065      }
5066      return state.themeGlobalStyleVariations[currentTheme2.stylesheet];
5067    }
5068    function getBlockPatterns(state) {
5069      return state.blockPatterns;
5070    }
5071    function getBlockPatternCategories(state) {
5072      return state.blockPatternCategories;
5073    }
5074    function getUserPatternCategories(state) {
5075      return state.userPatternCategories;
5076    }
5077    function getCurrentThemeGlobalStylesRevisions(state) {
5078      (0, import_deprecated2.default)("select( 'core' ).getCurrentThemeGlobalStylesRevisions()", {
5079        since: "6.5.0",
5080        alternative: "select( 'core' ).getRevisions( 'root', 'globalStyles', ${ recordKey } )"
5081      });
5082      const currentGlobalStylesId2 = __experimentalGetCurrentGlobalStylesId(state);
5083      if (!currentGlobalStylesId2) {
5084        return null;
5085      }
5086      return state.themeGlobalStyleRevisions[currentGlobalStylesId2];
5087    }
5088    function getDefaultTemplateId(state, query) {
5089      return state.defaultTemplates[JSON.stringify(query)];
5090    }
5091    var getRevisions = (state, kind, name, recordKey, query) => {
5092      logEntityDeprecation(kind, name, "getRevisions");
5093      const queriedStateRevisions = state.entities.records?.[kind]?.[name]?.revisions?.[recordKey];
5094      if (!queriedStateRevisions) {
5095        return null;
5096      }
5097      return getQueriedItems(queriedStateRevisions, query);
5098    };
5099    function hasRevision(state, kind, name, recordKey, revisionKey, query) {
5100      const queriedState = state.entities.records?.[kind]?.[name]?.revisions?.[recordKey];
5101      if (!queriedState) {
5102        return false;
5103      }
5104      const context = query?.context ?? "default";
5105      if (!query || !query._fields) {
5106        return !!queriedState.itemIsComplete[context]?.[revisionKey];
5107      }
5108      const item = queriedState.items[context]?.[revisionKey];
5109      if (!item) {
5110        return false;
5111      }
5112      const fields = get_normalized_comma_separable_default(query._fields) ?? [];
5113      for (let i = 0; i < fields.length; i++) {
5114        const path = fields[i].split(".");
5115        let value = item;
5116        for (let p = 0; p < path.length; p++) {
5117          const part = path[p];
5118          if (!value || !Object.hasOwn(value, part)) {
5119            return false;
5120          }
5121          value = value[part];
5122        }
5123      }
5124      return true;
5125    }
5126    var getRevision = (state, kind, name, recordKey, revisionKey, query) => {
5127      logEntityDeprecation(kind, name, "getRevision");
5128      const queriedState = state.entities.records?.[kind]?.[name]?.revisions?.[recordKey];
5129      if (!queriedState) {
5130        return void 0;
5131      }
5132      const context = query?.context ?? "default";
5133      if (!query || !query._fields) {
5134        if (!queriedState.itemIsComplete[context]?.[revisionKey]) {
5135          return void 0;
5136        }
5137        return queriedState.items[context][revisionKey];
5138      }
5139      const item = queriedState.items[context]?.[revisionKey];
5140      if (!item) {
5141        return item;
5142      }
5143      return getFilteredItem(item, query._fields);
5144    };
5145  
5146    // packages/core-data/build-module/actions.mjs
5147    var actions_exports = {};
5148    __export(actions_exports, {
5149      __experimentalBatch: () => __experimentalBatch,
5150      __experimentalReceiveCurrentGlobalStylesId: () => __experimentalReceiveCurrentGlobalStylesId,
5151      __experimentalReceiveThemeBaseGlobalStyles: () => __experimentalReceiveThemeBaseGlobalStyles,
5152      __experimentalReceiveThemeGlobalStyleVariations: () => __experimentalReceiveThemeGlobalStyleVariations,
5153      __experimentalSaveSpecifiedEntityEdits: () => __experimentalSaveSpecifiedEntityEdits,
5154      __unstableCreateUndoLevel: () => __unstableCreateUndoLevel,
5155      addEntities: () => addEntities,
5156      clearEntityRecordEdits: () => clearEntityRecordEdits,
5157      deleteEntityRecord: () => deleteEntityRecord,
5158      editEntityRecord: () => editEntityRecord,
5159      receiveAutosaves: () => receiveAutosaves,
5160      receiveCurrentTheme: () => receiveCurrentTheme,
5161      receiveCurrentUser: () => receiveCurrentUser,
5162      receiveDefaultTemplateId: () => receiveDefaultTemplateId,
5163      receiveEmbedPreview: () => receiveEmbedPreview,
5164      receiveEntityRecords: () => receiveEntityRecords,
5165      receiveNavigationFallbackId: () => receiveNavigationFallbackId,
5166      receiveRevisions: () => receiveRevisions,
5167      receiveThemeGlobalStyleRevisions: () => receiveThemeGlobalStyleRevisions,
5168      receiveThemeSupports: () => receiveThemeSupports,
5169      receiveUploadPermissions: () => receiveUploadPermissions,
5170      receiveUserPermission: () => receiveUserPermission,
5171      receiveUserPermissions: () => receiveUserPermissions,
5172      receiveUserQuery: () => receiveUserQuery,
5173      redo: () => redo,
5174      saveEditedEntityRecord: () => saveEditedEntityRecord,
5175      saveEntityRecord: () => saveEntityRecord,
5176      undo: () => undo
5177    });
5178    var import_es66 = __toESM(require_es6(), 1);
5179    var import_api_fetch4 = __toESM(require_api_fetch(), 1);
5180    var import_url3 = __toESM(require_url(), 1);
5181    var import_deprecated3 = __toESM(require_deprecated(), 1);
5182  
5183    // packages/core-data/build-module/batch/default-processor.mjs
5184    var import_api_fetch3 = __toESM(require_api_fetch(), 1);
5185    var maxItems = null;
5186    function chunk(arr, chunkSize) {
5187      const tmp = [...arr];
5188      const cache3 = [];
5189      while (tmp.length) {
5190        cache3.push(tmp.splice(0, chunkSize));
5191      }
5192      return cache3;
5193    }
5194    async function defaultProcessor(requests) {
5195      if (maxItems === null) {
5196        const preflightResponse = await (0, import_api_fetch3.default)({
5197          path: "/batch/v1",
5198          method: "OPTIONS"
5199        });
5200        maxItems = preflightResponse.endpoints[0].args.requests.maxItems;
5201      }
5202      const results = [];
5203      for (const batchRequests of chunk(requests, maxItems)) {
5204        const batchResponse = await (0, import_api_fetch3.default)({
5205          path: "/batch/v1",
5206          method: "POST",
5207          data: {
5208            validation: "require-all-validate",
5209            requests: batchRequests.map((request) => ({
5210              path: request.path,
5211              body: request.data,
5212              // Rename 'data' to 'body'.
5213              method: request.method,
5214              headers: request.headers
5215            }))
5216          }
5217        });
5218        let batchResults;
5219        if (batchResponse.failed) {
5220          batchResults = batchResponse.responses.map((response) => ({
5221            error: response?.body
5222          }));
5223        } else {
5224          batchResults = batchResponse.responses.map((response) => {
5225            const result = {};
5226            if (response.status >= 200 && response.status < 300) {
5227              result.output = response.body;
5228            } else {
5229              result.error = response.body;
5230            }
5231            return result;
5232          });
5233        }
5234        results.push(...batchResults);
5235      }
5236      return results;
5237    }
5238  
5239    // packages/core-data/build-module/batch/create-batch.mjs
5240    function createBatch(processor = defaultProcessor) {
5241      let lastId = 0;
5242      let queue = [];
5243      const pending = new ObservableSet();
5244      return {
5245        /**
5246         * Adds an input to the batch and returns a promise that is resolved or
5247         * rejected when the input is processed by `batch.run()`.
5248         *
5249         * You may also pass a thunk which allows inputs to be added
5250         * asynchronously.
5251         *
5252         * ```
5253         * // Both are allowed:
5254         * batch.add( { path: '/v1/books', ... } );
5255         * batch.add( ( add ) => add( { path: '/v1/books', ... } ) );
5256         * ```
5257         *
5258         * If a thunk is passed, `batch.run()` will pause until either:
5259         *
5260         * - The thunk calls its `add` argument, or;
5261         * - The thunk returns a promise and that promise resolves, or;
5262         * - The thunk returns a non-promise.
5263         *
5264         * @param {any|Function} inputOrThunk Input to add or thunk to execute.
5265         *
5266         * @return {Promise|any} If given an input, returns a promise that
5267         *                       is resolved or rejected when the batch is
5268         *                       processed. If given a thunk, returns the return
5269         *                       value of that thunk.
5270         */
5271        add(inputOrThunk) {
5272          const id = ++lastId;
5273          pending.add(id);
5274          const add = (input) => new Promise((resolve, reject) => {
5275            queue.push({
5276              input,
5277              resolve,
5278              reject
5279            });
5280            pending.delete(id);
5281          });
5282          if (typeof inputOrThunk === "function") {
5283            return Promise.resolve(inputOrThunk(add)).finally(() => {
5284              pending.delete(id);
5285            });
5286          }
5287          return add(inputOrThunk);
5288        },
5289        /**
5290         * Runs the batch. This calls `batchProcessor` and resolves or rejects
5291         * all promises returned by `add()`.
5292         *
5293         * @return {Promise<boolean>} A promise that resolves to a boolean that is true
5294         *                   if the processor returned no errors.
5295         */
5296        async run() {
5297          if (pending.size) {
5298            await new Promise((resolve) => {
5299              const unsubscribe = pending.subscribe(() => {
5300                if (!pending.size) {
5301                  unsubscribe();
5302                  resolve(void 0);
5303                }
5304              });
5305            });
5306          }
5307          let results;
5308          try {
5309            results = await processor(
5310              queue.map(({ input }) => input)
5311            );
5312            if (results.length !== queue.length) {
5313              throw new Error(
5314                "run: Array returned by processor must be same size as input array."
5315              );
5316            }
5317          } catch (error) {
5318            for (const { reject } of queue) {
5319              reject(error);
5320            }
5321            throw error;
5322          }
5323          let isSuccess = true;
5324          results.forEach((result, key) => {
5325            const queueItem = queue[key];
5326            if (result?.error) {
5327              queueItem?.reject(result.error);
5328              isSuccess = false;
5329            } else {
5330              queueItem?.resolve(result?.output ?? result);
5331            }
5332          });
5333          queue = [];
5334          return isSuccess;
5335        }
5336      };
5337    }
5338    var ObservableSet = class {
5339      constructor(...args) {
5340        this.set = new Set(...args);
5341        this.subscribers = /* @__PURE__ */ new Set();
5342      }
5343      get size() {
5344        return this.set.size;
5345      }
5346      add(value) {
5347        this.set.add(value);
5348        this.subscribers.forEach((subscriber) => subscriber());
5349        return this;
5350      }
5351      delete(value) {
5352        const isSuccess = this.set.delete(value);
5353        this.subscribers.forEach((subscriber) => subscriber());
5354        return isSuccess;
5355      }
5356      subscribe(subscriber) {
5357        this.subscribers.add(subscriber);
5358        return () => {
5359          this.subscribers.delete(subscriber);
5360        };
5361      }
5362    };
5363  
5364    // packages/core-data/build-module/actions.mjs
5365    function addTitleToAutoDraft(record) {
5366      return record.status === "auto-draft" ? { ...record, title: "" } : record;
5367    }
5368    function getServerMutatedMetaFields(updatedMeta, persistedMeta, syncedMeta) {
5369      const baseline = { ...persistedMeta, ...syncedMeta };
5370      return Object.fromEntries(
5371        Object.entries(updatedMeta ?? {}).filter(([key, value]) => {
5372          if (key === POST_META_KEY_FOR_CRDT_DOC_PERSISTENCE) {
5373            return false;
5374          }
5375          return !(0, import_es66.default)(value, baseline[key]);
5376        })
5377      );
5378    }
5379    function getServerMutatedFields(updatedRecord, persistedRecord, syncedChanges) {
5380      return Object.fromEntries(
5381        Object.entries(updatedRecord).flatMap(([key, value]) => {
5382          if (key === "meta") {
5383            const serverMutatedMeta = getServerMutatedMetaFields(
5384              value,
5385              persistedRecord.meta,
5386              syncedChanges.meta
5387            );
5388            return Object.keys(serverMutatedMeta).length ? [[key, serverMutatedMeta]] : [];
5389          }
5390          const baseline = key in syncedChanges ? syncedChanges[key] : persistedRecord[key];
5391          const wasServerMutated = !(0, import_es66.default)(
5392            getRawValue(value) ?? value,
5393            getRawValue(baseline) ?? baseline
5394          );
5395          return wasServerMutated ? [[key, value]] : [];
5396        })
5397      );
5398    }
5399    function receiveUserQuery(queryID, users2) {
5400      return {
5401        type: "RECEIVE_USER_QUERY",
5402        users: Array.isArray(users2) ? users2 : [users2],
5403        queryID
5404      };
5405    }
5406    function receiveCurrentUser(currentUser2) {
5407      return {
5408        type: "RECEIVE_CURRENT_USER",
5409        currentUser: currentUser2
5410      };
5411    }
5412    function addEntities(entities2) {
5413      return {
5414        type: "ADD_ENTITIES",
5415        entities: entities2
5416      };
5417    }
5418    function receiveEntityRecords(kind, name, records, query = void 0, invalidateCache = false, edits = void 0, meta = void 0) {
5419      if (kind === "postType") {
5420        records = Array.isArray(records) ? records.map(addTitleToAutoDraft) : addTitleToAutoDraft(records);
5421      }
5422      let action;
5423      if (query) {
5424        action = receiveQueriedItems(records, query, edits, meta);
5425      } else {
5426        action = receiveItems(records, edits, meta);
5427      }
5428      return {
5429        ...action,
5430        kind,
5431        name,
5432        invalidateCache
5433      };
5434    }
5435    function receiveCurrentTheme(currentTheme2) {
5436      return {
5437        type: "RECEIVE_CURRENT_THEME",
5438        currentTheme: currentTheme2
5439      };
5440    }
5441    function __experimentalReceiveCurrentGlobalStylesId(currentGlobalStylesId2) {
5442      return {
5443        type: "RECEIVE_CURRENT_GLOBAL_STYLES_ID",
5444        id: currentGlobalStylesId2
5445      };
5446    }
5447    function __experimentalReceiveThemeBaseGlobalStyles(stylesheet, globalStyles) {
5448      return {
5449        type: "RECEIVE_THEME_GLOBAL_STYLES",
5450        stylesheet,
5451        globalStyles
5452      };
5453    }
5454    function __experimentalReceiveThemeGlobalStyleVariations(stylesheet, variations) {
5455      return {
5456        type: "RECEIVE_THEME_GLOBAL_STYLE_VARIATIONS",
5457        stylesheet,
5458        variations
5459      };
5460    }
5461    function receiveThemeSupports() {
5462      (0, import_deprecated3.default)("wp.data.dispatch( 'core' ).receiveThemeSupports", {
5463        since: "5.9"
5464      });
5465      return {
5466        type: "DO_NOTHING"
5467      };
5468    }
5469    function receiveThemeGlobalStyleRevisions(currentId, revisions) {
5470      (0, import_deprecated3.default)(
5471        "wp.data.dispatch( 'core' ).receiveThemeGlobalStyleRevisions()",
5472        {
5473          since: "6.5.0",
5474          alternative: "wp.data.dispatch( 'core' ).receiveRevisions"
5475        }
5476      );
5477      return {
5478        type: "RECEIVE_THEME_GLOBAL_STYLE_REVISIONS",
5479        currentId,
5480        revisions
5481      };
5482    }
5483    function receiveEmbedPreview(url, preview) {
5484      return {
5485        type: "RECEIVE_EMBED_PREVIEW",
5486        url,
5487        preview
5488      };
5489    }
5490    var deleteEntityRecord = (kind, name, recordId, query, { __unstableFetch = import_api_fetch4.default, throwOnError = false } = {}) => async ({ dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
5491      logEntityDeprecation(kind, name, "deleteEntityRecord");
5492      const configs = await resolveSelect2.getEntitiesConfig(kind);
5493      const entityConfig = configs.find(
5494        (config) => config.kind === kind && config.name === name
5495      );
5496      let error;
5497      let deletedRecord = false;
5498      if (!entityConfig) {
5499        return;
5500      }
5501      const lock2 = await dispatch3.__unstableAcquireStoreLock(
5502        STORE_NAME,
5503        ["entities", "records", kind, name, recordId],
5504        { exclusive: true }
5505      );
5506      try {
5507        dispatch3({
5508          type: "DELETE_ENTITY_RECORD_START",
5509          kind,
5510          name,
5511          recordId
5512        });
5513        let hasError = false;
5514        const { baseURL } = entityConfig;
5515        try {
5516          let path = `$baseURL}/$recordId}`;
5517          if (query) {
5518            path = (0, import_url3.addQueryArgs)(path, query);
5519          }
5520          deletedRecord = await __unstableFetch({
5521            path,
5522            method: "DELETE"
5523          });
5524          await dispatch3(removeItems(kind, name, recordId, true));
5525          if (entityConfig.syncConfig) {
5526            const objectType = `$kind}/$name}`;
5527            const objectId = recordId;
5528            getSyncManager()?.unload(objectType, objectId);
5529          }
5530        } catch (_error) {
5531          hasError = true;
5532          error = _error;
5533        }
5534        dispatch3({
5535          type: "DELETE_ENTITY_RECORD_FINISH",
5536          kind,
5537          name,
5538          recordId,
5539          error
5540        });
5541        if (hasError && throwOnError) {
5542          throw error;
5543        }
5544        return deletedRecord;
5545      } finally {
5546        dispatch3.__unstableReleaseStoreLock(lock2);
5547      }
5548    };
5549    var editEntityRecord = (kind, name, recordId, edits, options = {}) => ({ select: select5, dispatch: dispatch3 }) => {
5550      logEntityDeprecation(kind, name, "editEntityRecord");
5551      const entityConfig = select5.getEntityConfig(kind, name);
5552      if (!entityConfig) {
5553        throw new Error(
5554          `The entity being edited ($kind}, $name}) does not have a loaded config.`
5555        );
5556      }
5557      const { mergedEdits = {} } = entityConfig;
5558      const record = select5.getRawEntityRecord(kind, name, recordId);
5559      const editedRecord = select5.getEditedEntityRecord(
5560        kind,
5561        name,
5562        recordId
5563      );
5564      const editsWithMerges = Object.keys(edits).reduce((acc, key) => {
5565        acc[key] = mergedEdits[key] ? { ...editedRecord[key], ...edits[key] } : edits[key];
5566        return acc;
5567      }, {});
5568      const edit = {
5569        kind,
5570        name,
5571        recordId,
5572        // Clear edits when they are equal to their persisted counterparts
5573        // so that the property is not considered dirty.
5574        edits: clearUnchangedEdits(editsWithMerges, record)
5575      };
5576      if (entityConfig.syncConfig) {
5577        const objectType = `$kind}/$name}`;
5578        const objectId = recordId;
5579        const isNewUndoLevel = options.undoIgnore ? false : !options.isCached;
5580        const origin = options.undoIgnore ? LOCAL_UNDO_IGNORED_ORIGIN : LOCAL_EDITOR_ORIGIN;
5581        getSyncManager()?.update(
5582          objectType,
5583          objectId,
5584          editsWithMerges,
5585          origin,
5586          { isNewUndoLevel }
5587        );
5588      }
5589      if (!options.undoIgnore) {
5590        select5.getUndoManager().addRecord(
5591          [
5592            {
5593              id: { kind, name, recordId },
5594              changes: Object.keys(edits).reduce((acc, key) => {
5595                acc[key] = {
5596                  from: editedRecord[key],
5597                  to: edits[key]
5598                };
5599                return acc;
5600              }, {})
5601            }
5602          ],
5603          options.isCached
5604        );
5605      }
5606      dispatch3({
5607        type: "EDIT_ENTITY_RECORD",
5608        ...edit
5609      });
5610    };
5611    var clearEntityRecordEdits = (kind, name, recordId) => ({ select: select5, dispatch: dispatch3 }) => {
5612      const entityConfig = select5.getEntityConfig(kind, name);
5613      logEntityDeprecation(kind, name, "clearEntityRecordEdits");
5614      if (!entityConfig) {
5615        throw new Error(
5616          `The entity being edited ($kind}, $name}) does not have a loaded config.`
5617        );
5618      }
5619      const currentEdits = select5.getEntityRecordEdits(
5620        kind,
5621        name,
5622        recordId
5623      );
5624      if (!currentEdits) {
5625        return;
5626      }
5627      const clearedEdits = Object.keys(currentEdits).reduce(
5628        (acc, key) => {
5629          acc[key] = void 0;
5630          return acc;
5631        },
5632        {}
5633      );
5634      dispatch3({
5635        type: "EDIT_ENTITY_RECORD",
5636        kind,
5637        name,
5638        recordId,
5639        edits: clearedEdits
5640      });
5641    };
5642    var undo = () => ({ select: select5, dispatch: dispatch3 }) => {
5643      const undoRecord = select5.getUndoManager().undo();
5644      if (!undoRecord) {
5645        return;
5646      }
5647      dispatch3({
5648        type: "UNDO",
5649        record: undoRecord
5650      });
5651    };
5652    var redo = () => ({ select: select5, dispatch: dispatch3 }) => {
5653      const redoRecord = select5.getUndoManager().redo();
5654      if (!redoRecord) {
5655        return;
5656      }
5657      dispatch3({
5658        type: "REDO",
5659        record: redoRecord
5660      });
5661    };
5662    var __unstableCreateUndoLevel = () => ({ select: select5 }) => {
5663      select5.getUndoManager().addRecord();
5664    };
5665    var saveEntityRecord = (kind, name, record, options = {}) => async ({ select: select5, resolveSelect: resolveSelect2, dispatch: dispatch3 }) => {
5666      const {
5667        isAutosave = false,
5668        __unstableFetch = import_api_fetch4.default,
5669        __unstableSkipSyncUpdate = false,
5670        throwOnError = false
5671      } = options;
5672      logEntityDeprecation(kind, name, "saveEntityRecord");
5673      const configs = await resolveSelect2.getEntitiesConfig(kind);
5674      const entityConfig = configs.find(
5675        (config) => config.kind === kind && config.name === name
5676      );
5677      if (!entityConfig) {
5678        return;
5679      }
5680      const entityIdKey = entityConfig.key ?? DEFAULT_ENTITY_KEY;
5681      const recordId = record[entityIdKey];
5682      const isNewRecord = !!entityIdKey && !recordId;
5683      const lock2 = await dispatch3.__unstableAcquireStoreLock(
5684        STORE_NAME,
5685        ["entities", "records", kind, name, recordId || v4_default()],
5686        { exclusive: true }
5687      );
5688      try {
5689        for (const [key, value] of Object.entries(record)) {
5690          if (typeof value === "function") {
5691            const evaluatedValue = value(
5692              select5.getEditedEntityRecord(kind, name, recordId)
5693            );
5694            dispatch3.editEntityRecord(
5695              kind,
5696              name,
5697              recordId,
5698              {
5699                [key]: evaluatedValue
5700              },
5701              { undoIgnore: true }
5702            );
5703            record[key] = evaluatedValue;
5704          }
5705        }
5706        dispatch3({
5707          type: "SAVE_ENTITY_RECORD_START",
5708          kind,
5709          name,
5710          recordId,
5711          isAutosave
5712        });
5713        let updatedRecord;
5714        let error;
5715        let hasError = false;
5716        const { baseURL } = entityConfig;
5717        try {
5718          const path = `$baseURL}$recordId ? "/" + recordId : ""}`;
5719          const persistedRecord = !isNewRecord ? select5.getRawEntityRecord(kind, name, recordId) : {};
5720          if (entityConfig.syncConfig && !__unstableSkipSyncUpdate && !isNewRecord && persistedRecord) {
5721            getSyncManager()?.update(
5722              `$kind}/$name}`,
5723              recordId,
5724              record,
5725              LOCAL_UNDO_IGNORED_ORIGIN
5726            );
5727          }
5728          if (isAutosave) {
5729            const merged = { ...persistedRecord, ...record };
5730            const data = [
5731              "title",
5732              "excerpt",
5733              "content",
5734              "meta"
5735            ].reduce(
5736              (acc, key) => {
5737                if (key in merged) {
5738                  acc[key] = merged[key];
5739                }
5740                return acc;
5741              },
5742              {
5743                // Do not update the `status` if we have edited it when auto saving.
5744                // It's very important to let the user explicitly save this change,
5745                // because it can lead to unexpected results. An example would be to
5746                // have a draft post and change the status to publish.
5747                status: merged.status === "auto-draft" ? "draft" : void 0
5748              }
5749            );
5750            if (entityConfig.syncConfig) {
5751              const crdtSnapshot = getSyncManager()?.getEntitySnapshot(
5752                `$kind}/$name}`,
5753                recordId
5754              );
5755              if (crdtSnapshot) {
5756                data[CRDT_AUTOSAVE_SNAPSHOT_KEY] = crdtSnapshot;
5757              }
5758            }
5759            updatedRecord = await __unstableFetch({
5760              path: `$path}/autosaves`,
5761              method: "POST",
5762              data
5763            });
5764            if (persistedRecord.id === updatedRecord.id) {
5765              let newRecord = {
5766                ...persistedRecord,
5767                ...data,
5768                ...updatedRecord
5769              };
5770              newRecord = Object.keys(newRecord).reduce(
5771                (acc, key) => {
5772                  if ([
5773                    "title",
5774                    "excerpt",
5775                    "content",
5776                    "meta"
5777                  ].includes(key)) {
5778                    acc[key] = newRecord[key];
5779                  } else if (key === "status") {
5780                    acc[key] = persistedRecord.status === "auto-draft" && newRecord.status === "draft" ? newRecord.status : persistedRecord.status;
5781                  } else {
5782                    acc[key] = persistedRecord[key];
5783                  }
5784                  return acc;
5785                },
5786                {}
5787              );
5788              dispatch3.receiveEntityRecords(
5789                kind,
5790                name,
5791                newRecord,
5792                void 0,
5793                true
5794              );
5795            } else {
5796              dispatch3.receiveAutosaves(
5797                persistedRecord.id,
5798                updatedRecord
5799              );
5800            }
5801          } else {
5802            let edits = record;
5803            if (entityConfig.__unstablePrePersist) {
5804              edits = {
5805                ...edits,
5806                ...await entityConfig.__unstablePrePersist(
5807                  persistedRecord,
5808                  edits
5809                )
5810              };
5811            }
5812            updatedRecord = await __unstableFetch({
5813              path,
5814              method: recordId ? "PUT" : "POST",
5815              data: edits
5816            });
5817            dispatch3.receiveEntityRecords(
5818              kind,
5819              name,
5820              updatedRecord,
5821              void 0,
5822              true,
5823              record
5824            );
5825            if (entityConfig.syncConfig) {
5826              let syncChanges;
5827              if (__unstableSkipSyncUpdate) {
5828                syncChanges = {};
5829              } else if (isNewRecord || !persistedRecord) {
5830                syncChanges = updatedRecord;
5831              } else {
5832                syncChanges = getServerMutatedFields(
5833                  updatedRecord,
5834                  persistedRecord,
5835                  record
5836                );
5837              }
5838              getSyncManager()?.update(
5839                `$kind}/$name}`,
5840                recordId,
5841                syncChanges,
5842                LOCAL_UNDO_IGNORED_ORIGIN,
5843                { isSave: true }
5844              );
5845            }
5846          }
5847        } catch (_error) {
5848          hasError = true;
5849          error = _error;
5850        }
5851        dispatch3({
5852          type: "SAVE_ENTITY_RECORD_FINISH",
5853          kind,
5854          name,
5855          recordId,
5856          error,
5857          isAutosave
5858        });
5859        if (hasError && throwOnError) {
5860          throw error;
5861        }
5862        return updatedRecord;
5863      } finally {
5864        dispatch3.__unstableReleaseStoreLock(lock2);
5865      }
5866    };
5867    var __experimentalBatch = (requests) => async ({ dispatch: dispatch3 }) => {
5868      const batch = createBatch();
5869      const api = {
5870        saveEntityRecord(kind, name, record, options) {
5871          return batch.add(
5872            (add) => dispatch3.saveEntityRecord(kind, name, record, {
5873              ...options,
5874              __unstableFetch: add
5875            })
5876          );
5877        },
5878        saveEditedEntityRecord(kind, name, recordId, options) {
5879          return batch.add(
5880            (add) => dispatch3.saveEditedEntityRecord(kind, name, recordId, {
5881              ...options,
5882              __unstableFetch: add
5883            })
5884          );
5885        },
5886        deleteEntityRecord(kind, name, recordId, query, options) {
5887          return batch.add(
5888            (add) => dispatch3.deleteEntityRecord(kind, name, recordId, query, {
5889              ...options,
5890              __unstableFetch: add
5891            })
5892          );
5893        }
5894      };
5895      const resultPromises = requests.map((request) => request(api));
5896      const [, ...results] = await Promise.all([
5897        batch.run(),
5898        ...resultPromises
5899      ]);
5900      return results;
5901    };
5902    var saveEditedEntityRecord = (kind, name, recordId, options) => async ({ select: select5, dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
5903      logEntityDeprecation(kind, name, "saveEditedEntityRecord");
5904      if (!select5.hasEditsForEntityRecord(kind, name, recordId)) {
5905        return;
5906      }
5907      const configs = await resolveSelect2.getEntitiesConfig(kind);
5908      const entityConfig = configs.find(
5909        (config) => config.kind === kind && config.name === name
5910      );
5911      if (!entityConfig) {
5912        return;
5913      }
5914      const entityIdKey = entityConfig.key || DEFAULT_ENTITY_KEY;
5915      const edits = select5.getEntityRecordNonTransientEdits(
5916        kind,
5917        name,
5918        recordId
5919      );
5920      const record = { [entityIdKey]: recordId, ...edits };
5921      return await dispatch3.saveEntityRecord(kind, name, record, options);
5922    };
5923    var __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async ({ select: select5, dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
5924      logEntityDeprecation(
5925        kind,
5926        name,
5927        "__experimentalSaveSpecifiedEntityEdits"
5928      );
5929      if (!select5.hasEditsForEntityRecord(kind, name, recordId)) {
5930        return;
5931      }
5932      const edits = select5.getEntityRecordNonTransientEdits(
5933        kind,
5934        name,
5935        recordId
5936      );
5937      const editsToSave = {};
5938      for (const item of itemsToSave) {
5939        setNestedValue(editsToSave, item, getNestedValue(edits, item));
5940      }
5941      const configs = await resolveSelect2.getEntitiesConfig(kind);
5942      const entityConfig = configs.find(
5943        (config) => config.kind === kind && config.name === name
5944      );
5945      const entityIdKey = entityConfig?.key || DEFAULT_ENTITY_KEY;
5946      if (recordId) {
5947        editsToSave[entityIdKey] = recordId;
5948      }
5949      return await dispatch3.saveEntityRecord(
5950        kind,
5951        name,
5952        editsToSave,
5953        options
5954      );
5955    };
5956    function receiveUploadPermissions(hasUploadPermissions) {
5957      (0, import_deprecated3.default)("wp.data.dispatch( 'core' ).receiveUploadPermissions", {
5958        since: "5.9",
5959        alternative: "receiveUserPermission"
5960      });
5961      return receiveUserPermission("create/media", hasUploadPermissions);
5962    }
5963    function receiveUserPermission(key, isAllowed) {
5964      return {
5965        type: "RECEIVE_USER_PERMISSION",
5966        key,
5967        isAllowed
5968      };
5969    }
5970    function receiveUserPermissions(permissions) {
5971      return {
5972        type: "RECEIVE_USER_PERMISSIONS",
5973        permissions
5974      };
5975    }
5976    function receiveAutosaves(postId, autosaves2) {
5977      return {
5978        type: "RECEIVE_AUTOSAVES",
5979        postId,
5980        autosaves: Array.isArray(autosaves2) ? autosaves2 : [autosaves2]
5981      };
5982    }
5983    function receiveNavigationFallbackId(fallbackId) {
5984      return {
5985        type: "RECEIVE_NAVIGATION_FALLBACK_ID",
5986        fallbackId
5987      };
5988    }
5989    function receiveDefaultTemplateId(query, templateId) {
5990      return {
5991        type: "RECEIVE_DEFAULT_TEMPLATE",
5992        query,
5993        templateId
5994      };
5995    }
5996    var receiveRevisions = (kind, name, recordKey, records, query, invalidateCache = false, meta) => async ({ dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
5997      logEntityDeprecation(kind, name, "receiveRevisions");
5998      const configs = await resolveSelect2.getEntitiesConfig(kind);
5999      const entityConfig = configs.find(
6000        (config) => config.kind === kind && config.name === name
6001      );
6002      const key = entityConfig?.revisionKey ?? DEFAULT_ENTITY_KEY;
6003      dispatch3({
6004        type: "RECEIVE_ITEM_REVISIONS",
6005        key,
6006        items: records,
6007        recordKey,
6008        meta,
6009        query,
6010        kind,
6011        name,
6012        invalidateCache
6013      });
6014    };
6015  
6016    // packages/core-data/build-module/private-actions.mjs
6017    var private_actions_exports = {};
6018    __export(private_actions_exports, {
6019      __unstableNotifySyncUndoManagerChange: () => __unstableNotifySyncUndoManagerChange,
6020      editMediaEntity: () => editMediaEntity,
6021      receiveEditorAssets: () => receiveEditorAssets,
6022      receiveEditorSettings: () => receiveEditorSettings,
6023      receiveRegisteredPostMeta: () => receiveRegisteredPostMeta,
6024      receiveViewConfig: () => receiveViewConfig,
6025      saveDirtyEntities: () => saveDirtyEntities,
6026      setCollaborationSupported: () => setCollaborationSupported,
6027      setSyncConnectionStatus: () => setSyncConnectionStatus
6028    });
6029    var import_api_fetch5 = __toESM(require_api_fetch(), 1);
6030    var import_notices = __toESM(require_notices(), 1);
6031    var import_block_editor5 = __toESM(require_block_editor(), 1);
6032    var import_html_entities = __toESM(require_html_entities(), 1);
6033    var import_i18n2 = __toESM(require_i18n(), 1);
6034    function receiveRegisteredPostMeta(postType, registeredPostMeta2) {
6035      return {
6036        type: "RECEIVE_REGISTERED_POST_META",
6037        postType,
6038        registeredPostMeta: registeredPostMeta2
6039      };
6040    }
6041    var editMediaEntity = (recordId, edits = {}, { __unstableFetch = import_api_fetch5.default, throwOnError = false } = {}) => async ({ dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
6042      if (!recordId) {
6043        return;
6044      }
6045      const kind = "postType";
6046      const name = "attachment";
6047      const configs = await resolveSelect2.getEntitiesConfig(kind);
6048      const entityConfig = configs.find(
6049        (config) => config.kind === kind && config.name === name
6050      );
6051      if (!entityConfig) {
6052        return;
6053      }
6054      const lock2 = await dispatch3.__unstableAcquireStoreLock(
6055        STORE_NAME,
6056        ["entities", "records", kind, name, recordId],
6057        { exclusive: true }
6058      );
6059      let updatedRecord;
6060      let error;
6061      let hasError = false;
6062      try {
6063        dispatch3({
6064          type: "SAVE_ENTITY_RECORD_START",
6065          kind,
6066          name,
6067          recordId
6068        });
6069        try {
6070          const path = `$entityConfig.baseURL}/$recordId}/edit`;
6071          const newRecord = await __unstableFetch({
6072            path,
6073            method: "POST",
6074            data: {
6075              ...edits
6076            }
6077          });
6078          if (newRecord) {
6079            dispatch3.receiveEntityRecords(
6080              kind,
6081              name,
6082              newRecord,
6083              void 0,
6084              true,
6085              void 0,
6086              void 0
6087            );
6088            updatedRecord = newRecord;
6089          }
6090        } catch (e) {
6091          error = e;
6092          hasError = true;
6093        }
6094        dispatch3({
6095          type: "SAVE_ENTITY_RECORD_FINISH",
6096          kind,
6097          name,
6098          recordId,
6099          error
6100        });
6101        if (hasError && throwOnError) {
6102          throw error;
6103        }
6104        return updatedRecord;
6105      } finally {
6106        dispatch3.__unstableReleaseStoreLock(lock2);
6107      }
6108    };
6109    function receiveEditorSettings(settings) {
6110      return {
6111        type: "RECEIVE_EDITOR_SETTINGS",
6112        settings
6113      };
6114    }
6115    function receiveEditorAssets(assets) {
6116      return {
6117        type: "RECEIVE_EDITOR_ASSETS",
6118        assets
6119      };
6120    }
6121    var setCollaborationSupported = (supported) => ({ dispatch: dispatch3 }) => {
6122      dispatch3({ type: "SET_COLLABORATION_SUPPORTED", supported });
6123      if (!supported && hasSyncManager()) {
6124        getSyncManager().unloadAll();
6125        dispatch3.__unstableNotifySyncUndoManagerChange({
6126          hasUndo: false,
6127          hasRedo: false
6128        });
6129      }
6130    };
6131    function receiveViewConfig(kind, name, config) {
6132      return {
6133        type: "RECEIVE_VIEW_CONFIG",
6134        kind,
6135        name,
6136        config
6137      };
6138    }
6139    function __unstableNotifySyncUndoManagerChange(state) {
6140      return {
6141        type: "SYNC_UNDO_MANAGER_CHANGE",
6142        ...state
6143      };
6144    }
6145    function setSyncConnectionStatus(kind, name, key, status) {
6146      if (!status) {
6147        return {
6148          type: "CLEAR_SYNC_CONNECTION_STATUS",
6149          kind,
6150          name,
6151          key
6152        };
6153      }
6154      return {
6155        type: "SET_SYNC_CONNECTION_STATUS",
6156        kind,
6157        name,
6158        key,
6159        status
6160      };
6161    }
6162    var saveDirtyEntities = ({
6163      onSave,
6164      dirtyEntityRecords = [],
6165      entitiesToSkip = [],
6166      close,
6167      successNoticeContent
6168    } = {}) => ({ registry }) => {
6169      const PUBLISH_ON_SAVE_ENTITIES = [
6170        { kind: "postType", name: "wp_navigation" }
6171      ];
6172      const saveNoticeId = "site-editor-save-success";
6173      const homeUrl = registry.select(STORE_NAME).getEntityRecord("root", "__unstableBase")?.home;
6174      registry.dispatch(import_notices.store).removeNotice(saveNoticeId);
6175      const entitiesToSave = dirtyEntityRecords.filter(
6176        ({ kind, name, key, property }) => {
6177          return !entitiesToSkip.some(
6178            (elt) => elt.kind === kind && elt.name === name && elt.key === key && elt.property === property
6179          );
6180        }
6181      );
6182      close?.(entitiesToSave);
6183      const siteItemsToSave = [];
6184      const pendingSavedRecords = [];
6185      entitiesToSave.forEach(({ kind, name, key, property }) => {
6186        if ("root" === kind && "site" === name) {
6187          siteItemsToSave.push(property);
6188        } else {
6189          if (PUBLISH_ON_SAVE_ENTITIES.some(
6190            (typeToPublish) => typeToPublish.kind === kind && typeToPublish.name === name
6191          )) {
6192            registry.dispatch(STORE_NAME).editEntityRecord(kind, name, key, {
6193              status: "publish"
6194            });
6195          }
6196          pendingSavedRecords.push(
6197            registry.dispatch(STORE_NAME).saveEditedEntityRecord(kind, name, key, {
6198              throwOnError: true
6199            }).catch(ensureError)
6200          );
6201        }
6202      });
6203      if (siteItemsToSave.length) {
6204        pendingSavedRecords.push(
6205          registry.dispatch(STORE_NAME).__experimentalSaveSpecifiedEntityEdits(
6206            "root",
6207            "site",
6208            void 0,
6209            siteItemsToSave,
6210            {
6211              throwOnError: true
6212            }
6213          ).catch(ensureError)
6214        );
6215      }
6216      registry.dispatch(import_block_editor5.store).__unstableMarkLastChangeAsPersistent();
6217      return Promise.all(pendingSavedRecords).then(async (values) => {
6218        if (onSave) {
6219          await onSave();
6220        }
6221        return values;
6222      }).then((values) => {
6223        const errors = values.filter((v) => v instanceof Error);
6224        if (errors.length) {
6225          const firstMessage = errors.find(
6226            (e) => e.message
6227          )?.message;
6228          registry.dispatch(import_notices.store).createErrorNotice(
6229            (0, import_html_entities.decodeEntities)(
6230              firstMessage || (0, import_i18n2.__)("Saving failed.")
6231            ),
6232            {
6233              type: "snackbar",
6234              id: saveNoticeId
6235            }
6236          );
6237        } else {
6238          registry.dispatch(import_notices.store).createSuccessNotice(
6239            successNoticeContent || (0, import_i18n2.__)("Site updated."),
6240            {
6241              type: "snackbar",
6242              id: saveNoticeId,
6243              actions: [
6244                {
6245                  label: (0, import_i18n2.__)("View site"),
6246                  url: homeUrl,
6247                  openInNewTab: true
6248                }
6249              ]
6250            }
6251          );
6252        }
6253      }).catch(
6254        (error) => registry.dispatch(import_notices.store).createErrorNotice(
6255          (0, import_html_entities.decodeEntities)(
6256            error?.message || (0, import_i18n2.__)("Saving failed.")
6257          ),
6258          {
6259            type: "snackbar",
6260            id: saveNoticeId
6261          }
6262        )
6263      );
6264      function ensureError(error) {
6265        if (error instanceof Error) {
6266          return error;
6267        }
6268        let message;
6269        if (!error) {
6270        } else if (typeof error.message === "string") {
6271          message = error.message;
6272        } else if (typeof error === "string") {
6273          message = error;
6274        } else if (
6275          // Only consider own method, lest we erroneously end up calling
6276          // `Object#toString` at the end of the prototype chain, thereby
6277          // returning `"[object Object]"`.
6278          Object.hasOwn(error, "toString") && typeof error.toString === "function"
6279        ) {
6280          const result = error.toString();
6281          if (typeof result === "string") {
6282            message = result;
6283          }
6284        }
6285        return new Error(message, { cause: error });
6286      }
6287    };
6288  
6289    // packages/core-data/build-module/resolvers.mjs
6290    var resolvers_exports = {};
6291    __export(resolvers_exports, {
6292      __experimentalGetCurrentGlobalStylesId: () => __experimentalGetCurrentGlobalStylesId2,
6293      __experimentalGetCurrentThemeBaseGlobalStyles: () => __experimentalGetCurrentThemeBaseGlobalStyles2,
6294      __experimentalGetCurrentThemeGlobalStylesVariations: () => __experimentalGetCurrentThemeGlobalStylesVariations2,
6295      canUser: () => canUser2,
6296      canUserEditEntityRecord: () => canUserEditEntityRecord2,
6297      getAuthors: () => getAuthors2,
6298      getAutosave: () => getAutosave2,
6299      getAutosaves: () => getAutosaves2,
6300      getBlockPatternCategories: () => getBlockPatternCategories2,
6301      getBlockPatterns: () => getBlockPatterns2,
6302      getCurrentTheme: () => getCurrentTheme2,
6303      getCurrentThemeGlobalStylesRevisions: () => getCurrentThemeGlobalStylesRevisions2,
6304      getCurrentUser: () => getCurrentUser2,
6305      getDefaultTemplateId: () => getDefaultTemplateId2,
6306      getEditedEntityRecord: () => getEditedEntityRecord2,
6307      getEditorAssets: () => getEditorAssets2,
6308      getEditorSettings: () => getEditorSettings2,
6309      getEmbedPreview: () => getEmbedPreview2,
6310      getEntitiesConfig: () => getEntitiesConfig2,
6311      getEntityRecord: () => getEntityRecord2,
6312      getEntityRecords: () => getEntityRecords2,
6313      getEntityRecordsTotalItems: () => getEntityRecordsTotalItems2,
6314      getEntityRecordsTotalPages: () => getEntityRecordsTotalPages2,
6315      getNavigationFallbackId: () => getNavigationFallbackId2,
6316      getRawEntityRecord: () => getRawEntityRecord2,
6317      getRegisteredPostMeta: () => getRegisteredPostMeta2,
6318      getRevision: () => getRevision2,
6319      getRevisions: () => getRevisions2,
6320      getThemeSupports: () => getThemeSupports2,
6321      getUserPatternCategories: () => getUserPatternCategories2,
6322      getViewConfig: () => getViewConfig2
6323    });
6324    var import_url6 = __toESM(require_url(), 1);
6325    var import_html_entities3 = __toESM(require_html_entities(), 1);
6326    var import_api_fetch9 = __toESM(require_api_fetch(), 1);
6327  
6328    // packages/core-data/build-module/fetch/index.mjs
6329    var import_api_fetch8 = __toESM(require_api_fetch(), 1);
6330  
6331    // packages/core-data/build-module/fetch/__experimental-fetch-link-suggestions.mjs
6332    var import_api_fetch6 = __toESM(require_api_fetch(), 1);
6333    var import_url4 = __toESM(require_url(), 1);
6334    var import_html_entities2 = __toESM(require_html_entities(), 1);
6335    var import_i18n3 = __toESM(require_i18n(), 1);
6336    async function fetchLinkSuggestions(search, searchOptions = {}, editorSettings2 = {}) {
6337      const searchOptionsToUse = searchOptions.isInitialSuggestions && searchOptions.initialSuggestionsSearchOptions ? {
6338        ...searchOptions,
6339        ...searchOptions.initialSuggestionsSearchOptions
6340      } : searchOptions;
6341      const {
6342        type,
6343        subtype,
6344        page,
6345        perPage = searchOptions.isInitialSuggestions ? 3 : 20
6346      } = searchOptionsToUse;
6347      const { disablePostFormats = false } = editorSettings2;
6348      const queries2 = [];
6349      if (!type || type === "post") {
6350        queries2.push(
6351          (0, import_api_fetch6.default)({
6352            path: (0, import_url4.addQueryArgs)("/wp/v2/search", {
6353              search,
6354              page,
6355              per_page: perPage,
6356              type: "post",
6357              subtype
6358            })
6359          }).then((results2) => {
6360            return results2.map((result) => {
6361              return {
6362                id: result.id,
6363                url: result.url,
6364                title: (0, import_html_entities2.decodeEntities)(result.title || "") || (0, import_i18n3.__)("(no title)"),
6365                type: result.subtype || result.type,
6366                kind: "post-type"
6367              };
6368            });
6369          }).catch(() => [])
6370          // Fail by returning no results.
6371        );
6372      }
6373      if (!type || type === "term") {
6374        queries2.push(
6375          (0, import_api_fetch6.default)({
6376            path: (0, import_url4.addQueryArgs)("/wp/v2/search", {
6377              search,
6378              page,
6379              per_page: perPage,
6380              type: "term",
6381              subtype
6382            })
6383          }).then((results2) => {
6384            return results2.map((result) => {
6385              return {
6386                id: result.id,
6387                url: result.url,
6388                title: (0, import_html_entities2.decodeEntities)(result.title || "") || (0, import_i18n3.__)("(no title)"),
6389                type: result.subtype || result.type,
6390                kind: "taxonomy"
6391              };
6392            });
6393          }).catch(() => [])
6394          // Fail by returning no results.
6395        );
6396      }
6397      if (!disablePostFormats && (!type || type === "post-format")) {
6398        queries2.push(
6399          (0, import_api_fetch6.default)({
6400            path: (0, import_url4.addQueryArgs)("/wp/v2/search", {
6401              search,
6402              page,
6403              per_page: perPage,
6404              type: "post-format",
6405              subtype
6406            })
6407          }).then((results2) => {
6408            return results2.map((result) => {
6409              return {
6410                id: result.id,
6411                url: result.url,
6412                title: (0, import_html_entities2.decodeEntities)(result.title || "") || (0, import_i18n3.__)("(no title)"),
6413                type: result.subtype || result.type,
6414                kind: "taxonomy"
6415              };
6416            });
6417          }).catch(() => [])
6418          // Fail by returning no results.
6419        );
6420      }
6421      if (!type || type === "attachment") {
6422        queries2.push(
6423          (0, import_api_fetch6.default)({
6424            path: (0, import_url4.addQueryArgs)("/wp/v2/media", {
6425              search,
6426              page,
6427              per_page: perPage
6428            })
6429          }).then((results2) => {
6430            return results2.map((result) => {
6431              return {
6432                id: result.id,
6433                url: result.source_url,
6434                title: (0, import_html_entities2.decodeEntities)(result.title.rendered || "") || (0, import_i18n3.__)("(no title)"),
6435                type: result.type,
6436                kind: "media"
6437              };
6438            });
6439          }).catch(() => [])
6440          // Fail by returning no results.
6441        );
6442      }
6443      const responses = await Promise.all(queries2);
6444      let results = responses.flat();
6445      results = results.filter((result) => !!result.id);
6446      results = sortResults(results, search);
6447      results = results.slice(0, perPage);
6448      return results;
6449    }
6450    function sortResults(results, search) {
6451      const searchTokens = tokenize(search);
6452      const scoreKey = (result) => `$result.kind}:$result.type}:$result.id}`;
6453      const scores = {};
6454      for (const result of results) {
6455        if (result.title) {
6456          const titleTokens = tokenize(result.title);
6457          const exactMatchingTokens = titleTokens.filter(
6458            (titleToken) => searchTokens.some(
6459              (searchToken) => titleToken === searchToken
6460            )
6461          );
6462          const subMatchingTokens = titleTokens.filter(
6463            (titleToken) => searchTokens.some(
6464              (searchToken) => titleToken !== searchToken && titleToken.includes(searchToken)
6465            )
6466          );
6467          const exactMatchScore = exactMatchingTokens.length / titleTokens.length * 10;
6468          const subMatchScore = subMatchingTokens.length / titleTokens.length;
6469          scores[scoreKey(result)] = exactMatchScore + subMatchScore;
6470        } else {
6471          scores[scoreKey(result)] = 0;
6472        }
6473      }
6474      return results.sort(
6475        (a, b) => scores[scoreKey(b)] - scores[scoreKey(a)]
6476      );
6477    }
6478    function tokenize(text) {
6479      return text.toLowerCase().match(/[\p{L}\p{N}]+/gu) || [];
6480    }
6481  
6482    // packages/core-data/build-module/fetch/__experimental-fetch-url-data.mjs
6483    var import_api_fetch7 = __toESM(require_api_fetch(), 1);
6484    var import_url5 = __toESM(require_url(), 1);
6485    var CACHE = /* @__PURE__ */ new Map();
6486    var fetchUrlData = async (url, options = {}) => {
6487      const endpoint = "/wp-block-editor/v1/url-details";
6488      const args = {
6489        url: (0, import_url5.prependHTTP)(url)
6490      };
6491      if (!(0, import_url5.isURL)(url)) {
6492        return Promise.reject(`$url} is not a valid URL.`);
6493      }
6494      const protocol = (0, import_url5.getProtocol)(url);
6495      if (!protocol || !(0, import_url5.isValidProtocol)(protocol) || !protocol.startsWith("http") || !/^https?:\/\/[^\/\s]/i.test(url)) {
6496        return Promise.reject(
6497          `$url} does not have a valid protocol. URLs must be "http" based`
6498        );
6499      }
6500      if (CACHE.has(url)) {
6501        return CACHE.get(url);
6502      }
6503      return (0, import_api_fetch7.default)({
6504        path: (0, import_url5.addQueryArgs)(endpoint, args),
6505        ...options
6506      }).then((res) => {
6507        CACHE.set(url, res);
6508        return res;
6509      });
6510    };
6511    var experimental_fetch_url_data_default = fetchUrlData;
6512  
6513    // packages/core-data/build-module/fetch/index.mjs
6514    async function fetchBlockPatterns() {
6515      const restPatterns = await (0, import_api_fetch8.default)({
6516        path: "/wp/v2/block-patterns/patterns"
6517      });
6518      if (!restPatterns) {
6519        return [];
6520      }
6521      return restPatterns.map(
6522        (pattern) => Object.fromEntries(
6523          Object.entries(pattern).map(([key, value]) => [
6524            camelCase(key),
6525            value
6526          ])
6527        )
6528      );
6529    }
6530  
6531    // packages/core-data/build-module/parsed-blocks-cache.mjs
6532    var import_data10 = __toESM(require_data(), 1);
6533    var import_blocks5 = __toESM(require_blocks(), 1);
6534    var caches = /* @__PURE__ */ new WeakMap();
6535    function getCacheKey(kind, name, id) {
6536      return `$kind}:$name}:$id}`;
6537    }
6538    function getBlockTypes2() {
6539      return (0, import_data10.select)(import_blocks5.store).getBlockTypes();
6540    }
6541    function getCachedBlocks(kind, name, id, content) {
6542      const cached = caches.get(getBlockTypes2())?.get(getCacheKey(kind, name, id));
6543      if (cached && cached.content === content) {
6544        return cached.blocks;
6545      }
6546    }
6547    function setCachedBlocks(kind, name, id, content, blocks) {
6548      const blockTypes = getBlockTypes2();
6549      let cache3 = caches.get(blockTypes);
6550      if (!cache3) {
6551        cache3 = /* @__PURE__ */ new Map();
6552        caches.set(blockTypes, cache3);
6553      }
6554      cache3.set(getCacheKey(kind, name, id), { content, blocks });
6555    }
6556  
6557    // packages/core-data/build-module/resolvers.mjs
6558    var getAuthors2 = (query) => async ({ dispatch: dispatch3 }) => {
6559      const path = (0, import_url6.addQueryArgs)(
6560        "/wp/v2/users/?who=authors&per_page=100",
6561        query
6562      );
6563      const users2 = await (0, import_api_fetch9.default)({ path });
6564      dispatch3.receiveUserQuery(path, users2);
6565    };
6566    var getCurrentUser2 = () => async ({ dispatch: dispatch3 }) => {
6567      const currentUser2 = await (0, import_api_fetch9.default)({ path: "/wp/v2/users/me" });
6568      dispatch3.receiveCurrentUser(currentUser2);
6569    };
6570    var getEntityRecord2 = (kind, name, key = "", query) => async ({ select: select5, dispatch: dispatch3, registry, resolveSelect: resolveSelect2 }) => {
6571      const configs = await resolveSelect2.getEntitiesConfig(kind);
6572      const entityConfig = configs.find(
6573        (config) => config.name === name && config.kind === kind
6574      );
6575      if (!entityConfig) {
6576        return;
6577      }
6578      const lock2 = await dispatch3.__unstableAcquireStoreLock(
6579        STORE_NAME,
6580        ["entities", "records", kind, name, key],
6581        { exclusive: false }
6582      );
6583      try {
6584        if (query !== void 0 && query._fields) {
6585          query = {
6586            ...query,
6587            _fields: [
6588              .../* @__PURE__ */ new Set([
6589                ...get_normalized_comma_separable_default(query._fields) || [],
6590                entityConfig.key || DEFAULT_ENTITY_KEY
6591              ])
6592            ].join()
6593          };
6594        }
6595        if (query !== void 0 && query._fields) {
6596          const hasRecord = select5.hasEntityRecord(
6597            kind,
6598            name,
6599            key,
6600            query
6601          );
6602          if (hasRecord) {
6603            return;
6604          }
6605        }
6606        const { baseURL } = entityConfig;
6607        const path = (0, import_url6.addQueryArgs)(baseURL + (key ? "/" + key : ""), {
6608          ...entityConfig.baseURLParams,
6609          ...query
6610        });
6611        const response = await (0, import_api_fetch9.default)({ path, parse: false });
6612        const record = await response.json();
6613        const permissions = getUserPermissionsFromAllowHeader(
6614          response.headers?.get("allow")
6615        );
6616        const receiveUserPermissionArgs = {};
6617        for (const action of ALLOWED_RESOURCE_ACTIONS) {
6618          receiveUserPermissionArgs[getUserPermissionCacheKey(action, {
6619            kind,
6620            name,
6621            id: key
6622          })] = permissions[action];
6623        }
6624        const canUserResolutionsArgs = [[{ kind, name, id: key }]];
6625        if (entityConfig.syncConfig && isNumericID(key) && !query) {
6626          const objectType = `$kind}/$name}`;
6627          const objectId = key;
6628          const recordWithTransients = { ...record };
6629          Object.entries(entityConfig.transientEdits ?? {}).filter(
6630            ([propName, transientConfig]) => void 0 === recordWithTransients[propName] && transientConfig && "object" === typeof transientConfig && "read" in transientConfig && "function" === typeof transientConfig.read
6631          ).forEach(([propName, transientConfig]) => {
6632            recordWithTransients[propName] = transientConfig.read(recordWithTransients);
6633          });
6634          if (recordWithTransients.blocks && typeof recordWithTransients.content?.raw === "string") {
6635            setCachedBlocks(
6636              kind,
6637              name,
6638              key,
6639              recordWithTransients.content.raw,
6640              recordWithTransients.blocks
6641            );
6642          }
6643          const syncManager2 = select5?.isCollaborationSupported?.() === false ? void 0 : getSyncManager();
6644          void syncManager2?.load(
6645            entityConfig.syncConfig,
6646            objectType,
6647            objectId,
6648            recordWithTransients,
6649            {
6650              // Handle edits sourced from the sync manager.
6651              editRecord: (edits, options = {}) => {
6652                if (!Object.keys(edits).length) {
6653                  return;
6654                }
6655                dispatch3({
6656                  type: "EDIT_ENTITY_RECORD",
6657                  kind,
6658                  name,
6659                  recordId: key,
6660                  edits,
6661                  meta: {
6662                    undo: void 0
6663                  },
6664                  options
6665                });
6666              },
6667              // Get the current entity record (with edits)
6668              getEditedRecord: async () => await resolveSelect2.getEditedEntityRecord(
6669                kind,
6670                name,
6671                key
6672              ),
6673              // Handle sync connection status changes.
6674              onStatusChange: (status) => {
6675                dispatch3.setSyncConnectionStatus(
6676                  kind,
6677                  name,
6678                  key,
6679                  status
6680                );
6681              },
6682              // Refetch the current entity record from the database.
6683              refetchRecord: async () => {
6684                dispatch3.receiveEntityRecords(
6685                  kind,
6686                  name,
6687                  await (0, import_api_fetch9.default)({ path, parse: true }),
6688                  query
6689                );
6690              },
6691              // Persist the CRDT document.
6692              //
6693              // TODO: Currently, persisted CRDT documents are stored in post meta.
6694              // This effectively means that only post entities support CRDT
6695              // persistence. As we add support for syncing additional entity,
6696              // we'll need to revisit where persisted CRDT documents are stored.
6697              persistCRDTDoc: () => {
6698                if (!entityConfig.syncConfig?.supportsPersistence) {
6699                  return;
6700                }
6701                return resolveSelect2.getEditedEntityRecord(kind, name, key).then(async (editedRecord) => {
6702                  const { meta, status } = editedRecord;
6703                  if ("auto-draft" === status || !meta) {
6704                    return;
6705                  }
6706                  const entityIdKey = entityConfig.key || DEFAULT_ENTITY_KEY;
6707                  const entityId = editedRecord[entityIdKey];
6708                  await saveCRDTDoc(
6709                    `$kind}/$name}`,
6710                    entityId
6711                  );
6712                });
6713              },
6714              addUndoMeta: (ydoc, meta) => {
6715                const selectionHistory = getSelectionHistory(ydoc);
6716                if (selectionHistory) {
6717                  meta.set(
6718                    "selectionHistory",
6719                    selectionHistory
6720                  );
6721                }
6722              },
6723              onUndoStackChange: (undoState) => {
6724                dispatch3.__unstableNotifySyncUndoManagerChange(
6725                  undoState
6726                );
6727              },
6728              restoreUndoMeta: (ydoc, meta) => {
6729                const selectionHistory = meta.get("selectionHistory");
6730                if (selectionHistory) {
6731                  setTimeout(() => {
6732                    restoreSelection(selectionHistory, ydoc);
6733                  }, 0);
6734                }
6735              }
6736            }
6737          );
6738        }
6739        registry.batch(() => {
6740          dispatch3.receiveEntityRecords(kind, name, record, query);
6741          dispatch3.receiveUserPermissions(receiveUserPermissionArgs);
6742          dispatch3.finishResolutions("canUser", canUserResolutionsArgs);
6743        });
6744      } finally {
6745        dispatch3.__unstableReleaseStoreLock(lock2);
6746      }
6747    };
6748    getEntityRecord2.shouldInvalidate = (action, kind, name) => {
6749      return kind === "root" && name === "site" && (action.type === "RECEIVE_ITEMS" && // Making sure persistedEdits is set seems to be the only way of
6750      // knowing whether it's an update or fetch. Only an update would
6751      // have persistedEdits.
6752      action.persistedEdits && action.persistedEdits.status !== "auto-draft" || action.type === "REMOVE_ITEMS") && action.kind === "postType" && action.name === "wp_template";
6753    };
6754    var getRawEntityRecord2 = forward_resolver_default("getEntityRecord");
6755    var getEditedEntityRecord2 = forward_resolver_default("getEntityRecord");
6756    var getEntityRecords2 = (kind, name, query = {}) => async ({ dispatch: dispatch3, registry, resolveSelect: resolveSelect2 }) => {
6757      const configs = await resolveSelect2.getEntitiesConfig(kind);
6758      const entityConfig = configs.find(
6759        (config) => config.name === name && config.kind === kind
6760      );
6761      if (!entityConfig) {
6762        return;
6763      }
6764      const lock2 = await dispatch3.__unstableAcquireStoreLock(
6765        STORE_NAME,
6766        ["entities", "records", kind, name],
6767        { exclusive: false }
6768      );
6769      const rawQuery = { ...query };
6770      const key = entityConfig.key || DEFAULT_ENTITY_KEY;
6771      function getResolutionsArgs(records, recordsQuery) {
6772        const normalizedQuery = normalizeQueryForResolution(recordsQuery);
6773        return records.filter((record) => record?.[key]).map((record) => [
6774          kind,
6775          name,
6776          record[key],
6777          normalizedQuery
6778        ]);
6779      }
6780      try {
6781        if (query._fields) {
6782          query = {
6783            ...query,
6784            _fields: [
6785              .../* @__PURE__ */ new Set([
6786                ...get_normalized_comma_separable_default(query._fields) || [],
6787                key
6788              ])
6789            ].join()
6790          };
6791        }
6792        const { baseURL } = entityConfig;
6793        const path = (0, import_url6.addQueryArgs)(baseURL, {
6794          ...entityConfig.baseURLParams,
6795          ...query
6796        });
6797        let records = [], meta;
6798        if (entityConfig.supportsPagination && query.per_page !== -1) {
6799          const response = await (0, import_api_fetch9.default)({ path, parse: false });
6800          records = Object.values(await response.json());
6801          meta = getPaginationMeta(response.headers);
6802        } else if (query.per_page === -1 && query[RECEIVE_INTERMEDIATE_RESULTS] === true) {
6803          let page = 1;
6804          let totalPages;
6805          do {
6806            const response = await (0, import_api_fetch9.default)({
6807              path: (0, import_url6.addQueryArgs)(path, { page, per_page: 100 }),
6808              parse: false
6809            });
6810            const pageRecords = Object.values(await response.json());
6811            const pageMeta = getPaginationMeta(response.headers);
6812            totalPages = pageMeta.totalPages ?? 1;
6813            if (!meta) {
6814              meta = {
6815                totalItems: pageMeta.totalItems,
6816                totalPages: 1
6817              };
6818            }
6819            records.push(...pageRecords);
6820            registry.batch(() => {
6821              dispatch3.receiveEntityRecords(
6822                kind,
6823                name,
6824                records,
6825                query,
6826                false,
6827                void 0,
6828                meta
6829              );
6830              dispatch3.finishResolutions(
6831                "getEntityRecord",
6832                getResolutionsArgs(pageRecords, rawQuery)
6833              );
6834            });
6835            page++;
6836          } while (page <= totalPages);
6837        } else {
6838          records = Object.values(await (0, import_api_fetch9.default)({ path }));
6839          meta = {
6840            totalItems: records.length,
6841            totalPages: 1
6842          };
6843        }
6844        if (entityConfig.syncConfig && -1 === query.per_page) {
6845          const objectType = `$kind}/$name}`;
6846          getSyncManager()?.loadCollection(
6847            entityConfig.syncConfig,
6848            objectType,
6849            {
6850              onStatusChange: (status) => {
6851                dispatch3.setSyncConnectionStatus(
6852                  kind,
6853                  name,
6854                  null,
6855                  status
6856                );
6857              },
6858              refetchRecords: async () => {
6859                dispatch3.receiveEntityRecords(
6860                  kind,
6861                  name,
6862                  await (0, import_api_fetch9.default)({ path, parse: true }),
6863                  query
6864                );
6865              }
6866            }
6867          );
6868        }
6869        if (query._fields) {
6870          records = records.map((record) => {
6871            query._fields.split(",").forEach((field) => {
6872              if (!record.hasOwnProperty(field)) {
6873                record[field] = void 0;
6874              }
6875            });
6876            return record;
6877          });
6878        }
6879        registry.batch(() => {
6880          dispatch3.receiveEntityRecords(
6881            kind,
6882            name,
6883            records,
6884            query,
6885            false,
6886            void 0,
6887            meta
6888          );
6889          const targetHints = records.filter(
6890            (record) => !!record?.[key] && !!record?._links?.self?.[0]?.targetHints?.allow
6891          ).map((record) => ({
6892            id: record[key],
6893            permissions: getUserPermissionsFromAllowHeader(
6894              record._links.self[0].targetHints.allow
6895            )
6896          }));
6897          const canUserResolutionsArgs = [];
6898          const receiveUserPermissionArgs = {};
6899          for (const targetHint of targetHints) {
6900            canUserResolutionsArgs.push([
6901              { kind, name, id: targetHint.id }
6902            ]);
6903            for (const action of ALLOWED_RESOURCE_ACTIONS) {
6904              receiveUserPermissionArgs[getUserPermissionCacheKey(action, {
6905                kind,
6906                name,
6907                id: targetHint.id
6908              })] = targetHint.permissions[action];
6909            }
6910          }
6911          if (targetHints.length > 0) {
6912            dispatch3.receiveUserPermissions(
6913              receiveUserPermissionArgs
6914            );
6915            dispatch3.finishResolutions(
6916              "canUser",
6917              canUserResolutionsArgs
6918            );
6919          }
6920          dispatch3.finishResolutions(
6921            "getEntityRecord",
6922            getResolutionsArgs(records, rawQuery)
6923          );
6924          dispatch3.__unstableReleaseStoreLock(lock2);
6925        });
6926      } catch {
6927        dispatch3.__unstableReleaseStoreLock(lock2);
6928      }
6929    };
6930    getEntityRecords2.shouldInvalidate = (action, kind, name) => {
6931      return (action.type === "RECEIVE_ITEMS" || action.type === "REMOVE_ITEMS") && action.invalidateCache && kind === action.kind && name === action.name;
6932    };
6933    var getEntityRecordsTotalItems2 = forward_resolver_default("getEntityRecords");
6934    var getEntityRecordsTotalPages2 = forward_resolver_default("getEntityRecords");
6935    var getCurrentTheme2 = () => async ({ dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
6936      const activeThemes = await resolveSelect2.getEntityRecords(
6937        "root",
6938        "theme",
6939        { status: "active" }
6940      );
6941      dispatch3.receiveCurrentTheme(activeThemes[0]);
6942    };
6943    var getThemeSupports2 = forward_resolver_default("getCurrentTheme");
6944    var getEmbedPreview2 = (url) => async ({ dispatch: dispatch3 }) => {
6945      try {
6946        const embedProxyResponse = await (0, import_api_fetch9.default)({
6947          path: (0, import_url6.addQueryArgs)("/oembed/1.0/proxy", { url })
6948        });
6949        dispatch3.receiveEmbedPreview(url, embedProxyResponse);
6950      } catch {
6951        dispatch3.receiveEmbedPreview(url, false);
6952      }
6953    };
6954    var canUser2 = (resource, id) => async ({ dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
6955      let resourcePath = null;
6956      if (typeof resource === "object") {
6957        if (!resource.kind || !resource.name) {
6958          throw new Error("The entity resource object is not valid.");
6959        }
6960        const configs = await resolveSelect2.getEntitiesConfig(
6961          resource.kind
6962        );
6963        const entityConfig = configs.find(
6964          (config) => config.name === resource.name && config.kind === resource.kind
6965        );
6966        if (!entityConfig) {
6967          return;
6968        }
6969        resourcePath = entityConfig.baseURL + (resource.id ? "/" + resource.id : "");
6970      } else {
6971        resourcePath = `/wp/v2/$resource}` + (id ? "/" + id : "");
6972      }
6973      let response;
6974      try {
6975        response = await (0, import_api_fetch9.default)({
6976          path: resourcePath,
6977          method: "OPTIONS",
6978          parse: false
6979        });
6980      } catch {
6981        return;
6982      }
6983      const permissions = getUserPermissionsFromAllowHeader(
6984        response.headers?.get("allow")
6985      );
6986      const receiveUserPermissionArgs = {};
6987      for (const action of ALLOWED_RESOURCE_ACTIONS) {
6988        receiveUserPermissionArgs[getUserPermissionCacheKey(action, resource, id)] = permissions[action];
6989      }
6990      dispatch3.receiveUserPermissions(receiveUserPermissionArgs);
6991    };
6992    canUser2.getResolutionArgs = (action, resource, id) => [resource, id];
6993    var canUserEditEntityRecord2 = (kind, name, recordId) => async ({ resolveSelect: resolveSelect2 }) => {
6994      await resolveSelect2.canUser("update", { kind, name, id: recordId });
6995    };
6996    var getAutosaves2 = (postType, postId) => async ({ dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
6997      const {
6998        rest_base: restBase,
6999        rest_namespace: restNamespace = "wp/v2",
7000        supports
7001      } = await resolveSelect2.getPostType(postType);
7002      if (!supports?.autosave) {
7003        return;
7004      }
7005      const autosaves2 = await (0, import_api_fetch9.default)({
7006        path: `/$restNamespace}/$restBase}/$postId}/autosaves?context=edit`
7007      });
7008      if (autosaves2 && autosaves2.length) {
7009        dispatch3.receiveAutosaves(postId, autosaves2);
7010      }
7011    };
7012    var getAutosave2 = (postType, postId) => async ({ resolveSelect: resolveSelect2 }) => {
7013      await resolveSelect2.getAutosaves(postType, postId);
7014    };
7015    var __experimentalGetCurrentGlobalStylesId2 = () => async ({ dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
7016      const activeThemes = await resolveSelect2.getEntityRecords(
7017        "root",
7018        "theme",
7019        { status: "active" }
7020      );
7021      const globalStylesURL = activeThemes?.[0]?._links?.["wp:user-global-styles"]?.[0]?.href;
7022      if (!globalStylesURL) {
7023        return;
7024      }
7025      const matches = globalStylesURL.match(/\/(\d+)(?:\?|$)/);
7026      const id = matches ? Number(matches[1]) : null;
7027      if (id) {
7028        dispatch3.__experimentalReceiveCurrentGlobalStylesId(id);
7029      }
7030    };
7031    var __experimentalGetCurrentThemeBaseGlobalStyles2 = () => async ({ resolveSelect: resolveSelect2, dispatch: dispatch3 }) => {
7032      const currentTheme2 = await resolveSelect2.getCurrentTheme();
7033      const themeGlobalStyles = await (0, import_api_fetch9.default)({
7034        path: `/wp/v2/global-styles/themes/$currentTheme2.stylesheet}?context=view`
7035      });
7036      dispatch3.__experimentalReceiveThemeBaseGlobalStyles(
7037        currentTheme2.stylesheet,
7038        themeGlobalStyles
7039      );
7040    };
7041    var __experimentalGetCurrentThemeGlobalStylesVariations2 = () => async ({ resolveSelect: resolveSelect2, dispatch: dispatch3 }) => {
7042      const currentTheme2 = await resolveSelect2.getCurrentTheme();
7043      const variations = await (0, import_api_fetch9.default)({
7044        path: `/wp/v2/global-styles/themes/$currentTheme2.stylesheet}/variations?context=view`
7045      });
7046      dispatch3.__experimentalReceiveThemeGlobalStyleVariations(
7047        currentTheme2.stylesheet,
7048        variations
7049      );
7050    };
7051    var getCurrentThemeGlobalStylesRevisions2 = () => async ({ resolveSelect: resolveSelect2, dispatch: dispatch3 }) => {
7052      const globalStylesId = await resolveSelect2.__experimentalGetCurrentGlobalStylesId();
7053      const record = globalStylesId ? await resolveSelect2.getEntityRecord(
7054        "root",
7055        "globalStyles",
7056        globalStylesId
7057      ) : void 0;
7058      const revisionsURL = record?._links?.["version-history"]?.[0]?.href;
7059      if (revisionsURL) {
7060        const resetRevisions = await (0, import_api_fetch9.default)({
7061          url: revisionsURL
7062        });
7063        const revisions = resetRevisions?.map(
7064          (revision) => Object.fromEntries(
7065            Object.entries(revision).map(([key, value]) => [
7066              camelCase(key),
7067              value
7068            ])
7069          )
7070        );
7071        dispatch3.receiveThemeGlobalStyleRevisions(
7072          globalStylesId,
7073          revisions
7074        );
7075      }
7076    };
7077    getCurrentThemeGlobalStylesRevisions2.shouldInvalidate = (action) => {
7078      return action.type === "SAVE_ENTITY_RECORD_FINISH" && action.kind === "root" && !action.error && action.name === "globalStyles";
7079    };
7080    var getBlockPatterns2 = () => async ({ dispatch: dispatch3 }) => {
7081      const patterns = await fetchBlockPatterns();
7082      dispatch3({ type: "RECEIVE_BLOCK_PATTERNS", patterns });
7083    };
7084    var getBlockPatternCategories2 = () => async ({ dispatch: dispatch3 }) => {
7085      const categories = await (0, import_api_fetch9.default)({
7086        path: "/wp/v2/block-patterns/categories"
7087      });
7088      dispatch3({ type: "RECEIVE_BLOCK_PATTERN_CATEGORIES", categories });
7089    };
7090    var getUserPatternCategories2 = () => async ({ dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
7091      const patternCategories = await resolveSelect2.getEntityRecords(
7092        "taxonomy",
7093        "wp_pattern_category",
7094        {
7095          per_page: -1,
7096          _fields: "id,name,description,slug",
7097          context: "view"
7098        }
7099      );
7100      const mappedPatternCategories = patternCategories?.map((userCategory) => ({
7101        ...userCategory,
7102        label: (0, import_html_entities3.decodeEntities)(userCategory.name),
7103        name: userCategory.slug
7104      })) || [];
7105      dispatch3({
7106        type: "RECEIVE_USER_PATTERN_CATEGORIES",
7107        patternCategories: mappedPatternCategories
7108      });
7109    };
7110    var getNavigationFallbackId2 = () => async ({ dispatch: dispatch3, select: select5, registry }) => {
7111      const fallback = await (0, import_api_fetch9.default)({
7112        path: (0, import_url6.addQueryArgs)("/wp-block-editor/v1/navigation-fallback", {
7113          _embed: true
7114        })
7115      });
7116      const record = fallback?._embedded?.self;
7117      registry.batch(() => {
7118        dispatch3.receiveNavigationFallbackId(fallback?.id);
7119        if (!record) {
7120          return;
7121        }
7122        const existingFallbackEntityRecord = select5.getEntityRecord(
7123          "postType",
7124          "wp_navigation",
7125          fallback.id
7126        );
7127        const invalidateNavigationQueries = !existingFallbackEntityRecord;
7128        dispatch3.receiveEntityRecords(
7129          "postType",
7130          "wp_navigation",
7131          record,
7132          void 0,
7133          invalidateNavigationQueries
7134        );
7135        dispatch3.finishResolution("getEntityRecord", [
7136          "postType",
7137          "wp_navigation",
7138          fallback.id
7139        ]);
7140      });
7141    };
7142    var getDefaultTemplateId2 = (query) => async ({ dispatch: dispatch3, registry, resolveSelect: resolveSelect2 }) => {
7143      const template = await (0, import_api_fetch9.default)({
7144        path: (0, import_url6.addQueryArgs)("/wp/v2/templates/lookup", query)
7145      });
7146      await resolveSelect2.getEntitiesConfig("postType");
7147      const id = template?.id;
7148      registry.batch(() => {
7149        dispatch3.receiveDefaultTemplateId(query, id || "");
7150        if (id) {
7151          template.id = id;
7152          dispatch3.receiveEntityRecords(
7153            "postType",
7154            template.type,
7155            template
7156          );
7157          dispatch3.finishResolution("getEntityRecord", [
7158            "postType",
7159            template.type,
7160            id
7161          ]);
7162        }
7163      });
7164    };
7165    var getRevisions2 = (kind, name, recordKey, query = {}) => async ({ dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
7166      const configs = await resolveSelect2.getEntitiesConfig(kind);
7167      const entityConfig = configs.find(
7168        (config) => config.name === name && config.kind === kind
7169      );
7170      if (!entityConfig) {
7171        return;
7172      }
7173      const rawQuery = { ...query };
7174      const lock2 = await dispatch3.__unstableAcquireStoreLock(
7175        STORE_NAME,
7176        ["entities", "records", kind, name, recordKey, "revisions"],
7177        { exclusive: false }
7178      );
7179      try {
7180        if (query._fields) {
7181          query = {
7182            ...query,
7183            _fields: [
7184              .../* @__PURE__ */ new Set([
7185                ...get_normalized_comma_separable_default(query._fields) || [],
7186                entityConfig.revisionKey || DEFAULT_ENTITY_KEY
7187              ])
7188            ].join()
7189          };
7190        }
7191        const path = (0, import_url6.addQueryArgs)(
7192          entityConfig.getRevisionsUrl(recordKey),
7193          query
7194        );
7195        let records, response;
7196        const meta = {};
7197        const isPaginated = entityConfig.supportsPagination && query.per_page !== -1;
7198        try {
7199          response = await (0, import_api_fetch9.default)({ path, parse: !isPaginated });
7200        } catch {
7201          return;
7202        }
7203        if (response) {
7204          if (isPaginated) {
7205            records = Object.values(await response.json());
7206            meta.totalItems = getPaginationMeta(
7207              response.headers
7208            ).totalItems;
7209          } else {
7210            records = Object.values(response);
7211          }
7212          if (query._fields) {
7213            records = records.map((record) => {
7214              query._fields.split(",").forEach((field) => {
7215                if (!record.hasOwnProperty(field)) {
7216                  record[field] = void 0;
7217                }
7218              });
7219              return record;
7220            });
7221          }
7222          await dispatch3.receiveRevisions(
7223            kind,
7224            name,
7225            recordKey,
7226            records,
7227            query,
7228            false,
7229            meta
7230          );
7231          const key = entityConfig.revisionKey || DEFAULT_ENTITY_KEY;
7232          const normalizedQuery = normalizeQueryForResolution(rawQuery);
7233          const resolutionsArgs = records.filter((record) => record[key]).map((record) => [
7234            kind,
7235            name,
7236            recordKey,
7237            record[key],
7238            normalizedQuery
7239          ]);
7240          dispatch3.finishResolutions("getRevision", resolutionsArgs);
7241        }
7242      } finally {
7243        dispatch3.__unstableReleaseStoreLock(lock2);
7244      }
7245    };
7246    getRevisions2.shouldInvalidate = (action, kind, name, recordKey) => action.type === "SAVE_ENTITY_RECORD_FINISH" && name === action.name && kind === action.kind && !action.error && recordKey === action.recordId;
7247    var getRevision2 = (kind, name, recordKey, revisionKey, query) => async ({ select: select5, dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
7248      const configs = await resolveSelect2.getEntitiesConfig(kind);
7249      const entityConfig = configs.find(
7250        (config) => config.name === name && config.kind === kind
7251      );
7252      if (!entityConfig) {
7253        return;
7254      }
7255      if (query !== void 0 && query._fields) {
7256        query = {
7257          ...query,
7258          _fields: [
7259            .../* @__PURE__ */ new Set([
7260              ...get_normalized_comma_separable_default(query._fields) || [],
7261              entityConfig.revisionKey || DEFAULT_ENTITY_KEY
7262            ])
7263          ].join()
7264        };
7265      }
7266      const lock2 = await dispatch3.__unstableAcquireStoreLock(
7267        STORE_NAME,
7268        [
7269          "entities",
7270          "records",
7271          kind,
7272          name,
7273          recordKey,
7274          "revisions",
7275          revisionKey
7276        ],
7277        { exclusive: false }
7278      );
7279      try {
7280        if (select5.hasRevision(kind, name, recordKey, revisionKey, query)) {
7281          return;
7282        }
7283        const path = (0, import_url6.addQueryArgs)(
7284          entityConfig.getRevisionsUrl(recordKey, revisionKey),
7285          query
7286        );
7287        let record;
7288        try {
7289          record = await (0, import_api_fetch9.default)({ path });
7290        } catch {
7291          return;
7292        }
7293        if (record) {
7294          await dispatch3.receiveRevisions(
7295            kind,
7296            name,
7297            recordKey,
7298            record,
7299            query
7300          );
7301        }
7302      } finally {
7303        dispatch3.__unstableReleaseStoreLock(lock2);
7304      }
7305    };
7306    var getRegisteredPostMeta2 = (postType) => async ({ dispatch: dispatch3, resolveSelect: resolveSelect2 }) => {
7307      let options;
7308      try {
7309        const {
7310          rest_namespace: restNamespace = "wp/v2",
7311          rest_base: restBase
7312        } = await resolveSelect2.getPostType(postType) || {};
7313        options = await (0, import_api_fetch9.default)({
7314          path: `$restNamespace}/$restBase}/?context=edit`,
7315          method: "OPTIONS"
7316        });
7317      } catch {
7318        return;
7319      }
7320      if (options) {
7321        dispatch3.receiveRegisteredPostMeta(
7322          postType,
7323          options?.schema?.properties?.meta?.properties
7324        );
7325      }
7326    };
7327    var getEntitiesConfig2 = (kind) => async ({ dispatch: dispatch3 }) => {
7328      const loader = additionalEntityConfigLoaders.find(
7329        (l) => l.kind === kind
7330      );
7331      if (!loader) {
7332        return;
7333      }
7334      try {
7335        const configs = await loader.loadEntities();
7336        if (!configs.length) {
7337          return;
7338        }
7339        dispatch3.addEntities(configs);
7340      } catch {
7341      }
7342    };
7343    var getEditorSettings2 = () => async ({ dispatch: dispatch3 }) => {
7344      const settings = await (0, import_api_fetch9.default)({
7345        path: "/wp-block-editor/v1/settings"
7346      });
7347      dispatch3.receiveEditorSettings(settings);
7348    };
7349    var getEditorAssets2 = () => async ({ dispatch: dispatch3 }) => {
7350      const assets = await (0, import_api_fetch9.default)({
7351        path: "/wp-block-editor/v1/assets"
7352      });
7353      dispatch3.receiveEditorAssets(assets);
7354    };
7355    var getViewConfig2 = (kind, name, options = {}) => async ({ dispatch: dispatch3 }) => {
7356      const query = { kind, name };
7357      const fields = get_normalized_comma_separable_default(options.fields);
7358      if (fields?.length) {
7359        query._fields = fields.join(",");
7360      }
7361      const config = await (0, import_api_fetch9.default)({
7362        path: (0, import_url6.addQueryArgs)("/wp/v2/view-config", query)
7363      });
7364      dispatch3.receiveViewConfig(kind, name, config);
7365    };
7366  
7367    // packages/core-data/build-module/locks/utils.mjs
7368    function deepCopyLocksTreePath(tree, path) {
7369      const newTree = { ...tree };
7370      let currentNode = newTree;
7371      for (const branchName of path) {
7372        currentNode.children = {
7373          ...currentNode.children,
7374          [branchName]: {
7375            locks: [],
7376            children: {},
7377            ...currentNode.children[branchName]
7378          }
7379        };
7380        currentNode = currentNode.children[branchName];
7381      }
7382      return newTree;
7383    }
7384    function getNode(tree, path) {
7385      let currentNode = tree;
7386      for (const branchName of path) {
7387        const nextNode = currentNode.children[branchName];
7388        if (!nextNode) {
7389          return null;
7390        }
7391        currentNode = nextNode;
7392      }
7393      return currentNode;
7394    }
7395    function* iteratePath(tree, path) {
7396      let currentNode = tree;
7397      yield currentNode;
7398      for (const branchName of path) {
7399        const nextNode = currentNode.children[branchName];
7400        if (!nextNode) {
7401          break;
7402        }
7403        yield nextNode;
7404        currentNode = nextNode;
7405      }
7406    }
7407    function* iterateDescendants(node) {
7408      const stack = Object.values(node.children);
7409      while (stack.length) {
7410        const childNode = stack.pop();
7411        yield childNode;
7412        stack.push(...Object.values(childNode.children));
7413      }
7414    }
7415    function hasConflictingLock({ exclusive }, locks2) {
7416      if (exclusive && locks2.length) {
7417        return true;
7418      }
7419      if (!exclusive && locks2.filter((lock2) => lock2.exclusive).length) {
7420        return true;
7421      }
7422      return false;
7423    }
7424  
7425    // packages/core-data/build-module/locks/reducer.mjs
7426    var DEFAULT_STATE = {
7427      requests: [],
7428      tree: {
7429        locks: [],
7430        children: {}
7431      }
7432    };
7433    function locks(state = DEFAULT_STATE, action) {
7434      switch (action.type) {
7435        case "ENQUEUE_LOCK_REQUEST": {
7436          const { request } = action;
7437          return {
7438            ...state,
7439            requests: [request, ...state.requests]
7440          };
7441        }
7442        case "GRANT_LOCK_REQUEST": {
7443          const { lock: lock2, request } = action;
7444          const { store: store2, path } = request;
7445          const storePath = [store2, ...path];
7446          const newTree = deepCopyLocksTreePath(state.tree, storePath);
7447          const node = getNode(newTree, storePath);
7448          node.locks = [...node.locks, lock2];
7449          return {
7450            ...state,
7451            requests: state.requests.filter((r2) => r2 !== request),
7452            tree: newTree
7453          };
7454        }
7455        case "RELEASE_LOCK": {
7456          const { lock: lock2 } = action;
7457          const storePath = [lock2.store, ...lock2.path];
7458          const newTree = deepCopyLocksTreePath(state.tree, storePath);
7459          const node = getNode(newTree, storePath);
7460          node.locks = node.locks.filter((l) => l !== lock2);
7461          return {
7462            ...state,
7463            tree: newTree
7464          };
7465        }
7466      }
7467      return state;
7468    }
7469  
7470    // packages/core-data/build-module/locks/selectors.mjs
7471    function getPendingLockRequests(state) {
7472      return state.requests;
7473    }
7474    function isLockAvailable(state, store2, path, { exclusive }) {
7475      const storePath = [store2, ...path];
7476      const locks2 = state.tree;
7477      for (const node2 of iteratePath(locks2, storePath)) {
7478        if (hasConflictingLock({ exclusive }, node2.locks)) {
7479          return false;
7480        }
7481      }
7482      const node = getNode(locks2, storePath);
7483      if (!node) {
7484        return true;
7485      }
7486      for (const descendant of iterateDescendants(node)) {
7487        if (hasConflictingLock({ exclusive }, descendant.locks)) {
7488          return false;
7489        }
7490      }
7491      return true;
7492    }
7493  
7494    // packages/core-data/build-module/locks/engine.mjs
7495    function createLocks() {
7496      let state = locks(void 0, { type: "@@INIT" });
7497      function processPendingLockRequests() {
7498        for (const request of getPendingLockRequests(state)) {
7499          const { store: store2, path, exclusive, notifyAcquired } = request;
7500          if (isLockAvailable(state, store2, path, { exclusive })) {
7501            const lock2 = { store: store2, path, exclusive };
7502            state = locks(state, {
7503              type: "GRANT_LOCK_REQUEST",
7504              lock: lock2,
7505              request
7506            });
7507            notifyAcquired(lock2);
7508          }
7509        }
7510      }
7511      function acquire(store2, path, exclusive) {
7512        return new Promise((resolve) => {
7513          state = locks(state, {
7514            type: "ENQUEUE_LOCK_REQUEST",
7515            request: { store: store2, path, exclusive, notifyAcquired: resolve }
7516          });
7517          processPendingLockRequests();
7518        });
7519      }
7520      function release(lock2) {
7521        state = locks(state, {
7522          type: "RELEASE_LOCK",
7523          lock: lock2
7524        });
7525        processPendingLockRequests();
7526      }
7527      return { acquire, release };
7528    }
7529  
7530    // packages/core-data/build-module/locks/actions.mjs
7531    function createLocksActions() {
7532      const locks2 = createLocks();
7533      function __unstableAcquireStoreLock(store2, path, { exclusive }) {
7534        return () => locks2.acquire(store2, path, exclusive);
7535      }
7536      function __unstableReleaseStoreLock(lock2) {
7537        return () => locks2.release(lock2);
7538      }
7539      return { __unstableAcquireStoreLock, __unstableReleaseStoreLock };
7540    }
7541  
7542    // packages/core-data/build-module/dynamic-entities.mjs
7543    var dynamicActions;
7544    var dynamicSelectors;
7545  
7546    // packages/core-data/build-module/entity-provider.mjs
7547    var import_element2 = __toESM(require_element(), 1);
7548  
7549    // packages/core-data/build-module/entity-context.mjs
7550    var import_element = __toESM(require_element(), 1);
7551    var EntityContext = (0, import_element.createContext)({});
7552    EntityContext.displayName = "EntityContext";
7553  
7554    // packages/core-data/build-module/entity-provider.mjs
7555    var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
7556    function EntityProvider({
7557      kind,
7558      type: name,
7559      id,
7560      revisionId,
7561      children
7562    }) {
7563      const parent = (0, import_element2.useContext)(EntityContext);
7564      const childContext = (0, import_element2.useMemo)(
7565        () => ({
7566          ...parent,
7567          ...kind && {
7568            [kind]: {
7569              ...parent?.[kind],
7570              [name]: id
7571            }
7572          },
7573          ...revisionId !== void 0 && kind && {
7574            revision: {
7575              ...parent?.revision,
7576              [kind]: {
7577                ...parent?.revision?.[kind],
7578                [name]: revisionId
7579              }
7580            }
7581          }
7582        }),
7583        [parent, kind, name, id, revisionId]
7584      );
7585      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(EntityContext.Provider, { value: childContext, children });
7586    }
7587  
7588    // packages/core-data/build-module/hooks/use-entity-record.mjs
7589    var import_data11 = __toESM(require_data(), 1);
7590    var import_deprecated4 = __toESM(require_deprecated(), 1);
7591    var import_element3 = __toESM(require_element(), 1);
7592  
7593    // packages/core-data/build-module/hooks/constants.mjs
7594    var Status = /* @__PURE__ */ ((Status2) => {
7595      Status2["Idle"] = "IDLE";
7596      Status2["Resolving"] = "RESOLVING";
7597      Status2["Error"] = "ERROR";
7598      Status2["Success"] = "SUCCESS";
7599      return Status2;
7600    })(Status || {});
7601  
7602    // packages/core-data/build-module/hooks/utils.mjs
7603    function getResolutionStatus(resolutionStatus) {
7604      let status;
7605      switch (resolutionStatus) {
7606        case "resolving":
7607          status = Status.Resolving;
7608          break;
7609        case "finished":
7610          status = Status.Success;
7611          break;
7612        case "error":
7613          status = Status.Error;
7614          break;
7615        default:
7616          status = Status.Idle;
7617      }
7618      return {
7619        status,
7620        isResolving: status === Status.Resolving,
7621        hasStarted: status !== Status.Idle,
7622        hasResolved: status === Status.Success || status === Status.Error
7623      };
7624    }
7625  
7626    // packages/core-data/build-module/hooks/use-entity-record.mjs
7627    var EMPTY_OBJECT3 = {};
7628    function useEntityRecord(kind, name, recordId, options = { enabled: true }) {
7629      const { editEntityRecord: editEntityRecord2, saveEditedEntityRecord: saveEditedEntityRecord2 } = (0, import_data11.useDispatch)(store);
7630      const mutations = (0, import_element3.useMemo)(
7631        () => ({
7632          edit: (record2, editOptions = {}) => editEntityRecord2(kind, name, recordId, record2, editOptions),
7633          save: (saveOptions = {}) => saveEditedEntityRecord2(kind, name, recordId, {
7634            throwOnError: true,
7635            ...saveOptions
7636          })
7637        }),
7638        [editEntityRecord2, kind, name, recordId, saveEditedEntityRecord2]
7639      );
7640      const { record, editedRecord, hasEdits, edits, ...resolution } = (0, import_data11.useSelect)(
7641        (select5) => {
7642          if (!options.enabled) {
7643            return {
7644              record: null,
7645              editedRecord: EMPTY_OBJECT3,
7646              hasEdits: false,
7647              edits: EMPTY_OBJECT3,
7648              ...getResolutionStatus()
7649            };
7650          }
7651          const storeSelectors = select5(store);
7652          const resolutionStatus = storeSelectors.getResolutionState(
7653            "getEntityRecord",
7654            [kind, name, recordId]
7655          )?.status;
7656          return {
7657            record: storeSelectors.getEntityRecord(
7658              kind,
7659              name,
7660              recordId
7661            ) ?? null,
7662            editedRecord: storeSelectors.getEditedEntityRecord(
7663              kind,
7664              name,
7665              recordId
7666            ),
7667            hasEdits: storeSelectors.hasEditsForEntityRecord(
7668              kind,
7669              name,
7670              recordId
7671            ),
7672            edits: storeSelectors.getEntityRecordNonTransientEdits(
7673              kind,
7674              name,
7675              recordId
7676            ),
7677            ...getResolutionStatus(resolutionStatus)
7678          };
7679        },
7680        [kind, name, recordId, options.enabled]
7681      );
7682      return {
7683        record,
7684        editedRecord,
7685        hasEdits,
7686        edits,
7687        ...resolution,
7688        ...mutations
7689      };
7690    }
7691    function useDeprecatedEntityRecord(kind, name, recordId, options) {
7692      (0, import_deprecated4.default)(`wp.data.__experimentalUseEntityRecord`, {
7693        alternative: "wp.data.useEntityRecord",
7694        since: "6.1"
7695      });
7696      return useEntityRecord(kind, name, recordId, options);
7697    }
7698  
7699    // packages/core-data/build-module/hooks/use-entity-records.mjs
7700    var import_url7 = __toESM(require_url(), 1);
7701    var import_deprecated5 = __toESM(require_deprecated(), 1);
7702    var import_data12 = __toESM(require_data(), 1);
7703    var import_element4 = __toESM(require_element(), 1);
7704    var EMPTY_ARRAY = [];
7705    function useEntityRecords(kind, name, queryArgs = {}, options = { enabled: true }) {
7706      const queryAsString = (0, import_url7.addQueryArgs)("", queryArgs);
7707      const { records, totalItems, totalPages, ...rest } = (0, import_data12.useSelect)(
7708        (select5) => {
7709          if (!options.enabled) {
7710            return {
7711              // Avoiding returning a new reference on every execution.
7712              records: EMPTY_ARRAY,
7713              totalItems: null,
7714              totalPages: null,
7715              ...getResolutionStatus()
7716            };
7717          }
7718          const storeSelectors = select5(store);
7719          const resolutionStatus = storeSelectors.getResolutionState(
7720            "getEntityRecords",
7721            [kind, name, queryArgs]
7722          )?.status;
7723          return {
7724            records: storeSelectors.getEntityRecords(
7725              kind,
7726              name,
7727              queryArgs
7728            ),
7729            totalItems: storeSelectors.getEntityRecordsTotalItems(
7730              kind,
7731              name,
7732              queryArgs
7733            ),
7734            totalPages: storeSelectors.getEntityRecordsTotalPages(
7735              kind,
7736              name,
7737              queryArgs
7738            ),
7739            ...getResolutionStatus(resolutionStatus)
7740          };
7741        },
7742        [kind, name, queryAsString, options.enabled]
7743      );
7744      return {
7745        records,
7746        totalItems,
7747        totalPages,
7748        ...rest
7749      };
7750    }
7751    function useDeprecatedEntityRecords(kind, name, queryArgs, options) {
7752      (0, import_deprecated5.default)(`wp.data.__experimentalUseEntityRecords`, {
7753        alternative: "wp.data.useEntityRecords",
7754        since: "6.1"
7755      });
7756      return useEntityRecords(kind, name, queryArgs, options);
7757    }
7758    function useEntityRecordsWithPermissions(kind, name, queryArgs = {}, options = { enabled: true }) {
7759      const entityConfig = (0, import_data12.useSelect)(
7760        (select5) => select5(store).getEntityConfig(kind, name),
7761        [kind, name]
7762      );
7763      const { records: data, ...ret } = useEntityRecords(
7764        kind,
7765        name,
7766        {
7767          ...queryArgs,
7768          // If _fields is provided, we need to include _links in the request for permission caching to work.
7769          ...queryArgs._fields ? {
7770            _fields: [
7771              .../* @__PURE__ */ new Set([
7772                ...get_normalized_comma_separable_default(
7773                  queryArgs._fields
7774                ) || [],
7775                "_links"
7776              ])
7777            ].join()
7778          } : {}
7779        },
7780        options
7781      );
7782      const ids = (0, import_element4.useMemo)(
7783        () => data?.map(
7784          // @ts-expect-error `data` is `unknown[]`, so the callback signature does not line up.
7785          (record) => record[entityConfig?.key ?? "id"]
7786        ) ?? [],
7787        [data, entityConfig?.key]
7788      );
7789      const permissions = (0, import_data12.useSelect)(
7790        (select5) => {
7791          const { getEntityRecordsPermissions: getEntityRecordsPermissions2 } = unlock(
7792            select5(store)
7793          );
7794          return getEntityRecordsPermissions2(kind, name, ids);
7795        },
7796        [ids, kind, name]
7797      );
7798      const dataWithPermissions = (0, import_element4.useMemo)(
7799        () => data?.map((record, index) => ({
7800          // @ts-expect-error `record` is `unknown`, which cannot be spread.
7801          ...record,
7802          permissions: permissions[index]
7803        })) ?? [],
7804        [data, permissions]
7805      );
7806      return { records: dataWithPermissions, ...ret };
7807    }
7808  
7809    // packages/core-data/build-module/hooks/use-resource-permissions.mjs
7810    var import_deprecated6 = __toESM(require_deprecated(), 1);
7811    var import_warning = __toESM(require_warning(), 1);
7812  
7813    // packages/core-data/build-module/hooks/use-query-select.mjs
7814    var import_data13 = __toESM(require_data(), 1);
7815  
7816    // node_modules/memize/dist/index.js
7817    function memize(fn, options) {
7818      var size = 0;
7819      var head;
7820      var tail;
7821      options = options || {};
7822      function memoized() {
7823        var node = head, len = arguments.length, args, i;
7824        searchCache: while (node) {
7825          if (node.args.length !== arguments.length) {
7826            node = node.next;
7827            continue;
7828          }
7829          for (i = 0; i < len; i++) {
7830            if (node.args[i] !== arguments[i]) {
7831              node = node.next;
7832              continue searchCache;
7833            }
7834          }
7835          if (node !== head) {
7836            if (node === tail) {
7837              tail = node.prev;
7838            }
7839            node.prev.next = node.next;
7840            if (node.next) {
7841              node.next.prev = node.prev;
7842            }
7843            node.next = head;
7844            node.prev = null;
7845            head.prev = node;
7846            head = node;
7847          }
7848          return node.val;
7849        }
7850        args = new Array(len);
7851        for (i = 0; i < len; i++) {
7852          args[i] = arguments[i];
7853        }
7854        node = {
7855          args,
7856          // Generate the result from original function
7857          val: fn.apply(null, args)
7858        };
7859        if (head) {
7860          head.prev = node;
7861          node.next = head;
7862        } else {
7863          tail = node;
7864        }
7865        if (size === /** @type {MemizeOptions} */
7866        options.maxSize) {
7867          tail = /** @type {MemizeCacheNode} */
7868          tail.prev;
7869          tail.next = null;
7870        } else {
7871          size++;
7872        }
7873        head = node;
7874        return node.val;
7875      }
7876      memoized.clear = function() {
7877        head = null;
7878        tail = null;
7879        size = 0;
7880      };
7881      return memoized;
7882    }
7883  
7884    // packages/core-data/build-module/hooks/use-query-select.mjs
7885    var META_SELECTORS = [
7886      "getIsResolving",
7887      "hasStartedResolution",
7888      "hasFinishedResolution",
7889      "isResolving",
7890      "getCachedResolvers"
7891    ];
7892    function useQuerySelect(mapQuerySelect, deps) {
7893      return (0, import_data13.useSelect)((select5, registry) => {
7894        const resolve = (store2) => enrichSelectors(select5(store2));
7895        return mapQuerySelect(resolve, registry);
7896      }, deps);
7897    }
7898    var enrichSelectors = memize(((selectors) => {
7899      const resolvers = {};
7900      for (const selectorName in selectors) {
7901        if (META_SELECTORS.includes(selectorName)) {
7902          continue;
7903        }
7904        Object.defineProperty(resolvers, selectorName, {
7905          get: () => (...args) => {
7906            const data = selectors[selectorName](...args);
7907            const resolutionStatus = selectors.getResolutionState(
7908              selectorName,
7909              args
7910            )?.status;
7911            return {
7912              data,
7913              ...getResolutionStatus(resolutionStatus)
7914            };
7915          }
7916        });
7917      }
7918      return resolvers;
7919    }));
7920  
7921    // packages/core-data/build-module/hooks/use-resource-permissions.mjs
7922    function useResourcePermissions(resource, id) {
7923      const isEntity = typeof resource === "object";
7924      const resourceAsString = isEntity ? JSON.stringify(resource) : resource;
7925      if (isEntity && typeof id !== "undefined") {
7926        (0, import_warning.default)(
7927          `When 'resource' is an entity object, passing 'id' as a separate argument isn't supported.`
7928        );
7929      }
7930      return useQuerySelect(
7931        (resolve) => {
7932          const hasId = isEntity ? !!resource.id : !!id;
7933          const { canUser: canUser3 } = resolve(store);
7934          const collectionResource = isEntity ? { kind: resource.kind, name: resource.name } : resource;
7935          const create3 = canUser3("create", collectionResource);
7936          if (!hasId) {
7937            const read2 = canUser3("read", collectionResource);
7938            const isResolving2 = create3.isResolving || read2.isResolving;
7939            const hasResolved2 = create3.hasResolved && read2.hasResolved;
7940            let status2 = Status.Idle;
7941            if (isResolving2) {
7942              status2 = Status.Resolving;
7943            } else if (hasResolved2) {
7944              status2 = Status.Success;
7945            }
7946            return {
7947              status: status2,
7948              isResolving: isResolving2,
7949              hasResolved: hasResolved2,
7950              canCreate: create3.hasResolved && create3.data,
7951              canRead: read2.hasResolved && read2.data
7952            };
7953          }
7954          const read = canUser3("read", resource, id);
7955          const update = canUser3("update", resource, id);
7956          const _delete = canUser3("delete", resource, id);
7957          const isResolving = read.isResolving || create3.isResolving || update.isResolving || _delete.isResolving;
7958          const hasResolved = read.hasResolved && create3.hasResolved && update.hasResolved && _delete.hasResolved;
7959          let status = Status.Idle;
7960          if (isResolving) {
7961            status = Status.Resolving;
7962          } else if (hasResolved) {
7963            status = Status.Success;
7964          }
7965          return {
7966            status,
7967            isResolving,
7968            hasResolved,
7969            canRead: hasResolved && read.data,
7970            canCreate: hasResolved && create3.data,
7971            canUpdate: hasResolved && update.data,
7972            canDelete: hasResolved && _delete.data
7973          };
7974        },
7975        [resourceAsString, id]
7976      );
7977    }
7978    var use_resource_permissions_default = useResourcePermissions;
7979    function useDeprecatedResourcePermissions(resource, id) {
7980      (0, import_deprecated6.default)(`wp.data.__experimentalUseResourcePermissions`, {
7981        alternative: "wp.data.useResourcePermissions",
7982        since: "6.1"
7983      });
7984      return useResourcePermissions(resource, id);
7985    }
7986  
7987    // packages/core-data/build-module/hooks/use-entity-block-editor.mjs
7988    var import_element6 = __toESM(require_element(), 1);
7989    var import_data14 = __toESM(require_data(), 1);
7990    var import_blocks6 = __toESM(require_blocks(), 1);
7991  
7992    // packages/core-data/build-module/hooks/use-entity-id.mjs
7993    var import_element5 = __toESM(require_element(), 1);
7994    function useEntityId(kind, name) {
7995      const context = (0, import_element5.useContext)(EntityContext);
7996      return context?.[kind]?.[name];
7997    }
7998  
7999    // packages/core-data/build-module/footnotes/index.mjs
8000    var import_rich_text4 = __toESM(require_rich_text(), 1);
8001    var import_warning2 = __toESM(require_warning(), 1);
8002  
8003    // packages/core-data/build-module/footnotes/get-rich-text-values-cached.mjs
8004    var import_block_editor6 = __toESM(require_block_editor(), 1);
8005    var unlockedApis;
8006    var cache = /* @__PURE__ */ new WeakMap();
8007    function getRichTextValuesCached(block) {
8008      if (!unlockedApis) {
8009        unlockedApis = unlock(import_block_editor6.privateApis);
8010      }
8011      if (!cache.has(block)) {
8012        const values = unlockedApis.getRichTextValues([block]);
8013        cache.set(block, values);
8014      }
8015      return cache.get(block);
8016    }
8017  
8018    // packages/core-data/build-module/footnotes/get-footnotes-order.mjs
8019    var cache2 = /* @__PURE__ */ new WeakMap();
8020    function getBlockFootnotesOrder(block) {
8021      if (!cache2.has(block)) {
8022        const order = [];
8023        for (const value of getRichTextValuesCached(block)) {
8024          if (!value) {
8025            continue;
8026          }
8027          value.replacements.forEach(({ type, attributes }) => {
8028            if (type === "core/footnote") {
8029              order.push(attributes["data-fn"]);
8030            }
8031          });
8032        }
8033        cache2.set(block, order);
8034      }
8035      return cache2.get(block);
8036    }
8037    function getFootnotesOrder(blocks) {
8038      return blocks.flatMap(getBlockFootnotesOrder);
8039    }
8040  
8041    // packages/core-data/build-module/footnotes/index.mjs
8042    var oldFootnotes = {};
8043    function updateFootnotesFromMeta(blocks, meta) {
8044      const output = { blocks };
8045      if (!meta) {
8046        return output;
8047      }
8048      if (meta.footnotes === void 0) {
8049        return output;
8050      }
8051      const newOrder = getFootnotesOrder(blocks);
8052      let parsed;
8053      try {
8054        parsed = JSON.parse(meta.footnotes || "[]");
8055      } catch {
8056      }
8057      let footnotes = [];
8058      if (Array.isArray(parsed)) {
8059        footnotes = parsed;
8060      } else {
8061        (0, import_warning2.default)("Footnotes post meta is not a JSON array; ignoring it.");
8062      }
8063      const currentOrder = footnotes.map((fn) => fn.id);
8064      if (currentOrder.join("") === newOrder.join("")) {
8065        return output;
8066      }
8067      const newFootnotes = newOrder.map(
8068        (fnId) => footnotes.find((fn) => fn.id === fnId) || oldFootnotes[fnId] || {
8069          id: fnId,
8070          content: ""
8071        }
8072      );
8073      function updateAttributes(attributes) {
8074        if (!attributes || Array.isArray(attributes) || typeof attributes !== "object") {
8075          return attributes;
8076        }
8077        attributes = { ...attributes };
8078        for (const key in attributes) {
8079          const value = attributes[key];
8080          if (Array.isArray(value)) {
8081            attributes[key] = value.map(updateAttributes);
8082            continue;
8083          }
8084          if (typeof value !== "string" && !(value instanceof import_rich_text4.RichTextData)) {
8085            continue;
8086          }
8087          const richTextValue = typeof value === "string" ? import_rich_text4.RichTextData.fromHTMLString(value) : new import_rich_text4.RichTextData(value);
8088          let hasFootnotes = false;
8089          richTextValue.replacements.forEach((replacement) => {
8090            if (replacement.type === "core/footnote") {
8091              const id = replacement.attributes["data-fn"];
8092              const index = newOrder.indexOf(id);
8093              const countValue = (0, import_rich_text4.create)({
8094                html: replacement.innerHTML
8095              });
8096              countValue.text = String(index + 1);
8097              countValue.formats = Array.from(
8098                { length: countValue.text.length },
8099                () => countValue.formats[0]
8100              );
8101              countValue.replacements = Array.from(
8102                { length: countValue.text.length },
8103                () => countValue.replacements[0]
8104              );
8105              replacement.innerHTML = (0, import_rich_text4.toHTMLString)({
8106                value: countValue
8107              });
8108              hasFootnotes = true;
8109            }
8110          });
8111          if (hasFootnotes) {
8112            attributes[key] = typeof value === "string" ? richTextValue.toHTMLString() : richTextValue;
8113          }
8114        }
8115        return attributes;
8116      }
8117      function updateBlocksAttributes(__blocks) {
8118        return __blocks.map((block) => {
8119          return {
8120            ...block,
8121            attributes: updateAttributes(block.attributes),
8122            innerBlocks: updateBlocksAttributes(block.innerBlocks)
8123          };
8124        });
8125      }
8126      const newBlocks = updateBlocksAttributes(blocks);
8127      oldFootnotes = {
8128        ...oldFootnotes,
8129        ...footnotes.reduce((acc, fn) => {
8130          if (!newOrder.includes(fn.id)) {
8131            acc[fn.id] = fn;
8132          }
8133          return acc;
8134        }, {})
8135      };
8136      return {
8137        meta: {
8138          ...meta,
8139          footnotes: JSON.stringify(newFootnotes)
8140        },
8141        blocks: newBlocks
8142      };
8143    }
8144  
8145    // packages/core-data/build-module/hooks/use-entity-block-editor.mjs
8146    var EMPTY_ARRAY2 = [];
8147    function useEntityBlockEditor(kind, name, { id: _id } = {}) {
8148      const providerId = useEntityId(kind, name);
8149      const id = _id ?? providerId;
8150      const { content, editedBlocks, meta } = (0, import_data14.useSelect)(
8151        (select5) => {
8152          if (!id) {
8153            return {};
8154          }
8155          const { getEditedEntityRecord: getEditedEntityRecord3 } = select5(STORE_NAME);
8156          const editedRecord = getEditedEntityRecord3(kind, name, id);
8157          return {
8158            editedBlocks: editedRecord.blocks,
8159            content: editedRecord.content,
8160            meta: editedRecord.meta
8161          };
8162        },
8163        [kind, name, id]
8164      );
8165      const { __unstableCreateUndoLevel: __unstableCreateUndoLevel2, editEntityRecord: editEntityRecord2 } = (0, import_data14.useDispatch)(STORE_NAME);
8166      const blocks = (0, import_element6.useMemo)(() => {
8167        if (!id) {
8168          return void 0;
8169        }
8170        if (editedBlocks) {
8171          return editedBlocks;
8172        }
8173        if (!content || typeof content !== "string") {
8174          return EMPTY_ARRAY2;
8175        }
8176        let _blocks = getCachedBlocks(kind, name, id, content);
8177        if (!_blocks) {
8178          _blocks = (0, import_blocks6.parse)(content);
8179          setCachedBlocks(kind, name, id, content, _blocks);
8180        }
8181        return _blocks;
8182      }, [kind, name, id, editedBlocks, content]);
8183      const onChange = (0, import_element6.useCallback)(
8184        (newBlocks, options) => {
8185          const noChange = blocks === newBlocks;
8186          if (noChange) {
8187            return __unstableCreateUndoLevel2(kind, name, id);
8188          }
8189          const { selection, ...rest } = options;
8190          const edits = {
8191            selection,
8192            content: ({ blocks: blocksForSerialization = [] }) => (0, import_blocks6.__unstableSerializeAndClean)(blocksForSerialization),
8193            ...updateFootnotesFromMeta(newBlocks, meta)
8194          };
8195          editEntityRecord2(kind, name, id, edits, {
8196            isCached: false,
8197            ...rest
8198          });
8199        },
8200        [
8201          kind,
8202          name,
8203          id,
8204          blocks,
8205          meta,
8206          __unstableCreateUndoLevel2,
8207          editEntityRecord2
8208        ]
8209      );
8210      const onInput = (0, import_element6.useCallback)(
8211        (newBlocks, options) => {
8212          const { selection, ...rest } = options;
8213          const edits = {
8214            selection,
8215            ...updateFootnotesFromMeta(newBlocks, meta)
8216          };
8217          editEntityRecord2(kind, name, id, edits, {
8218            isCached: true,
8219            ...rest
8220          });
8221        },
8222        [kind, name, id, meta, editEntityRecord2]
8223      );
8224      return [blocks, onInput, onChange];
8225    }
8226  
8227    // packages/core-data/build-module/hooks/use-entity-prop.mjs
8228    var import_element7 = __toESM(require_element(), 1);
8229    var import_data15 = __toESM(require_data(), 1);
8230    var REVISION_QUERY = {
8231      context: "edit",
8232      _fields: "id,date,author,meta,title,excerpt,content.raw"
8233    };
8234    function useEntityProp(kind, name, prop, _id) {
8235      const providerId = useEntityId(kind, name);
8236      const id = _id ?? providerId;
8237      const context = (0, import_element7.useContext)(EntityContext);
8238      const revisionId = String(id) === String(providerId) ? context?.revision?.[kind]?.[name] : void 0;
8239      const { value, fullValue } = (0, import_data15.useSelect)(
8240        (select5) => {
8241          if (revisionId) {
8242            const revision = select5(STORE_NAME).getRevision(
8243              kind,
8244              name,
8245              id,
8246              revisionId,
8247              REVISION_QUERY
8248            );
8249            const propValue = revision?.[prop];
8250            if (propValue === void 0) {
8251              return {};
8252            }
8253            const isRawAttribute = propValue !== null && typeof propValue === "object" && "raw" in propValue;
8254            return {
8255              value: isRawAttribute ? propValue.raw : propValue,
8256              fullValue: propValue
8257            };
8258          }
8259          const { getEntityRecord: getEntityRecord3, getEditedEntityRecord: getEditedEntityRecord3 } = select5(STORE_NAME);
8260          const record = getEntityRecord3(kind, name, id);
8261          const editedRecord = getEditedEntityRecord3(kind, name, id);
8262          return record && editedRecord ? {
8263            value: editedRecord[prop],
8264            fullValue: record[prop]
8265          } : {};
8266        },
8267        [kind, name, id, prop, revisionId]
8268      );
8269      const { editEntityRecord: editEntityRecord2 } = (0, import_data15.useDispatch)(STORE_NAME);
8270      const setValue = (0, import_element7.useCallback)(
8271        (newValue) => {
8272          if (revisionId) {
8273            return;
8274          }
8275          editEntityRecord2(kind, name, id, {
8276            [prop]: newValue
8277          });
8278        },
8279        [editEntityRecord2, kind, name, id, prop, revisionId]
8280      );
8281      return [value, setValue, fullValue];
8282    }
8283  
8284    // packages/core-data/build-module/hooks/use-post-editor-awareness-state.mjs
8285    var import_compose3 = __toESM(require_compose(), 1);
8286    var import_element8 = __toESM(require_element(), 1);
8287    var defaultResolvedSelection = {
8288      richTextOffset: null,
8289      localClientId: null,
8290      attributeKey: null
8291    };
8292    var defaultState = {
8293      activeCollaborators: [],
8294      resolveSelection: () => defaultResolvedSelection,
8295      getDebugData: () => ({
8296        doc: {},
8297        clients: {},
8298        collaboratorMap: {}
8299      }),
8300      isCurrentCollaboratorDisconnected: false
8301    };
8302    function getAwarenessState(awareness, newState) {
8303      const activeCollaborators = (newState ?? awareness.getCurrentState()).filter(
8304        (collaborator) => isCollaboratorInfo(collaborator.collaboratorInfo)
8305      );
8306      return {
8307        activeCollaborators,
8308        resolveSelection: (selection, blocks) => awareness.convertSelectionStateToAbsolute(selection, blocks),
8309        getDebugData: () => awareness.getDebugData(),
8310        isCurrentCollaboratorDisconnected: activeCollaborators.find((collaborator) => collaborator.isMe)?.isConnected === false
8311      };
8312    }
8313    function usePostEditorAwarenessState(postId, postType) {
8314      const [state, setState] = (0, import_element8.useState)(defaultState);
8315      (0, import_element8.useEffect)(() => {
8316        if (null === postId || null === postType) {
8317          setState(defaultState);
8318          return;
8319        }
8320        const objectType = `postType/$postType}`;
8321        const objectId = postId.toString();
8322        const awareness = getSyncManager()?.getAwareness(
8323          objectType,
8324          objectId
8325        );
8326        if (!awareness) {
8327          setState(defaultState);
8328          return;
8329        }
8330        awareness.setUp();
8331        setState(getAwarenessState(awareness));
8332        const unsubscribe = awareness?.onStateChange(
8333          (newState) => {
8334            setState(getAwarenessState(awareness, newState));
8335          }
8336        );
8337        return unsubscribe;
8338      }, [postId, postType]);
8339      return state;
8340    }
8341    function useActiveCollaborators(postId, postType) {
8342      return usePostEditorAwarenessState(postId, postType).activeCollaborators;
8343    }
8344    function useResolvedSelection(postId, postType) {
8345      const blocks = usePostContentBlocks();
8346      const awarenessState = usePostEditorAwarenessState(postId, postType);
8347      return (0, import_element8.useCallback)(
8348        (selection) => awarenessState.resolveSelection(selection, blocks),
8349        [blocks, awarenessState]
8350      );
8351    }
8352    function useLastPostSave(postId, postType) {
8353      const [lastSave, setLastSave] = (0, import_element8.useState)(null);
8354      (0, import_element8.useEffect)(() => {
8355        if (null === postId || null === postType) {
8356          setLastSave(null);
8357          return;
8358        }
8359        const awareness = getSyncManager()?.getAwareness(
8360          `postType/$postType}`,
8361          postId.toString()
8362        );
8363        if (!awareness) {
8364          setLastSave(null);
8365          return;
8366        }
8367        awareness.setUp();
8368        const stateMap = awareness.doc.getMap("state");
8369        const recordMap = awareness.doc.getMap("document");
8370        const setupTime = Date.now();
8371        const observer = (event) => {
8372          if (event.keysChanged.has("savedAt")) {
8373            const savedAt = stateMap.get("savedAt");
8374            const savedByClientId = stateMap.get("savedBy");
8375            if (typeof savedAt === "number" && typeof savedByClientId === "number" && savedAt > setupTime) {
8376              const postStatus = recordMap.get("status");
8377              setLastSave({ savedAt, savedByClientId, postStatus });
8378            }
8379          }
8380        };
8381        stateMap.observe(observer);
8382        return () => {
8383          stateMap.unobserve(observer);
8384        };
8385      }, [postId, postType]);
8386      return lastSave;
8387    }
8388    function useOnCollaboratorJoin(postId, postType, callback) {
8389      const { activeCollaborators } = usePostEditorAwarenessState(
8390        postId,
8391        postType
8392      );
8393      const prevCollaborators = (0, import_compose3.usePrevious)(activeCollaborators);
8394      (0, import_element8.useEffect)(() => {
8395        if (!prevCollaborators || prevCollaborators.length === 0) {
8396          return;
8397        }
8398        const prevMap = new Map(
8399          prevCollaborators.map((collaborator) => [
8400            collaborator.clientId,
8401            collaborator
8402          ])
8403        );
8404        const me = activeCollaborators.find(
8405          (collaborator) => collaborator.isMe
8406        );
8407        for (const collaborator of activeCollaborators) {
8408          if (!prevMap.has(collaborator.clientId) && !collaborator.isMe) {
8409            callback(collaborator, me);
8410          }
8411        }
8412      }, [activeCollaborators, prevCollaborators, callback]);
8413    }
8414    function useOnCollaboratorLeave(postId, postType, callback) {
8415      const { activeCollaborators } = usePostEditorAwarenessState(
8416        postId,
8417        postType
8418      );
8419      const prevCollaborators = (0, import_compose3.usePrevious)(activeCollaborators);
8420      (0, import_element8.useEffect)(() => {
8421        if (!prevCollaborators || prevCollaborators.length === 0) {
8422          return;
8423        }
8424        const newMap = new Map(
8425          activeCollaborators.map((collaborator) => [
8426            collaborator.clientId,
8427            collaborator
8428          ])
8429        );
8430        for (const prevCollab of prevCollaborators) {
8431          if (prevCollab.isMe || !prevCollab.isConnected) {
8432            continue;
8433          }
8434          const newCollab = newMap.get(prevCollab.clientId);
8435          if (!newCollab?.isConnected) {
8436            callback(prevCollab);
8437          }
8438        }
8439      }, [activeCollaborators, prevCollaborators, callback]);
8440    }
8441    function useOnPostSave(postId, postType, callback) {
8442      const { activeCollaborators } = usePostEditorAwarenessState(
8443        postId,
8444        postType
8445      );
8446      const lastPostSave = useLastPostSave(postId, postType);
8447      const prevPostSave = (0, import_compose3.usePrevious)(lastPostSave);
8448      (0, import_element8.useEffect)(() => {
8449        if (!lastPostSave) {
8450          return;
8451        }
8452        if (prevPostSave && lastPostSave.savedAt === prevPostSave.savedAt) {
8453          return;
8454        }
8455        const saver = activeCollaborators.find(
8456          (collaborator) => collaborator.clientId === lastPostSave.savedByClientId && !collaborator.isMe
8457        );
8458        if (!saver) {
8459          return;
8460        }
8461        callback(lastPostSave, saver, prevPostSave ?? null);
8462      }, [lastPostSave, prevPostSave, activeCollaborators, callback]);
8463    }
8464  
8465    // packages/icons/build-module/library/footer.mjs
8466    var import_primitives = __toESM(require_primitives(), 1);
8467    var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
8468    var footer_default = /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_primitives.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", style: { fill: "none" }, stroke: "currentColor", strokeWidth: "1.5", children: [
8469      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_primitives.Path, { d: "M9.75 4.75H18C18.6904 4.75 19.25 5.30964 19.25 6V14.25M9.75 4.75H6C5.30964 4.75 4.75 5.30964 4.75 6V14.25M9.75 4.75V14.25M19.25 14.25V18C19.25 18.6904 18.6904 19.25 18 19.25H6C5.30964 19.25 4.75 18.6904 4.75 18V14.25M19.25 14.25H9.75M9.75 14.25H4.75", vectorEffect: "non-scaling-stroke" }),
8470      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_primitives.Path, { d: "M19.25 15.5V18C19.25 18.6904 18.6904 19.25 18 19.25H6C5.30964 19.25 4.75 18.6904 4.75 18V15.5C4.75 14.8096 5.30964 14.25 6 14.25H18C18.6904 14.25 19.25 14.8096 19.25 15.5Z", fill: "currentColor", vectorEffect: "non-scaling-stroke" })
8471    ] });
8472  
8473    // packages/icons/build-module/library/header.mjs
8474    var import_primitives2 = __toESM(require_primitives(), 1);
8475    var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
8476    var header_default = /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_primitives2.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", style: { fill: "none" }, stroke: "currentColor", strokeWidth: "1.5", children: [
8477      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_primitives2.Path, { d: "M9.75 19.25H18C18.6904 19.25 19.25 18.6904 19.25 18V9.75M9.75 19.25H6C5.30964 19.25 4.75 18.6904 4.75 18V9.75M9.75 19.25V9.75M19.25 9.75V6C19.25 5.30964 18.6904 4.75 18 4.75H6C5.30964 4.75 4.75 5.30964 4.75 6V9.75M19.25 9.75H9.75M9.75 9.75H4.75", vectorEffect: "non-scaling-stroke" }),
8478      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_primitives2.Path, { d: "M19.25 8.5V6C19.25 5.30964 18.6904 4.75 18 4.75H6C5.30964 4.75 4.75 5.30964 4.75 6V8.5C4.75 9.19036 5.30964 9.75 6 9.75H18C18.6904 9.75 19.25 9.19036 19.25 8.5Z", fill: "currentColor", vectorEffect: "non-scaling-stroke" })
8479    ] });
8480  
8481    // packages/icons/build-module/library/layout.mjs
8482    var import_primitives3 = __toESM(require_primitives(), 1);
8483    var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
8484    var layout_default = /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_primitives3.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", style: { fill: "none" }, stroke: "currentColor", strokeWidth: "1.5", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_primitives3.Path, { d: "M9.75 19.25H18C18.6904 19.25 19.25 18.6904 19.25 18V9.75M9.75 19.25H6C5.30964 19.25 4.75 18.6904 4.75 18V9.75M9.75 19.25V9.75M19.25 9.75V6C19.25 5.30964 18.6904 4.75 18 4.75H6C5.30964 4.75 4.75 5.30964 4.75 6V9.75M19.25 9.75H9.75M9.75 9.75H4.75", vectorEffect: "non-scaling-stroke" }) });
8485  
8486    // packages/icons/build-module/library/navigation-overlay.mjs
8487    var import_primitives4 = __toESM(require_primitives(), 1);
8488    var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
8489    var navigation_overlay_default = /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_primitives4.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", style: { fill: "none" }, stroke: "currentColor", strokeWidth: "1.5", children: [
8490      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_primitives4.Path, { d: "M4.75 9.25V16C4.75 16.6904 5.30964 17.25 6 17.25H8M4.75 9.25V6C4.75 5.30964 5.30964 4.75 6 4.75H16C16.6904 4.75 17.25 5.30964 17.25 6V8M4.75 9.25H8", vectorEffect: "non-scaling-stroke" }),
8491      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_primitives4.Path, { d: "M10.75 11.25C10.75 10.9739 10.9739 10.75 11.25 10.75H18.75C19.0261 10.75 19.25 10.9739 19.25 11.25V18.75C19.25 19.0261 19.0261 19.25 18.75 19.25H11.25C10.9739 19.25 10.75 19.0261 10.75 18.75V11.25Z", fill: "currentColor", vectorEffect: "non-scaling-stroke" })
8492    ] });
8493  
8494    // packages/icons/build-module/library/sidebar.mjs
8495    var import_primitives5 = __toESM(require_primitives(), 1);
8496    var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
8497    var sidebar_default = /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_primitives5.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", style: { fill: "none" }, stroke: "currentColor", strokeWidth: "1.5", children: [
8498      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_primitives5.Path, { d: "M9.75 19.25H18C18.6904 19.25 19.25 18.6904 19.25 18V9.75M9.75 19.25H6C5.30964 19.25 4.75 18.6904 4.75 18V9.75M9.75 19.25V9.75M19.25 9.75V6C19.25 5.30964 18.6904 4.75 18 4.75H6C5.30964 4.75 4.75 5.30964 4.75 6V9.75M19.25 9.75H9.75M9.75 9.75H4.75", vectorEffect: "non-scaling-stroke" }),
8499      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_primitives5.Path, { d: "M6 19.25H9.75V9.75H4.75V18C4.75 18.6904 5.30964 19.25 6 19.25Z", fill: "currentColor", vectorEffect: "non-scaling-stroke" })
8500    ] });
8501  
8502    // packages/icons/build-module/library/symbol-filled.mjs
8503    var import_primitives6 = __toESM(require_primitives(), 1);
8504    var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
8505    var symbol_filled_default = /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_primitives6.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", style: { fill: "none" }, stroke: "currentColor", strokeWidth: "1.5", children: [
8506      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_primitives6.Path, { d: "M15.2071 6.20711L20.2929 11.2929C20.6834 11.6834 20.6834 12.3166 20.2929 12.7071L15.2071 17.7929C14.8166 18.1834 14.1834 18.1834 13.7929 17.7929L8.70711 12.7071C8.31658 12.3166 8.31658 11.6834 8.70711 11.2929L13.7929 6.20711C14.1834 5.81658 14.8166 5.81658 15.2071 6.20711Z", fill: "currentColor", vectorEffect: "non-scaling-stroke" }),
8507      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_primitives6.Path, { d: "M9.5 5.5L3.70711 11.2929C3.31658 11.6834 3.31658 12.3166 3.70711 12.7071L9.5 18.5", vectorEffect: "non-scaling-stroke" })
8508    ] });
8509  
8510    // packages/core-data/build-module/utils/get-template-part-icon.mjs
8511    function getTemplatePartIcon(areaOrIconName) {
8512      if ("header" === areaOrIconName) {
8513        return header_default;
8514      } else if ("footer" === areaOrIconName) {
8515        return footer_default;
8516      } else if ("sidebar" === areaOrIconName) {
8517        return sidebar_default;
8518      } else if ("navigation-overlay" === areaOrIconName) {
8519        return navigation_overlay_default;
8520      }
8521      return symbol_filled_default;
8522    }
8523  
8524    // packages/core-data/build-module/utils/get-template-info.mjs
8525    var EMPTY_OBJECT4 = {};
8526    var getTemplateInfo = (params) => {
8527      if (!params) {
8528        return EMPTY_OBJECT4;
8529      }
8530      const { templateTypes, templateAreas, template } = params;
8531      const { description, slug, title, area } = template;
8532      const { title: defaultTitle, description: defaultDescription } = Object.values(templateTypes).find((type) => type.slug === slug) ?? EMPTY_OBJECT4;
8533      const templateTitle = typeof title === "string" ? title : title?.rendered;
8534      const templateDescription = typeof description === "string" ? description : description?.raw;
8535      const templateAreasWithIcon = templateAreas?.map((item) => ({
8536        ...item,
8537        icon: getTemplatePartIcon(item.icon)
8538      }));
8539      const templateIcon = templateAreasWithIcon?.find((item) => area === item.area)?.icon || layout_default;
8540      return {
8541        title: templateTitle && templateTitle !== slug ? templateTitle : defaultTitle || slug,
8542        description: templateDescription || defaultDescription,
8543        icon: templateIcon
8544      };
8545    };
8546  
8547    // node_modules/clsx/dist/clsx.mjs
8548    function r(e) {
8549      var t, f, n = "";
8550      if ("string" == typeof e || "number" == typeof e) n += e;
8551      else if ("object" == typeof e) if (Array.isArray(e)) {
8552        var o = e.length;
8553        for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
8554      } else for (f in e) e[f] && (n && (n += " "), n += f);
8555      return n;
8556    }
8557    function clsx() {
8558      for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
8559      return n;
8560    }
8561    var clsx_default = clsx;
8562  
8563    // packages/core-data/build-module/components/entities-saved-states/index.mjs
8564    var import_components3 = __toESM(require_components(), 1);
8565    var import_i18n7 = __toESM(require_i18n(), 1);
8566    var import_element10 = __toESM(require_element(), 1);
8567    var import_compose4 = __toESM(require_compose(), 1);
8568    var import_data19 = __toESM(require_data(), 1);
8569  
8570    // packages/core-data/build-module/components/entities-saved-states/entity-type-list.mjs
8571    var import_i18n6 = __toESM(require_i18n(), 1);
8572    var import_data17 = __toESM(require_data(), 1);
8573    var import_components2 = __toESM(require_components(), 1);
8574  
8575    // packages/global-styles-engine/build-module/utils/get-global-styles-changes.mjs
8576    var import_i18n4 = __toESM(require_i18n(), 1);
8577    var import_blocks7 = __toESM(require_blocks(), 1);
8578    var globalStylesChangesCache = /* @__PURE__ */ new Map();
8579    var EMPTY_ARRAY3 = [];
8580    var translationMap = {
8581      caption: (0, import_i18n4.__)("Caption"),
8582      link: (0, import_i18n4.__)("Link"),
8583      button: (0, import_i18n4.__)("Button"),
8584      heading: (0, import_i18n4.__)("Heading"),
8585      h1: (0, import_i18n4.__)("H1"),
8586      h2: (0, import_i18n4.__)("H2"),
8587      h3: (0, import_i18n4.__)("H3"),
8588      h4: (0, import_i18n4.__)("H4"),
8589      h5: (0, import_i18n4.__)("H5"),
8590      h6: (0, import_i18n4.__)("H6"),
8591      "settings.color": (0, import_i18n4.__)("Color"),
8592      "settings.typography": (0, import_i18n4.__)("Typography"),
8593      "settings.shadow": (0, import_i18n4.__)("Shadow"),
8594      "settings.layout": (0, import_i18n4.__)("Layout"),
8595      "styles.color": (0, import_i18n4.__)("Colors"),
8596      "styles.spacing": (0, import_i18n4.__)("Spacing"),
8597      "styles.background": (0, import_i18n4.__)("Background"),
8598      "styles.typography": (0, import_i18n4.__)("Typography"),
8599      "styles.border": (0, import_i18n4.__)("Border"),
8600      "styles.shadow": (0, import_i18n4.__)("Shadow"),
8601      "styles.outline": (0, import_i18n4.__)("Outline"),
8602      "styles.filter": (0, import_i18n4.__)("Filter"),
8603      "styles.dimensions": (0, import_i18n4.__)("Dimensions")
8604    };
8605    var getBlockNames = memize(
8606      () => (0, import_blocks7.getBlockTypes)().reduce(
8607        (accumulator, {
8608          name,
8609          title
8610        }) => {
8611          accumulator[name] = title;
8612          return accumulator;
8613        },
8614        {}
8615      )
8616    );
8617    var isObject = (obj) => obj !== null && typeof obj === "object";
8618    function getTranslation(key) {
8619      if (translationMap[key]) {
8620        return translationMap[key];
8621      }
8622      const keyArray = key.split(".");
8623      if (keyArray?.[0] === "blocks") {
8624        const blockName = getBlockNames()?.[keyArray[1]];
8625        return blockName || keyArray[1];
8626      }
8627      if (keyArray?.[0] === "elements") {
8628        return translationMap[keyArray[1]] || keyArray[1];
8629      }
8630      return void 0;
8631    }
8632    function deepCompare(changedObject, originalObject, parentPath = "") {
8633      if (!isObject(changedObject) && !isObject(originalObject)) {
8634        return changedObject !== originalObject ? parentPath.split(".").slice(0, 2).join(".") : void 0;
8635      }
8636      changedObject = isObject(changedObject) ? changedObject : {};
8637      originalObject = isObject(originalObject) ? originalObject : {};
8638      const allKeys = /* @__PURE__ */ new Set([
8639        ...Object.keys(changedObject),
8640        ...Object.keys(originalObject)
8641      ]);
8642      let diffs = [];
8643      for (const key of allKeys) {
8644        const path = parentPath ? parentPath + "." + key : key;
8645        const changedPath = deepCompare(
8646          changedObject[key],
8647          originalObject[key],
8648          path
8649        );
8650        if (changedPath) {
8651          diffs = diffs.concat(changedPath);
8652        }
8653      }
8654      return diffs;
8655    }
8656    var COMPARED_STYLE_KEYS = [
8657      "background",
8658      "color",
8659      "typography",
8660      "spacing",
8661      "border",
8662      "shadow",
8663      "outline",
8664      "filter",
8665      "dimensions"
8666    ];
8667    function pickComparedStyles(config) {
8668      return Object.fromEntries(
8669        COMPARED_STYLE_KEYS.map((key) => [key, config?.styles?.[key]])
8670      );
8671    }
8672    function getGlobalStylesChangelist(next, previous) {
8673      const cacheKey = JSON.stringify({ next, previous });
8674      if (globalStylesChangesCache.has(cacheKey)) {
8675        return globalStylesChangesCache.get(cacheKey);
8676      }
8677      const changedValueTree = deepCompare(
8678        {
8679          styles: pickComparedStyles(next),
8680          blocks: next?.styles?.blocks,
8681          elements: next?.styles?.elements,
8682          settings: next?.settings
8683        },
8684        {
8685          styles: pickComparedStyles(previous),
8686          blocks: previous?.styles?.blocks,
8687          elements: previous?.styles?.elements,
8688          settings: previous?.settings
8689        }
8690      );
8691      if (!changedValueTree || Array.isArray(changedValueTree) && !changedValueTree.length) {
8692        globalStylesChangesCache.set(cacheKey, []);
8693        return [];
8694      }
8695      const changedValueArray = Array.isArray(changedValueTree) ? changedValueTree : [changedValueTree];
8696      const result = [...new Set(changedValueArray)].reduce((acc, curr) => {
8697        const translation = getTranslation(curr);
8698        if (translation) {
8699          acc.push([curr.split(".")[0], translation]);
8700        }
8701        return acc;
8702      }, []);
8703      globalStylesChangesCache.set(cacheKey, result);
8704      return result;
8705    }
8706    function getGlobalStylesChanges(next, previous, options = {}) {
8707      let changeList = getGlobalStylesChangelist(next, previous);
8708      const changesLength = changeList.length;
8709      const { maxResults } = options;
8710      if (changesLength) {
8711        if (!!maxResults && changesLength > maxResults) {
8712          changeList = changeList.slice(0, maxResults);
8713        }
8714        return Object.entries(
8715          changeList.reduce((acc, curr) => {
8716            const group = acc[curr[0]] || [];
8717            if (!group.includes(curr[1])) {
8718              acc[curr[0]] = [...group, curr[1]];
8719            }
8720            return acc;
8721          }, {})
8722        ).map(([key, changeValues]) => {
8723          const changeValuesLength = changeValues.length;
8724          const joinedChangesValue = changeValues.join(
8725            /* translators: Used between list items, there is a space after the comma. */
8726            (0, import_i18n4.__)(", ")
8727            // eslint-disable-line @wordpress/i18n-no-flanking-whitespace
8728          );
8729          switch (key) {
8730            case "blocks": {
8731              return (0, import_i18n4.sprintf)(
8732                // translators: %s: a list of block names separated by a comma.
8733                (0, import_i18n4._n)("%s block.", "%s blocks.", changeValuesLength),
8734                joinedChangesValue
8735              );
8736            }
8737            case "elements": {
8738              return (0, import_i18n4.sprintf)(
8739                // translators: %s: a list of element names separated by a comma.
8740                (0, import_i18n4._n)("%s element.", "%s elements.", changeValuesLength),
8741                joinedChangesValue
8742              );
8743            }
8744            case "settings": {
8745              return (0, import_i18n4.sprintf)(
8746                // translators: %s: a list of theme.json setting labels separated by a comma.
8747                (0, import_i18n4.__)("%s settings."),
8748                joinedChangesValue
8749              );
8750            }
8751            case "styles": {
8752              return (0, import_i18n4.sprintf)(
8753                // translators: %s: a list of theme.json top-level styles labels separated by a comma.
8754                (0, import_i18n4.__)("%s styles."),
8755                joinedChangesValue
8756              );
8757            }
8758            default: {
8759              return (0, import_i18n4.sprintf)(
8760                // translators: %s: a list of global styles changes separated by a comma.
8761                (0, import_i18n4.__)("%s."),
8762                joinedChangesValue
8763              );
8764            }
8765          }
8766        });
8767      }
8768      return EMPTY_ARRAY3;
8769    }
8770  
8771    // packages/core-data/build-module/components/entities-saved-states/entity-record-item.mjs
8772    var import_components = __toESM(require_components(), 1);
8773    var import_i18n5 = __toESM(require_i18n(), 1);
8774    var import_data16 = __toESM(require_data(), 1);
8775    var import_html_entities4 = __toESM(require_html_entities(), 1);
8776    var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
8777    function EntityRecordItem({ record, checked, onChange }) {
8778      const { name, kind, title, key } = record;
8779      const { entityRecordTitle } = (0, import_data16.useSelect)(
8780        (select5) => {
8781          if ("postType" !== kind || "wp_template" !== name) {
8782            return {
8783              entityRecordTitle: title
8784            };
8785          }
8786          const template = select5(STORE_NAME).getEditedEntityRecord(
8787            kind,
8788            name,
8789            key
8790          );
8791          const { default_template_types: templateTypes = [] } = select5(STORE_NAME).getCurrentTheme() ?? {};
8792          return {
8793            entityRecordTitle: getTemplateInfo({
8794              template,
8795              templateTypes
8796            }).title
8797          };
8798        },
8799        [name, kind, title, key]
8800      );
8801      return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_jsx_runtime8.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_components.PanelRow, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
8802        import_components.CheckboxControl,
8803        {
8804          label: (0, import_html_entities4.decodeEntities)(entityRecordTitle) || (0, import_i18n5.__)("Untitled"),
8805          checked,
8806          onChange,
8807          className: "entities-saved-states__change-control"
8808        }
8809      ) }) });
8810    }
8811  
8812    // packages/core-data/build-module/components/entities-saved-states/entity-type-list.mjs
8813    var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
8814    function getEntityDescription(entity2, count) {
8815      switch (entity2) {
8816        case "site":
8817          return 1 === count ? (0, import_i18n6.__)("This change will affect your whole site.") : (0, import_i18n6.__)("These changes will affect your whole site.");
8818        case "wp_template":
8819          return (0, import_i18n6.__)(
8820            "This change will affect other parts of your site that use this template."
8821          );
8822        case "page":
8823        case "post":
8824          return (0, import_i18n6.__)("The following has been modified.");
8825      }
8826    }
8827    function GlobalStylesDescription({ record }) {
8828      const { editedRecord, savedRecord } = (0, import_data17.useSelect)(
8829        (select5) => {
8830          const { getEditedEntityRecord: getEditedEntityRecord3, getEntityRecord: getEntityRecord3 } = select5(STORE_NAME);
8831          return {
8832            editedRecord: getEditedEntityRecord3(
8833              record.kind,
8834              record.name,
8835              record.key
8836            ),
8837            savedRecord: getEntityRecord3(
8838              record.kind,
8839              record.name,
8840              record.key
8841            )
8842          };
8843        },
8844        [record.kind, record.name, record.key]
8845      );
8846      const globalStylesChanges = getGlobalStylesChanges(
8847        editedRecord,
8848        savedRecord,
8849        {
8850          maxResults: 10
8851        }
8852      );
8853      return globalStylesChanges.length ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("ul", { className: "entities-saved-states__changes", children: globalStylesChanges.map((change) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("li", { children: change }, change)) }) : null;
8854    }
8855    function EntityDescription({ record, count }) {
8856      if ("globalStyles" === record?.name) {
8857        return null;
8858      }
8859      const description = getEntityDescription(record?.name, count);
8860      return description ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_components2.PanelRow, { children: description }) : null;
8861    }
8862    function EntityTypeList({
8863      list,
8864      unselectedEntities,
8865      setUnselectedEntities
8866    }) {
8867      const count = list.length;
8868      const firstRecord = list[0];
8869      const entityConfig = (0, import_data17.useSelect)(
8870        (select5) => select5(STORE_NAME).getEntityConfig(
8871          firstRecord.kind,
8872          firstRecord.name
8873        ),
8874        [firstRecord.kind, firstRecord.name]
8875      );
8876      let entityLabel = entityConfig.label;
8877      if (firstRecord?.name === "wp_template_part") {
8878        entityLabel = 1 === count ? (0, import_i18n6.__)("Template Part") : (0, import_i18n6.__)("Template Parts");
8879      }
8880      return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(
8881        import_components2.PanelBody,
8882        {
8883          title: entityLabel,
8884          initialOpen: true,
8885          className: "entities-saved-states__panel-body",
8886          children: [
8887            /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(EntityDescription, { record: firstRecord, count }),
8888            list.map((record) => {
8889              return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
8890                EntityRecordItem,
8891                {
8892                  record,
8893                  checked: !unselectedEntities.some(
8894                    (elt) => elt.kind === record.kind && elt.name === record.name && elt.key === record.key && elt.property === record.property
8895                  ),
8896                  onChange: (value) => setUnselectedEntities(record, value)
8897                },
8898                record.key || record.property
8899              );
8900            }),
8901            "globalStyles" === firstRecord?.name && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(GlobalStylesDescription, { record: firstRecord })
8902          ]
8903        }
8904      );
8905    }
8906  
8907    // packages/core-data/build-module/components/entities-saved-states/hooks/use-is-dirty.mjs
8908    var import_data18 = __toESM(require_data(), 1);
8909    var import_element9 = __toESM(require_element(), 1);
8910    var useIsDirty = () => {
8911      const { editedEntities, siteEdits, siteEntityConfig } = (0, import_data18.useSelect)(
8912        (select5) => {
8913          const {
8914            __experimentalGetDirtyEntityRecords: __experimentalGetDirtyEntityRecords2,
8915            getEntityRecordEdits: getEntityRecordEdits2,
8916            getEntityConfig: getEntityConfig2
8917          } = select5(STORE_NAME);
8918          return {
8919            editedEntities: __experimentalGetDirtyEntityRecords2(),
8920            siteEdits: getEntityRecordEdits2("root", "site"),
8921            siteEntityConfig: getEntityConfig2("root", "site")
8922          };
8923        },
8924        []
8925      );
8926      const dirtyEntityRecords = (0, import_element9.useMemo)(() => {
8927        const editedEntitiesWithoutSite = editedEntities.filter(
8928          (record) => !(record.kind === "root" && record.name === "site")
8929        );
8930        const siteEntityLabels = siteEntityConfig?.meta?.labels ?? {};
8931        const {
8932          title: siteTitleEdit,
8933          description: siteDescriptionEdit,
8934          site_logo: siteLogoEdit,
8935          site_icon: siteIconEdit,
8936          ...otherSiteEdits
8937        } = siteEdits ?? {};
8938        const orderedSiteProperties = [
8939          siteTitleEdit !== void 0 && "title",
8940          siteDescriptionEdit !== void 0 && "description",
8941          siteLogoEdit !== void 0 && "site_logo",
8942          siteIconEdit !== void 0 && "site_icon",
8943          ...Object.keys(otherSiteEdits)
8944        ].filter(Boolean);
8945        const editedSiteEntities = orderedSiteProperties.map(
8946          (property) => ({
8947            kind: "root",
8948            name: "site",
8949            title: siteEntityLabels[property] || property,
8950            property
8951          })
8952        );
8953        return [...editedEntitiesWithoutSite, ...editedSiteEntities];
8954      }, [editedEntities, siteEdits, siteEntityConfig]);
8955      const [unselectedEntities, _setUnselectedEntities] = (0, import_element9.useState)([]);
8956      const setUnselectedEntities = ({ kind, name, key, property }, checked) => {
8957        if (checked) {
8958          _setUnselectedEntities(
8959            unselectedEntities.filter(
8960              (elt) => elt.kind !== kind || elt.name !== name || elt.key !== key || elt.property !== property
8961            )
8962          );
8963        } else {
8964          _setUnselectedEntities([
8965            ...unselectedEntities,
8966            { kind, name, key, property }
8967          ]);
8968        }
8969      };
8970      const isDirty = dirtyEntityRecords.length - unselectedEntities.length > 0;
8971      return {
8972        dirtyEntityRecords,
8973        isDirty,
8974        setUnselectedEntities,
8975        unselectedEntities
8976      };
8977    };
8978  
8979    // packages/core-data/build-module/components/entities-saved-states/index.mjs
8980    var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
8981    function EntitiesSavedStates({
8982      close,
8983      renderDialog,
8984      variant
8985    }) {
8986      const isDirtyProps = useIsDirty();
8987      return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
8988        EntitiesSavedStatesExtensible,
8989        {
8990          close,
8991          renderDialog,
8992          variant,
8993          ...isDirtyProps
8994        }
8995      );
8996    }
8997    function EntitiesSavedStatesExtensible({
8998      additionalPrompt = void 0,
8999      close,
9000      onSave = void 0,
9001      saveEnabled: saveEnabledProp = void 0,
9002      saveLabel = (0, import_i18n7.__)("Save"),
9003      renderDialog,
9004      dirtyEntityRecords,
9005      isDirty,
9006      setUnselectedEntities,
9007      unselectedEntities,
9008      variant = "default",
9009      successNoticeContent
9010    }) {
9011      const saveButtonRef = (0, import_element10.useRef)();
9012      const { saveDirtyEntities: saveDirtyEntities2 } = unlock((0, import_data19.useDispatch)(STORE_NAME));
9013      const partitionedSavables = dirtyEntityRecords.reduce((acc, record) => {
9014        const { name } = record;
9015        if (!acc[name]) {
9016          acc[name] = [];
9017        }
9018        acc[name].push(record);
9019        return acc;
9020      }, {});
9021      const {
9022        site: siteSavables,
9023        wp_template: templateSavables,
9024        wp_template_part: templatePartSavables,
9025        ...contentSavables
9026      } = partitionedSavables;
9027      const sortedPartitionedSavables = [
9028        siteSavables,
9029        templateSavables,
9030        templatePartSavables,
9031        ...Object.values(contentSavables)
9032      ].filter(Array.isArray);
9033      const saveEnabled = saveEnabledProp ?? isDirty;
9034      const dismissPanel = (0, import_element10.useCallback)(() => close(), [close]);
9035      const [saveDialogRef, saveDialogProps] = (0, import_compose4.__experimentalUseDialog)({
9036        onClose: () => dismissPanel()
9037      });
9038      const dialogLabelId = (0, import_compose4.useInstanceId)(
9039        EntitiesSavedStatesExtensible,
9040        "entities-saved-states__panel-label"
9041      );
9042      const dialogDescriptionId = (0, import_compose4.useInstanceId)(
9043        EntitiesSavedStatesExtensible,
9044        "entities-saved-states__panel-description"
9045      );
9046      const selectItemsToSaveDescription = !!dirtyEntityRecords.length ? (0, import_i18n7.__)("Select the items you want to save.") : void 0;
9047      const isInline = variant === "inline";
9048      const actionButtons = /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_jsx_runtime10.Fragment, { children: [
9049        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
9050          import_components3.FlexItem,
9051          {
9052            isBlock: isInline ? false : true,
9053            as: import_components3.Button,
9054            variant: isInline ? "tertiary" : "secondary",
9055            size: isInline ? void 0 : "compact",
9056            onClick: dismissPanel,
9057            children: (0, import_i18n7.__)("Cancel")
9058          }
9059        ),
9060        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
9061          import_components3.FlexItem,
9062          {
9063            isBlock: isInline ? false : true,
9064            as: import_components3.Button,
9065            ref: saveButtonRef,
9066            variant: "primary",
9067            size: isInline ? void 0 : "compact",
9068            disabled: !saveEnabled,
9069            accessibleWhenDisabled: true,
9070            onClick: () => saveDirtyEntities2({
9071              onSave,
9072              dirtyEntityRecords,
9073              entitiesToSkip: unselectedEntities,
9074              close,
9075              successNoticeContent
9076            }),
9077            className: "entities-saved-states__save-button",
9078            children: saveLabel
9079          }
9080        )
9081      ] });
9082      return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(
9083        "div",
9084        {
9085          ref: renderDialog ? saveDialogRef : void 0,
9086          ...renderDialog && saveDialogProps,
9087          className: clsx_default("entities-saved-states__panel", {
9088            "is-inline": isInline
9089          }),
9090          role: renderDialog ? "dialog" : void 0,
9091          "aria-labelledby": renderDialog ? dialogLabelId : void 0,
9092          "aria-describedby": renderDialog ? dialogDescriptionId : void 0,
9093          children: [
9094            !isInline && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_components3.Flex, { className: "entities-saved-states__panel-header", gap: 2, children: actionButtons }),
9095            /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { className: "entities-saved-states__text-prompt", children: [
9096              /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "entities-saved-states__text-prompt--header-wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
9097                "strong",
9098                {
9099                  id: renderDialog ? dialogLabelId : void 0,
9100                  className: "entities-saved-states__text-prompt--header",
9101                  children: (0, import_i18n7.__)("Are you ready to save?")
9102                }
9103              ) }),
9104              /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { id: renderDialog ? dialogDescriptionId : void 0, children: [
9105                additionalPrompt,
9106                /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("p", { className: "entities-saved-states__text-prompt--changes-count", children: isDirty ? (0, import_element10.createInterpolateElement)(
9107                  (0, import_i18n7.sprintf)(
9108                    /* translators: %d: number of site changes waiting to be saved. */
9109                    (0, import_i18n7._n)(
9110                      "There is <strong>%d site change</strong> waiting to be saved.",
9111                      "There are <strong>%d site changes</strong> waiting to be saved.",
9112                      dirtyEntityRecords.length
9113                    ),
9114                    dirtyEntityRecords.length
9115                  ),
9116                  { strong: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("strong", {}) }
9117                ) : selectItemsToSaveDescription })
9118              ] })
9119            ] }),
9120            sortedPartitionedSavables.map((list) => {
9121              return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
9122                EntityTypeList,
9123                {
9124                  list,
9125                  unselectedEntities,
9126                  setUnselectedEntities
9127                },
9128                list[0].name
9129              );
9130            }),
9131            isInline && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
9132              import_components3.Flex,
9133              {
9134                direction: "row",
9135                justify: "flex-end",
9136                className: "entities-saved-states__panel-footer",
9137                children: actionButtons
9138              }
9139            )
9140          ]
9141        }
9142      );
9143    }
9144  
9145    // packages/core-data/build-module/private-apis.mjs
9146    var lockedApis = {
9147      EntitiesSavedStates,
9148      EntitiesSavedStatesExtensible,
9149      getTemplateInfo,
9150      getTemplatePartIcon,
9151      useEntitiesSavedStatesIsDirty: useIsDirty,
9152      useEntityRecordsWithPermissions,
9153      RECEIVE_INTERMEDIATE_RESULTS,
9154      CRDT_AUTOSAVE_SNAPSHOT_KEY,
9155      entityContainsSnapshot,
9156      getEntitySnapshot,
9157      retrySyncConnection,
9158      useActiveCollaborators,
9159      useResolvedSelection,
9160      useOnCollaboratorJoin,
9161      useOnCollaboratorLeave,
9162      useOnPostSave,
9163      SelectionType,
9164      SelectionDirection
9165    };
9166    var privateApis = {};
9167    lock(privateApis, lockedApis);
9168  
9169    // packages/core-data/build-module/index.mjs
9170    var entitiesConfig2 = [
9171      ...rootEntitiesConfig,
9172      ...additionalEntityConfigLoaders.filter((config) => !!config.name)
9173    ];
9174    var entitySelectors = entitiesConfig2.reduce((result, entity2) => {
9175      const { kind, name, plural } = entity2;
9176      const getEntityRecordMethodName = getMethodName(kind, name);
9177      result[getEntityRecordMethodName] = (state, key, query) => {
9178        logEntityDeprecation(kind, name, getEntityRecordMethodName, {
9179          isShorthandSelector: true,
9180          alternativeFunctionName: "getEntityRecord"
9181        });
9182        return getEntityRecord(state, kind, name, key, query);
9183      };
9184      if (plural) {
9185        const getEntityRecordsMethodName = getMethodName(kind, plural, "get");
9186        result[getEntityRecordsMethodName] = (state, query) => {
9187          logEntityDeprecation(kind, name, getEntityRecordsMethodName, {
9188            isShorthandSelector: true,
9189            alternativeFunctionName: "getEntityRecords"
9190          });
9191          return getEntityRecords(state, kind, name, query);
9192        };
9193      }
9194      return result;
9195    }, {});
9196    var entityResolvers = entitiesConfig2.reduce((result, entity2) => {
9197      const { kind, name, plural } = entity2;
9198      const getEntityRecordMethodName = getMethodName(kind, name);
9199      result[getEntityRecordMethodName] = (key, query) => {
9200        logEntityDeprecation(kind, name, getEntityRecordMethodName, {
9201          isShorthandSelector: true,
9202          alternativeFunctionName: "getEntityRecord"
9203        });
9204        return getEntityRecord2(kind, name, key, query);
9205      };
9206      if (plural) {
9207        const getEntityRecordsMethodName = getMethodName(kind, plural, "get");
9208        result[getEntityRecordsMethodName] = (...args) => {
9209          logEntityDeprecation(kind, plural, getEntityRecordsMethodName, {
9210            isShorthandSelector: true,
9211            alternativeFunctionName: "getEntityRecords"
9212          });
9213          return getEntityRecords2(kind, name, ...args);
9214        };
9215        result[getEntityRecordsMethodName].shouldInvalidate = (action) => getEntityRecords2.shouldInvalidate(action, kind, name);
9216      }
9217      return result;
9218    }, {});
9219    var entityActions = entitiesConfig2.reduce((result, entity2) => {
9220      const { kind, name } = entity2;
9221      const saveEntityRecordMethodName = getMethodName(kind, name, "save");
9222      result[saveEntityRecordMethodName] = (record, options) => {
9223        logEntityDeprecation(kind, name, saveEntityRecordMethodName, {
9224          isShorthandSelector: true,
9225          alternativeFunctionName: "saveEntityRecord"
9226        });
9227        return saveEntityRecord(kind, name, record, options);
9228      };
9229      const deleteEntityRecordMethodName = getMethodName(kind, name, "delete");
9230      result[deleteEntityRecordMethodName] = (key, query, options) => {
9231        logEntityDeprecation(kind, name, deleteEntityRecordMethodName, {
9232          isShorthandSelector: true,
9233          alternativeFunctionName: "deleteEntityRecord"
9234        });
9235        return deleteEntityRecord(kind, name, key, query, options);
9236      };
9237      return result;
9238    }, {});
9239    var storeConfig = () => ({
9240      reducer: reducer_default2,
9241      actions: {
9242        ...dynamicActions,
9243        ...actions_exports,
9244        ...entityActions,
9245        ...createLocksActions()
9246      },
9247      selectors: {
9248        ...dynamicSelectors,
9249        ...selectors_exports,
9250        ...entitySelectors
9251      },
9252      resolvers: { ...resolvers_exports, ...entityResolvers }
9253    });
9254    var store = (0, import_data20.createReduxStore)(STORE_NAME, storeConfig());
9255    unlock(store).registerPrivateSelectors(private_selectors_exports);
9256    unlock(store).registerPrivateActions(private_actions_exports);
9257    (0, import_data20.register)(store);
9258    return __toCommonJS(index_exports);
9259  })();
9260  (window.wp ||= {}).coreData = wp.coreData;
9261  })();