[Summary view] [Print] [Text view]

   1  /******/ (() => { // webpackBootstrap
   2  /******/     var __webpack_modules__ = ({
   3  
   4  /***/ 287:
   5  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
   6  
   7  "use strict";
   8  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
   9  /* harmony export */   fL: () => (/* binding */ pascalCase),
  10  /* harmony export */   l3: () => (/* binding */ pascalCaseTransform)
  11  /* harmony export */ });
  12  /* unused harmony export pascalCaseTransformMerge */
  13  /* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1635);
  14  /* harmony import */ var no_case__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2226);
  15  
  16  
  17  function pascalCaseTransform(input, index) {
  18      var firstChar = input.charAt(0);
  19      var lowerChars = input.substr(1).toLowerCase();
  20      if (index > 0 && firstChar >= "0" && firstChar <= "9") {
  21          return "_" + firstChar + lowerChars;
  22      }
  23      return "" + firstChar.toUpperCase() + lowerChars;
  24  }
  25  function pascalCaseTransformMerge(input) {
  26      return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
  27  }
  28  function pascalCase(input, options) {
  29      if (options === void 0) { options = {}; }
  30      return (0,no_case__WEBPACK_IMPORTED_MODULE_0__/* .noCase */ .W)(input, (0,tslib__WEBPACK_IMPORTED_MODULE_1__/* .__assign */ .Cl)({ delimiter: "", transform: pascalCaseTransform }, options));
  31  }
  32  
  33  
  34  /***/ }),
  35  
  36  /***/ 533:
  37  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
  38  
  39  "use strict";
  40  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
  41  /* harmony export */   A: () => (/* binding */ get_normalized_comma_separable_default)
  42  /* harmony export */ });
  43  function getNormalizedCommaSeparable(value) {
  44    if (typeof value === "string") {
  45      return value.split(",");
  46    } else if (Array.isArray(value)) {
  47      return value;
  48    }
  49    return null;
  50  }
  51  var get_normalized_comma_separable_default = getNormalizedCommaSeparable;
  52  
  53  
  54  
  55  /***/ }),
  56  
  57  /***/ 1455:
  58  /***/ ((module) => {
  59  
  60  "use strict";
  61  module.exports = window["wp"]["apiFetch"];
  62  
  63  /***/ }),
  64  
  65  /***/ 1635:
  66  /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
  67  
  68  "use strict";
  69  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
  70  /* harmony export */   Cl: () => (/* binding */ __assign)
  71  /* harmony export */ });
  72  /* unused harmony exports __extends, __rest, __decorate, __param, __esDecorate, __runInitializers, __propKey, __setFunctionName, __metadata, __awaiter, __generator, __createBinding, __exportStar, __values, __read, __spread, __spreadArrays, __spreadArray, __await, __asyncGenerator, __asyncDelegator, __asyncValues, __makeTemplateObject, __importStar, __importDefault, __classPrivateFieldGet, __classPrivateFieldSet, __classPrivateFieldIn, __addDisposableResource, __disposeResources, __rewriteRelativeImportExtension */
  73  /******************************************************************************
  74  Copyright (c) Microsoft Corporation.
  75  
  76  Permission to use, copy, modify, and/or distribute this software for any
  77  purpose with or without fee is hereby granted.
  78  
  79  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  80  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  81  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  82  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  83  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  84  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  85  PERFORMANCE OF THIS SOFTWARE.
  86  ***************************************************************************** */
  87  /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
  88  
  89  var extendStatics = function(d, b) {
  90    extendStatics = Object.setPrototypeOf ||
  91        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
  92        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
  93    return extendStatics(d, b);
  94  };
  95  
  96  function __extends(d, b) {
  97    if (typeof b !== "function" && b !== null)
  98        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
  99    extendStatics(d, b);
 100    function __() { this.constructor = d; }
 101    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 102  }
 103  
 104  var __assign = function() {
 105    __assign = Object.assign || function __assign(t) {
 106        for (var s, i = 1, n = arguments.length; i < n; i++) {
 107            s = arguments[i];
 108            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
 109        }
 110        return t;
 111    }
 112    return __assign.apply(this, arguments);
 113  }
 114  
 115  function __rest(s, e) {
 116    var t = {};
 117    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
 118        t[p] = s[p];
 119    if (s != null && typeof Object.getOwnPropertySymbols === "function")
 120        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
 121            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
 122                t[p[i]] = s[p[i]];
 123        }
 124    return t;
 125  }
 126  
 127  function __decorate(decorators, target, key, desc) {
 128    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 129    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
 130    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
 131    return c > 3 && r && Object.defineProperty(target, key, r), r;
 132  }
 133  
 134  function __param(paramIndex, decorator) {
 135    return function (target, key) { decorator(target, key, paramIndex); }
 136  }
 137  
 138  function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
 139    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
 140    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
 141    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
 142    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
 143    var _, done = false;
 144    for (var i = decorators.length - 1; i >= 0; i--) {
 145        var context = {};
 146        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
 147        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
 148        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
 149        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
 150        if (kind === "accessor") {
 151            if (result === void 0) continue;
 152            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
 153            if (_ = accept(result.get)) descriptor.get = _;
 154            if (_ = accept(result.set)) descriptor.set = _;
 155            if (_ = accept(result.init)) initializers.unshift(_);
 156        }
 157        else if (_ = accept(result)) {
 158            if (kind === "field") initializers.unshift(_);
 159            else descriptor[key] = _;
 160        }
 161    }
 162    if (target) Object.defineProperty(target, contextIn.name, descriptor);
 163    done = true;
 164  };
 165  
 166  function __runInitializers(thisArg, initializers, value) {
 167    var useValue = arguments.length > 2;
 168    for (var i = 0; i < initializers.length; i++) {
 169        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
 170    }
 171    return useValue ? value : void 0;
 172  };
 173  
 174  function __propKey(x) {
 175    return typeof x === "symbol" ? x : "".concat(x);
 176  };
 177  
 178  function __setFunctionName(f, name, prefix) {
 179    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
 180    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 181  };
 182  
 183  function __metadata(metadataKey, metadataValue) {
 184    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
 185  }
 186  
 187  function __awaiter(thisArg, _arguments, P, generator) {
 188    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 189    return new (P || (P = Promise))(function (resolve, reject) {
 190        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 191        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 192        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 193        step((generator = generator.apply(thisArg, _arguments || [])).next());
 194    });
 195  }
 196  
 197  function __generator(thisArg, body) {
 198    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
 199    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
 200    function verb(n) { return function (v) { return step([n, v]); }; }
 201    function step(op) {
 202        if (f) throw new TypeError("Generator is already executing.");
 203        while (g && (g = 0, op[0] && (_ = 0)), _) try {
 204            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
 205            if (y = 0, t) op = [op[0] & 2, t.value];
 206            switch (op[0]) {
 207                case 0: case 1: t = op; break;
 208                case 4: _.label++; return { value: op[1], done: false };
 209                case 5: _.label++; y = op[1]; op = [0]; continue;
 210                case 7: op = _.ops.pop(); _.trys.pop(); continue;
 211                default:
 212                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
 213                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
 214                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
 215                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
 216                    if (t[2]) _.ops.pop();
 217                    _.trys.pop(); continue;
 218            }
 219            op = body.call(thisArg, _);
 220        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
 221        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
 222    }
 223  }
 224  
 225  var __createBinding = Object.create ? (function(o, m, k, k2) {
 226    if (k2 === undefined) k2 = k;
 227    var desc = Object.getOwnPropertyDescriptor(m, k);
 228    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
 229        desc = { enumerable: true, get: function() { return m[k]; } };
 230    }
 231    Object.defineProperty(o, k2, desc);
 232  }) : (function(o, m, k, k2) {
 233    if (k2 === undefined) k2 = k;
 234    o[k2] = m[k];
 235  });
 236  
 237  function __exportStar(m, o) {
 238    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
 239  }
 240  
 241  function __values(o) {
 242    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
 243    if (m) return m.call(o);
 244    if (o && typeof o.length === "number") return {
 245        next: function () {
 246            if (o && i >= o.length) o = void 0;
 247            return { value: o && o[i++], done: !o };
 248        }
 249    };
 250    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 251  }
 252  
 253  function __read(o, n) {
 254    var m = typeof Symbol === "function" && o[Symbol.iterator];
 255    if (!m) return o;
 256    var i = m.call(o), r, ar = [], e;
 257    try {
 258        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
 259    }
 260    catch (error) { e = { error: error }; }
 261    finally {
 262        try {
 263            if (r && !r.done && (m = i["return"])) m.call(i);
 264        }
 265        finally { if (e) throw e.error; }
 266    }
 267    return ar;
 268  }
 269  
 270  /** @deprecated */
 271  function __spread() {
 272    for (var ar = [], i = 0; i < arguments.length; i++)
 273        ar = ar.concat(__read(arguments[i]));
 274    return ar;
 275  }
 276  
 277  /** @deprecated */
 278  function __spreadArrays() {
 279    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
 280    for (var r = Array(s), k = 0, i = 0; i < il; i++)
 281        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
 282            r[k] = a[j];
 283    return r;
 284  }
 285  
 286  function __spreadArray(to, from, pack) {
 287    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
 288        if (ar || !(i in from)) {
 289            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
 290            ar[i] = from[i];
 291        }
 292    }
 293    return to.concat(ar || Array.prototype.slice.call(from));
 294  }
 295  
 296  function __await(v) {
 297    return this instanceof __await ? (this.v = v, this) : new __await(v);
 298  }
 299  
 300  function __asyncGenerator(thisArg, _arguments, generator) {
 301    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
 302    var g = generator.apply(thisArg, _arguments || []), i, q = [];
 303    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
 304    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
 305    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
 306    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
 307    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
 308    function fulfill(value) { resume("next", value); }
 309    function reject(value) { resume("throw", value); }
 310    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 311  }
 312  
 313  function __asyncDelegator(o) {
 314    var i, p;
 315    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
 316    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
 317  }
 318  
 319  function __asyncValues(o) {
 320    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
 321    var m = o[Symbol.asyncIterator], i;
 322    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
 323    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
 324    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 325  }
 326  
 327  function __makeTemplateObject(cooked, raw) {
 328    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
 329    return cooked;
 330  };
 331  
 332  var __setModuleDefault = Object.create ? (function(o, v) {
 333    Object.defineProperty(o, "default", { enumerable: true, value: v });
 334  }) : function(o, v) {
 335    o["default"] = v;
 336  };
 337  
 338  var ownKeys = function(o) {
 339    ownKeys = Object.getOwnPropertyNames || function (o) {
 340      var ar = [];
 341      for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
 342      return ar;
 343    };
 344    return ownKeys(o);
 345  };
 346  
 347  function __importStar(mod) {
 348    if (mod && mod.__esModule) return mod;
 349    var result = {};
 350    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
 351    __setModuleDefault(result, mod);
 352    return result;
 353  }
 354  
 355  function __importDefault(mod) {
 356    return (mod && mod.__esModule) ? mod : { default: mod };
 357  }
 358  
 359  function __classPrivateFieldGet(receiver, state, kind, f) {
 360    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
 361    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
 362    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 363  }
 364  
 365  function __classPrivateFieldSet(receiver, state, value, kind, f) {
 366    if (kind === "m") throw new TypeError("Private method is not writable");
 367    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
 368    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
 369    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 370  }
 371  
 372  function __classPrivateFieldIn(state, receiver) {
 373    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
 374    return typeof state === "function" ? receiver === state : state.has(receiver);
 375  }
 376  
 377  function __addDisposableResource(env, value, async) {
 378    if (value !== null && value !== void 0) {
 379      if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
 380      var dispose, inner;
 381      if (async) {
 382        if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
 383        dispose = value[Symbol.asyncDispose];
 384      }
 385      if (dispose === void 0) {
 386        if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
 387        dispose = value[Symbol.dispose];
 388        if (async) inner = dispose;
 389      }
 390      if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
 391      if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
 392      env.stack.push({ value: value, dispose: dispose, async: async });
 393    }
 394    else if (async) {
 395      env.stack.push({ async: true });
 396    }
 397    return value;
 398  }
 399  
 400  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
 401    var e = new Error(message);
 402    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 403  };
 404  
 405  function __disposeResources(env) {
 406    function fail(e) {
 407      env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
 408      env.hasError = true;
 409    }
 410    var r, s = 0;
 411    function next() {
 412      while (r = env.stack.pop()) {
 413        try {
 414          if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
 415          if (r.dispose) {
 416            var result = r.dispose.call(r.value);
 417            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
 418          }
 419          else s |= 1;
 420        }
 421        catch (e) {
 422          fail(e);
 423        }
 424      }
 425      if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
 426      if (env.hasError) throw env.error;
 427    }
 428    return next();
 429  }
 430  
 431  function __rewriteRelativeImportExtension(path, preserveJsx) {
 432    if (typeof path === "string" && /^\.\.?\//.test(path)) {
 433        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
 434            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
 435        });
 436    }
 437    return path;
 438  }
 439  
 440  /* unused harmony default export */ var __WEBPACK_DEFAULT_EXPORT__ = ({
 441    __extends,
 442    __assign,
 443    __rest,
 444    __decorate,
 445    __param,
 446    __esDecorate,
 447    __runInitializers,
 448    __propKey,
 449    __setFunctionName,
 450    __metadata,
 451    __awaiter,
 452    __generator,
 453    __createBinding,
 454    __exportStar,
 455    __values,
 456    __read,
 457    __spread,
 458    __spreadArrays,
 459    __spreadArray,
 460    __await,
 461    __asyncGenerator,
 462    __asyncDelegator,
 463    __asyncValues,
 464    __makeTemplateObject,
 465    __importStar,
 466    __importDefault,
 467    __classPrivateFieldGet,
 468    __classPrivateFieldSet,
 469    __classPrivateFieldIn,
 470    __addDisposableResource,
 471    __disposeResources,
 472    __rewriteRelativeImportExtension,
 473  });
 474  
 475  
 476  /***/ }),
 477  
 478  /***/ 2226:
 479  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 480  
 481  "use strict";
 482  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 483  /* harmony export */   W: () => (/* binding */ noCase)
 484  /* harmony export */ });
 485  /* harmony import */ var lower_case__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7314);
 486  
 487  // Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case").
 488  var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
 489  // Remove all non-word characters.
 490  var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
 491  /**
 492   * Normalize the string into something other libraries can manipulate easier.
 493   */
 494  function noCase(input, options) {
 495      if (options === void 0) { options = {}; }
 496      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 ? lower_case__WEBPACK_IMPORTED_MODULE_0__/* .lowerCase */ .g : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
 497      var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
 498      var start = 0;
 499      var end = result.length;
 500      // Trim the delimiter from around the output string.
 501      while (result.charAt(start) === "\0")
 502          start++;
 503      while (result.charAt(end - 1) === "\0")
 504          end--;
 505      // Transform each token independently.
 506      return result.slice(start, end).split("\0").map(transform).join(delimiter);
 507  }
 508  /**
 509   * Replace `re` in the input string with the replacement value.
 510   */
 511  function replace(input, re, value) {
 512      if (re instanceof RegExp)
 513          return input.replace(re, value);
 514      return re.reduce(function (input, re) { return input.replace(re, value); }, input);
 515  }
 516  
 517  
 518  /***/ }),
 519  
 520  /***/ 2239:
 521  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 522  
 523  "use strict";
 524  
 525  // EXPORTS
 526  __webpack_require__.d(__webpack_exports__, {
 527    A: () => (/* binding */ createLocksActions)
 528  });
 529  
 530  ;// ./node_modules/@wordpress/core-data/build-module/locks/utils.js
 531  function deepCopyLocksTreePath(tree, path) {
 532    const newTree = { ...tree };
 533    let currentNode = newTree;
 534    for (const branchName of path) {
 535      currentNode.children = {
 536        ...currentNode.children,
 537        [branchName]: {
 538          locks: [],
 539          children: {},
 540          ...currentNode.children[branchName]
 541        }
 542      };
 543      currentNode = currentNode.children[branchName];
 544    }
 545    return newTree;
 546  }
 547  function getNode(tree, path) {
 548    let currentNode = tree;
 549    for (const branchName of path) {
 550      const nextNode = currentNode.children[branchName];
 551      if (!nextNode) {
 552        return null;
 553      }
 554      currentNode = nextNode;
 555    }
 556    return currentNode;
 557  }
 558  function* iteratePath(tree, path) {
 559    let currentNode = tree;
 560    yield currentNode;
 561    for (const branchName of path) {
 562      const nextNode = currentNode.children[branchName];
 563      if (!nextNode) {
 564        break;
 565      }
 566      yield nextNode;
 567      currentNode = nextNode;
 568    }
 569  }
 570  function* iterateDescendants(node) {
 571    const stack = Object.values(node.children);
 572    while (stack.length) {
 573      const childNode = stack.pop();
 574      yield childNode;
 575      stack.push(...Object.values(childNode.children));
 576    }
 577  }
 578  function hasConflictingLock({ exclusive }, locks) {
 579    if (exclusive && locks.length) {
 580      return true;
 581    }
 582    if (!exclusive && locks.filter((lock) => lock.exclusive).length) {
 583      return true;
 584    }
 585    return false;
 586  }
 587  
 588  
 589  ;// ./node_modules/@wordpress/core-data/build-module/locks/reducer.js
 590  
 591  const DEFAULT_STATE = {
 592    requests: [],
 593    tree: {
 594      locks: [],
 595      children: {}
 596    }
 597  };
 598  function locks(state = DEFAULT_STATE, action) {
 599    switch (action.type) {
 600      case "ENQUEUE_LOCK_REQUEST": {
 601        const { request } = action;
 602        return {
 603          ...state,
 604          requests: [request, ...state.requests]
 605        };
 606      }
 607      case "GRANT_LOCK_REQUEST": {
 608        const { lock, request } = action;
 609        const { store, path } = request;
 610        const storePath = [store, ...path];
 611        const newTree = deepCopyLocksTreePath(state.tree, storePath);
 612        const node = getNode(newTree, storePath);
 613        node.locks = [...node.locks, lock];
 614        return {
 615          ...state,
 616          requests: state.requests.filter((r) => r !== request),
 617          tree: newTree
 618        };
 619      }
 620      case "RELEASE_LOCK": {
 621        const { lock } = action;
 622        const storePath = [lock.store, ...lock.path];
 623        const newTree = deepCopyLocksTreePath(state.tree, storePath);
 624        const node = getNode(newTree, storePath);
 625        node.locks = node.locks.filter((l) => l !== lock);
 626        return {
 627          ...state,
 628          tree: newTree
 629        };
 630      }
 631    }
 632    return state;
 633  }
 634  
 635  
 636  ;// ./node_modules/@wordpress/core-data/build-module/locks/selectors.js
 637  
 638  function getPendingLockRequests(state) {
 639    return state.requests;
 640  }
 641  function isLockAvailable(state, store, path, { exclusive }) {
 642    const storePath = [store, ...path];
 643    const locks = state.tree;
 644    for (const node2 of iteratePath(locks, storePath)) {
 645      if (hasConflictingLock({ exclusive }, node2.locks)) {
 646        return false;
 647      }
 648    }
 649    const node = getNode(locks, storePath);
 650    if (!node) {
 651      return true;
 652    }
 653    for (const descendant of iterateDescendants(node)) {
 654      if (hasConflictingLock({ exclusive }, descendant.locks)) {
 655        return false;
 656      }
 657    }
 658    return true;
 659  }
 660  
 661  
 662  ;// ./node_modules/@wordpress/core-data/build-module/locks/engine.js
 663  
 664  
 665  function createLocks() {
 666    let state = locks(void 0, { type: "@@INIT" });
 667    function processPendingLockRequests() {
 668      for (const request of getPendingLockRequests(state)) {
 669        const { store, path, exclusive, notifyAcquired } = request;
 670        if (isLockAvailable(state, store, path, { exclusive })) {
 671          const lock = { store, path, exclusive };
 672          state = locks(state, {
 673            type: "GRANT_LOCK_REQUEST",
 674            lock,
 675            request
 676          });
 677          notifyAcquired(lock);
 678        }
 679      }
 680    }
 681    function acquire(store, path, exclusive) {
 682      return new Promise((resolve) => {
 683        state = locks(state, {
 684          type: "ENQUEUE_LOCK_REQUEST",
 685          request: { store, path, exclusive, notifyAcquired: resolve }
 686        });
 687        processPendingLockRequests();
 688      });
 689    }
 690    function release(lock) {
 691      state = locks(state, {
 692        type: "RELEASE_LOCK",
 693        lock
 694      });
 695      processPendingLockRequests();
 696    }
 697    return { acquire, release };
 698  }
 699  
 700  
 701  ;// ./node_modules/@wordpress/core-data/build-module/locks/actions.js
 702  
 703  function createLocksActions() {
 704    const locks = createLocks();
 705    function __unstableAcquireStoreLock(store, path, { exclusive }) {
 706      return () => locks.acquire(store, path, exclusive);
 707    }
 708    function __unstableReleaseStoreLock(lock) {
 709      return () => locks.release(lock);
 710    }
 711    return { __unstableAcquireStoreLock, __unstableReleaseStoreLock };
 712  }
 713  
 714  
 715  
 716  /***/ }),
 717  
 718  /***/ 2278:
 719  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 720  
 721  "use strict";
 722  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 723  /* harmony export */   E: () => (/* binding */ STORE_NAME)
 724  /* harmony export */ });
 725  const STORE_NAME = "core";
 726  
 727  
 728  
 729  /***/ }),
 730  
 731  /***/ 2577:
 732  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 733  
 734  "use strict";
 735  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 736  /* harmony export */   CO: () => (/* binding */ ALLOWED_RESOURCE_ACTIONS),
 737  /* harmony export */   kC: () => (/* binding */ getUserPermissionCacheKey),
 738  /* harmony export */   qY: () => (/* binding */ getUserPermissionsFromAllowHeader)
 739  /* harmony export */ });
 740  const ALLOWED_RESOURCE_ACTIONS = [
 741    "create",
 742    "read",
 743    "update",
 744    "delete"
 745  ];
 746  function getUserPermissionsFromAllowHeader(allowedMethods) {
 747    const permissions = {};
 748    if (!allowedMethods) {
 749      return permissions;
 750    }
 751    const methods = {
 752      create: "POST",
 753      read: "GET",
 754      update: "PUT",
 755      delete: "DELETE"
 756    };
 757    for (const [actionName, methodName] of Object.entries(methods)) {
 758      permissions[actionName] = allowedMethods.includes(methodName);
 759    }
 760    return permissions;
 761  }
 762  function getUserPermissionCacheKey(action, resource, id) {
 763    const key = (typeof resource === "object" ? [action, resource.kind, resource.name, resource.id] : [action, resource, id]).filter(Boolean).join("/");
 764    return key;
 765  }
 766  
 767  
 768  
 769  /***/ }),
 770  
 771  /***/ 2859:
 772  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 773  
 774  "use strict";
 775  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 776  /* harmony export */   n: () => (/* binding */ Status)
 777  /* harmony export */ });
 778  var Status = /* @__PURE__ */ ((Status2) => {
 779    Status2["Idle"] = "IDLE";
 780    Status2["Resolving"] = "RESOLVING";
 781    Status2["Error"] = "ERROR";
 782    Status2["Success"] = "SUCCESS";
 783    return Status2;
 784  })(Status || {});
 785  
 786  
 787  
 788  /***/ }),
 789  
 790  /***/ 3249:
 791  /***/ ((module) => {
 792  
 793  "use strict";
 794  
 795  
 796  function _typeof(obj) {
 797    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
 798      _typeof = function (obj) {
 799        return typeof obj;
 800      };
 801    } else {
 802      _typeof = function (obj) {
 803        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
 804      };
 805    }
 806  
 807    return _typeof(obj);
 808  }
 809  
 810  function _classCallCheck(instance, Constructor) {
 811    if (!(instance instanceof Constructor)) {
 812      throw new TypeError("Cannot call a class as a function");
 813    }
 814  }
 815  
 816  function _defineProperties(target, props) {
 817    for (var i = 0; i < props.length; i++) {
 818      var descriptor = props[i];
 819      descriptor.enumerable = descriptor.enumerable || false;
 820      descriptor.configurable = true;
 821      if ("value" in descriptor) descriptor.writable = true;
 822      Object.defineProperty(target, descriptor.key, descriptor);
 823    }
 824  }
 825  
 826  function _createClass(Constructor, protoProps, staticProps) {
 827    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
 828    if (staticProps) _defineProperties(Constructor, staticProps);
 829    return Constructor;
 830  }
 831  
 832  /**
 833   * Given an instance of EquivalentKeyMap, returns its internal value pair tuple
 834   * for a key, if one exists. The tuple members consist of the last reference
 835   * value for the key (used in efficient subsequent lookups) and the value
 836   * assigned for the key at the leaf node.
 837   *
 838   * @param {EquivalentKeyMap} instance EquivalentKeyMap instance.
 839   * @param {*} key                     The key for which to return value pair.
 840   *
 841   * @return {?Array} Value pair, if exists.
 842   */
 843  function getValuePair(instance, key) {
 844    var _map = instance._map,
 845        _arrayTreeMap = instance._arrayTreeMap,
 846        _objectTreeMap = instance._objectTreeMap; // Map keeps a reference to the last object-like key used to set the
 847    // value, which can be used to shortcut immediately to the value.
 848  
 849    if (_map.has(key)) {
 850      return _map.get(key);
 851    } // Sort keys to ensure stable retrieval from tree.
 852  
 853  
 854    var properties = Object.keys(key).sort(); // Tree by type to avoid conflicts on numeric object keys, empty value.
 855  
 856    var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap;
 857  
 858    for (var i = 0; i < properties.length; i++) {
 859      var property = properties[i];
 860      map = map.get(property);
 861  
 862      if (map === undefined) {
 863        return;
 864      }
 865  
 866      var propertyValue = key[property];
 867      map = map.get(propertyValue);
 868  
 869      if (map === undefined) {
 870        return;
 871      }
 872    }
 873  
 874    var valuePair = map.get('_ekm_value');
 875  
 876    if (!valuePair) {
 877      return;
 878    } // If reached, it implies that an object-like key was set with another
 879    // reference, so delete the reference and replace with the current.
 880  
 881  
 882    _map.delete(valuePair[0]);
 883  
 884    valuePair[0] = key;
 885    map.set('_ekm_value', valuePair);
 886  
 887    _map.set(key, valuePair);
 888  
 889    return valuePair;
 890  }
 891  /**
 892   * Variant of a Map object which enables lookup by equivalent (deeply equal)
 893   * object and array keys.
 894   */
 895  
 896  
 897  var EquivalentKeyMap =
 898  /*#__PURE__*/
 899  function () {
 900    /**
 901     * Constructs a new instance of EquivalentKeyMap.
 902     *
 903     * @param {Iterable.<*>} iterable Initial pair of key, value for map.
 904     */
 905    function EquivalentKeyMap(iterable) {
 906      _classCallCheck(this, EquivalentKeyMap);
 907  
 908      this.clear();
 909  
 910      if (iterable instanceof EquivalentKeyMap) {
 911        // Map#forEach is only means of iterating with support for IE11.
 912        var iterablePairs = [];
 913        iterable.forEach(function (value, key) {
 914          iterablePairs.push([key, value]);
 915        });
 916        iterable = iterablePairs;
 917      }
 918  
 919      if (iterable != null) {
 920        for (var i = 0; i < iterable.length; i++) {
 921          this.set(iterable[i][0], iterable[i][1]);
 922        }
 923      }
 924    }
 925    /**
 926     * Accessor property returning the number of elements.
 927     *
 928     * @return {number} Number of elements.
 929     */
 930  
 931  
 932    _createClass(EquivalentKeyMap, [{
 933      key: "set",
 934  
 935      /**
 936       * Add or update an element with a specified key and value.
 937       *
 938       * @param {*} key   The key of the element to add.
 939       * @param {*} value The value of the element to add.
 940       *
 941       * @return {EquivalentKeyMap} Map instance.
 942       */
 943      value: function set(key, value) {
 944        // Shortcut non-object-like to set on internal Map.
 945        if (key === null || _typeof(key) !== 'object') {
 946          this._map.set(key, value);
 947  
 948          return this;
 949        } // Sort keys to ensure stable assignment into tree.
 950  
 951  
 952        var properties = Object.keys(key).sort();
 953        var valuePair = [key, value]; // Tree by type to avoid conflicts on numeric object keys, empty value.
 954  
 955        var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap;
 956  
 957        for (var i = 0; i < properties.length; i++) {
 958          var property = properties[i];
 959  
 960          if (!map.has(property)) {
 961            map.set(property, new EquivalentKeyMap());
 962          }
 963  
 964          map = map.get(property);
 965          var propertyValue = key[property];
 966  
 967          if (!map.has(propertyValue)) {
 968            map.set(propertyValue, new EquivalentKeyMap());
 969          }
 970  
 971          map = map.get(propertyValue);
 972        } // If an _ekm_value exists, there was already an equivalent key. Before
 973        // overriding, ensure that the old key reference is removed from map to
 974        // avoid memory leak of accumulating equivalent keys. This is, in a
 975        // sense, a poor man's WeakMap, while still enabling iterability.
 976  
 977  
 978        var previousValuePair = map.get('_ekm_value');
 979  
 980        if (previousValuePair) {
 981          this._map.delete(previousValuePair[0]);
 982        }
 983  
 984        map.set('_ekm_value', valuePair);
 985  
 986        this._map.set(key, valuePair);
 987  
 988        return this;
 989      }
 990      /**
 991       * Returns a specified element.
 992       *
 993       * @param {*} key The key of the element to return.
 994       *
 995       * @return {?*} The element associated with the specified key or undefined
 996       *              if the key can't be found.
 997       */
 998  
 999    }, {
1000      key: "get",
1001      value: function get(key) {
1002        // Shortcut non-object-like to get from internal Map.
1003        if (key === null || _typeof(key) !== 'object') {
1004          return this._map.get(key);
1005        }
1006  
1007        var valuePair = getValuePair(this, key);
1008  
1009        if (valuePair) {
1010          return valuePair[1];
1011        }
1012      }
1013      /**
1014       * Returns a boolean indicating whether an element with the specified key
1015       * exists or not.
1016       *
1017       * @param {*} key The key of the element to test for presence.
1018       *
1019       * @return {boolean} Whether an element with the specified key exists.
1020       */
1021  
1022    }, {
1023      key: "has",
1024      value: function has(key) {
1025        if (key === null || _typeof(key) !== 'object') {
1026          return this._map.has(key);
1027        } // Test on the _presence_ of the pair, not its value, as even undefined
1028        // can be a valid member value for a key.
1029  
1030  
1031        return getValuePair(this, key) !== undefined;
1032      }
1033      /**
1034       * Removes the specified element.
1035       *
1036       * @param {*} key The key of the element to remove.
1037       *
1038       * @return {boolean} Returns true if an element existed and has been
1039       *                   removed, or false if the element does not exist.
1040       */
1041  
1042    }, {
1043      key: "delete",
1044      value: function _delete(key) {
1045        if (!this.has(key)) {
1046          return false;
1047        } // This naive implementation will leave orphaned child trees. A better
1048        // implementation should traverse and remove orphans.
1049  
1050  
1051        this.set(key, undefined);
1052        return true;
1053      }
1054      /**
1055       * Executes a provided function once per each key/value pair, in insertion
1056       * order.
1057       *
1058       * @param {Function} callback Function to execute for each element.
1059       * @param {*}        thisArg  Value to use as `this` when executing
1060       *                            `callback`.
1061       */
1062  
1063    }, {
1064      key: "forEach",
1065      value: function forEach(callback) {
1066        var _this = this;
1067  
1068        var thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;
1069  
1070        this._map.forEach(function (value, key) {
1071          // Unwrap value from object-like value pair.
1072          if (key !== null && _typeof(key) === 'object') {
1073            value = value[1];
1074          }
1075  
1076          callback.call(thisArg, value, key, _this);
1077        });
1078      }
1079      /**
1080       * Removes all elements.
1081       */
1082  
1083    }, {
1084      key: "clear",
1085      value: function clear() {
1086        this._map = new Map();
1087        this._arrayTreeMap = new Map();
1088        this._objectTreeMap = new Map();
1089      }
1090    }, {
1091      key: "size",
1092      get: function get() {
1093        return this._map.size;
1094      }
1095    }]);
1096  
1097    return EquivalentKeyMap;
1098  }();
1099  
1100  module.exports = EquivalentKeyMap;
1101  
1102  
1103  /***/ }),
1104  
1105  /***/ 3377:
1106  /***/ (() => {
1107  
1108  
1109  
1110  /***/ }),
1111  
1112  /***/ 3440:
1113  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
1114  
1115  "use strict";
1116  // ESM COMPAT FLAG
1117  __webpack_require__.r(__webpack_exports__);
1118  
1119  // EXPORTS
1120  __webpack_require__.d(__webpack_exports__, {
1121    __experimentalBatch: () => (/* binding */ __experimentalBatch),
1122    __experimentalReceiveCurrentGlobalStylesId: () => (/* binding */ __experimentalReceiveCurrentGlobalStylesId),
1123    __experimentalReceiveThemeBaseGlobalStyles: () => (/* binding */ __experimentalReceiveThemeBaseGlobalStyles),
1124    __experimentalReceiveThemeGlobalStyleVariations: () => (/* binding */ __experimentalReceiveThemeGlobalStyleVariations),
1125    __experimentalSaveSpecifiedEntityEdits: () => (/* binding */ __experimentalSaveSpecifiedEntityEdits),
1126    __unstableCreateUndoLevel: () => (/* binding */ __unstableCreateUndoLevel),
1127    addEntities: () => (/* binding */ addEntities),
1128    deleteEntityRecord: () => (/* binding */ deleteEntityRecord),
1129    editEntityRecord: () => (/* binding */ editEntityRecord),
1130    receiveAutosaves: () => (/* binding */ receiveAutosaves),
1131    receiveCurrentTheme: () => (/* binding */ receiveCurrentTheme),
1132    receiveCurrentUser: () => (/* binding */ receiveCurrentUser),
1133    receiveDefaultTemplateId: () => (/* binding */ receiveDefaultTemplateId),
1134    receiveEmbedPreview: () => (/* binding */ receiveEmbedPreview),
1135    receiveEntityRecords: () => (/* binding */ receiveEntityRecords),
1136    receiveNavigationFallbackId: () => (/* binding */ receiveNavigationFallbackId),
1137    receiveRevisions: () => (/* binding */ receiveRevisions),
1138    receiveThemeGlobalStyleRevisions: () => (/* binding */ receiveThemeGlobalStyleRevisions),
1139    receiveThemeSupports: () => (/* binding */ receiveThemeSupports),
1140    receiveUploadPermissions: () => (/* binding */ receiveUploadPermissions),
1141    receiveUserPermission: () => (/* binding */ receiveUserPermission),
1142    receiveUserPermissions: () => (/* binding */ receiveUserPermissions),
1143    receiveUserQuery: () => (/* binding */ receiveUserQuery),
1144    redo: () => (/* binding */ redo),
1145    saveEditedEntityRecord: () => (/* binding */ saveEditedEntityRecord),
1146    saveEntityRecord: () => (/* binding */ saveEntityRecord),
1147    undo: () => (/* binding */ undo)
1148  });
1149  
1150  // EXTERNAL MODULE: ./node_modules/fast-deep-equal/es6/index.js
1151  var es6 = __webpack_require__(7734);
1152  var es6_default = /*#__PURE__*/__webpack_require__.n(es6);
1153  ;// ./node_modules/@wordpress/core-data/node_modules/uuid/dist/esm-browser/native.js
1154  const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
1155  /* harmony default export */ const esm_browser_native = ({
1156    randomUUID
1157  });
1158  ;// ./node_modules/@wordpress/core-data/node_modules/uuid/dist/esm-browser/rng.js
1159  // Unique ID creation requires a high quality random # generator. In the browser we therefore
1160  // require the crypto API and do not support built-in fallback to lower quality random number
1161  // generators (like Math.random()).
1162  let getRandomValues;
1163  const rnds8 = new Uint8Array(16);
1164  function rng() {
1165    // lazy load so that environments that need to polyfill have a chance to do so
1166    if (!getRandomValues) {
1167      // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
1168      getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
1169  
1170      if (!getRandomValues) {
1171        throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
1172      }
1173    }
1174  
1175    return getRandomValues(rnds8);
1176  }
1177  ;// ./node_modules/@wordpress/core-data/node_modules/uuid/dist/esm-browser/stringify.js
1178  
1179  /**
1180   * Convert array of 16 byte values to UUID string format of the form:
1181   * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
1182   */
1183  
1184  const byteToHex = [];
1185  
1186  for (let i = 0; i < 256; ++i) {
1187    byteToHex.push((i + 0x100).toString(16).slice(1));
1188  }
1189  
1190  function unsafeStringify(arr, offset = 0) {
1191    // Note: Be careful editing this code!  It's been tuned for performance
1192    // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
1193    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]];
1194  }
1195  
1196  function stringify(arr, offset = 0) {
1197    const uuid = unsafeStringify(arr, offset); // Consistency check for valid UUID.  If this throws, it's likely due to one
1198    // of the following:
1199    // - One or more input array values don't map to a hex octet (leading to
1200    // "undefined" in the uuid)
1201    // - Invalid input values for the RFC `version` or `variant` fields
1202  
1203    if (!validate(uuid)) {
1204      throw TypeError('Stringified UUID is invalid');
1205    }
1206  
1207    return uuid;
1208  }
1209  
1210  /* harmony default export */ const esm_browser_stringify = ((/* unused pure expression or super */ null && (stringify)));
1211  ;// ./node_modules/@wordpress/core-data/node_modules/uuid/dist/esm-browser/v4.js
1212  
1213  
1214  
1215  
1216  function v4(options, buf, offset) {
1217    if (esm_browser_native.randomUUID && !buf && !options) {
1218      return esm_browser_native.randomUUID();
1219    }
1220  
1221    options = options || {};
1222    const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
1223  
1224    rnds[6] = rnds[6] & 0x0f | 0x40;
1225    rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
1226  
1227    if (buf) {
1228      offset = offset || 0;
1229  
1230      for (let i = 0; i < 16; ++i) {
1231        buf[offset + i] = rnds[i];
1232      }
1233  
1234      return buf;
1235    }
1236  
1237    return unsafeStringify(rnds);
1238  }
1239  
1240  /* harmony default export */ const esm_browser_v4 = (v4);
1241  // EXTERNAL MODULE: external ["wp","apiFetch"]
1242  var external_wp_apiFetch_ = __webpack_require__(1455);
1243  var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_);
1244  // EXTERNAL MODULE: external ["wp","url"]
1245  var external_wp_url_ = __webpack_require__(3832);
1246  // EXTERNAL MODULE: external ["wp","deprecated"]
1247  var external_wp_deprecated_ = __webpack_require__(4040);
1248  var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_);
1249  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/utils/set-nested-value.js
1250  var set_nested_value = __webpack_require__(5003);
1251  ;// ./node_modules/@wordpress/core-data/build-module/utils/get-nested-value.js
1252  function getNestedValue(object, path, defaultValue) {
1253    if (!object || typeof object !== "object" || typeof path !== "string" && !Array.isArray(path)) {
1254      return object;
1255    }
1256    const normalizedPath = Array.isArray(path) ? path : path.split(".");
1257    let value = object;
1258    normalizedPath.forEach((fieldName) => {
1259      value = value?.[fieldName];
1260    });
1261    return value !== void 0 ? value : defaultValue;
1262  }
1263  
1264  
1265  ;// ./node_modules/@wordpress/core-data/build-module/queried-data/actions.js
1266  function receiveItems(items, edits, meta) {
1267    return {
1268      type: "RECEIVE_ITEMS",
1269      items: Array.isArray(items) ? items : [items],
1270      persistedEdits: edits,
1271      meta
1272    };
1273  }
1274  function removeItems(kind, name, records, invalidateCache = false) {
1275    return {
1276      type: "REMOVE_ITEMS",
1277      itemIds: Array.isArray(records) ? records : [records],
1278      kind,
1279      name,
1280      invalidateCache
1281    };
1282  }
1283  function receiveQueriedItems(items, query = {}, edits, meta) {
1284    return {
1285      ...receiveItems(items, edits, meta),
1286      query
1287    };
1288  }
1289  
1290  
1291  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/entities.js + 2 modules
1292  var entities = __webpack_require__(5914);
1293  ;// ./node_modules/@wordpress/core-data/build-module/batch/default-processor.js
1294  
1295  let maxItems = null;
1296  function chunk(arr, chunkSize) {
1297    const tmp = [...arr];
1298    const cache = [];
1299    while (tmp.length) {
1300      cache.push(tmp.splice(0, chunkSize));
1301    }
1302    return cache;
1303  }
1304  async function defaultProcessor(requests) {
1305    if (maxItems === null) {
1306      const preflightResponse = await external_wp_apiFetch_default()({
1307        path: "/batch/v1",
1308        method: "OPTIONS"
1309      });
1310      maxItems = preflightResponse.endpoints[0].args.requests.maxItems;
1311    }
1312    const results = [];
1313    for (const batchRequests of chunk(requests, maxItems)) {
1314      const batchResponse = await external_wp_apiFetch_default()({
1315        path: "/batch/v1",
1316        method: "POST",
1317        data: {
1318          validation: "require-all-validate",
1319          requests: batchRequests.map((request) => ({
1320            path: request.path,
1321            body: request.data,
1322            // Rename 'data' to 'body'.
1323            method: request.method,
1324            headers: request.headers
1325          }))
1326        }
1327      });
1328      let batchResults;
1329      if (batchResponse.failed) {
1330        batchResults = batchResponse.responses.map((response) => ({
1331          error: response?.body
1332        }));
1333      } else {
1334        batchResults = batchResponse.responses.map((response) => {
1335          const result = {};
1336          if (response.status >= 200 && response.status < 300) {
1337            result.output = response.body;
1338          } else {
1339            result.error = response.body;
1340          }
1341          return result;
1342        });
1343      }
1344      results.push(...batchResults);
1345    }
1346    return results;
1347  }
1348  
1349  
1350  ;// ./node_modules/@wordpress/core-data/build-module/batch/create-batch.js
1351  
1352  function createBatch(processor = defaultProcessor) {
1353    let lastId = 0;
1354    let queue = [];
1355    const pending = new ObservableSet();
1356    return {
1357      /**
1358       * Adds an input to the batch and returns a promise that is resolved or
1359       * rejected when the input is processed by `batch.run()`.
1360       *
1361       * You may also pass a thunk which allows inputs to be added
1362       * asynchronously.
1363       *
1364       * ```
1365       * // Both are allowed:
1366       * batch.add( { path: '/v1/books', ... } );
1367       * batch.add( ( add ) => add( { path: '/v1/books', ... } ) );
1368       * ```
1369       *
1370       * If a thunk is passed, `batch.run()` will pause until either:
1371       *
1372       * - The thunk calls its `add` argument, or;
1373       * - The thunk returns a promise and that promise resolves, or;
1374       * - The thunk returns a non-promise.
1375       *
1376       * @param {any|Function} inputOrThunk Input to add or thunk to execute.
1377       *
1378       * @return {Promise|any} If given an input, returns a promise that
1379       *                       is resolved or rejected when the batch is
1380       *                       processed. If given a thunk, returns the return
1381       *                       value of that thunk.
1382       */
1383      add(inputOrThunk) {
1384        const id = ++lastId;
1385        pending.add(id);
1386        const add = (input) => new Promise((resolve, reject) => {
1387          queue.push({
1388            input,
1389            resolve,
1390            reject
1391          });
1392          pending.delete(id);
1393        });
1394        if (typeof inputOrThunk === "function") {
1395          return Promise.resolve(inputOrThunk(add)).finally(() => {
1396            pending.delete(id);
1397          });
1398        }
1399        return add(inputOrThunk);
1400      },
1401      /**
1402       * Runs the batch. This calls `batchProcessor` and resolves or rejects
1403       * all promises returned by `add()`.
1404       *
1405       * @return {Promise<boolean>} A promise that resolves to a boolean that is true
1406       *                   if the processor returned no errors.
1407       */
1408      async run() {
1409        if (pending.size) {
1410          await new Promise((resolve) => {
1411            const unsubscribe = pending.subscribe(() => {
1412              if (!pending.size) {
1413                unsubscribe();
1414                resolve(void 0);
1415              }
1416            });
1417          });
1418        }
1419        let results;
1420        try {
1421          results = await processor(
1422            queue.map(({ input }) => input)
1423          );
1424          if (results.length !== queue.length) {
1425            throw new Error(
1426              "run: Array returned by processor must be same size as input array."
1427            );
1428          }
1429        } catch (error) {
1430          for (const { reject } of queue) {
1431            reject(error);
1432          }
1433          throw error;
1434        }
1435        let isSuccess = true;
1436        results.forEach((result, key) => {
1437          const queueItem = queue[key];
1438          if (result?.error) {
1439            queueItem?.reject(result.error);
1440            isSuccess = false;
1441          } else {
1442            queueItem?.resolve(result?.output ?? result);
1443          }
1444        });
1445        queue = [];
1446        return isSuccess;
1447      }
1448    };
1449  }
1450  class ObservableSet {
1451    constructor(...args) {
1452      this.set = new Set(...args);
1453      this.subscribers = /* @__PURE__ */ new Set();
1454    }
1455    get size() {
1456      return this.set.size;
1457    }
1458    add(value) {
1459      this.set.add(value);
1460      this.subscribers.forEach((subscriber) => subscriber());
1461      return this;
1462    }
1463    delete(value) {
1464      const isSuccess = this.set.delete(value);
1465      this.subscribers.forEach((subscriber) => subscriber());
1466      return isSuccess;
1467    }
1468    subscribe(subscriber) {
1469      this.subscribers.add(subscriber);
1470      return () => {
1471        this.subscribers.delete(subscriber);
1472      };
1473    }
1474  }
1475  
1476  
1477  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/name.js
1478  var build_module_name = __webpack_require__(2278);
1479  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/utils/log-entity-deprecation.js
1480  var log_entity_deprecation = __webpack_require__(9410);
1481  ;// ./node_modules/@wordpress/core-data/build-module/actions.js
1482  
1483  
1484  
1485  
1486  
1487  
1488  
1489  
1490  
1491  
1492  
1493  
1494  function receiveUserQuery(queryID, users) {
1495    return {
1496      type: "RECEIVE_USER_QUERY",
1497      users: Array.isArray(users) ? users : [users],
1498      queryID
1499    };
1500  }
1501  function receiveCurrentUser(currentUser) {
1502    return {
1503      type: "RECEIVE_CURRENT_USER",
1504      currentUser
1505    };
1506  }
1507  function addEntities(entities) {
1508    return {
1509      type: "ADD_ENTITIES",
1510      entities
1511    };
1512  }
1513  function receiveEntityRecords(kind, name, records, query, invalidateCache = false, edits, meta) {
1514    if (kind === "postType") {
1515      records = (Array.isArray(records) ? records : [records]).map(
1516        (record) => record.status === "auto-draft" ? { ...record, title: "" } : record
1517      );
1518    }
1519    let action;
1520    if (query) {
1521      action = receiveQueriedItems(records, query, edits, meta);
1522    } else {
1523      action = receiveItems(records, edits, meta);
1524    }
1525    return {
1526      ...action,
1527      kind,
1528      name,
1529      invalidateCache
1530    };
1531  }
1532  function receiveCurrentTheme(currentTheme) {
1533    return {
1534      type: "RECEIVE_CURRENT_THEME",
1535      currentTheme
1536    };
1537  }
1538  function __experimentalReceiveCurrentGlobalStylesId(currentGlobalStylesId) {
1539    return {
1540      type: "RECEIVE_CURRENT_GLOBAL_STYLES_ID",
1541      id: currentGlobalStylesId
1542    };
1543  }
1544  function __experimentalReceiveThemeBaseGlobalStyles(stylesheet, globalStyles) {
1545    return {
1546      type: "RECEIVE_THEME_GLOBAL_STYLES",
1547      stylesheet,
1548      globalStyles
1549    };
1550  }
1551  function __experimentalReceiveThemeGlobalStyleVariations(stylesheet, variations) {
1552    return {
1553      type: "RECEIVE_THEME_GLOBAL_STYLE_VARIATIONS",
1554      stylesheet,
1555      variations
1556    };
1557  }
1558  function receiveThemeSupports() {
1559    external_wp_deprecated_default()("wp.data.dispatch( 'core' ).receiveThemeSupports", {
1560      since: "5.9"
1561    });
1562    return {
1563      type: "DO_NOTHING"
1564    };
1565  }
1566  function receiveThemeGlobalStyleRevisions(currentId, revisions) {
1567    external_wp_deprecated_default()(
1568      "wp.data.dispatch( 'core' ).receiveThemeGlobalStyleRevisions()",
1569      {
1570        since: "6.5.0",
1571        alternative: "wp.data.dispatch( 'core' ).receiveRevisions"
1572      }
1573    );
1574    return {
1575      type: "RECEIVE_THEME_GLOBAL_STYLE_REVISIONS",
1576      currentId,
1577      revisions
1578    };
1579  }
1580  function receiveEmbedPreview(url, preview) {
1581    return {
1582      type: "RECEIVE_EMBED_PREVIEW",
1583      url,
1584      preview
1585    };
1586  }
1587  const deleteEntityRecord = (kind, name, recordId, query, { __unstableFetch = (external_wp_apiFetch_default()), throwOnError = false } = {}) => async ({ dispatch, resolveSelect }) => {
1588    (0,log_entity_deprecation/* default */.A)(kind, name, "deleteEntityRecord");
1589    const configs = await resolveSelect.getEntitiesConfig(kind);
1590    const entityConfig = configs.find(
1591      (config) => config.kind === kind && config.name === name
1592    );
1593    let error;
1594    let deletedRecord = false;
1595    if (!entityConfig) {
1596      return;
1597    }
1598    const lock = await dispatch.__unstableAcquireStoreLock(
1599      build_module_name/* STORE_NAME */.E,
1600      ["entities", "records", kind, name, recordId],
1601      { exclusive: true }
1602    );
1603    try {
1604      dispatch({
1605        type: "DELETE_ENTITY_RECORD_START",
1606        kind,
1607        name,
1608        recordId
1609      });
1610      let hasError = false;
1611      let { baseURL } = entityConfig;
1612      if (kind === "postType" && name === "wp_template" && recordId && typeof recordId === "string" && !/^\d+$/.test(recordId)) {
1613        baseURL = baseURL.slice(0, baseURL.lastIndexOf("/")) + "/templates";
1614      }
1615      try {
1616        let path = `$baseURL}/$recordId}`;
1617        if (query) {
1618          path = (0,external_wp_url_.addQueryArgs)(path, query);
1619        }
1620        deletedRecord = await __unstableFetch({
1621          path,
1622          method: "DELETE"
1623        });
1624        await dispatch(removeItems(kind, name, recordId, true));
1625      } catch (_error) {
1626        hasError = true;
1627        error = _error;
1628      }
1629      dispatch({
1630        type: "DELETE_ENTITY_RECORD_FINISH",
1631        kind,
1632        name,
1633        recordId,
1634        error
1635      });
1636      if (hasError && throwOnError) {
1637        throw error;
1638      }
1639      return deletedRecord;
1640    } finally {
1641      dispatch.__unstableReleaseStoreLock(lock);
1642    }
1643  };
1644  const editEntityRecord = (kind, name, recordId, edits, options = {}) => ({ select, dispatch }) => {
1645    (0,log_entity_deprecation/* default */.A)(kind, name, "editEntityRecord");
1646    const entityConfig = select.getEntityConfig(kind, name);
1647    if (!entityConfig) {
1648      throw new Error(
1649        `The entity being edited ($kind}, $name}) does not have a loaded config.`
1650      );
1651    }
1652    const { mergedEdits = {} } = entityConfig;
1653    const record = select.getRawEntityRecord(kind, name, recordId);
1654    const editedRecord = select.getEditedEntityRecord(
1655      kind,
1656      name,
1657      recordId
1658    );
1659    const edit = {
1660      kind,
1661      name,
1662      recordId,
1663      // Clear edits when they are equal to their persisted counterparts
1664      // so that the property is not considered dirty.
1665      edits: Object.keys(edits).reduce((acc, key) => {
1666        const recordValue = record[key];
1667        const editedRecordValue = editedRecord[key];
1668        const value = mergedEdits[key] ? { ...editedRecordValue, ...edits[key] } : edits[key];
1669        acc[key] = es6_default()(recordValue, value) ? void 0 : value;
1670        return acc;
1671      }, {})
1672    };
1673    if (window.__experimentalEnableSync && entityConfig.syncConfig) {
1674      if (false) {}
1675    }
1676    if (!options.undoIgnore) {
1677      select.getUndoManager().addRecord(
1678        [
1679          {
1680            id: { kind, name, recordId },
1681            changes: Object.keys(edits).reduce((acc, key) => {
1682              acc[key] = {
1683                from: editedRecord[key],
1684                to: edits[key]
1685              };
1686              return acc;
1687            }, {})
1688          }
1689        ],
1690        options.isCached
1691      );
1692    }
1693    dispatch({
1694      type: "EDIT_ENTITY_RECORD",
1695      ...edit
1696    });
1697  };
1698  const undo = () => ({ select, dispatch }) => {
1699    const undoRecord = select.getUndoManager().undo();
1700    if (!undoRecord) {
1701      return;
1702    }
1703    dispatch({
1704      type: "UNDO",
1705      record: undoRecord
1706    });
1707  };
1708  const redo = () => ({ select, dispatch }) => {
1709    const redoRecord = select.getUndoManager().redo();
1710    if (!redoRecord) {
1711      return;
1712    }
1713    dispatch({
1714      type: "REDO",
1715      record: redoRecord
1716    });
1717  };
1718  const __unstableCreateUndoLevel = () => ({ select }) => {
1719    select.getUndoManager().addRecord();
1720  };
1721  const saveEntityRecord = (kind, name, record, {
1722    isAutosave = false,
1723    __unstableFetch = (external_wp_apiFetch_default()),
1724    throwOnError = false
1725  } = {}) => async ({ select, resolveSelect, dispatch }) => {
1726    (0,log_entity_deprecation/* default */.A)(kind, name, "saveEntityRecord");
1727    const configs = await resolveSelect.getEntitiesConfig(kind);
1728    const entityConfig = configs.find(
1729      (config) => config.kind === kind && config.name === name
1730    );
1731    if (!entityConfig) {
1732      return;
1733    }
1734    const entityIdKey = entityConfig.key ?? entities/* DEFAULT_ENTITY_KEY */.C_;
1735    const recordId = record[entityIdKey];
1736    const isNewRecord = !!entityIdKey && !recordId;
1737    const lock = await dispatch.__unstableAcquireStoreLock(
1738      build_module_name/* STORE_NAME */.E,
1739      ["entities", "records", kind, name, recordId || esm_browser_v4()],
1740      { exclusive: true }
1741    );
1742    try {
1743      for (const [key, value] of Object.entries(record)) {
1744        if (typeof value === "function") {
1745          const evaluatedValue = value(
1746            select.getEditedEntityRecord(kind, name, recordId)
1747          );
1748          dispatch.editEntityRecord(
1749            kind,
1750            name,
1751            recordId,
1752            {
1753              [key]: evaluatedValue
1754            },
1755            { undoIgnore: true }
1756          );
1757          record[key] = evaluatedValue;
1758        }
1759      }
1760      dispatch({
1761        type: "SAVE_ENTITY_RECORD_START",
1762        kind,
1763        name,
1764        recordId,
1765        isAutosave
1766      });
1767      let updatedRecord;
1768      let error;
1769      let hasError = false;
1770      let { baseURL } = entityConfig;
1771      if (kind === "postType" && name === "wp_template" && recordId && typeof recordId === "string" && !/^\d+$/.test(recordId)) {
1772        baseURL = baseURL.slice(0, baseURL.lastIndexOf("/")) + "/templates";
1773      }
1774      try {
1775        const path = `$baseURL}$recordId ? "/" + recordId : ""}`;
1776        const persistedRecord = !isNewRecord ? select.getRawEntityRecord(kind, name, recordId) : {};
1777        if (isAutosave) {
1778          const currentUser = select.getCurrentUser();
1779          const currentUserId = currentUser ? currentUser.id : void 0;
1780          const autosavePost = await resolveSelect.getAutosave(
1781            persistedRecord.type,
1782            persistedRecord.id,
1783            currentUserId
1784          );
1785          let data = {
1786            ...persistedRecord,
1787            ...autosavePost,
1788            ...record
1789          };
1790          data = Object.keys(data).reduce(
1791            (acc, key) => {
1792              if ([
1793                "title",
1794                "excerpt",
1795                "content",
1796                "meta"
1797              ].includes(key)) {
1798                acc[key] = data[key];
1799              }
1800              return acc;
1801            },
1802            {
1803              // Do not update the `status` if we have edited it when auto saving.
1804              // It's very important to let the user explicitly save this change,
1805              // because it can lead to unexpected results. An example would be to
1806              // have a draft post and change the status to publish.
1807              status: data.status === "auto-draft" ? "draft" : void 0
1808            }
1809          );
1810          updatedRecord = await __unstableFetch({
1811            path: `$path}/autosaves`,
1812            method: "POST",
1813            data
1814          });
1815          if (persistedRecord.id === updatedRecord.id) {
1816            let newRecord = {
1817              ...persistedRecord,
1818              ...data,
1819              ...updatedRecord
1820            };
1821            newRecord = Object.keys(newRecord).reduce(
1822              (acc, key) => {
1823                if (["title", "excerpt", "content"].includes(
1824                  key
1825                )) {
1826                  acc[key] = newRecord[key];
1827                } else if (key === "status") {
1828                  acc[key] = persistedRecord.status === "auto-draft" && newRecord.status === "draft" ? newRecord.status : persistedRecord.status;
1829                } else {
1830                  acc[key] = persistedRecord[key];
1831                }
1832                return acc;
1833              },
1834              {}
1835            );
1836            dispatch.receiveEntityRecords(
1837              kind,
1838              name,
1839              newRecord,
1840              void 0,
1841              true
1842            );
1843          } else {
1844            dispatch.receiveAutosaves(
1845              persistedRecord.id,
1846              updatedRecord
1847            );
1848          }
1849        } else {
1850          let edits = record;
1851          if (entityConfig.__unstablePrePersist) {
1852            edits = {
1853              ...edits,
1854              ...entityConfig.__unstablePrePersist(
1855                persistedRecord,
1856                edits
1857              )
1858            };
1859          }
1860          updatedRecord = await __unstableFetch({
1861            path,
1862            method: recordId ? "PUT" : "POST",
1863            data: edits
1864          });
1865          dispatch.receiveEntityRecords(
1866            kind,
1867            name,
1868            updatedRecord,
1869            void 0,
1870            true,
1871            edits
1872          );
1873        }
1874      } catch (_error) {
1875        hasError = true;
1876        error = _error;
1877      }
1878      dispatch({
1879        type: "SAVE_ENTITY_RECORD_FINISH",
1880        kind,
1881        name,
1882        recordId,
1883        error,
1884        isAutosave
1885      });
1886      if (hasError && throwOnError) {
1887        throw error;
1888      }
1889      return updatedRecord;
1890    } finally {
1891      dispatch.__unstableReleaseStoreLock(lock);
1892    }
1893  };
1894  const __experimentalBatch = (requests) => async ({ dispatch }) => {
1895    const batch = createBatch();
1896    const api = {
1897      saveEntityRecord(kind, name, record, options) {
1898        return batch.add(
1899          (add) => dispatch.saveEntityRecord(kind, name, record, {
1900            ...options,
1901            __unstableFetch: add
1902          })
1903        );
1904      },
1905      saveEditedEntityRecord(kind, name, recordId, options) {
1906        return batch.add(
1907          (add) => dispatch.saveEditedEntityRecord(kind, name, recordId, {
1908            ...options,
1909            __unstableFetch: add
1910          })
1911        );
1912      },
1913      deleteEntityRecord(kind, name, recordId, query, options) {
1914        return batch.add(
1915          (add) => dispatch.deleteEntityRecord(kind, name, recordId, query, {
1916            ...options,
1917            __unstableFetch: add
1918          })
1919        );
1920      }
1921    };
1922    const resultPromises = requests.map((request) => request(api));
1923    const [, ...results] = await Promise.all([
1924      batch.run(),
1925      ...resultPromises
1926    ]);
1927    return results;
1928  };
1929  const saveEditedEntityRecord = (kind, name, recordId, options) => async ({ select, dispatch, resolveSelect }) => {
1930    (0,log_entity_deprecation/* default */.A)(kind, name, "saveEditedEntityRecord");
1931    if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
1932      return;
1933    }
1934    const configs = await resolveSelect.getEntitiesConfig(kind);
1935    const entityConfig = configs.find(
1936      (config) => config.kind === kind && config.name === name
1937    );
1938    if (!entityConfig) {
1939      return;
1940    }
1941    const entityIdKey = entityConfig.key || entities/* DEFAULT_ENTITY_KEY */.C_;
1942    const edits = select.getEntityRecordNonTransientEdits(
1943      kind,
1944      name,
1945      recordId
1946    );
1947    const record = { [entityIdKey]: recordId, ...edits };
1948    return await dispatch.saveEntityRecord(kind, name, record, options);
1949  };
1950  const __experimentalSaveSpecifiedEntityEdits = (kind, name, recordId, itemsToSave, options) => async ({ select, dispatch, resolveSelect }) => {
1951    (0,log_entity_deprecation/* default */.A)(
1952      kind,
1953      name,
1954      "__experimentalSaveSpecifiedEntityEdits"
1955    );
1956    if (!select.hasEditsForEntityRecord(kind, name, recordId)) {
1957      return;
1958    }
1959    const edits = select.getEntityRecordNonTransientEdits(
1960      kind,
1961      name,
1962      recordId
1963    );
1964    const editsToSave = {};
1965    for (const item of itemsToSave) {
1966      (0,set_nested_value/* default */.A)(editsToSave, item, getNestedValue(edits, item));
1967    }
1968    const configs = await resolveSelect.getEntitiesConfig(kind);
1969    const entityConfig = configs.find(
1970      (config) => config.kind === kind && config.name === name
1971    );
1972    const entityIdKey = entityConfig?.key || entities/* DEFAULT_ENTITY_KEY */.C_;
1973    if (recordId) {
1974      editsToSave[entityIdKey] = recordId;
1975    }
1976    return await dispatch.saveEntityRecord(
1977      kind,
1978      name,
1979      editsToSave,
1980      options
1981    );
1982  };
1983  function receiveUploadPermissions(hasUploadPermissions) {
1984    external_wp_deprecated_default()("wp.data.dispatch( 'core' ).receiveUploadPermissions", {
1985      since: "5.9",
1986      alternative: "receiveUserPermission"
1987    });
1988    return receiveUserPermission("create/media", hasUploadPermissions);
1989  }
1990  function receiveUserPermission(key, isAllowed) {
1991    return {
1992      type: "RECEIVE_USER_PERMISSION",
1993      key,
1994      isAllowed
1995    };
1996  }
1997  function receiveUserPermissions(permissions) {
1998    return {
1999      type: "RECEIVE_USER_PERMISSIONS",
2000      permissions
2001    };
2002  }
2003  function receiveAutosaves(postId, autosaves) {
2004    return {
2005      type: "RECEIVE_AUTOSAVES",
2006      postId,
2007      autosaves: Array.isArray(autosaves) ? autosaves : [autosaves]
2008    };
2009  }
2010  function receiveNavigationFallbackId(fallbackId) {
2011    return {
2012      type: "RECEIVE_NAVIGATION_FALLBACK_ID",
2013      fallbackId
2014    };
2015  }
2016  function receiveDefaultTemplateId(query, templateId) {
2017    return {
2018      type: "RECEIVE_DEFAULT_TEMPLATE",
2019      query,
2020      templateId
2021    };
2022  }
2023  const receiveRevisions = (kind, name, recordKey, records, query, invalidateCache = false, meta) => async ({ dispatch, resolveSelect }) => {
2024    (0,log_entity_deprecation/* default */.A)(kind, name, "receiveRevisions");
2025    const configs = await resolveSelect.getEntitiesConfig(kind);
2026    const entityConfig = configs.find(
2027      (config) => config.kind === kind && config.name === name
2028    );
2029    const key = entityConfig && entityConfig?.revisionKey ? entityConfig.revisionKey : entities/* DEFAULT_ENTITY_KEY */.C_;
2030    dispatch({
2031      type: "RECEIVE_ITEM_REVISIONS",
2032      key,
2033      items: Array.isArray(records) ? records : [records],
2034      recordKey,
2035      meta,
2036      query,
2037      kind,
2038      name,
2039      invalidateCache
2040    });
2041  };
2042  
2043  
2044  
2045  /***/ }),
2046  
2047  /***/ 3832:
2048  /***/ ((module) => {
2049  
2050  "use strict";
2051  module.exports = window["wp"]["url"];
2052  
2053  /***/ }),
2054  
2055  /***/ 4027:
2056  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
2057  
2058  "use strict";
2059  
2060  // EXPORTS
2061  __webpack_require__.d(__webpack_exports__, {
2062    A: () => (/* binding */ get_query_parts_default)
2063  });
2064  
2065  // UNUSED EXPORTS: getQueryParts
2066  
2067  // EXTERNAL MODULE: external ["wp","url"]
2068  var external_wp_url_ = __webpack_require__(3832);
2069  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/utils/get-normalized-comma-separable.js
2070  var get_normalized_comma_separable = __webpack_require__(533);
2071  ;// ./node_modules/@wordpress/core-data/build-module/utils/with-weak-map-cache.js
2072  function withWeakMapCache(fn) {
2073    const cache = /* @__PURE__ */ new WeakMap();
2074    return (key) => {
2075      let value;
2076      if (cache.has(key)) {
2077        value = cache.get(key);
2078      } else {
2079        value = fn(key);
2080        if (key !== null && typeof key === "object") {
2081          cache.set(key, value);
2082        }
2083      }
2084      return value;
2085    };
2086  }
2087  var with_weak_map_cache_default = withWeakMapCache;
2088  
2089  
2090  ;// ./node_modules/@wordpress/core-data/build-module/queried-data/get-query-parts.js
2091  
2092  
2093  function getQueryParts(query) {
2094    const parts = {
2095      stableKey: "",
2096      page: 1,
2097      perPage: 10,
2098      fields: null,
2099      include: null,
2100      context: "default"
2101    };
2102    const keys = Object.keys(query).sort();
2103    for (let i = 0; i < keys.length; i++) {
2104      const key = keys[i];
2105      let value = query[key];
2106      switch (key) {
2107        case "page":
2108          parts[key] = Number(value);
2109          break;
2110        case "per_page":
2111          parts.perPage = Number(value);
2112          break;
2113        case "context":
2114          parts.context = value;
2115          break;
2116        default:
2117          if (key === "_fields") {
2118            parts.fields = (0,get_normalized_comma_separable/* default */.A)(value) ?? [];
2119            value = parts.fields.join();
2120          }
2121          if (key === "include") {
2122            if (typeof value === "number") {
2123              value = value.toString();
2124            }
2125            parts.include = ((0,get_normalized_comma_separable/* default */.A)(value) ?? []).map(Number);
2126            value = parts.include.join();
2127          }
2128          parts.stableKey += (parts.stableKey ? "&" : "") + (0,external_wp_url_.addQueryArgs)("", { [key]: value }).slice(1);
2129      }
2130    }
2131    return parts;
2132  }
2133  var get_query_parts_default = with_weak_map_cache_default(getQueryParts);
2134  
2135  
2136  
2137  /***/ }),
2138  
2139  /***/ 4040:
2140  /***/ ((module) => {
2141  
2142  "use strict";
2143  module.exports = window["wp"]["deprecated"];
2144  
2145  /***/ }),
2146  
2147  /***/ 4460:
2148  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
2149  
2150  "use strict";
2151  
2152  // EXPORTS
2153  __webpack_require__.d(__webpack_exports__, {
2154    A: () => (/* binding */ EntityProvider)
2155  });
2156  
2157  ;// external "ReactJSXRuntime"
2158  const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"];
2159  // EXTERNAL MODULE: external ["wp","element"]
2160  var external_wp_element_ = __webpack_require__(6087);
2161  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/entity-context.js
2162  var entity_context = __webpack_require__(8843);
2163  ;// ./node_modules/@wordpress/core-data/build-module/entity-provider.js
2164  
2165  
2166  
2167  function EntityProvider({ kind, type: name, id, children }) {
2168    const parent = (0,external_wp_element_.useContext)(entity_context/* EntityContext */.D);
2169    const childContext = (0,external_wp_element_.useMemo)(
2170      () => ({
2171        ...parent,
2172        [kind]: {
2173          ...parent?.[kind],
2174          [name]: id
2175        }
2176      }),
2177      [parent, kind, name, id]
2178    );
2179    return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(entity_context/* EntityContext */.D.Provider, { value: childContext, children });
2180  }
2181  
2182  
2183  
2184  /***/ }),
2185  
2186  /***/ 4565:
2187  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
2188  
2189  "use strict";
2190  __webpack_require__.r(__webpack_exports__);
2191  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
2192  /* harmony export */   EntityProvider: () => (/* reexport safe */ _entity_provider__WEBPACK_IMPORTED_MODULE_17__.A),
2193  /* harmony export */   __experimentalFetchLinkSuggestions: () => (/* reexport safe */ _fetch__WEBPACK_IMPORTED_MODULE_14__.Y3),
2194  /* harmony export */   __experimentalFetchUrlData: () => (/* reexport safe */ _fetch__WEBPACK_IMPORTED_MODULE_14__.gr),
2195  /* harmony export */   __experimentalUseEntityRecord: () => (/* reexport safe */ _hooks__WEBPACK_IMPORTED_MODULE_15__.qh),
2196  /* harmony export */   __experimentalUseEntityRecords: () => (/* reexport safe */ _hooks__WEBPACK_IMPORTED_MODULE_15__.bM),
2197  /* harmony export */   __experimentalUseResourcePermissions: () => (/* reexport safe */ _hooks__WEBPACK_IMPORTED_MODULE_15__._),
2198  /* harmony export */   fetchBlockPatterns: () => (/* reexport safe */ _fetch__WEBPACK_IMPORTED_MODULE_14__.l$),
2199  /* harmony export */   privateApis: () => (/* reexport safe */ _private_apis__WEBPACK_IMPORTED_MODULE_16__.j),
2200  /* harmony export */   store: () => (/* binding */ store),
2201  /* harmony export */   useEntityBlockEditor: () => (/* reexport safe */ _hooks__WEBPACK_IMPORTED_MODULE_15__.hg),
2202  /* harmony export */   useEntityId: () => (/* reexport safe */ _hooks__WEBPACK_IMPORTED_MODULE_15__.mV),
2203  /* harmony export */   useEntityProp: () => (/* reexport safe */ _hooks__WEBPACK_IMPORTED_MODULE_15__.S$),
2204  /* harmony export */   useEntityRecord: () => (/* reexport safe */ _hooks__WEBPACK_IMPORTED_MODULE_15__.MA),
2205  /* harmony export */   useEntityRecords: () => (/* reexport safe */ _hooks__WEBPACK_IMPORTED_MODULE_15__.$u),
2206  /* harmony export */   useResourcePermissions: () => (/* reexport safe */ _hooks__WEBPACK_IMPORTED_MODULE_15__.qs)
2207  /* harmony export */ });
2208  /* harmony import */ var _wordpress_data__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7143);
2209  /* harmony import */ var _wordpress_data__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_data__WEBPACK_IMPORTED_MODULE_0__);
2210  /* harmony import */ var _reducer__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(5469);
2211  /* harmony import */ var _selectors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8368);
2212  /* harmony import */ var _private_selectors__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(8741);
2213  /* harmony import */ var _actions__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(3440);
2214  /* harmony import */ var _private_actions__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(9424);
2215  /* harmony import */ var _resolvers__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6384);
2216  /* harmony import */ var _locks_actions__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(2239);
2217  /* harmony import */ var _entities__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5914);
2218  /* harmony import */ var _name__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(2278);
2219  /* harmony import */ var _lock_unlock__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(6378);
2220  /* harmony import */ var _dynamic_entities__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(8582);
2221  /* harmony import */ var _utils_log_entity_deprecation__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9410);
2222  /* harmony import */ var _entity_provider__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(4460);
2223  /* harmony import */ var _entity_types__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(3377);
2224  /* harmony import */ var _entity_types__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(_entity_types__WEBPACK_IMPORTED_MODULE_13__);
2225  /* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
2226  /* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _entity_types__WEBPACK_IMPORTED_MODULE_13__) if(["default","EntityProvider","store"].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _entity_types__WEBPACK_IMPORTED_MODULE_13__[__WEBPACK_IMPORT_KEY__]
2227  /* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
2228  /* harmony import */ var _fetch__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(7006);
2229  /* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(5891);
2230  /* harmony import */ var _private_apis__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(7826);
2231  
2232  
2233  
2234  
2235  
2236  
2237  
2238  
2239  
2240  
2241  
2242  
2243  
2244  const entitiesConfig = [
2245    ..._entities__WEBPACK_IMPORTED_MODULE_1__/* .rootEntitiesConfig */ .Mr,
2246    ..._entities__WEBPACK_IMPORTED_MODULE_1__/* .additionalEntityConfigLoaders */ .L2.filter((config) => !!config.name)
2247  ];
2248  const entitySelectors = entitiesConfig.reduce((result, entity) => {
2249    const { kind, name, plural } = entity;
2250    const getEntityRecordMethodName = (0,_entities__WEBPACK_IMPORTED_MODULE_1__/* .getMethodName */ .zD)(kind, name);
2251    result[getEntityRecordMethodName] = (state, key, query) => {
2252      (0,_utils_log_entity_deprecation__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(kind, name, getEntityRecordMethodName, {
2253        isShorthandSelector: true,
2254        alternativeFunctionName: "getEntityRecord"
2255      });
2256      return _selectors__WEBPACK_IMPORTED_MODULE_3__.getEntityRecord(state, kind, name, key, query);
2257    };
2258    if (plural) {
2259      const getEntityRecordsMethodName = (0,_entities__WEBPACK_IMPORTED_MODULE_1__/* .getMethodName */ .zD)(kind, plural, "get");
2260      result[getEntityRecordsMethodName] = (state, query) => {
2261        (0,_utils_log_entity_deprecation__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(kind, name, getEntityRecordsMethodName, {
2262          isShorthandSelector: true,
2263          alternativeFunctionName: "getEntityRecords"
2264        });
2265        return _selectors__WEBPACK_IMPORTED_MODULE_3__.getEntityRecords(state, kind, name, query);
2266      };
2267    }
2268    return result;
2269  }, {});
2270  const entityResolvers = entitiesConfig.reduce((result, entity) => {
2271    const { kind, name, plural } = entity;
2272    const getEntityRecordMethodName = (0,_entities__WEBPACK_IMPORTED_MODULE_1__/* .getMethodName */ .zD)(kind, name);
2273    result[getEntityRecordMethodName] = (key, query) => {
2274      (0,_utils_log_entity_deprecation__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(kind, name, getEntityRecordMethodName, {
2275        isShorthandSelector: true,
2276        alternativeFunctionName: "getEntityRecord"
2277      });
2278      return _resolvers__WEBPACK_IMPORTED_MODULE_4__.getEntityRecord(kind, name, key, query);
2279    };
2280    if (plural) {
2281      const getEntityRecordsMethodName = (0,_entities__WEBPACK_IMPORTED_MODULE_1__/* .getMethodName */ .zD)(kind, plural, "get");
2282      result[getEntityRecordsMethodName] = (...args) => {
2283        (0,_utils_log_entity_deprecation__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(kind, plural, getEntityRecordsMethodName, {
2284          isShorthandSelector: true,
2285          alternativeFunctionName: "getEntityRecords"
2286        });
2287        return _resolvers__WEBPACK_IMPORTED_MODULE_4__.getEntityRecords(kind, name, ...args);
2288      };
2289      result[getEntityRecordsMethodName].shouldInvalidate = (action) => _resolvers__WEBPACK_IMPORTED_MODULE_4__.getEntityRecords.shouldInvalidate(action, kind, name);
2290    }
2291    return result;
2292  }, {});
2293  const entityActions = entitiesConfig.reduce((result, entity) => {
2294    const { kind, name } = entity;
2295    const saveEntityRecordMethodName = (0,_entities__WEBPACK_IMPORTED_MODULE_1__/* .getMethodName */ .zD)(kind, name, "save");
2296    result[saveEntityRecordMethodName] = (record, options) => {
2297      (0,_utils_log_entity_deprecation__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(kind, name, saveEntityRecordMethodName, {
2298        isShorthandSelector: true,
2299        alternativeFunctionName: "saveEntityRecord"
2300      });
2301      return _actions__WEBPACK_IMPORTED_MODULE_5__.saveEntityRecord(kind, name, record, options);
2302    };
2303    const deleteEntityRecordMethodName = (0,_entities__WEBPACK_IMPORTED_MODULE_1__/* .getMethodName */ .zD)(kind, name, "delete");
2304    result[deleteEntityRecordMethodName] = (key, query, options) => {
2305      (0,_utils_log_entity_deprecation__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(kind, name, deleteEntityRecordMethodName, {
2306        isShorthandSelector: true,
2307        alternativeFunctionName: "deleteEntityRecord"
2308      });
2309      return _actions__WEBPACK_IMPORTED_MODULE_5__.deleteEntityRecord(kind, name, key, query, options);
2310    };
2311    return result;
2312  }, {});
2313  const storeConfig = () => ({
2314    reducer: _reducer__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Ay,
2315    actions: {
2316      ..._dynamic_entities__WEBPACK_IMPORTED_MODULE_7__/* .dynamicActions */ .B,
2317      ..._actions__WEBPACK_IMPORTED_MODULE_5__,
2318      ...entityActions,
2319      ...(0,_locks_actions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)()
2320    },
2321    selectors: {
2322      ..._dynamic_entities__WEBPACK_IMPORTED_MODULE_7__/* .dynamicSelectors */ .A,
2323      ..._selectors__WEBPACK_IMPORTED_MODULE_3__,
2324      ...entitySelectors
2325    },
2326    resolvers: { ..._resolvers__WEBPACK_IMPORTED_MODULE_4__, ...entityResolvers }
2327  });
2328  const store = (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_0__.createReduxStore)(_name__WEBPACK_IMPORTED_MODULE_9__/* .STORE_NAME */ .E, storeConfig());
2329  (0,_lock_unlock__WEBPACK_IMPORTED_MODULE_10__/* .unlock */ .T)(store).registerPrivateSelectors(_private_selectors__WEBPACK_IMPORTED_MODULE_11__);
2330  (0,_lock_unlock__WEBPACK_IMPORTED_MODULE_10__/* .unlock */ .T)(store).registerPrivateActions(_private_actions__WEBPACK_IMPORTED_MODULE_12__);
2331  (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_0__.register)(store);
2332  
2333  
2334  
2335  
2336  
2337  
2338  
2339  
2340  
2341  /***/ }),
2342  
2343  /***/ 4997:
2344  /***/ ((module) => {
2345  
2346  "use strict";
2347  module.exports = window["wp"]["blocks"];
2348  
2349  /***/ }),
2350  
2351  /***/ 5003:
2352  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
2353  
2354  "use strict";
2355  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
2356  /* harmony export */   A: () => (/* binding */ setNestedValue)
2357  /* harmony export */ });
2358  function setNestedValue(object, path, value) {
2359    if (!object || typeof object !== "object") {
2360      return object;
2361    }
2362    const normalizedPath = Array.isArray(path) ? path : path.split(".");
2363    normalizedPath.reduce((acc, key, idx) => {
2364      if (acc[key] === void 0) {
2365        if (Number.isInteger(normalizedPath[idx + 1])) {
2366          acc[key] = [];
2367        } else {
2368          acc[key] = {};
2369        }
2370      }
2371      if (idx === normalizedPath.length - 1) {
2372        acc[key] = value;
2373      }
2374      return acc[key];
2375    }, object);
2376    return object;
2377  }
2378  
2379  
2380  
2381  /***/ }),
2382  
2383  /***/ 5101:
2384  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
2385  
2386  "use strict";
2387  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
2388  /* harmony export */   Z: () => (/* binding */ RECEIVE_INTERMEDIATE_RESULTS)
2389  /* harmony export */ });
2390  const RECEIVE_INTERMEDIATE_RESULTS = Symbol(
2391    "RECEIVE_INTERMEDIATE_RESULTS"
2392  );
2393  
2394  
2395  
2396  /***/ }),
2397  
2398  /***/ 5469:
2399  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
2400  
2401  "use strict";
2402  
2403  // EXPORTS
2404  __webpack_require__.d(__webpack_exports__, {
2405    Ay: () => (/* binding */ reducer_reducer_default)
2406  });
2407  
2408  // UNUSED EXPORTS: autosaves, blockPatternCategories, blockPatterns, currentGlobalStylesId, currentTheme, currentUser, defaultTemplates, editsReference, embedPreviews, entities, entitiesConfig, navigationFallbackId, registeredPostMeta, themeBaseGlobalStyles, themeGlobalStyleRevisions, themeGlobalStyleVariations, undoManager, userPatternCategories, userPermissions, users
2409  
2410  // EXTERNAL MODULE: ./node_modules/fast-deep-equal/es6/index.js
2411  var es6 = __webpack_require__(7734);
2412  var es6_default = /*#__PURE__*/__webpack_require__.n(es6);
2413  ;// external ["wp","compose"]
2414  const external_wp_compose_namespaceObject = window["wp"]["compose"];
2415  // EXTERNAL MODULE: external ["wp","data"]
2416  var external_wp_data_ = __webpack_require__(7143);
2417  ;// external ["wp","isShallowEqual"]
2418  const external_wp_isShallowEqual_namespaceObject = window["wp"]["isShallowEqual"];
2419  var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject);
2420  ;// ./node_modules/@wordpress/undo-manager/build-module/index.js
2421  
2422  function mergeHistoryChanges(changes1, changes2) {
2423    const newChanges = { ...changes1 };
2424    Object.entries(changes2).forEach(([key, value]) => {
2425      if (newChanges[key]) {
2426        newChanges[key] = { ...newChanges[key], to: value.to };
2427      } else {
2428        newChanges[key] = value;
2429      }
2430    });
2431    return newChanges;
2432  }
2433  const addHistoryChangesIntoRecord = (record, changes) => {
2434    const existingChangesIndex = record?.findIndex(
2435      ({ id: recordIdentifier }) => {
2436        return typeof recordIdentifier === "string" ? recordIdentifier === changes.id : external_wp_isShallowEqual_default()(recordIdentifier, changes.id);
2437      }
2438    );
2439    const nextRecord = [...record];
2440    if (existingChangesIndex !== -1) {
2441      nextRecord[existingChangesIndex] = {
2442        id: changes.id,
2443        changes: mergeHistoryChanges(
2444          nextRecord[existingChangesIndex].changes,
2445          changes.changes
2446        )
2447      };
2448    } else {
2449      nextRecord.push(changes);
2450    }
2451    return nextRecord;
2452  };
2453  function createUndoManager() {
2454    let history = [];
2455    let stagedRecord = [];
2456    let offset = 0;
2457    const dropPendingRedos = () => {
2458      history = history.slice(0, offset || void 0);
2459      offset = 0;
2460    };
2461    const appendStagedRecordToLatestHistoryRecord = () => {
2462      const index = history.length === 0 ? 0 : history.length - 1;
2463      let latestRecord = history[index] ?? [];
2464      stagedRecord.forEach((changes) => {
2465        latestRecord = addHistoryChangesIntoRecord(latestRecord, changes);
2466      });
2467      stagedRecord = [];
2468      history[index] = latestRecord;
2469    };
2470    const isRecordEmpty = (record) => {
2471      const filteredRecord = record.filter(({ changes }) => {
2472        return Object.values(changes).some(
2473          ({ from, to }) => typeof from !== "function" && typeof to !== "function" && !external_wp_isShallowEqual_default()(from, to)
2474        );
2475      });
2476      return !filteredRecord.length;
2477    };
2478    return {
2479      addRecord(record, isStaged = false) {
2480        const isEmpty = !record || isRecordEmpty(record);
2481        if (isStaged) {
2482          if (isEmpty) {
2483            return;
2484          }
2485          record.forEach((changes) => {
2486            stagedRecord = addHistoryChangesIntoRecord(
2487              stagedRecord,
2488              changes
2489            );
2490          });
2491        } else {
2492          dropPendingRedos();
2493          if (stagedRecord.length) {
2494            appendStagedRecordToLatestHistoryRecord();
2495          }
2496          if (isEmpty) {
2497            return;
2498          }
2499          history.push(record);
2500        }
2501      },
2502      undo() {
2503        if (stagedRecord.length) {
2504          dropPendingRedos();
2505          appendStagedRecordToLatestHistoryRecord();
2506        }
2507        const undoRecord = history[history.length - 1 + offset];
2508        if (!undoRecord) {
2509          return;
2510        }
2511        offset -= 1;
2512        return undoRecord;
2513      },
2514      redo() {
2515        const redoRecord = history[history.length + offset];
2516        if (!redoRecord) {
2517          return;
2518        }
2519        offset += 1;
2520        return redoRecord;
2521      },
2522      hasUndo() {
2523        return !!history[history.length - 1 + offset];
2524      },
2525      hasRedo() {
2526        return !!history[history.length + offset];
2527      }
2528    };
2529  }
2530  
2531  
2532  ;// ./node_modules/@wordpress/core-data/build-module/utils/if-matching-action.js
2533  const ifMatchingAction = (isMatch) => (reducer) => (state, action) => {
2534    if (state === void 0 || isMatch(action)) {
2535      return reducer(state, action);
2536    }
2537    return state;
2538  };
2539  var if_matching_action_default = ifMatchingAction;
2540  
2541  
2542  ;// ./node_modules/@wordpress/core-data/build-module/utils/replace-action.js
2543  const replaceAction = (replacer) => (reducer) => (state, action) => {
2544    return reducer(state, replacer(action));
2545  };
2546  var replace_action_default = replaceAction;
2547  
2548  
2549  ;// ./node_modules/@wordpress/core-data/build-module/utils/conservative-map-item.js
2550  
2551  function conservativeMapItem(item, nextItem) {
2552    if (!item) {
2553      return nextItem;
2554    }
2555    let hasChanges = false;
2556    const result = {};
2557    for (const key in nextItem) {
2558      if (es6_default()(item[key], nextItem[key])) {
2559        result[key] = item[key];
2560      } else {
2561        hasChanges = true;
2562        result[key] = nextItem[key];
2563      }
2564    }
2565    if (!hasChanges) {
2566      return item;
2567    }
2568    for (const key in item) {
2569      if (!result.hasOwnProperty(key)) {
2570        result[key] = item[key];
2571      }
2572    }
2573    return result;
2574  }
2575  
2576  
2577  ;// ./node_modules/@wordpress/core-data/build-module/utils/on-sub-key.js
2578  const onSubKey = (actionProperty) => (reducer) => (state = {}, action) => {
2579    const key = action[actionProperty];
2580    if (key === void 0) {
2581      return state;
2582    }
2583    const nextKeyState = reducer(state[key], action);
2584    if (nextKeyState === state[key]) {
2585      return state;
2586    }
2587    return {
2588      ...state,
2589      [key]: nextKeyState
2590    };
2591  };
2592  var on_sub_key_default = onSubKey;
2593  
2594  
2595  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/entities.js + 2 modules
2596  var entities = __webpack_require__(5914);
2597  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/get-query-parts.js + 1 modules
2598  var get_query_parts = __webpack_require__(4027);
2599  ;// ./node_modules/@wordpress/core-data/build-module/queried-data/reducer.js
2600  
2601  
2602  
2603  
2604  
2605  function getContextFromAction(action) {
2606    const { query } = action;
2607    if (!query) {
2608      return "default";
2609    }
2610    const queryParts = (0,get_query_parts/* default */.A)(query);
2611    return queryParts.context;
2612  }
2613  function getMergedItemIds(itemIds, nextItemIds, page, perPage) {
2614    const receivedAllIds = page === 1 && perPage === -1;
2615    if (receivedAllIds) {
2616      return nextItemIds;
2617    }
2618    const nextItemIdsStartIndex = (page - 1) * perPage;
2619    const size = Math.max(
2620      itemIds?.length ?? 0,
2621      nextItemIdsStartIndex + nextItemIds.length
2622    );
2623    const mergedItemIds = new Array(size);
2624    for (let i = 0; i < size; i++) {
2625      const isInNextItemsRange = i >= nextItemIdsStartIndex && i < nextItemIdsStartIndex + perPage;
2626      mergedItemIds[i] = isInNextItemsRange ? nextItemIds[i - nextItemIdsStartIndex] : itemIds?.[i];
2627    }
2628    return mergedItemIds;
2629  }
2630  function removeEntitiesById(entities, ids) {
2631    return Object.fromEntries(
2632      Object.entries(entities).filter(
2633        ([id]) => !ids.some((itemId) => {
2634          if (Number.isInteger(itemId)) {
2635            return itemId === +id;
2636          }
2637          return itemId === id;
2638        })
2639      )
2640    );
2641  }
2642  function items(state = {}, action) {
2643    switch (action.type) {
2644      case "RECEIVE_ITEMS": {
2645        const context = getContextFromAction(action);
2646        const key = action.key || entities/* DEFAULT_ENTITY_KEY */.C_;
2647        return {
2648          ...state,
2649          [context]: {
2650            ...state[context],
2651            ...action.items.reduce((accumulator, value) => {
2652              const itemId = value?.[key];
2653              accumulator[itemId] = conservativeMapItem(
2654                state?.[context]?.[itemId],
2655                value
2656              );
2657              return accumulator;
2658            }, {})
2659          }
2660        };
2661      }
2662      case "REMOVE_ITEMS":
2663        return Object.fromEntries(
2664          Object.entries(state).map(([itemId, contextState]) => [
2665            itemId,
2666            removeEntitiesById(contextState, action.itemIds)
2667          ])
2668        );
2669    }
2670    return state;
2671  }
2672  function itemIsComplete(state = {}, action) {
2673    switch (action.type) {
2674      case "RECEIVE_ITEMS": {
2675        const context = getContextFromAction(action);
2676        const { query, key = entities/* DEFAULT_ENTITY_KEY */.C_ } = action;
2677        const queryParts = query ? (0,get_query_parts/* default */.A)(query) : {};
2678        const isCompleteQuery = !query || !Array.isArray(queryParts.fields);
2679        return {
2680          ...state,
2681          [context]: {
2682            ...state[context],
2683            ...action.items.reduce((result, item) => {
2684              const itemId = item?.[key];
2685              result[itemId] = state?.[context]?.[itemId] || isCompleteQuery;
2686              return result;
2687            }, {})
2688          }
2689        };
2690      }
2691      case "REMOVE_ITEMS":
2692        return Object.fromEntries(
2693          Object.entries(state).map(([itemId, contextState]) => [
2694            itemId,
2695            removeEntitiesById(contextState, action.itemIds)
2696          ])
2697        );
2698    }
2699    return state;
2700  }
2701  const receiveQueries = (0,external_wp_compose_namespaceObject.compose)([
2702    // Limit to matching action type so we don't attempt to replace action on
2703    // an unhandled action.
2704    if_matching_action_default((action) => "query" in action),
2705    // Inject query parts into action for use both in `onSubKey` and reducer.
2706    replace_action_default((action) => {
2707      if (action.query) {
2708        return {
2709          ...action,
2710          ...(0,get_query_parts/* default */.A)(action.query)
2711        };
2712      }
2713      return action;
2714    }),
2715    on_sub_key_default("context"),
2716    // Queries shape is shared, but keyed by query `stableKey` part. Original
2717    // reducer tracks only a single query object.
2718    on_sub_key_default("stableKey")
2719  ])((state = {}, action) => {
2720    const { type, page, perPage, key = entities/* DEFAULT_ENTITY_KEY */.C_ } = action;
2721    if (type !== "RECEIVE_ITEMS") {
2722      return state;
2723    }
2724    return {
2725      itemIds: getMergedItemIds(
2726        state?.itemIds || [],
2727        action.items.map((item) => item?.[key]).filter(Boolean),
2728        page,
2729        perPage
2730      ),
2731      meta: action.meta
2732    };
2733  });
2734  const queries = (state = {}, action) => {
2735    switch (action.type) {
2736      case "RECEIVE_ITEMS":
2737        return receiveQueries(state, action);
2738      case "REMOVE_ITEMS":
2739        const removedItems = action.itemIds.reduce((result, itemId) => {
2740          result[itemId] = true;
2741          return result;
2742        }, {});
2743        return Object.fromEntries(
2744          Object.entries(state).map(
2745            ([queryGroup, contextQueries]) => [
2746              queryGroup,
2747              Object.fromEntries(
2748                Object.entries(contextQueries).map(
2749                  ([query, queryItems]) => [
2750                    query,
2751                    {
2752                      ...queryItems,
2753                      itemIds: queryItems.itemIds.filter(
2754                        (queryId) => !removedItems[queryId]
2755                      )
2756                    }
2757                  ]
2758                )
2759              )
2760            ]
2761          )
2762        );
2763      default:
2764        return state;
2765    }
2766  };
2767  var reducer_default = (0,external_wp_data_.combineReducers)({
2768    items,
2769    itemIsComplete,
2770    queries
2771  });
2772  
2773  
2774  ;// ./node_modules/@wordpress/core-data/build-module/reducer.js
2775  
2776  
2777  
2778  
2779  
2780  
2781  
2782  function users(state = { byId: {}, queries: {} }, action) {
2783    switch (action.type) {
2784      case "RECEIVE_USER_QUERY":
2785        return {
2786          byId: {
2787            ...state.byId,
2788            // Key users by their ID.
2789            ...action.users.reduce(
2790              (newUsers, user) => ({
2791                ...newUsers,
2792                [user.id]: user
2793              }),
2794              {}
2795            )
2796          },
2797          queries: {
2798            ...state.queries,
2799            [action.queryID]: action.users.map((user) => user.id)
2800          }
2801        };
2802    }
2803    return state;
2804  }
2805  function currentUser(state = {}, action) {
2806    switch (action.type) {
2807      case "RECEIVE_CURRENT_USER":
2808        return action.currentUser;
2809    }
2810    return state;
2811  }
2812  function currentTheme(state = void 0, action) {
2813    switch (action.type) {
2814      case "RECEIVE_CURRENT_THEME":
2815        return action.currentTheme.stylesheet;
2816    }
2817    return state;
2818  }
2819  function currentGlobalStylesId(state = void 0, action) {
2820    switch (action.type) {
2821      case "RECEIVE_CURRENT_GLOBAL_STYLES_ID":
2822        return action.id;
2823    }
2824    return state;
2825  }
2826  function themeBaseGlobalStyles(state = {}, action) {
2827    switch (action.type) {
2828      case "RECEIVE_THEME_GLOBAL_STYLES":
2829        return {
2830          ...state,
2831          [action.stylesheet]: action.globalStyles
2832        };
2833    }
2834    return state;
2835  }
2836  function themeGlobalStyleVariations(state = {}, action) {
2837    switch (action.type) {
2838      case "RECEIVE_THEME_GLOBAL_STYLE_VARIATIONS":
2839        return {
2840          ...state,
2841          [action.stylesheet]: action.variations
2842        };
2843    }
2844    return state;
2845  }
2846  const withMultiEntityRecordEdits = (reducer) => (state, action) => {
2847    if (action.type === "UNDO" || action.type === "REDO") {
2848      const { record } = action;
2849      let newState = state;
2850      record.forEach(({ id: { kind, name, recordId }, changes }) => {
2851        newState = reducer(newState, {
2852          type: "EDIT_ENTITY_RECORD",
2853          kind,
2854          name,
2855          recordId,
2856          edits: Object.entries(changes).reduce(
2857            (acc, [key, value]) => {
2858              acc[key] = action.type === "UNDO" ? value.from : value.to;
2859              return acc;
2860            },
2861            {}
2862          )
2863        });
2864      });
2865      return newState;
2866    }
2867    return reducer(state, action);
2868  };
2869  function entity(entityConfig) {
2870    return (0,external_wp_compose_namespaceObject.compose)([
2871      withMultiEntityRecordEdits,
2872      // Limit to matching action type so we don't attempt to replace action on
2873      // an unhandled action.
2874      if_matching_action_default(
2875        (action) => action.name && action.kind && action.name === entityConfig.name && action.kind === entityConfig.kind
2876      ),
2877      // Inject the entity config into the action.
2878      replace_action_default((action) => {
2879        return {
2880          key: entityConfig.key || entities/* DEFAULT_ENTITY_KEY */.C_,
2881          ...action
2882        };
2883      })
2884    ])(
2885      (0,external_wp_data_.combineReducers)({
2886        queriedData: reducer_default,
2887        edits: (state = {}, action) => {
2888          switch (action.type) {
2889            case "RECEIVE_ITEMS":
2890              const context = action?.query?.context ?? "default";
2891              if (context !== "default") {
2892                return state;
2893              }
2894              const nextState = { ...state };
2895              for (const record of action.items) {
2896                const recordId = record?.[action.key];
2897                const edits = nextState[recordId];
2898                if (!edits) {
2899                  continue;
2900                }
2901                const nextEdits2 = Object.keys(edits).reduce(
2902                  (acc, key) => {
2903                    if (
2904                      // Edits are the "raw" attribute values, but records may have
2905                      // objects with more properties, so we use `get` here for the
2906                      // comparison.
2907                      !es6_default()(
2908                        edits[key],
2909                        record[key]?.raw ?? record[key]
2910                      ) && // Sometimes the server alters the sent value which means
2911                      // we need to also remove the edits before the api request.
2912                      (!action.persistedEdits || !es6_default()(
2913                        edits[key],
2914                        action.persistedEdits[key]
2915                      ))
2916                    ) {
2917                      acc[key] = edits[key];
2918                    }
2919                    return acc;
2920                  },
2921                  {}
2922                );
2923                if (Object.keys(nextEdits2).length) {
2924                  nextState[recordId] = nextEdits2;
2925                } else {
2926                  delete nextState[recordId];
2927                }
2928              }
2929              return nextState;
2930            case "EDIT_ENTITY_RECORD":
2931              const nextEdits = {
2932                ...state[action.recordId],
2933                ...action.edits
2934              };
2935              Object.keys(nextEdits).forEach((key) => {
2936                if (nextEdits[key] === void 0) {
2937                  delete nextEdits[key];
2938                }
2939              });
2940              return {
2941                ...state,
2942                [action.recordId]: nextEdits
2943              };
2944          }
2945          return state;
2946        },
2947        saving: (state = {}, action) => {
2948          switch (action.type) {
2949            case "SAVE_ENTITY_RECORD_START":
2950            case "SAVE_ENTITY_RECORD_FINISH":
2951              return {
2952                ...state,
2953                [action.recordId]: {
2954                  pending: action.type === "SAVE_ENTITY_RECORD_START",
2955                  error: action.error,
2956                  isAutosave: action.isAutosave
2957                }
2958              };
2959          }
2960          return state;
2961        },
2962        deleting: (state = {}, action) => {
2963          switch (action.type) {
2964            case "DELETE_ENTITY_RECORD_START":
2965            case "DELETE_ENTITY_RECORD_FINISH":
2966              return {
2967                ...state,
2968                [action.recordId]: {
2969                  pending: action.type === "DELETE_ENTITY_RECORD_START",
2970                  error: action.error
2971                }
2972              };
2973          }
2974          return state;
2975        },
2976        revisions: (state = {}, action) => {
2977          if (action.type === "RECEIVE_ITEM_REVISIONS") {
2978            const recordKey = action.recordKey;
2979            delete action.recordKey;
2980            const newState = reducer_default(state[recordKey], {
2981              ...action,
2982              type: "RECEIVE_ITEMS"
2983            });
2984            return {
2985              ...state,
2986              [recordKey]: newState
2987            };
2988          }
2989          if (action.type === "REMOVE_ITEMS") {
2990            return Object.fromEntries(
2991              Object.entries(state).filter(
2992                ([id]) => !action.itemIds.some((itemId) => {
2993                  if (Number.isInteger(itemId)) {
2994                    return itemId === +id;
2995                  }
2996                  return itemId === id;
2997                })
2998              )
2999            );
3000          }
3001          return state;
3002        }
3003      })
3004    );
3005  }
3006  function entitiesConfig(state = entities/* rootEntitiesConfig */.Mr, action) {
3007    switch (action.type) {
3008      case "ADD_ENTITIES":
3009        return [...state, ...action.entities];
3010    }
3011    return state;
3012  }
3013  const reducer_entities = (state = {}, action) => {
3014    const newConfig = entitiesConfig(state.config, action);
3015    let entitiesDataReducer = state.reducer;
3016    if (!entitiesDataReducer || newConfig !== state.config) {
3017      const entitiesByKind = newConfig.reduce((acc, record) => {
3018        const { kind } = record;
3019        if (!acc[kind]) {
3020          acc[kind] = [];
3021        }
3022        acc[kind].push(record);
3023        return acc;
3024      }, {});
3025      entitiesDataReducer = (0,external_wp_data_.combineReducers)(
3026        Object.fromEntries(
3027          Object.entries(entitiesByKind).map(
3028            ([kind, subEntities]) => {
3029              const kindReducer = (0,external_wp_data_.combineReducers)(
3030                Object.fromEntries(
3031                  subEntities.map((entityConfig) => [
3032                    entityConfig.name,
3033                    entity(entityConfig)
3034                  ])
3035                )
3036              );
3037              return [kind, kindReducer];
3038            }
3039          )
3040        )
3041      );
3042    }
3043    const newData = entitiesDataReducer(state.records, action);
3044    if (newData === state.records && newConfig === state.config && entitiesDataReducer === state.reducer) {
3045      return state;
3046    }
3047    return {
3048      reducer: entitiesDataReducer,
3049      records: newData,
3050      config: newConfig
3051    };
3052  };
3053  function undoManager(state = createUndoManager()) {
3054    return state;
3055  }
3056  function editsReference(state = {}, action) {
3057    switch (action.type) {
3058      case "EDIT_ENTITY_RECORD":
3059      case "UNDO":
3060      case "REDO":
3061        return {};
3062    }
3063    return state;
3064  }
3065  function embedPreviews(state = {}, action) {
3066    switch (action.type) {
3067      case "RECEIVE_EMBED_PREVIEW":
3068        const { url, preview } = action;
3069        return {
3070          ...state,
3071          [url]: preview
3072        };
3073    }
3074    return state;
3075  }
3076  function userPermissions(state = {}, action) {
3077    switch (action.type) {
3078      case "RECEIVE_USER_PERMISSION":
3079        return {
3080          ...state,
3081          [action.key]: action.isAllowed
3082        };
3083      case "RECEIVE_USER_PERMISSIONS":
3084        return {
3085          ...state,
3086          ...action.permissions
3087        };
3088    }
3089    return state;
3090  }
3091  function autosaves(state = {}, action) {
3092    switch (action.type) {
3093      case "RECEIVE_AUTOSAVES":
3094        const { postId, autosaves: autosavesData } = action;
3095        return {
3096          ...state,
3097          [postId]: autosavesData
3098        };
3099    }
3100    return state;
3101  }
3102  function blockPatterns(state = [], action) {
3103    switch (action.type) {
3104      case "RECEIVE_BLOCK_PATTERNS":
3105        return action.patterns;
3106    }
3107    return state;
3108  }
3109  function blockPatternCategories(state = [], action) {
3110    switch (action.type) {
3111      case "RECEIVE_BLOCK_PATTERN_CATEGORIES":
3112        return action.categories;
3113    }
3114    return state;
3115  }
3116  function userPatternCategories(state = [], action) {
3117    switch (action.type) {
3118      case "RECEIVE_USER_PATTERN_CATEGORIES":
3119        return action.patternCategories;
3120    }
3121    return state;
3122  }
3123  function navigationFallbackId(state = null, action) {
3124    switch (action.type) {
3125      case "RECEIVE_NAVIGATION_FALLBACK_ID":
3126        return action.fallbackId;
3127    }
3128    return state;
3129  }
3130  function themeGlobalStyleRevisions(state = {}, action) {
3131    switch (action.type) {
3132      case "RECEIVE_THEME_GLOBAL_STYLE_REVISIONS":
3133        return {
3134          ...state,
3135          [action.currentId]: action.revisions
3136        };
3137    }
3138    return state;
3139  }
3140  function defaultTemplates(state = {}, action) {
3141    switch (action.type) {
3142      case "RECEIVE_DEFAULT_TEMPLATE":
3143        return {
3144          ...state,
3145          [JSON.stringify(action.query)]: action.templateId
3146        };
3147    }
3148    return state;
3149  }
3150  function registeredPostMeta(state = {}, action) {
3151    switch (action.type) {
3152      case "RECEIVE_REGISTERED_POST_META":
3153        return {
3154          ...state,
3155          [action.postType]: action.registeredPostMeta
3156        };
3157    }
3158    return state;
3159  }
3160  var reducer_reducer_default = (0,external_wp_data_.combineReducers)({
3161    users,
3162    currentTheme,
3163    currentGlobalStylesId,
3164    currentUser,
3165    themeGlobalStyleVariations,
3166    themeBaseGlobalStyles,
3167    themeGlobalStyleRevisions,
3168    entities: reducer_entities,
3169    editsReference,
3170    undoManager,
3171    embedPreviews,
3172    userPermissions,
3173    autosaves,
3174    blockPatterns,
3175    blockPatternCategories,
3176    userPatternCategories,
3177    navigationFallbackId,
3178    defaultTemplates,
3179    registeredPostMeta
3180  });
3181  
3182  
3183  
3184  /***/ }),
3185  
3186  /***/ 5663:
3187  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
3188  
3189  "use strict";
3190  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
3191  /* harmony export */   xQ: () => (/* binding */ camelCase)
3192  /* harmony export */ });
3193  /* unused harmony exports camelCaseTransform, camelCaseTransformMerge */
3194  /* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1635);
3195  /* harmony import */ var pascal_case__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(287);
3196  
3197  
3198  function camelCaseTransform(input, index) {
3199      if (index === 0)
3200          return input.toLowerCase();
3201      return (0,pascal_case__WEBPACK_IMPORTED_MODULE_0__/* .pascalCaseTransform */ .l3)(input, index);
3202  }
3203  function camelCaseTransformMerge(input, index) {
3204      if (index === 0)
3205          return input.toLowerCase();
3206      return pascalCaseTransformMerge(input);
3207  }
3208  function camelCase(input, options) {
3209      if (options === void 0) { options = {}; }
3210      return (0,pascal_case__WEBPACK_IMPORTED_MODULE_0__/* .pascalCase */ .fL)(input, (0,tslib__WEBPACK_IMPORTED_MODULE_1__/* .__assign */ .Cl)({ transform: camelCaseTransform }, options));
3211  }
3212  
3213  
3214  /***/ }),
3215  
3216  /***/ 5891:
3217  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
3218  
3219  "use strict";
3220  
3221  // EXPORTS
3222  __webpack_require__.d(__webpack_exports__, {
3223    qh: () => (/* reexport */ __experimentalUseEntityRecord),
3224    bM: () => (/* reexport */ use_entity_records/* __experimentalUseEntityRecords */.bM),
3225    _: () => (/* reexport */ __experimentalUseResourcePermissions),
3226    hg: () => (/* reexport */ useEntityBlockEditor),
3227    mV: () => (/* reexport */ useEntityId),
3228    S$: () => (/* reexport */ useEntityProp),
3229    MA: () => (/* reexport */ useEntityRecord),
3230    $u: () => (/* reexport */ use_entity_records/* default */.Ay),
3231    qs: () => (/* reexport */ use_resource_permissions_default)
3232  });
3233  
3234  // EXTERNAL MODULE: external ["wp","data"]
3235  var external_wp_data_ = __webpack_require__(7143);
3236  // EXTERNAL MODULE: external ["wp","deprecated"]
3237  var external_wp_deprecated_ = __webpack_require__(4040);
3238  var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_);
3239  // EXTERNAL MODULE: external ["wp","element"]
3240  var external_wp_element_ = __webpack_require__(6087);
3241  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/hooks/use-query-select.js + 2 modules
3242  var use_query_select = __webpack_require__(7541);
3243  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/index.js
3244  var build_module = __webpack_require__(4565);
3245  ;// ./node_modules/@wordpress/core-data/build-module/hooks/use-entity-record.js
3246  
3247  
3248  
3249  
3250  
3251  const EMPTY_OBJECT = {};
3252  function useEntityRecord(kind, name, recordId, options = { enabled: true }) {
3253    const { editEntityRecord, saveEditedEntityRecord } = (0,external_wp_data_.useDispatch)(build_module.store);
3254    const mutations = (0,external_wp_element_.useMemo)(
3255      () => ({
3256        edit: (record2, editOptions = {}) => editEntityRecord(kind, name, recordId, record2, editOptions),
3257        save: (saveOptions = {}) => saveEditedEntityRecord(kind, name, recordId, {
3258          throwOnError: true,
3259          ...saveOptions
3260        })
3261      }),
3262      [editEntityRecord, kind, name, recordId, saveEditedEntityRecord]
3263    );
3264    const { editedRecord, hasEdits, edits } = (0,external_wp_data_.useSelect)(
3265      (select) => {
3266        if (!options.enabled) {
3267          return {
3268            editedRecord: EMPTY_OBJECT,
3269            hasEdits: false,
3270            edits: EMPTY_OBJECT
3271          };
3272        }
3273        return {
3274          editedRecord: select(build_module.store).getEditedEntityRecord(
3275            kind,
3276            name,
3277            recordId
3278          ),
3279          hasEdits: select(build_module.store).hasEditsForEntityRecord(
3280            kind,
3281            name,
3282            recordId
3283          ),
3284          edits: select(build_module.store).getEntityRecordNonTransientEdits(
3285            kind,
3286            name,
3287            recordId
3288          )
3289        };
3290      },
3291      [kind, name, recordId, options.enabled]
3292    );
3293    const { data: record, ...querySelectRest } = (0,use_query_select/* default */.A)(
3294      (query) => {
3295        if (!options.enabled) {
3296          return {
3297            data: null
3298          };
3299        }
3300        return query(build_module.store).getEntityRecord(kind, name, recordId);
3301      },
3302      [kind, name, recordId, options.enabled]
3303    );
3304    return {
3305      record,
3306      editedRecord,
3307      hasEdits,
3308      edits,
3309      ...querySelectRest,
3310      ...mutations
3311    };
3312  }
3313  function __experimentalUseEntityRecord(kind, name, recordId, options) {
3314    external_wp_deprecated_default()(`wp.data.__experimentalUseEntityRecord`, {
3315      alternative: "wp.data.useEntityRecord",
3316      since: "6.1"
3317    });
3318    return useEntityRecord(kind, name, recordId, options);
3319  }
3320  
3321  
3322  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/hooks/use-entity-records.js
3323  var use_entity_records = __webpack_require__(7078);
3324  ;// external ["wp","warning"]
3325  const external_wp_warning_namespaceObject = window["wp"]["warning"];
3326  var external_wp_warning_default = /*#__PURE__*/__webpack_require__.n(external_wp_warning_namespaceObject);
3327  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/hooks/constants.js
3328  var constants = __webpack_require__(2859);
3329  ;// ./node_modules/@wordpress/core-data/build-module/hooks/use-resource-permissions.js
3330  
3331  
3332  
3333  
3334  
3335  function useResourcePermissions(resource, id) {
3336    const isEntity = typeof resource === "object";
3337    const resourceAsString = isEntity ? JSON.stringify(resource) : resource;
3338    if (isEntity && typeof id !== "undefined") {
3339      external_wp_warning_default()(
3340        `When 'resource' is an entity object, passing 'id' as a separate argument isn't supported.`
3341      );
3342    }
3343    return (0,use_query_select/* default */.A)(
3344      (resolve) => {
3345        const hasId = isEntity ? !!resource.id : !!id;
3346        const { canUser } = resolve(build_module.store);
3347        const create = canUser(
3348          "create",
3349          isEntity ? { kind: resource.kind, name: resource.name } : resource
3350        );
3351        if (!hasId) {
3352          const read2 = canUser("read", resource);
3353          const isResolving2 = create.isResolving || read2.isResolving;
3354          const hasResolved2 = create.hasResolved && read2.hasResolved;
3355          let status2 = constants/* Status */.n.Idle;
3356          if (isResolving2) {
3357            status2 = constants/* Status */.n.Resolving;
3358          } else if (hasResolved2) {
3359            status2 = constants/* Status */.n.Success;
3360          }
3361          return {
3362            status: status2,
3363            isResolving: isResolving2,
3364            hasResolved: hasResolved2,
3365            canCreate: create.hasResolved && create.data,
3366            canRead: read2.hasResolved && read2.data
3367          };
3368        }
3369        const read = canUser("read", resource, id);
3370        const update = canUser("update", resource, id);
3371        const _delete = canUser("delete", resource, id);
3372        const isResolving = read.isResolving || create.isResolving || update.isResolving || _delete.isResolving;
3373        const hasResolved = read.hasResolved && create.hasResolved && update.hasResolved && _delete.hasResolved;
3374        let status = constants/* Status */.n.Idle;
3375        if (isResolving) {
3376          status = constants/* Status */.n.Resolving;
3377        } else if (hasResolved) {
3378          status = constants/* Status */.n.Success;
3379        }
3380        return {
3381          status,
3382          isResolving,
3383          hasResolved,
3384          canRead: hasResolved && read.data,
3385          canCreate: hasResolved && create.data,
3386          canUpdate: hasResolved && update.data,
3387          canDelete: hasResolved && _delete.data
3388        };
3389      },
3390      [resourceAsString, id]
3391    );
3392  }
3393  var use_resource_permissions_default = useResourcePermissions;
3394  function __experimentalUseResourcePermissions(resource, id) {
3395    external_wp_deprecated_default()(`wp.data.__experimentalUseResourcePermissions`, {
3396      alternative: "wp.data.useResourcePermissions",
3397      since: "6.1"
3398    });
3399    return useResourcePermissions(resource, id);
3400  }
3401  
3402  
3403  // EXTERNAL MODULE: external ["wp","blocks"]
3404  var external_wp_blocks_ = __webpack_require__(4997);
3405  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/name.js
3406  var build_module_name = __webpack_require__(2278);
3407  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/entity-context.js
3408  var entity_context = __webpack_require__(8843);
3409  ;// ./node_modules/@wordpress/core-data/build-module/hooks/use-entity-id.js
3410  
3411  
3412  function useEntityId(kind, name) {
3413    const context = (0,external_wp_element_.useContext)(entity_context/* EntityContext */.D);
3414    return context?.[kind]?.[name];
3415  }
3416  
3417  
3418  ;// external ["wp","richText"]
3419  const external_wp_richText_namespaceObject = window["wp"]["richText"];
3420  ;// external ["wp","blockEditor"]
3421  const external_wp_blockEditor_namespaceObject = window["wp"]["blockEditor"];
3422  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/lock-unlock.js + 1 modules
3423  var lock_unlock = __webpack_require__(6378);
3424  ;// ./node_modules/@wordpress/core-data/build-module/footnotes/get-rich-text-values-cached.js
3425  
3426  
3427  let unlockedApis;
3428  const cache = /* @__PURE__ */ new WeakMap();
3429  function getRichTextValuesCached(block) {
3430    if (!unlockedApis) {
3431      unlockedApis = (0,lock_unlock/* unlock */.T)(external_wp_blockEditor_namespaceObject.privateApis);
3432    }
3433    if (!cache.has(block)) {
3434      const values = unlockedApis.getRichTextValues([block]);
3435      cache.set(block, values);
3436    }
3437    return cache.get(block);
3438  }
3439  
3440  
3441  ;// ./node_modules/@wordpress/core-data/build-module/footnotes/get-footnotes-order.js
3442  
3443  const get_footnotes_order_cache = /* @__PURE__ */ new WeakMap();
3444  function getBlockFootnotesOrder(block) {
3445    if (!get_footnotes_order_cache.has(block)) {
3446      const order = [];
3447      for (const value of getRichTextValuesCached(block)) {
3448        if (!value) {
3449          continue;
3450        }
3451        value.replacements.forEach(({ type, attributes }) => {
3452          if (type === "core/footnote") {
3453            order.push(attributes["data-fn"]);
3454          }
3455        });
3456      }
3457      get_footnotes_order_cache.set(block, order);
3458    }
3459    return get_footnotes_order_cache.get(block);
3460  }
3461  function getFootnotesOrder(blocks) {
3462    return blocks.flatMap(getBlockFootnotesOrder);
3463  }
3464  
3465  
3466  ;// ./node_modules/@wordpress/core-data/build-module/footnotes/index.js
3467  
3468  
3469  let oldFootnotes = {};
3470  function updateFootnotesFromMeta(blocks, meta) {
3471    const output = { blocks };
3472    if (!meta) {
3473      return output;
3474    }
3475    if (meta.footnotes === void 0) {
3476      return output;
3477    }
3478    const newOrder = getFootnotesOrder(blocks);
3479    const footnotes = meta.footnotes ? JSON.parse(meta.footnotes) : [];
3480    const currentOrder = footnotes.map((fn) => fn.id);
3481    if (currentOrder.join("") === newOrder.join("")) {
3482      return output;
3483    }
3484    const newFootnotes = newOrder.map(
3485      (fnId) => footnotes.find((fn) => fn.id === fnId) || oldFootnotes[fnId] || {
3486        id: fnId,
3487        content: ""
3488      }
3489    );
3490    function updateAttributes(attributes) {
3491      if (!attributes || Array.isArray(attributes) || typeof attributes !== "object") {
3492        return attributes;
3493      }
3494      attributes = { ...attributes };
3495      for (const key in attributes) {
3496        const value = attributes[key];
3497        if (Array.isArray(value)) {
3498          attributes[key] = value.map(updateAttributes);
3499          continue;
3500        }
3501        if (typeof value !== "string" && !(value instanceof external_wp_richText_namespaceObject.RichTextData)) {
3502          continue;
3503        }
3504        const richTextValue = typeof value === "string" ? external_wp_richText_namespaceObject.RichTextData.fromHTMLString(value) : new external_wp_richText_namespaceObject.RichTextData(value);
3505        let hasFootnotes = false;
3506        richTextValue.replacements.forEach((replacement) => {
3507          if (replacement.type === "core/footnote") {
3508            const id = replacement.attributes["data-fn"];
3509            const index = newOrder.indexOf(id);
3510            const countValue = (0,external_wp_richText_namespaceObject.create)({
3511              html: replacement.innerHTML
3512            });
3513            countValue.text = String(index + 1);
3514            countValue.formats = Array.from(
3515              { length: countValue.text.length },
3516              () => countValue.formats[0]
3517            );
3518            countValue.replacements = Array.from(
3519              { length: countValue.text.length },
3520              () => countValue.replacements[0]
3521            );
3522            replacement.innerHTML = (0,external_wp_richText_namespaceObject.toHTMLString)({
3523              value: countValue
3524            });
3525            hasFootnotes = true;
3526          }
3527        });
3528        if (hasFootnotes) {
3529          attributes[key] = typeof value === "string" ? richTextValue.toHTMLString() : richTextValue;
3530        }
3531      }
3532      return attributes;
3533    }
3534    function updateBlocksAttributes(__blocks) {
3535      return __blocks.map((block) => {
3536        return {
3537          ...block,
3538          attributes: updateAttributes(block.attributes),
3539          innerBlocks: updateBlocksAttributes(block.innerBlocks)
3540        };
3541      });
3542    }
3543    const newBlocks = updateBlocksAttributes(blocks);
3544    oldFootnotes = {
3545      ...oldFootnotes,
3546      ...footnotes.reduce((acc, fn) => {
3547        if (!newOrder.includes(fn.id)) {
3548          acc[fn.id] = fn;
3549        }
3550        return acc;
3551      }, {})
3552    };
3553    return {
3554      meta: {
3555        ...meta,
3556        footnotes: JSON.stringify(newFootnotes)
3557      },
3558      blocks: newBlocks
3559    };
3560  }
3561  
3562  
3563  ;// ./node_modules/@wordpress/core-data/build-module/hooks/use-entity-block-editor.js
3564  
3565  
3566  
3567  
3568  
3569  
3570  const EMPTY_ARRAY = [];
3571  const parsedBlocksCache = /* @__PURE__ */ new WeakMap();
3572  function useEntityBlockEditor(kind, name, { id: _id } = {}) {
3573    const providerId = useEntityId(kind, name);
3574    const id = _id ?? providerId;
3575    const { getEntityRecord, getEntityRecordEdits } = (0,external_wp_data_.useSelect)(build_module_name/* STORE_NAME */.E);
3576    const { content, editedBlocks, meta } = (0,external_wp_data_.useSelect)(
3577      (select) => {
3578        if (!id) {
3579          return {};
3580        }
3581        const { getEditedEntityRecord } = select(build_module_name/* STORE_NAME */.E);
3582        const editedRecord = getEditedEntityRecord(kind, name, id);
3583        return {
3584          editedBlocks: editedRecord.blocks,
3585          content: editedRecord.content,
3586          meta: editedRecord.meta
3587        };
3588      },
3589      [kind, name, id]
3590    );
3591    const { __unstableCreateUndoLevel, editEntityRecord } = (0,external_wp_data_.useDispatch)(build_module_name/* STORE_NAME */.E);
3592    const blocks = (0,external_wp_element_.useMemo)(() => {
3593      if (!id) {
3594        return void 0;
3595      }
3596      if (editedBlocks) {
3597        return editedBlocks;
3598      }
3599      if (!content || typeof content !== "string") {
3600        return EMPTY_ARRAY;
3601      }
3602      const edits = getEntityRecordEdits(kind, name, id);
3603      const isUnedited = !edits || !Object.keys(edits).length;
3604      const cackeKey = isUnedited ? getEntityRecord(kind, name, id) : edits;
3605      let _blocks = parsedBlocksCache.get(cackeKey);
3606      if (!_blocks) {
3607        _blocks = (0,external_wp_blocks_.parse)(content);
3608        parsedBlocksCache.set(cackeKey, _blocks);
3609      }
3610      return _blocks;
3611    }, [
3612      kind,
3613      name,
3614      id,
3615      editedBlocks,
3616      content,
3617      getEntityRecord,
3618      getEntityRecordEdits
3619    ]);
3620    const onChange = (0,external_wp_element_.useCallback)(
3621      (newBlocks, options) => {
3622        const noChange = blocks === newBlocks;
3623        if (noChange) {
3624          return __unstableCreateUndoLevel(kind, name, id);
3625        }
3626        const { selection, ...rest } = options;
3627        const edits = {
3628          selection,
3629          content: ({ blocks: blocksForSerialization = [] }) => (0,external_wp_blocks_.__unstableSerializeAndClean)(blocksForSerialization),
3630          ...updateFootnotesFromMeta(newBlocks, meta)
3631        };
3632        editEntityRecord(kind, name, id, edits, {
3633          isCached: false,
3634          ...rest
3635        });
3636      },
3637      [
3638        kind,
3639        name,
3640        id,
3641        blocks,
3642        meta,
3643        __unstableCreateUndoLevel,
3644        editEntityRecord
3645      ]
3646    );
3647    const onInput = (0,external_wp_element_.useCallback)(
3648      (newBlocks, options) => {
3649        const { selection, ...rest } = options;
3650        const footnotesChanges = updateFootnotesFromMeta(newBlocks, meta);
3651        const edits = { selection, ...footnotesChanges };
3652        editEntityRecord(kind, name, id, edits, {
3653          isCached: true,
3654          ...rest
3655        });
3656      },
3657      [kind, name, id, meta, editEntityRecord]
3658    );
3659    return [blocks, onInput, onChange];
3660  }
3661  
3662  
3663  ;// ./node_modules/@wordpress/core-data/build-module/hooks/use-entity-prop.js
3664  
3665  
3666  
3667  
3668  function useEntityProp(kind, name, prop, _id) {
3669    const providerId = useEntityId(kind, name);
3670    const id = _id ?? providerId;
3671    const { value, fullValue } = (0,external_wp_data_.useSelect)(
3672      (select) => {
3673        const { getEntityRecord, getEditedEntityRecord } = select(build_module_name/* STORE_NAME */.E);
3674        const record = getEntityRecord(kind, name, id);
3675        const editedRecord = getEditedEntityRecord(kind, name, id);
3676        return record && editedRecord ? {
3677          value: editedRecord[prop],
3678          fullValue: record[prop]
3679        } : {};
3680      },
3681      [kind, name, id, prop]
3682    );
3683    const { editEntityRecord } = (0,external_wp_data_.useDispatch)(build_module_name/* STORE_NAME */.E);
3684    const setValue = (0,external_wp_element_.useCallback)(
3685      (newValue) => {
3686        editEntityRecord(kind, name, id, {
3687          [prop]: newValue
3688        });
3689      },
3690      [editEntityRecord, kind, name, id, prop]
3691    );
3692    return [value, setValue, fullValue];
3693  }
3694  
3695  
3696  ;// ./node_modules/@wordpress/core-data/build-module/hooks/index.js
3697  
3698  
3699  
3700  
3701  
3702  
3703  
3704  
3705  
3706  /***/ }),
3707  
3708  /***/ 5914:
3709  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
3710  
3711  "use strict";
3712  
3713  // EXPORTS
3714  __webpack_require__.d(__webpack_exports__, {
3715    C_: () => (/* binding */ DEFAULT_ENTITY_KEY),
3716    L2: () => (/* binding */ additionalEntityConfigLoaders),
3717    TK: () => (/* binding */ deprecatedEntities),
3718    zD: () => (/* binding */ getMethodName),
3719    Mr: () => (/* binding */ rootEntitiesConfig)
3720  });
3721  
3722  // UNUSED EXPORTS: prePersistPostType
3723  
3724  // EXTERNAL MODULE: ./node_modules/tslib/tslib.es6.mjs
3725  var tslib_es6 = __webpack_require__(1635);
3726  // EXTERNAL MODULE: ./node_modules/no-case/dist.es2015/index.js
3727  var dist_es2015 = __webpack_require__(2226);
3728  ;// ./node_modules/upper-case-first/dist.es2015/index.js
3729  /**
3730   * Upper case the first character of an input string.
3731   */
3732  function upperCaseFirst(input) {
3733      return input.charAt(0).toUpperCase() + input.substr(1);
3734  }
3735  
3736  ;// ./node_modules/capital-case/dist.es2015/index.js
3737  
3738  
3739  
3740  function capitalCaseTransform(input) {
3741      return upperCaseFirst(input.toLowerCase());
3742  }
3743  function capitalCase(input, options) {
3744      if (options === void 0) { options = {}; }
3745      return (0,dist_es2015/* noCase */.W)(input, (0,tslib_es6/* __assign */.Cl)({ delimiter: " ", transform: capitalCaseTransform }, options));
3746  }
3747  
3748  // EXTERNAL MODULE: ./node_modules/pascal-case/dist.es2015/index.js
3749  var pascal_case_dist_es2015 = __webpack_require__(287);
3750  // EXTERNAL MODULE: external ["wp","apiFetch"]
3751  var external_wp_apiFetch_ = __webpack_require__(1455);
3752  var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_);
3753  // EXTERNAL MODULE: external ["wp","blocks"]
3754  var external_wp_blocks_ = __webpack_require__(4997);
3755  // EXTERNAL MODULE: external ["wp","i18n"]
3756  var external_wp_i18n_ = __webpack_require__(7723);
3757  ;// ./node_modules/@wordpress/core-data/build-module/entities.js
3758  
3759  
3760  
3761  
3762  
3763  const DEFAULT_ENTITY_KEY = "id";
3764  const POST_RAW_ATTRIBUTES = ["title", "excerpt", "content"];
3765  const blocksTransientEdits = {
3766    blocks: {
3767      read: (record) => (0,external_wp_blocks_.parse)(record.content?.raw ?? ""),
3768      write: (record) => ({
3769        content: (0,external_wp_blocks_.__unstableSerializeAndClean)(record.blocks)
3770      })
3771    }
3772  };
3773  const rootEntitiesConfig = [
3774    {
3775      label: (0,external_wp_i18n_.__)("Base"),
3776      kind: "root",
3777      key: false,
3778      name: "__unstableBase",
3779      baseURL: "/",
3780      baseURLParams: {
3781        // Please also change the preload path when changing this.
3782        // @see lib/compat/wordpress-6.8/preload.php
3783        _fields: [
3784          "description",
3785          "gmt_offset",
3786          "home",
3787          "name",
3788          "site_icon",
3789          "site_icon_url",
3790          "site_logo",
3791          "timezone_string",
3792          "url",
3793          "page_for_posts",
3794          "page_on_front",
3795          "show_on_front"
3796        ].join(",")
3797      },
3798      // The entity doesn't support selecting multiple records.
3799      // The property is maintained for backward compatibility.
3800      plural: "__unstableBases"
3801    },
3802    {
3803      label: (0,external_wp_i18n_.__)("Post Type"),
3804      name: "postType",
3805      kind: "root",
3806      key: "slug",
3807      baseURL: "/wp/v2/types",
3808      baseURLParams: { context: "edit" },
3809      plural: "postTypes"
3810    },
3811    {
3812      name: "media",
3813      kind: "root",
3814      baseURL: "/wp/v2/media",
3815      baseURLParams: { context: "edit" },
3816      plural: "mediaItems",
3817      label: (0,external_wp_i18n_.__)("Media"),
3818      rawAttributes: ["caption", "title", "description"],
3819      supportsPagination: true
3820    },
3821    {
3822      name: "taxonomy",
3823      kind: "root",
3824      key: "slug",
3825      baseURL: "/wp/v2/taxonomies",
3826      baseURLParams: { context: "edit" },
3827      plural: "taxonomies",
3828      label: (0,external_wp_i18n_.__)("Taxonomy")
3829    },
3830    {
3831      name: "sidebar",
3832      kind: "root",
3833      baseURL: "/wp/v2/sidebars",
3834      baseURLParams: { context: "edit" },
3835      plural: "sidebars",
3836      transientEdits: { blocks: true },
3837      label: (0,external_wp_i18n_.__)("Widget areas")
3838    },
3839    {
3840      name: "widget",
3841      kind: "root",
3842      baseURL: "/wp/v2/widgets",
3843      baseURLParams: { context: "edit" },
3844      plural: "widgets",
3845      transientEdits: { blocks: true },
3846      label: (0,external_wp_i18n_.__)("Widgets")
3847    },
3848    {
3849      name: "widgetType",
3850      kind: "root",
3851      baseURL: "/wp/v2/widget-types",
3852      baseURLParams: { context: "edit" },
3853      plural: "widgetTypes",
3854      label: (0,external_wp_i18n_.__)("Widget types")
3855    },
3856    {
3857      label: (0,external_wp_i18n_.__)("User"),
3858      name: "user",
3859      kind: "root",
3860      baseURL: "/wp/v2/users",
3861      getTitle: (record) => record?.name || record?.slug,
3862      baseURLParams: { context: "edit" },
3863      plural: "users",
3864      supportsPagination: true
3865    },
3866    {
3867      name: "comment",
3868      kind: "root",
3869      baseURL: "/wp/v2/comments",
3870      baseURLParams: { context: "edit" },
3871      plural: "comments",
3872      label: (0,external_wp_i18n_.__)("Comment"),
3873      supportsPagination: true
3874    },
3875    {
3876      name: "menu",
3877      kind: "root",
3878      baseURL: "/wp/v2/menus",
3879      baseURLParams: { context: "edit" },
3880      plural: "menus",
3881      label: (0,external_wp_i18n_.__)("Menu"),
3882      supportsPagination: true
3883    },
3884    {
3885      name: "menuItem",
3886      kind: "root",
3887      baseURL: "/wp/v2/menu-items",
3888      baseURLParams: { context: "edit" },
3889      plural: "menuItems",
3890      label: (0,external_wp_i18n_.__)("Menu Item"),
3891      rawAttributes: ["title"],
3892      supportsPagination: true
3893    },
3894    {
3895      name: "menuLocation",
3896      kind: "root",
3897      baseURL: "/wp/v2/menu-locations",
3898      baseURLParams: { context: "edit" },
3899      plural: "menuLocations",
3900      label: (0,external_wp_i18n_.__)("Menu Location"),
3901      key: "name"
3902    },
3903    {
3904      label: (0,external_wp_i18n_.__)("Global Styles"),
3905      name: "globalStyles",
3906      kind: "root",
3907      baseURL: "/wp/v2/global-styles",
3908      baseURLParams: { context: "edit" },
3909      plural: "globalStylesVariations",
3910      // Should be different from name.
3911      getTitle: () => (0,external_wp_i18n_.__)("Custom Styles"),
3912      getRevisionsUrl: (parentId, revisionId) => `/wp/v2/global-styles/$parentId}/revisions$revisionId ? "/" + revisionId : ""}`,
3913      supportsPagination: true
3914    },
3915    {
3916      label: (0,external_wp_i18n_.__)("Themes"),
3917      name: "theme",
3918      kind: "root",
3919      baseURL: "/wp/v2/themes",
3920      baseURLParams: { context: "edit" },
3921      plural: "themes",
3922      key: "stylesheet"
3923    },
3924    {
3925      label: (0,external_wp_i18n_.__)("Plugins"),
3926      name: "plugin",
3927      kind: "root",
3928      baseURL: "/wp/v2/plugins",
3929      baseURLParams: { context: "edit" },
3930      plural: "plugins",
3931      key: "plugin"
3932    },
3933    {
3934      label: (0,external_wp_i18n_.__)("Status"),
3935      name: "status",
3936      kind: "root",
3937      baseURL: "/wp/v2/statuses",
3938      baseURLParams: { context: "edit" },
3939      plural: "statuses",
3940      key: "slug"
3941    },
3942    {
3943      label: (0,external_wp_i18n_.__)("Registered Templates"),
3944      name: "registeredTemplate",
3945      kind: "root",
3946      baseURL: "/wp/v2/registered-templates",
3947      key: "id"
3948    }
3949  ];
3950  const deprecatedEntities = {
3951    root: {
3952      media: {
3953        since: "6.9",
3954        alternative: {
3955          kind: "postType",
3956          name: "attachment"
3957        }
3958      }
3959    }
3960  };
3961  const additionalEntityConfigLoaders = [
3962    { kind: "postType", loadEntities: loadPostTypeEntities },
3963    { kind: "taxonomy", loadEntities: loadTaxonomyEntities },
3964    {
3965      kind: "root",
3966      name: "site",
3967      plural: "sites",
3968      loadEntities: loadSiteEntity
3969    }
3970  ];
3971  const prePersistPostType = (persistedRecord, edits) => {
3972    const newEdits = {};
3973    if (persistedRecord?.status === "auto-draft") {
3974      if (!edits.status && !newEdits.status) {
3975        newEdits.status = "draft";
3976      }
3977      if ((!edits.title || edits.title === "Auto Draft") && !newEdits.title && (!persistedRecord?.title || persistedRecord?.title === "Auto Draft")) {
3978        newEdits.title = "";
3979      }
3980    }
3981    return newEdits;
3982  };
3983  async function loadPostTypeEntities() {
3984    const postTypes = await external_wp_apiFetch_default()({
3985      path: "/wp/v2/types?context=view"
3986    });
3987    return Object.entries(postTypes ?? {}).map(([name, postType]) => {
3988      const isTemplate = ["wp_template", "wp_template_part"].includes(
3989        name
3990      );
3991      const namespace = postType?.rest_namespace ?? "wp/v2";
3992      const entity = {
3993        kind: "postType",
3994        baseURL: `/$namespace}/$postType.rest_base}`,
3995        baseURLParams: { context: "edit" },
3996        name,
3997        label: postType.name,
3998        transientEdits: {
3999          ...blocksTransientEdits,
4000          selection: true
4001        },
4002        mergedEdits: { meta: true },
4003        rawAttributes: POST_RAW_ATTRIBUTES,
4004        getTitle: (record) => record?.title?.rendered || record?.title || (isTemplate ? capitalCase(record.slug ?? "") : String(record.id)),
4005        __unstablePrePersist: isTemplate ? void 0 : prePersistPostType,
4006        __unstable_rest_base: postType.rest_base,
4007        supportsPagination: true,
4008        getRevisionsUrl: (parentId, revisionId) => `/$namespace}/$postType.rest_base}/$parentId}/revisions$revisionId ? "/" + revisionId : ""}`,
4009        revisionKey: DEFAULT_ENTITY_KEY
4010      };
4011      if (window.__experimentalEnableSync) {
4012        if (false) {}
4013      }
4014      return entity;
4015    });
4016  }
4017  async function loadTaxonomyEntities() {
4018    const taxonomies = await external_wp_apiFetch_default()({
4019      path: "/wp/v2/taxonomies?context=view"
4020    });
4021    return Object.entries(taxonomies ?? {}).map(([name, taxonomy]) => {
4022      const namespace = taxonomy?.rest_namespace ?? "wp/v2";
4023      return {
4024        kind: "taxonomy",
4025        baseURL: `/$namespace}/$taxonomy.rest_base}`,
4026        baseURLParams: { context: "edit" },
4027        name,
4028        label: taxonomy.name,
4029        getTitle: (record) => record?.name,
4030        supportsPagination: true
4031      };
4032    });
4033  }
4034  async function loadSiteEntity() {
4035    const entity = {
4036      label: (0,external_wp_i18n_.__)("Site"),
4037      name: "site",
4038      kind: "root",
4039      key: false,
4040      baseURL: "/wp/v2/settings",
4041      meta: {}
4042    };
4043    if (window.__experimentalEnableSync) {
4044      if (false) {}
4045    }
4046    const site = await external_wp_apiFetch_default()({
4047      path: entity.baseURL,
4048      method: "OPTIONS"
4049    });
4050    const labels = {};
4051    Object.entries(site?.schema?.properties ?? {}).forEach(
4052      ([key, value]) => {
4053        if (typeof value === "object" && value.title) {
4054          labels[key] = value.title;
4055        }
4056      }
4057    );
4058    return [{ ...entity, meta: { labels } }];
4059  }
4060  const getMethodName = (kind, name, prefix = "get") => {
4061    const kindPrefix = kind === "root" ? "" : (0,pascal_case_dist_es2015/* pascalCase */.fL)(kind);
4062    const suffix = (0,pascal_case_dist_es2015/* pascalCase */.fL)(name);
4063    return `$prefix}$kindPrefix}$suffix}`;
4064  };
4065  
4066  
4067  
4068  /***/ }),
4069  
4070  /***/ 6087:
4071  /***/ ((module) => {
4072  
4073  "use strict";
4074  module.exports = window["wp"]["element"];
4075  
4076  /***/ }),
4077  
4078  /***/ 6378:
4079  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
4080  
4081  "use strict";
4082  
4083  // EXPORTS
4084  __webpack_require__.d(__webpack_exports__, {
4085    s: () => (/* binding */ lock),
4086    T: () => (/* binding */ unlock)
4087  });
4088  
4089  ;// external ["wp","privateApis"]
4090  const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
4091  ;// ./node_modules/@wordpress/core-data/build-module/lock-unlock.js
4092  
4093  const { lock, unlock } = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
4094    "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
4095    "@wordpress/core-data"
4096  );
4097  
4098  
4099  
4100  /***/ }),
4101  
4102  /***/ 6384:
4103  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
4104  
4105  "use strict";
4106  // ESM COMPAT FLAG
4107  __webpack_require__.r(__webpack_exports__);
4108  
4109  // EXPORTS
4110  __webpack_require__.d(__webpack_exports__, {
4111    __experimentalGetCurrentGlobalStylesId: () => (/* binding */ __experimentalGetCurrentGlobalStylesId),
4112    __experimentalGetCurrentThemeBaseGlobalStyles: () => (/* binding */ __experimentalGetCurrentThemeBaseGlobalStyles),
4113    __experimentalGetCurrentThemeGlobalStylesVariations: () => (/* binding */ __experimentalGetCurrentThemeGlobalStylesVariations),
4114    canUser: () => (/* binding */ canUser),
4115    canUserEditEntityRecord: () => (/* binding */ canUserEditEntityRecord),
4116    getAuthors: () => (/* binding */ getAuthors),
4117    getAutosave: () => (/* binding */ getAutosave),
4118    getAutosaves: () => (/* binding */ getAutosaves),
4119    getBlockPatternCategories: () => (/* binding */ getBlockPatternCategories),
4120    getBlockPatterns: () => (/* binding */ getBlockPatterns),
4121    getCurrentTheme: () => (/* binding */ getCurrentTheme),
4122    getCurrentThemeGlobalStylesRevisions: () => (/* binding */ getCurrentThemeGlobalStylesRevisions),
4123    getCurrentUser: () => (/* binding */ getCurrentUser),
4124    getDefaultTemplateId: () => (/* binding */ getDefaultTemplateId),
4125    getEditedEntityRecord: () => (/* binding */ getEditedEntityRecord),
4126    getEmbedPreview: () => (/* binding */ getEmbedPreview),
4127    getEntitiesConfig: () => (/* binding */ getEntitiesConfig),
4128    getEntityRecord: () => (/* binding */ getEntityRecord),
4129    getEntityRecords: () => (/* binding */ getEntityRecords),
4130    getEntityRecordsTotalItems: () => (/* binding */ getEntityRecordsTotalItems),
4131    getEntityRecordsTotalPages: () => (/* binding */ getEntityRecordsTotalPages),
4132    getNavigationFallbackId: () => (/* binding */ getNavigationFallbackId),
4133    getRawEntityRecord: () => (/* binding */ getRawEntityRecord),
4134    getRegisteredPostMeta: () => (/* binding */ getRegisteredPostMeta),
4135    getRevision: () => (/* binding */ getRevision),
4136    getRevisions: () => (/* binding */ getRevisions),
4137    getThemeSupports: () => (/* binding */ getThemeSupports),
4138    getUserPatternCategories: () => (/* binding */ getUserPatternCategories)
4139  });
4140  
4141  // EXTERNAL MODULE: ./node_modules/camel-case/dist.es2015/index.js
4142  var dist_es2015 = __webpack_require__(5663);
4143  // EXTERNAL MODULE: external ["wp","url"]
4144  var external_wp_url_ = __webpack_require__(3832);
4145  // EXTERNAL MODULE: external ["wp","htmlEntities"]
4146  var external_wp_htmlEntities_ = __webpack_require__(8537);
4147  // EXTERNAL MODULE: external ["wp","apiFetch"]
4148  var external_wp_apiFetch_ = __webpack_require__(1455);
4149  var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_);
4150  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/name.js
4151  var build_module_name = __webpack_require__(2278);
4152  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/entities.js + 2 modules
4153  var entities = __webpack_require__(5914);
4154  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/utils/get-normalized-comma-separable.js
4155  var get_normalized_comma_separable = __webpack_require__(533);
4156  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/utils/user-permissions.js
4157  var user_permissions = __webpack_require__(2577);
4158  ;// ./node_modules/@wordpress/core-data/build-module/utils/forward-resolver.js
4159  const forwardResolver = (resolverName) => (...args) => async ({ resolveSelect }) => {
4160    await resolveSelect[resolverName](...args);
4161  };
4162  var forward_resolver_default = forwardResolver;
4163  
4164  
4165  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/utils/receive-intermediate-results.js
4166  var receive_intermediate_results = __webpack_require__(5101);
4167  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/fetch/index.js + 2 modules
4168  var fetch = __webpack_require__(7006);
4169  ;// ./node_modules/@wordpress/core-data/build-module/resolvers.js
4170  
4171  
4172  
4173  
4174  
4175  
4176  
4177  
4178  
4179  const getAuthors = (query) => async ({ dispatch }) => {
4180    const path = (0,external_wp_url_.addQueryArgs)(
4181      "/wp/v2/users/?who=authors&per_page=100",
4182      query
4183    );
4184    const users = await external_wp_apiFetch_default()({ path });
4185    dispatch.receiveUserQuery(path, users);
4186  };
4187  const getCurrentUser = () => async ({ dispatch }) => {
4188    const currentUser = await external_wp_apiFetch_default()({ path: "/wp/v2/users/me" });
4189    dispatch.receiveCurrentUser(currentUser);
4190  };
4191  const getEntityRecord = (kind, name, key = "", query) => async ({ select, dispatch, registry, resolveSelect }) => {
4192    const configs = await resolveSelect.getEntitiesConfig(kind);
4193    const entityConfig = configs.find(
4194      (config) => config.name === name && config.kind === kind
4195    );
4196    if (!entityConfig) {
4197      return;
4198    }
4199    const lock = await dispatch.__unstableAcquireStoreLock(
4200      build_module_name/* STORE_NAME */.E,
4201      ["entities", "records", kind, name, key],
4202      { exclusive: false }
4203    );
4204    try {
4205      if (query !== void 0 && query._fields) {
4206        query = {
4207          ...query,
4208          _fields: [
4209            .../* @__PURE__ */ new Set([
4210              ...(0,get_normalized_comma_separable/* default */.A)(query._fields) || [],
4211              entityConfig.key || entities/* DEFAULT_ENTITY_KEY */.C_
4212            ])
4213          ].join()
4214        };
4215      }
4216      if (query !== void 0 && query._fields) {
4217        const hasRecord = select.hasEntityRecord(
4218          kind,
4219          name,
4220          key,
4221          query
4222        );
4223        if (hasRecord) {
4224          return;
4225        }
4226      }
4227      let { baseURL } = entityConfig;
4228      if (kind === "postType" && name === "wp_template" && key && typeof key === "string" && !/^\d+$/.test(key)) {
4229        baseURL = baseURL.slice(0, baseURL.lastIndexOf("/")) + "/templates";
4230      }
4231      const path = (0,external_wp_url_.addQueryArgs)(baseURL + (key ? "/" + key : ""), {
4232        ...entityConfig.baseURLParams,
4233        ...query
4234      });
4235      const response = await external_wp_apiFetch_default()({ path, parse: false });
4236      const record = await response.json();
4237      const permissions = (0,user_permissions/* getUserPermissionsFromAllowHeader */.qY)(
4238        response.headers?.get("allow")
4239      );
4240      const canUserResolutionsArgs = [];
4241      const receiveUserPermissionArgs = {};
4242      for (const action of user_permissions/* ALLOWED_RESOURCE_ACTIONS */.CO) {
4243        receiveUserPermissionArgs[(0,user_permissions/* getUserPermissionCacheKey */.kC)(action, {
4244          kind,
4245          name,
4246          id: key
4247        })] = permissions[action];
4248        canUserResolutionsArgs.push([
4249          action,
4250          { kind, name, id: key }
4251        ]);
4252      }
4253      if (window.__experimentalEnableSync && entityConfig.syncConfig && !query) {
4254        if (false) {}
4255      }
4256      registry.batch(() => {
4257        dispatch.receiveEntityRecords(kind, name, record, query);
4258        dispatch.receiveUserPermissions(receiveUserPermissionArgs);
4259        dispatch.finishResolutions("canUser", canUserResolutionsArgs);
4260      });
4261    } finally {
4262      dispatch.__unstableReleaseStoreLock(lock);
4263    }
4264  };
4265  getEntityRecord.shouldInvalidate = (action, kind, name) => {
4266    return kind === "root" && name === "site" && (action.type === "RECEIVE_ITEMS" && // Making sure persistedEdits is set seems to be the only way of
4267    // knowing whether it's an update or fetch. Only an update would
4268    // have persistedEdits.
4269    action.persistedEdits && action.persistedEdits.status !== "auto-draft" || action.type === "REMOVE_ITEMS") && action.kind === "postType" && action.name === "wp_template";
4270  };
4271  const getRawEntityRecord = forward_resolver_default("getEntityRecord");
4272  const getEditedEntityRecord = forward_resolver_default("getEntityRecord");
4273  const getEntityRecords = (kind, name, query = {}) => async ({ dispatch, registry, resolveSelect }) => {
4274    const configs = await resolveSelect.getEntitiesConfig(kind);
4275    const entityConfig = configs.find(
4276      (config) => config.name === name && config.kind === kind
4277    );
4278    if (!entityConfig) {
4279      return;
4280    }
4281    const lock = await dispatch.__unstableAcquireStoreLock(
4282      build_module_name/* STORE_NAME */.E,
4283      ["entities", "records", kind, name],
4284      { exclusive: false }
4285    );
4286    const rawQuery = { ...query };
4287    const key = entityConfig.key || entities/* DEFAULT_ENTITY_KEY */.C_;
4288    function getResolutionsArgs(records, recordsQuery) {
4289      const queryArgs = Object.fromEntries(
4290        Object.entries(recordsQuery).filter(([k, v]) => {
4291          return ["context", "_fields"].includes(k) && !!v;
4292        })
4293      );
4294      return records.filter((record) => record?.[key]).map((record) => [
4295        kind,
4296        name,
4297        record[key],
4298        Object.keys(queryArgs).length > 0 ? queryArgs : void 0
4299      ]);
4300    }
4301    try {
4302      if (query._fields) {
4303        query = {
4304          ...query,
4305          _fields: [
4306            .../* @__PURE__ */ new Set([
4307              ...(0,get_normalized_comma_separable/* default */.A)(query._fields) || [],
4308              key
4309            ])
4310          ].join()
4311        };
4312      }
4313      let { baseURL } = entityConfig;
4314      const { combinedTemplates = true } = query;
4315      if (kind === "postType" && name === "wp_template" && combinedTemplates) {
4316        baseURL = baseURL.slice(0, baseURL.lastIndexOf("/")) + "/templates";
4317      }
4318      const path = (0,external_wp_url_.addQueryArgs)(baseURL, {
4319        ...entityConfig.baseURLParams,
4320        ...query
4321      });
4322      let records = [], meta;
4323      if (entityConfig.supportsPagination && query.per_page !== -1) {
4324        const response = await external_wp_apiFetch_default()({ path, parse: false });
4325        records = Object.values(await response.json());
4326        meta = {
4327          totalItems: parseInt(
4328            response.headers.get("X-WP-Total")
4329          ),
4330          totalPages: parseInt(
4331            response.headers.get("X-WP-TotalPages")
4332          )
4333        };
4334      } else if (query.per_page === -1 && query[receive_intermediate_results/* RECEIVE_INTERMEDIATE_RESULTS */.Z] === true) {
4335        let page = 1;
4336        let totalPages;
4337        do {
4338          const response = await external_wp_apiFetch_default()({
4339            path: (0,external_wp_url_.addQueryArgs)(path, { page, per_page: 100 }),
4340            parse: false
4341          });
4342          const pageRecords = Object.values(await response.json());
4343          totalPages = parseInt(
4344            response.headers.get("X-WP-TotalPages")
4345          );
4346          if (!meta) {
4347            meta = {
4348              totalItems: parseInt(
4349                response.headers.get("X-WP-Total")
4350              ),
4351              totalPages: 1
4352            };
4353          }
4354          records.push(...pageRecords);
4355          registry.batch(() => {
4356            dispatch.receiveEntityRecords(
4357              kind,
4358              name,
4359              records,
4360              query,
4361              false,
4362              void 0,
4363              meta
4364            );
4365            dispatch.finishResolutions(
4366              "getEntityRecord",
4367              getResolutionsArgs(pageRecords, rawQuery)
4368            );
4369          });
4370          page++;
4371        } while (page <= totalPages);
4372      } else {
4373        records = Object.values(await external_wp_apiFetch_default()({ path }));
4374        meta = {
4375          totalItems: records.length,
4376          totalPages: 1
4377        };
4378      }
4379      if (query._fields) {
4380        records = records.map((record) => {
4381          query._fields.split(",").forEach((field) => {
4382            if (!record.hasOwnProperty(field)) {
4383              record[field] = void 0;
4384            }
4385          });
4386          return record;
4387        });
4388      }
4389      registry.batch(() => {
4390        dispatch.receiveEntityRecords(
4391          kind,
4392          name,
4393          records,
4394          query,
4395          false,
4396          void 0,
4397          meta
4398        );
4399        const targetHints = records.filter(
4400          (record) => !!record?.[key] && !!record?._links?.self?.[0]?.targetHints?.allow
4401        ).map((record) => ({
4402          id: record[key],
4403          permissions: (0,user_permissions/* getUserPermissionsFromAllowHeader */.qY)(
4404            record._links.self[0].targetHints.allow
4405          )
4406        }));
4407        const canUserResolutionsArgs = [];
4408        const receiveUserPermissionArgs = {};
4409        for (const targetHint of targetHints) {
4410          for (const action of user_permissions/* ALLOWED_RESOURCE_ACTIONS */.CO) {
4411            canUserResolutionsArgs.push([
4412              action,
4413              { kind, name, id: targetHint.id }
4414            ]);
4415            receiveUserPermissionArgs[(0,user_permissions/* getUserPermissionCacheKey */.kC)(action, {
4416              kind,
4417              name,
4418              id: targetHint.id
4419            })] = targetHint.permissions[action];
4420          }
4421        }
4422        if (targetHints.length > 0) {
4423          dispatch.receiveUserPermissions(
4424            receiveUserPermissionArgs
4425          );
4426          dispatch.finishResolutions(
4427            "canUser",
4428            canUserResolutionsArgs
4429          );
4430        }
4431        dispatch.finishResolutions(
4432          "getEntityRecord",
4433          getResolutionsArgs(records, rawQuery)
4434        );
4435        dispatch.__unstableReleaseStoreLock(lock);
4436      });
4437    } catch (e) {
4438      dispatch.__unstableReleaseStoreLock(lock);
4439    }
4440  };
4441  getEntityRecords.shouldInvalidate = (action, kind, name) => {
4442    return (action.type === "RECEIVE_ITEMS" || action.type === "REMOVE_ITEMS") && action.invalidateCache && kind === action.kind && name === action.name;
4443  };
4444  const getEntityRecordsTotalItems = forward_resolver_default("getEntityRecords");
4445  const getEntityRecordsTotalPages = forward_resolver_default("getEntityRecords");
4446  const getCurrentTheme = () => async ({ dispatch, resolveSelect }) => {
4447    const activeThemes = await resolveSelect.getEntityRecords(
4448      "root",
4449      "theme",
4450      { status: "active" }
4451    );
4452    dispatch.receiveCurrentTheme(activeThemes[0]);
4453  };
4454  const getThemeSupports = forward_resolver_default("getCurrentTheme");
4455  const getEmbedPreview = (url) => async ({ dispatch }) => {
4456    try {
4457      const embedProxyResponse = await external_wp_apiFetch_default()({
4458        path: (0,external_wp_url_.addQueryArgs)("/oembed/1.0/proxy", { url })
4459      });
4460      dispatch.receiveEmbedPreview(url, embedProxyResponse);
4461    } catch (error) {
4462      dispatch.receiveEmbedPreview(url, false);
4463    }
4464  };
4465  const canUser = (requestedAction, resource, id) => async ({ dispatch, registry, resolveSelect }) => {
4466    if (!user_permissions/* ALLOWED_RESOURCE_ACTIONS */.CO.includes(requestedAction)) {
4467      throw new Error(`'$requestedAction}' is not a valid action.`);
4468    }
4469    const { hasStartedResolution } = registry.select(build_module_name/* STORE_NAME */.E);
4470    for (const relatedAction of user_permissions/* ALLOWED_RESOURCE_ACTIONS */.CO) {
4471      if (relatedAction === requestedAction) {
4472        continue;
4473      }
4474      const isAlreadyResolving = hasStartedResolution("canUser", [
4475        relatedAction,
4476        resource,
4477        id
4478      ]);
4479      if (isAlreadyResolving) {
4480        return;
4481      }
4482    }
4483    let resourcePath = null;
4484    if (typeof resource === "object") {
4485      if (!resource.kind || !resource.name) {
4486        throw new Error("The entity resource object is not valid.");
4487      }
4488      const configs = await resolveSelect.getEntitiesConfig(
4489        resource.kind
4490      );
4491      const entityConfig = configs.find(
4492        (config) => config.name === resource.name && config.kind === resource.kind
4493      );
4494      if (!entityConfig) {
4495        return;
4496      }
4497      resourcePath = entityConfig.baseURL + (resource.id ? "/" + resource.id : "");
4498    } else {
4499      resourcePath = `/wp/v2/$resource}` + (id ? "/" + id : "");
4500    }
4501    let response;
4502    try {
4503      response = await external_wp_apiFetch_default()({
4504        path: resourcePath,
4505        method: "OPTIONS",
4506        parse: false
4507      });
4508    } catch (error) {
4509      return;
4510    }
4511    const permissions = (0,user_permissions/* getUserPermissionsFromAllowHeader */.qY)(
4512      response.headers?.get("allow")
4513    );
4514    registry.batch(() => {
4515      for (const action of user_permissions/* ALLOWED_RESOURCE_ACTIONS */.CO) {
4516        const key = (0,user_permissions/* getUserPermissionCacheKey */.kC)(action, resource, id);
4517        dispatch.receiveUserPermission(key, permissions[action]);
4518        if (action !== requestedAction) {
4519          dispatch.finishResolution("canUser", [
4520            action,
4521            resource,
4522            id
4523          ]);
4524        }
4525      }
4526    });
4527  };
4528  const canUserEditEntityRecord = (kind, name, recordId) => async ({ dispatch }) => {
4529    await dispatch(canUser("update", { kind, name, id: recordId }));
4530  };
4531  const getAutosaves = (postType, postId) => async ({ dispatch, resolveSelect }) => {
4532    const {
4533      rest_base: restBase,
4534      rest_namespace: restNamespace = "wp/v2",
4535      supports
4536    } = await resolveSelect.getPostType(postType);
4537    if (!supports?.autosave) {
4538      return;
4539    }
4540    const autosaves = await external_wp_apiFetch_default()({
4541      path: `/$restNamespace}/$restBase}/$postId}/autosaves?context=edit`
4542    });
4543    if (autosaves && autosaves.length) {
4544      dispatch.receiveAutosaves(postId, autosaves);
4545    }
4546  };
4547  const getAutosave = (postType, postId) => async ({ resolveSelect }) => {
4548    await resolveSelect.getAutosaves(postType, postId);
4549  };
4550  const __experimentalGetCurrentGlobalStylesId = () => async ({ dispatch, resolveSelect }) => {
4551    const activeThemes = await resolveSelect.getEntityRecords(
4552      "root",
4553      "theme",
4554      { status: "active" }
4555    );
4556    const globalStylesURL = activeThemes?.[0]?._links?.["wp:user-global-styles"]?.[0]?.href;
4557    if (!globalStylesURL) {
4558      return;
4559    }
4560    const matches = globalStylesURL.match(/\/(\d+)(?:\?|$)/);
4561    const id = matches ? Number(matches[1]) : null;
4562    if (id) {
4563      dispatch.__experimentalReceiveCurrentGlobalStylesId(id);
4564    }
4565  };
4566  const __experimentalGetCurrentThemeBaseGlobalStyles = () => async ({ resolveSelect, dispatch }) => {
4567    const currentTheme = await resolveSelect.getCurrentTheme();
4568    const themeGlobalStyles = await external_wp_apiFetch_default()({
4569      path: `/wp/v2/global-styles/themes/$currentTheme.stylesheet}?context=view`
4570    });
4571    dispatch.__experimentalReceiveThemeBaseGlobalStyles(
4572      currentTheme.stylesheet,
4573      themeGlobalStyles
4574    );
4575  };
4576  const __experimentalGetCurrentThemeGlobalStylesVariations = () => async ({ resolveSelect, dispatch }) => {
4577    const currentTheme = await resolveSelect.getCurrentTheme();
4578    const variations = await external_wp_apiFetch_default()({
4579      path: `/wp/v2/global-styles/themes/$currentTheme.stylesheet}/variations?context=view`
4580    });
4581    dispatch.__experimentalReceiveThemeGlobalStyleVariations(
4582      currentTheme.stylesheet,
4583      variations
4584    );
4585  };
4586  const getCurrentThemeGlobalStylesRevisions = () => async ({ resolveSelect, dispatch }) => {
4587    const globalStylesId = await resolveSelect.__experimentalGetCurrentGlobalStylesId();
4588    const record = globalStylesId ? await resolveSelect.getEntityRecord(
4589      "root",
4590      "globalStyles",
4591      globalStylesId
4592    ) : void 0;
4593    const revisionsURL = record?._links?.["version-history"]?.[0]?.href;
4594    if (revisionsURL) {
4595      const resetRevisions = await external_wp_apiFetch_default()({
4596        url: revisionsURL
4597      });
4598      const revisions = resetRevisions?.map(
4599        (revision) => Object.fromEntries(
4600          Object.entries(revision).map(([key, value]) => [
4601            (0,dist_es2015/* camelCase */.xQ)(key),
4602            value
4603          ])
4604        )
4605      );
4606      dispatch.receiveThemeGlobalStyleRevisions(
4607        globalStylesId,
4608        revisions
4609      );
4610    }
4611  };
4612  getCurrentThemeGlobalStylesRevisions.shouldInvalidate = (action) => {
4613    return action.type === "SAVE_ENTITY_RECORD_FINISH" && action.kind === "root" && !action.error && action.name === "globalStyles";
4614  };
4615  const getBlockPatterns = () => async ({ dispatch }) => {
4616    const patterns = await (0,fetch/* fetchBlockPatterns */.l$)();
4617    dispatch({ type: "RECEIVE_BLOCK_PATTERNS", patterns });
4618  };
4619  const getBlockPatternCategories = () => async ({ dispatch }) => {
4620    const categories = await external_wp_apiFetch_default()({
4621      path: "/wp/v2/block-patterns/categories"
4622    });
4623    dispatch({ type: "RECEIVE_BLOCK_PATTERN_CATEGORIES", categories });
4624  };
4625  const getUserPatternCategories = () => async ({ dispatch, resolveSelect }) => {
4626    const patternCategories = await resolveSelect.getEntityRecords(
4627      "taxonomy",
4628      "wp_pattern_category",
4629      {
4630        per_page: -1,
4631        _fields: "id,name,description,slug",
4632        context: "view"
4633      }
4634    );
4635    const mappedPatternCategories = patternCategories?.map((userCategory) => ({
4636      ...userCategory,
4637      label: (0,external_wp_htmlEntities_.decodeEntities)(userCategory.name),
4638      name: userCategory.slug
4639    })) || [];
4640    dispatch({
4641      type: "RECEIVE_USER_PATTERN_CATEGORIES",
4642      patternCategories: mappedPatternCategories
4643    });
4644  };
4645  const getNavigationFallbackId = () => async ({ dispatch, select, registry }) => {
4646    const fallback = await external_wp_apiFetch_default()({
4647      path: (0,external_wp_url_.addQueryArgs)("/wp-block-editor/v1/navigation-fallback", {
4648        _embed: true
4649      })
4650    });
4651    const record = fallback?._embedded?.self;
4652    registry.batch(() => {
4653      dispatch.receiveNavigationFallbackId(fallback?.id);
4654      if (!record) {
4655        return;
4656      }
4657      const existingFallbackEntityRecord = select.getEntityRecord(
4658        "postType",
4659        "wp_navigation",
4660        fallback.id
4661      );
4662      const invalidateNavigationQueries = !existingFallbackEntityRecord;
4663      dispatch.receiveEntityRecords(
4664        "postType",
4665        "wp_navigation",
4666        record,
4667        void 0,
4668        invalidateNavigationQueries
4669      );
4670      dispatch.finishResolution("getEntityRecord", [
4671        "postType",
4672        "wp_navigation",
4673        fallback.id
4674      ]);
4675    });
4676  };
4677  const getDefaultTemplateId = (query) => async ({ dispatch, registry, resolveSelect }) => {
4678    const template = await external_wp_apiFetch_default()({
4679      path: (0,external_wp_url_.addQueryArgs)("/wp/v2/templates/lookup", query)
4680    });
4681    await resolveSelect.getEntitiesConfig("postType");
4682    const id = template?.wp_id || template?.id;
4683    if (id) {
4684      template.id = id;
4685      registry.batch(() => {
4686        dispatch.receiveDefaultTemplateId(query, id);
4687        dispatch.receiveEntityRecords("postType", template.type, [
4688          template
4689        ]);
4690        dispatch.finishResolution("getEntityRecord", [
4691          "postType",
4692          template.type,
4693          id
4694        ]);
4695      });
4696    }
4697  };
4698  getDefaultTemplateId.shouldInvalidate = (action) => {
4699    return action.type === "RECEIVE_ITEMS" && action.kind === "root" && action.name === "site";
4700  };
4701  const getRevisions = (kind, name, recordKey, query = {}) => async ({ dispatch, registry, resolveSelect }) => {
4702    const configs = await resolveSelect.getEntitiesConfig(kind);
4703    const entityConfig = configs.find(
4704      (config) => config.name === name && config.kind === kind
4705    );
4706    if (!entityConfig) {
4707      return;
4708    }
4709    if (query._fields) {
4710      query = {
4711        ...query,
4712        _fields: [
4713          .../* @__PURE__ */ new Set([
4714            ...(0,get_normalized_comma_separable/* default */.A)(query._fields) || [],
4715            entityConfig.revisionKey || entities/* DEFAULT_ENTITY_KEY */.C_
4716          ])
4717        ].join()
4718      };
4719    }
4720    const path = (0,external_wp_url_.addQueryArgs)(
4721      entityConfig.getRevisionsUrl(recordKey),
4722      query
4723    );
4724    let records, response;
4725    const meta = {};
4726    const isPaginated = entityConfig.supportsPagination && query.per_page !== -1;
4727    try {
4728      response = await external_wp_apiFetch_default()({ path, parse: !isPaginated });
4729    } catch (error) {
4730      return;
4731    }
4732    if (response) {
4733      if (isPaginated) {
4734        records = Object.values(await response.json());
4735        meta.totalItems = parseInt(
4736          response.headers.get("X-WP-Total")
4737        );
4738      } else {
4739        records = Object.values(response);
4740      }
4741      if (query._fields) {
4742        records = records.map((record) => {
4743          query._fields.split(",").forEach((field) => {
4744            if (!record.hasOwnProperty(field)) {
4745              record[field] = void 0;
4746            }
4747          });
4748          return record;
4749        });
4750      }
4751      registry.batch(() => {
4752        dispatch.receiveRevisions(
4753          kind,
4754          name,
4755          recordKey,
4756          records,
4757          query,
4758          false,
4759          meta
4760        );
4761        if (!query?._fields && !query.context) {
4762          const key = entityConfig.key || entities/* DEFAULT_ENTITY_KEY */.C_;
4763          const resolutionsArgs = records.filter((record) => record[key]).map((record) => [
4764            kind,
4765            name,
4766            recordKey,
4767            record[key]
4768          ]);
4769          dispatch.finishResolutions(
4770            "getRevision",
4771            resolutionsArgs
4772          );
4773        }
4774      });
4775    }
4776  };
4777  getRevisions.shouldInvalidate = (action, kind, name, recordKey) => action.type === "SAVE_ENTITY_RECORD_FINISH" && name === action.name && kind === action.kind && !action.error && recordKey === action.recordId;
4778  const getRevision = (kind, name, recordKey, revisionKey, query) => async ({ dispatch, resolveSelect }) => {
4779    const configs = await resolveSelect.getEntitiesConfig(kind);
4780    const entityConfig = configs.find(
4781      (config) => config.name === name && config.kind === kind
4782    );
4783    if (!entityConfig) {
4784      return;
4785    }
4786    if (query !== void 0 && query._fields) {
4787      query = {
4788        ...query,
4789        _fields: [
4790          .../* @__PURE__ */ new Set([
4791            ...(0,get_normalized_comma_separable/* default */.A)(query._fields) || [],
4792            entityConfig.revisionKey || entities/* DEFAULT_ENTITY_KEY */.C_
4793          ])
4794        ].join()
4795      };
4796    }
4797    const path = (0,external_wp_url_.addQueryArgs)(
4798      entityConfig.getRevisionsUrl(recordKey, revisionKey),
4799      query
4800    );
4801    let record;
4802    try {
4803      record = await external_wp_apiFetch_default()({ path });
4804    } catch (error) {
4805      return;
4806    }
4807    if (record) {
4808      dispatch.receiveRevisions(kind, name, recordKey, record, query);
4809    }
4810  };
4811  const getRegisteredPostMeta = (postType) => async ({ dispatch, resolveSelect }) => {
4812    let options;
4813    try {
4814      const {
4815        rest_namespace: restNamespace = "wp/v2",
4816        rest_base: restBase
4817      } = await resolveSelect.getPostType(postType) || {};
4818      options = await external_wp_apiFetch_default()({
4819        path: `$restNamespace}/$restBase}/?context=edit`,
4820        method: "OPTIONS"
4821      });
4822    } catch (error) {
4823      return;
4824    }
4825    if (options) {
4826      dispatch.receiveRegisteredPostMeta(
4827        postType,
4828        options?.schema?.properties?.meta?.properties
4829      );
4830    }
4831  };
4832  const getEntitiesConfig = (kind) => async ({ dispatch }) => {
4833    const loader = entities/* additionalEntityConfigLoaders */.L2.find(
4834      (l) => l.kind === kind
4835    );
4836    if (!loader) {
4837      return;
4838    }
4839    try {
4840      const configs = await loader.loadEntities();
4841      if (!configs.length) {
4842        return;
4843      }
4844      dispatch.addEntities(configs);
4845    } catch {
4846    }
4847  };
4848  
4849  
4850  
4851  /***/ }),
4852  
4853  /***/ 7006:
4854  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
4855  
4856  "use strict";
4857  
4858  // EXPORTS
4859  __webpack_require__.d(__webpack_exports__, {
4860    Y3: () => (/* reexport */ fetchLinkSuggestions),
4861    gr: () => (/* reexport */ experimental_fetch_url_data_default),
4862    l$: () => (/* binding */ fetchBlockPatterns)
4863  });
4864  
4865  // EXTERNAL MODULE: ./node_modules/camel-case/dist.es2015/index.js
4866  var dist_es2015 = __webpack_require__(5663);
4867  // EXTERNAL MODULE: external ["wp","apiFetch"]
4868  var external_wp_apiFetch_ = __webpack_require__(1455);
4869  var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_);
4870  // EXTERNAL MODULE: external ["wp","url"]
4871  var external_wp_url_ = __webpack_require__(3832);
4872  // EXTERNAL MODULE: external ["wp","htmlEntities"]
4873  var external_wp_htmlEntities_ = __webpack_require__(8537);
4874  // EXTERNAL MODULE: external ["wp","i18n"]
4875  var external_wp_i18n_ = __webpack_require__(7723);
4876  ;// ./node_modules/@wordpress/core-data/build-module/fetch/__experimental-fetch-link-suggestions.js
4877  
4878  
4879  
4880  
4881  async function fetchLinkSuggestions(search, searchOptions = {}, editorSettings = {}) {
4882    const searchOptionsToUse = searchOptions.isInitialSuggestions && searchOptions.initialSuggestionsSearchOptions ? {
4883      ...searchOptions,
4884      ...searchOptions.initialSuggestionsSearchOptions
4885    } : searchOptions;
4886    const {
4887      type,
4888      subtype,
4889      page,
4890      perPage = searchOptions.isInitialSuggestions ? 3 : 20
4891    } = searchOptionsToUse;
4892    const { disablePostFormats = false } = editorSettings;
4893    const queries = [];
4894    if (!type || type === "post") {
4895      queries.push(
4896        external_wp_apiFetch_default()({
4897          path: (0,external_wp_url_.addQueryArgs)("/wp/v2/search", {
4898            search,
4899            page,
4900            per_page: perPage,
4901            type: "post",
4902            subtype
4903          })
4904        }).then((results2) => {
4905          return results2.map((result) => {
4906            return {
4907              id: result.id,
4908              url: result.url,
4909              title: (0,external_wp_htmlEntities_.decodeEntities)(result.title || "") || (0,external_wp_i18n_.__)("(no title)"),
4910              type: result.subtype || result.type,
4911              kind: "post-type"
4912            };
4913          });
4914        }).catch(() => [])
4915        // Fail by returning no results.
4916      );
4917    }
4918    if (!type || type === "term") {
4919      queries.push(
4920        external_wp_apiFetch_default()({
4921          path: (0,external_wp_url_.addQueryArgs)("/wp/v2/search", {
4922            search,
4923            page,
4924            per_page: perPage,
4925            type: "term",
4926            subtype
4927          })
4928        }).then((results2) => {
4929          return results2.map((result) => {
4930            return {
4931              id: result.id,
4932              url: result.url,
4933              title: (0,external_wp_htmlEntities_.decodeEntities)(result.title || "") || (0,external_wp_i18n_.__)("(no title)"),
4934              type: result.subtype || result.type,
4935              kind: "taxonomy"
4936            };
4937          });
4938        }).catch(() => [])
4939        // Fail by returning no results.
4940      );
4941    }
4942    if (!disablePostFormats && (!type || type === "post-format")) {
4943      queries.push(
4944        external_wp_apiFetch_default()({
4945          path: (0,external_wp_url_.addQueryArgs)("/wp/v2/search", {
4946            search,
4947            page,
4948            per_page: perPage,
4949            type: "post-format",
4950            subtype
4951          })
4952        }).then((results2) => {
4953          return results2.map((result) => {
4954            return {
4955              id: result.id,
4956              url: result.url,
4957              title: (0,external_wp_htmlEntities_.decodeEntities)(result.title || "") || (0,external_wp_i18n_.__)("(no title)"),
4958              type: result.subtype || result.type,
4959              kind: "taxonomy"
4960            };
4961          });
4962        }).catch(() => [])
4963        // Fail by returning no results.
4964      );
4965    }
4966    if (!type || type === "attachment") {
4967      queries.push(
4968        external_wp_apiFetch_default()({
4969          path: (0,external_wp_url_.addQueryArgs)("/wp/v2/media", {
4970            search,
4971            page,
4972            per_page: perPage
4973          })
4974        }).then((results2) => {
4975          return results2.map((result) => {
4976            return {
4977              id: result.id,
4978              url: result.source_url,
4979              title: (0,external_wp_htmlEntities_.decodeEntities)(result.title.rendered || "") || (0,external_wp_i18n_.__)("(no title)"),
4980              type: result.type,
4981              kind: "media"
4982            };
4983          });
4984        }).catch(() => [])
4985        // Fail by returning no results.
4986      );
4987    }
4988    const responses = await Promise.all(queries);
4989    let results = responses.flat();
4990    results = results.filter((result) => !!result.id);
4991    results = sortResults(results, search);
4992    results = results.slice(0, perPage);
4993    return results;
4994  }
4995  function sortResults(results, search) {
4996    const searchTokens = tokenize(search);
4997    const scores = {};
4998    for (const result of results) {
4999      if (result.title) {
5000        const titleTokens = tokenize(result.title);
5001        const exactMatchingTokens = titleTokens.filter(
5002          (titleToken) => searchTokens.some(
5003            (searchToken) => titleToken === searchToken
5004          )
5005        );
5006        const subMatchingTokens = titleTokens.filter(
5007          (titleToken) => searchTokens.some(
5008            (searchToken) => titleToken !== searchToken && titleToken.includes(searchToken)
5009          )
5010        );
5011        const exactMatchScore = exactMatchingTokens.length / titleTokens.length * 10;
5012        const subMatchScore = subMatchingTokens.length / titleTokens.length;
5013        scores[result.id] = exactMatchScore + subMatchScore;
5014      } else {
5015        scores[result.id] = 0;
5016      }
5017    }
5018    return results.sort((a, b) => scores[b.id] - scores[a.id]);
5019  }
5020  function tokenize(text) {
5021    return text.toLowerCase().match(/[\p{L}\p{N}]+/gu) || [];
5022  }
5023  
5024  
5025  ;// ./node_modules/@wordpress/core-data/build-module/fetch/__experimental-fetch-url-data.js
5026  
5027  
5028  const CACHE = /* @__PURE__ */ new Map();
5029  const fetchUrlData = async (url, options = {}) => {
5030    const endpoint = "/wp-block-editor/v1/url-details";
5031    const args = {
5032      url: (0,external_wp_url_.prependHTTP)(url)
5033    };
5034    if (!(0,external_wp_url_.isURL)(url)) {
5035      return Promise.reject(`$url} is not a valid URL.`);
5036    }
5037    const protocol = (0,external_wp_url_.getProtocol)(url);
5038    if (!protocol || !(0,external_wp_url_.isValidProtocol)(protocol) || !protocol.startsWith("http") || !/^https?:\/\/[^\/\s]/i.test(url)) {
5039      return Promise.reject(
5040        `$url} does not have a valid protocol. URLs must be "http" based`
5041      );
5042    }
5043    if (CACHE.has(url)) {
5044      return CACHE.get(url);
5045    }
5046    return external_wp_apiFetch_default()({
5047      path: (0,external_wp_url_.addQueryArgs)(endpoint, args),
5048      ...options
5049    }).then((res) => {
5050      CACHE.set(url, res);
5051      return res;
5052    });
5053  };
5054  var experimental_fetch_url_data_default = fetchUrlData;
5055  
5056  
5057  ;// ./node_modules/@wordpress/core-data/build-module/fetch/index.js
5058  
5059  
5060  
5061  
5062  async function fetchBlockPatterns() {
5063    const restPatterns = await external_wp_apiFetch_default()({
5064      path: "/wp/v2/block-patterns/patterns"
5065    });
5066    if (!restPatterns) {
5067      return [];
5068    }
5069    return restPatterns.map(
5070      (pattern) => Object.fromEntries(
5071        Object.entries(pattern).map(([key, value]) => [
5072          (0,dist_es2015/* camelCase */.xQ)(key),
5073          value
5074        ])
5075      )
5076    );
5077  }
5078  
5079  
5080  
5081  /***/ }),
5082  
5083  /***/ 7078:
5084  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
5085  
5086  "use strict";
5087  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
5088  /* harmony export */   Ay: () => (/* binding */ useEntityRecords),
5089  /* harmony export */   bM: () => (/* binding */ __experimentalUseEntityRecords),
5090  /* harmony export */   pU: () => (/* binding */ useEntityRecordsWithPermissions)
5091  /* harmony export */ });
5092  /* harmony import */ var _wordpress_url__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3832);
5093  /* harmony import */ var _wordpress_url__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_url__WEBPACK_IMPORTED_MODULE_0__);
5094  /* harmony import */ var _wordpress_deprecated__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4040);
5095  /* harmony import */ var _wordpress_deprecated__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_deprecated__WEBPACK_IMPORTED_MODULE_1__);
5096  /* harmony import */ var _wordpress_data__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7143);
5097  /* harmony import */ var _wordpress_data__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_wordpress_data__WEBPACK_IMPORTED_MODULE_2__);
5098  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6087);
5099  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_3__);
5100  /* harmony import */ var _use_query_select__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(7541);
5101  /* harmony import */ var ___WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4565);
5102  /* harmony import */ var _lock_unlock__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(6378);
5103  /* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(533);
5104  
5105  
5106  
5107  
5108  
5109  
5110  
5111  
5112  const EMPTY_ARRAY = [];
5113  function useEntityRecords(kind, name, queryArgs = {}, options = { enabled: true }) {
5114    const queryAsString = (0,_wordpress_url__WEBPACK_IMPORTED_MODULE_0__.addQueryArgs)("", queryArgs);
5115    const { data: records, ...rest } = (0,_use_query_select__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A)(
5116      (query) => {
5117        if (!options.enabled) {
5118          return {
5119            // Avoiding returning a new reference on every execution.
5120            data: EMPTY_ARRAY
5121          };
5122        }
5123        return query(___WEBPACK_IMPORTED_MODULE_4__.store).getEntityRecords(kind, name, queryArgs);
5124      },
5125      [kind, name, queryAsString, options.enabled]
5126    );
5127    const { totalItems, totalPages } = (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_2__.useSelect)(
5128      (select) => {
5129        if (!options.enabled) {
5130          return {
5131            totalItems: null,
5132            totalPages: null
5133          };
5134        }
5135        return {
5136          totalItems: select(___WEBPACK_IMPORTED_MODULE_4__.store).getEntityRecordsTotalItems(
5137            kind,
5138            name,
5139            queryArgs
5140          ),
5141          totalPages: select(___WEBPACK_IMPORTED_MODULE_4__.store).getEntityRecordsTotalPages(
5142            kind,
5143            name,
5144            queryArgs
5145          )
5146        };
5147      },
5148      [kind, name, queryAsString, options.enabled]
5149    );
5150    return {
5151      records,
5152      totalItems,
5153      totalPages,
5154      ...rest
5155    };
5156  }
5157  function __experimentalUseEntityRecords(kind, name, queryArgs, options) {
5158    _wordpress_deprecated__WEBPACK_IMPORTED_MODULE_1___default()(`wp.data.__experimentalUseEntityRecords`, {
5159      alternative: "wp.data.useEntityRecords",
5160      since: "6.1"
5161    });
5162    return useEntityRecords(kind, name, queryArgs, options);
5163  }
5164  function useEntityRecordsWithPermissions(kind, name, queryArgs = {}, options = { enabled: true }) {
5165    const entityConfig = (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_2__.useSelect)(
5166      (select) => select(___WEBPACK_IMPORTED_MODULE_4__.store).getEntityConfig(kind, name),
5167      [kind, name]
5168    );
5169    const { records: data, ...ret } = useEntityRecords(
5170      kind,
5171      name,
5172      {
5173        ...queryArgs,
5174        // If _fields is provided, we need to include _links in the request for permission caching to work.
5175        ...queryArgs._fields ? {
5176          _fields: [
5177            .../* @__PURE__ */ new Set([
5178              ...(0,_utils__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A)(
5179                queryArgs._fields
5180              ) || [],
5181              "_links"
5182            ])
5183          ].join()
5184        } : {}
5185      },
5186      options
5187    );
5188    const ids = (0,_wordpress_element__WEBPACK_IMPORTED_MODULE_3__.useMemo)(
5189      () => data?.map(
5190        // @ts-ignore
5191        (record) => record[entityConfig?.key ?? "id"]
5192      ) ?? [],
5193      [data, entityConfig?.key]
5194    );
5195    const permissions = (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_2__.useSelect)(
5196      (select) => {
5197        const { getEntityRecordsPermissions } = (0,_lock_unlock__WEBPACK_IMPORTED_MODULE_7__/* .unlock */ .T)(
5198          select(___WEBPACK_IMPORTED_MODULE_4__.store)
5199        );
5200        return getEntityRecordsPermissions(kind, name, ids);
5201      },
5202      [ids, kind, name]
5203    );
5204    const dataWithPermissions = (0,_wordpress_element__WEBPACK_IMPORTED_MODULE_3__.useMemo)(
5205      () => data?.map((record, index) => ({
5206        // @ts-ignore
5207        ...record,
5208        permissions: permissions[index]
5209      })) ?? [],
5210      [data, permissions]
5211    );
5212    return { records: dataWithPermissions, ...ret };
5213  }
5214  
5215  
5216  
5217  /***/ }),
5218  
5219  /***/ 7143:
5220  /***/ ((module) => {
5221  
5222  "use strict";
5223  module.exports = window["wp"]["data"];
5224  
5225  /***/ }),
5226  
5227  /***/ 7314:
5228  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
5229  
5230  "use strict";
5231  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
5232  /* harmony export */   g: () => (/* binding */ lowerCase)
5233  /* harmony export */ });
5234  /* unused harmony export localeLowerCase */
5235  /**
5236   * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
5237   */
5238  var SUPPORTED_LOCALE = {
5239      tr: {
5240          regexp: /\u0130|\u0049|\u0049\u0307/g,
5241          map: {
5242              İ: "\u0069",
5243              I: "\u0131",
5244              İ: "\u0069",
5245          },
5246      },
5247      az: {
5248          regexp: /\u0130/g,
5249          map: {
5250              İ: "\u0069",
5251              I: "\u0131",
5252              İ: "\u0069",
5253          },
5254      },
5255      lt: {
5256          regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g,
5257          map: {
5258              I: "\u0069\u0307",
5259              J: "\u006A\u0307",
5260              Į: "\u012F\u0307",
5261              Ì: "\u0069\u0307\u0300",
5262              Í: "\u0069\u0307\u0301",
5263              Ĩ: "\u0069\u0307\u0303",
5264          },
5265      },
5266  };
5267  /**
5268   * Localized lower case.
5269   */
5270  function localeLowerCase(str, locale) {
5271      var lang = SUPPORTED_LOCALE[locale.toLowerCase()];
5272      if (lang)
5273          return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; }));
5274      return lowerCase(str);
5275  }
5276  /**
5277   * Lower case as a function.
5278   */
5279  function lowerCase(str) {
5280      return str.toLowerCase();
5281  }
5282  
5283  
5284  /***/ }),
5285  
5286  /***/ 7541:
5287  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
5288  
5289  "use strict";
5290  
5291  // EXPORTS
5292  __webpack_require__.d(__webpack_exports__, {
5293    A: () => (/* binding */ useQuerySelect)
5294  });
5295  
5296  // UNUSED EXPORTS: META_SELECTORS
5297  
5298  // EXTERNAL MODULE: external ["wp","data"]
5299  var external_wp_data_ = __webpack_require__(7143);
5300  ;// ./node_modules/memize/dist/index.js
5301  /**
5302   * Memize options object.
5303   *
5304   * @typedef MemizeOptions
5305   *
5306   * @property {number} [maxSize] Maximum size of the cache.
5307   */
5308  
5309  /**
5310   * Internal cache entry.
5311   *
5312   * @typedef MemizeCacheNode
5313   *
5314   * @property {?MemizeCacheNode|undefined} [prev] Previous node.
5315   * @property {?MemizeCacheNode|undefined} [next] Next node.
5316   * @property {Array<*>}                   args   Function arguments for cache
5317   *                                               entry.
5318   * @property {*}                          val    Function result.
5319   */
5320  
5321  /**
5322   * Properties of the enhanced function for controlling cache.
5323   *
5324   * @typedef MemizeMemoizedFunction
5325   *
5326   * @property {()=>void} clear Clear the cache.
5327   */
5328  
5329  /**
5330   * Accepts a function to be memoized, and returns a new memoized function, with
5331   * optional options.
5332   *
5333   * @template {(...args: any[]) => any} F
5334   *
5335   * @param {F}             fn        Function to memoize.
5336   * @param {MemizeOptions} [options] Options object.
5337   *
5338   * @return {((...args: Parameters<F>) => ReturnType<F>) & MemizeMemoizedFunction} Memoized function.
5339   */
5340  function memize(fn, options) {
5341      var size = 0;
5342  
5343      /** @type {?MemizeCacheNode|undefined} */
5344      var head;
5345  
5346      /** @type {?MemizeCacheNode|undefined} */
5347      var tail;
5348  
5349      options = options || {};
5350  
5351  	function memoized(/* ...args */) {
5352          var node = head,
5353              len = arguments.length,
5354              args,
5355              i;
5356  
5357          searchCache: while (node) {
5358              // Perform a shallow equality test to confirm that whether the node
5359              // under test is a candidate for the arguments passed. Two arrays
5360              // are shallowly equal if their length matches and each entry is
5361              // strictly equal between the two sets. Avoid abstracting to a
5362              // function which could incur an arguments leaking deoptimization.
5363  
5364              // Check whether node arguments match arguments length
5365              if (node.args.length !== arguments.length) {
5366                  node = node.next;
5367                  continue;
5368              }
5369  
5370              // Check whether node arguments match arguments values
5371              for (i = 0; i < len; i++) {
5372                  if (node.args[i] !== arguments[i]) {
5373                      node = node.next;
5374                      continue searchCache;
5375                  }
5376              }
5377  
5378              // At this point we can assume we've found a match
5379  
5380              // Surface matched node to head if not already
5381              if (node !== head) {
5382                  // As tail, shift to previous. Must only shift if not also
5383                  // head, since if both head and tail, there is no previous.
5384                  if (node === tail) {
5385                      tail = node.prev;
5386                  }
5387  
5388                  // Adjust siblings to point to each other. If node was tail,
5389                  // this also handles new tail's empty `next` assignment.
5390                  /** @type {MemizeCacheNode} */ (node.prev).next = node.next;
5391                  if (node.next) {
5392                      node.next.prev = node.prev;
5393                  }
5394  
5395                  node.next = head;
5396                  node.prev = null;
5397                  /** @type {MemizeCacheNode} */ (head).prev = node;
5398                  head = node;
5399              }
5400  
5401              // Return immediately
5402              return node.val;
5403          }
5404  
5405          // No cached value found. Continue to insertion phase:
5406  
5407          // Create a copy of arguments (avoid leaking deoptimization)
5408          args = new Array(len);
5409          for (i = 0; i < len; i++) {
5410              args[i] = arguments[i];
5411          }
5412  
5413          node = {
5414              args: args,
5415  
5416              // Generate the result from original function
5417              val: fn.apply(null, args),
5418          };
5419  
5420          // Don't need to check whether node is already head, since it would
5421          // have been returned above already if it was
5422  
5423          // Shift existing head down list
5424          if (head) {
5425              head.prev = node;
5426              node.next = head;
5427          } else {
5428              // If no head, follows that there's no tail (at initial or reset)
5429              tail = node;
5430          }
5431  
5432          // Trim tail if we're reached max size and are pending cache insertion
5433          if (size === /** @type {MemizeOptions} */ (options).maxSize) {
5434              tail = /** @type {MemizeCacheNode} */ (tail).prev;
5435              /** @type {MemizeCacheNode} */ (tail).next = null;
5436          } else {
5437              size++;
5438          }
5439  
5440          head = node;
5441  
5442          return node.val;
5443      }
5444  
5445      memoized.clear = function () {
5446          head = null;
5447          tail = null;
5448          size = 0;
5449      };
5450  
5451      // Ignore reason: There's not a clear solution to create an intersection of
5452      // the function with additional properties, where the goal is to retain the
5453      // function signature of the incoming argument and add control properties
5454      // on the return value.
5455  
5456      // @ts-ignore
5457      return memoized;
5458  }
5459  
5460  
5461  
5462  ;// ./node_modules/@wordpress/core-data/build-module/hooks/memoize.js
5463  
5464  var memoize_default = memize;
5465  
5466  
5467  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/hooks/constants.js
5468  var constants = __webpack_require__(2859);
5469  ;// ./node_modules/@wordpress/core-data/build-module/hooks/use-query-select.js
5470  
5471  
5472  
5473  const META_SELECTORS = [
5474    "getIsResolving",
5475    "hasStartedResolution",
5476    "hasFinishedResolution",
5477    "isResolving",
5478    "getCachedResolvers"
5479  ];
5480  function useQuerySelect(mapQuerySelect, deps) {
5481    return (0,external_wp_data_.useSelect)((select, registry) => {
5482      const resolve = (store) => enrichSelectors(select(store));
5483      return mapQuerySelect(resolve, registry);
5484    }, deps);
5485  }
5486  const enrichSelectors = memoize_default(((selectors) => {
5487    const resolvers = {};
5488    for (const selectorName in selectors) {
5489      if (META_SELECTORS.includes(selectorName)) {
5490        continue;
5491      }
5492      Object.defineProperty(resolvers, selectorName, {
5493        get: () => (...args) => {
5494          const data = selectors[selectorName](...args);
5495          const resolutionStatus = selectors.getResolutionState(
5496            selectorName,
5497            args
5498          )?.status;
5499          let status;
5500          switch (resolutionStatus) {
5501            case "resolving":
5502              status = constants/* Status */.n.Resolving;
5503              break;
5504            case "finished":
5505              status = constants/* Status */.n.Success;
5506              break;
5507            case "error":
5508              status = constants/* Status */.n.Error;
5509              break;
5510            case void 0:
5511              status = constants/* Status */.n.Idle;
5512              break;
5513          }
5514          return {
5515            data,
5516            status,
5517            isResolving: status === constants/* Status */.n.Resolving,
5518            hasStarted: status !== constants/* Status */.n.Idle,
5519            hasResolved: status === constants/* Status */.n.Success || status === constants/* Status */.n.Error
5520          };
5521        }
5522      });
5523    }
5524    return resolvers;
5525  }));
5526  
5527  
5528  
5529  /***/ }),
5530  
5531  /***/ 7723:
5532  /***/ ((module) => {
5533  
5534  "use strict";
5535  module.exports = window["wp"]["i18n"];
5536  
5537  /***/ }),
5538  
5539  /***/ 7734:
5540  /***/ ((module) => {
5541  
5542  "use strict";
5543  
5544  
5545  // do not edit .js files directly - edit src/index.jst
5546  
5547  
5548    var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';
5549  
5550  
5551  module.exports = function equal(a, b) {
5552    if (a === b) return true;
5553  
5554    if (a && b && typeof a == 'object' && typeof b == 'object') {
5555      if (a.constructor !== b.constructor) return false;
5556  
5557      var length, i, keys;
5558      if (Array.isArray(a)) {
5559        length = a.length;
5560        if (length != b.length) return false;
5561        for (i = length; i-- !== 0;)
5562          if (!equal(a[i], b[i])) return false;
5563        return true;
5564      }
5565  
5566  
5567      if ((a instanceof Map) && (b instanceof Map)) {
5568        if (a.size !== b.size) return false;
5569        for (i of a.entries())
5570          if (!b.has(i[0])) return false;
5571        for (i of a.entries())
5572          if (!equal(i[1], b.get(i[0]))) return false;
5573        return true;
5574      }
5575  
5576      if ((a instanceof Set) && (b instanceof Set)) {
5577        if (a.size !== b.size) return false;
5578        for (i of a.entries())
5579          if (!b.has(i[0])) return false;
5580        return true;
5581      }
5582  
5583      if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
5584        length = a.length;
5585        if (length != b.length) return false;
5586        for (i = length; i-- !== 0;)
5587          if (a[i] !== b[i]) return false;
5588        return true;
5589      }
5590  
5591  
5592      if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
5593      if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
5594      if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
5595  
5596      keys = Object.keys(a);
5597      length = keys.length;
5598      if (length !== Object.keys(b).length) return false;
5599  
5600      for (i = length; i-- !== 0;)
5601        if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
5602  
5603      for (i = length; i-- !== 0;) {
5604        var key = keys[i];
5605  
5606        if (!equal(a[key], b[key])) return false;
5607      }
5608  
5609      return true;
5610    }
5611  
5612    // true if both NaN, false otherwise
5613    return a!==a && b!==b;
5614  };
5615  
5616  
5617  /***/ }),
5618  
5619  /***/ 7826:
5620  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
5621  
5622  "use strict";
5623  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
5624  /* harmony export */   j: () => (/* binding */ privateApis)
5625  /* harmony export */ });
5626  /* harmony import */ var _hooks_use_entity_records__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7078);
5627  /* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5101);
5628  /* harmony import */ var _lock_unlock__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6378);
5629  
5630  
5631  
5632  const privateApis = {};
5633  (0,_lock_unlock__WEBPACK_IMPORTED_MODULE_0__/* .lock */ .s)(privateApis, {
5634    useEntityRecordsWithPermissions: _hooks_use_entity_records__WEBPACK_IMPORTED_MODULE_1__/* .useEntityRecordsWithPermissions */ .pU,
5635    RECEIVE_INTERMEDIATE_RESULTS: _utils__WEBPACK_IMPORTED_MODULE_2__/* .RECEIVE_INTERMEDIATE_RESULTS */ .Z
5636  });
5637  
5638  
5639  
5640  /***/ }),
5641  
5642  /***/ 8368:
5643  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
5644  
5645  "use strict";
5646  // ESM COMPAT FLAG
5647  __webpack_require__.r(__webpack_exports__);
5648  
5649  // EXPORTS
5650  __webpack_require__.d(__webpack_exports__, {
5651    __experimentalGetCurrentGlobalStylesId: () => (/* binding */ __experimentalGetCurrentGlobalStylesId),
5652    __experimentalGetCurrentThemeBaseGlobalStyles: () => (/* binding */ __experimentalGetCurrentThemeBaseGlobalStyles),
5653    __experimentalGetCurrentThemeGlobalStylesVariations: () => (/* binding */ __experimentalGetCurrentThemeGlobalStylesVariations),
5654    __experimentalGetDirtyEntityRecords: () => (/* binding */ __experimentalGetDirtyEntityRecords),
5655    __experimentalGetEntitiesBeingSaved: () => (/* binding */ __experimentalGetEntitiesBeingSaved),
5656    __experimentalGetEntityRecordNoResolver: () => (/* binding */ __experimentalGetEntityRecordNoResolver),
5657    canUser: () => (/* binding */ canUser),
5658    canUserEditEntityRecord: () => (/* binding */ canUserEditEntityRecord),
5659    getAuthors: () => (/* binding */ getAuthors),
5660    getAutosave: () => (/* binding */ getAutosave),
5661    getAutosaves: () => (/* binding */ getAutosaves),
5662    getBlockPatternCategories: () => (/* binding */ getBlockPatternCategories),
5663    getBlockPatterns: () => (/* binding */ getBlockPatterns),
5664    getCurrentTheme: () => (/* binding */ getCurrentTheme),
5665    getCurrentThemeGlobalStylesRevisions: () => (/* binding */ getCurrentThemeGlobalStylesRevisions),
5666    getCurrentUser: () => (/* binding */ getCurrentUser),
5667    getDefaultTemplateId: () => (/* binding */ getDefaultTemplateId),
5668    getEditedEntityRecord: () => (/* binding */ getEditedEntityRecord),
5669    getEmbedPreview: () => (/* binding */ getEmbedPreview),
5670    getEntitiesByKind: () => (/* binding */ getEntitiesByKind),
5671    getEntitiesConfig: () => (/* binding */ getEntitiesConfig),
5672    getEntity: () => (/* binding */ getEntity),
5673    getEntityConfig: () => (/* binding */ getEntityConfig),
5674    getEntityRecord: () => (/* binding */ getEntityRecord),
5675    getEntityRecordEdits: () => (/* binding */ getEntityRecordEdits),
5676    getEntityRecordNonTransientEdits: () => (/* binding */ getEntityRecordNonTransientEdits),
5677    getEntityRecords: () => (/* binding */ getEntityRecords),
5678    getEntityRecordsTotalItems: () => (/* binding */ getEntityRecordsTotalItems),
5679    getEntityRecordsTotalPages: () => (/* binding */ getEntityRecordsTotalPages),
5680    getLastEntityDeleteError: () => (/* binding */ getLastEntityDeleteError),
5681    getLastEntitySaveError: () => (/* binding */ getLastEntitySaveError),
5682    getRawEntityRecord: () => (/* binding */ getRawEntityRecord),
5683    getRedoEdit: () => (/* binding */ getRedoEdit),
5684    getReferenceByDistinctEdits: () => (/* binding */ getReferenceByDistinctEdits),
5685    getRevision: () => (/* binding */ getRevision),
5686    getRevisions: () => (/* binding */ getRevisions),
5687    getThemeSupports: () => (/* binding */ getThemeSupports),
5688    getUndoEdit: () => (/* binding */ getUndoEdit),
5689    getUserPatternCategories: () => (/* binding */ getUserPatternCategories),
5690    getUserQueryResults: () => (/* binding */ getUserQueryResults),
5691    hasEditsForEntityRecord: () => (/* binding */ hasEditsForEntityRecord),
5692    hasEntityRecord: () => (/* binding */ hasEntityRecord),
5693    hasEntityRecords: () => (/* binding */ hasEntityRecords),
5694    hasFetchedAutosaves: () => (/* binding */ hasFetchedAutosaves),
5695    hasRedo: () => (/* binding */ hasRedo),
5696    hasUndo: () => (/* binding */ hasUndo),
5697    isAutosavingEntityRecord: () => (/* binding */ isAutosavingEntityRecord),
5698    isDeletingEntityRecord: () => (/* binding */ isDeletingEntityRecord),
5699    isPreviewEmbedFallback: () => (/* binding */ isPreviewEmbedFallback),
5700    isRequestingEmbedPreview: () => (/* binding */ isRequestingEmbedPreview),
5701    isSavingEntityRecord: () => (/* binding */ isSavingEntityRecord)
5702  });
5703  
5704  // EXTERNAL MODULE: external ["wp","data"]
5705  var external_wp_data_ = __webpack_require__(7143);
5706  // EXTERNAL MODULE: external ["wp","url"]
5707  var external_wp_url_ = __webpack_require__(3832);
5708  // EXTERNAL MODULE: external ["wp","deprecated"]
5709  var external_wp_deprecated_ = __webpack_require__(4040);
5710  var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_);
5711  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/name.js
5712  var build_module_name = __webpack_require__(2278);
5713  // EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js
5714  var equivalent_key_map = __webpack_require__(3249);
5715  var equivalent_key_map_default = /*#__PURE__*/__webpack_require__.n(equivalent_key_map);
5716  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/queried-data/get-query-parts.js + 1 modules
5717  var get_query_parts = __webpack_require__(4027);
5718  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/utils/set-nested-value.js
5719  var set_nested_value = __webpack_require__(5003);
5720  ;// ./node_modules/@wordpress/core-data/build-module/queried-data/selectors.js
5721  
5722  
5723  
5724  
5725  const queriedItemsCacheByState = /* @__PURE__ */ new WeakMap();
5726  function getQueriedItemsUncached(state, query) {
5727    const { stableKey, page, perPage, include, fields, context } = (0,get_query_parts/* default */.A)(query);
5728    let itemIds;
5729    if (state.queries?.[context]?.[stableKey]) {
5730      itemIds = state.queries[context][stableKey].itemIds;
5731    }
5732    if (!itemIds) {
5733      return null;
5734    }
5735    const startOffset = perPage === -1 ? 0 : (page - 1) * perPage;
5736    const endOffset = perPage === -1 ? itemIds.length : Math.min(startOffset + perPage, itemIds.length);
5737    const items = [];
5738    for (let i = startOffset; i < endOffset; i++) {
5739      const itemId = itemIds[i];
5740      if (Array.isArray(include) && !include.includes(itemId)) {
5741        continue;
5742      }
5743      if (itemId === void 0) {
5744        continue;
5745      }
5746      if (!state.items[context]?.hasOwnProperty(itemId)) {
5747        return null;
5748      }
5749      const item = state.items[context][itemId];
5750      let filteredItem;
5751      if (Array.isArray(fields)) {
5752        filteredItem = {};
5753        for (let f = 0; f < fields.length; f++) {
5754          const field = fields[f].split(".");
5755          let value = item;
5756          field.forEach((fieldName) => {
5757            value = value?.[fieldName];
5758          });
5759          (0,set_nested_value/* default */.A)(filteredItem, field, value);
5760        }
5761      } else {
5762        if (!state.itemIsComplete[context]?.[itemId]) {
5763          return null;
5764        }
5765        filteredItem = item;
5766      }
5767      items.push(filteredItem);
5768    }
5769    return items;
5770  }
5771  const getQueriedItems = (0,external_wp_data_.createSelector)((state, query = {}) => {
5772    let queriedItemsCache = queriedItemsCacheByState.get(state);
5773    if (queriedItemsCache) {
5774      const queriedItems = queriedItemsCache.get(query);
5775      if (queriedItems !== void 0) {
5776        return queriedItems;
5777      }
5778    } else {
5779      queriedItemsCache = new (equivalent_key_map_default())();
5780      queriedItemsCacheByState.set(state, queriedItemsCache);
5781    }
5782    const items = getQueriedItemsUncached(state, query);
5783    queriedItemsCache.set(query, items);
5784    return items;
5785  });
5786  function getQueriedTotalItems(state, query = {}) {
5787    const { stableKey, context } = (0,get_query_parts/* default */.A)(query);
5788    return state.queries?.[context]?.[stableKey]?.meta?.totalItems ?? null;
5789  }
5790  function getQueriedTotalPages(state, query = {}) {
5791    const { stableKey, context } = (0,get_query_parts/* default */.A)(query);
5792    return state.queries?.[context]?.[stableKey]?.meta?.totalPages ?? null;
5793  }
5794  
5795  
5796  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/entities.js + 2 modules
5797  var entities = __webpack_require__(5914);
5798  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/utils/get-normalized-comma-separable.js
5799  var get_normalized_comma_separable = __webpack_require__(533);
5800  ;// ./node_modules/@wordpress/core-data/build-module/utils/is-numeric-id.js
5801  function isNumericID(id) {
5802    return /^\s*\d+\s*$/.test(id);
5803  }
5804  
5805  
5806  ;// ./node_modules/@wordpress/core-data/build-module/utils/is-raw-attribute.js
5807  function isRawAttribute(entity, attribute) {
5808    return (entity.rawAttributes || []).includes(attribute);
5809  }
5810  
5811  
5812  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/utils/user-permissions.js
5813  var user_permissions = __webpack_require__(2577);
5814  // EXTERNAL MODULE: ./node_modules/@wordpress/core-data/build-module/utils/log-entity-deprecation.js
5815  var log_entity_deprecation = __webpack_require__(9410);
5816  ;// ./node_modules/@wordpress/core-data/build-module/selectors.js
5817  
5818  
5819  
5820  
5821  
5822  
5823  
5824  
5825  const EMPTY_OBJECT = {};
5826  const isRequestingEmbedPreview = (0,external_wp_data_.createRegistrySelector)(
5827    (select) => (state, url) => {
5828      return select(build_module_name/* STORE_NAME */.E).isResolving("getEmbedPreview", [
5829        url
5830      ]);
5831    }
5832  );
5833  function getAuthors(state, query) {
5834    external_wp_deprecated_default()("select( 'core' ).getAuthors()", {
5835      since: "5.9",
5836      alternative: "select( 'core' ).getUsers({ who: 'authors' })"
5837    });
5838    const path = (0,external_wp_url_.addQueryArgs)(
5839      "/wp/v2/users/?who=authors&per_page=100",
5840      query
5841    );
5842    return getUserQueryResults(state, path);
5843  }
5844  function getCurrentUser(state) {
5845    return state.currentUser;
5846  }
5847  const getUserQueryResults = (0,external_wp_data_.createSelector)(
5848    (state, queryID) => {
5849      const queryResults = state.users.queries[queryID] ?? [];
5850      return queryResults.map((id) => state.users.byId[id]);
5851    },
5852    (state, queryID) => [
5853      state.users.queries[queryID],
5854      state.users.byId
5855    ]
5856  );
5857  function getEntitiesByKind(state, kind) {
5858    external_wp_deprecated_default()("wp.data.select( 'core' ).getEntitiesByKind()", {
5859      since: "6.0",
5860      alternative: "wp.data.select( 'core' ).getEntitiesConfig()"
5861    });
5862    return getEntitiesConfig(state, kind);
5863  }
5864  const getEntitiesConfig = (0,external_wp_data_.createSelector)(
5865    (state, kind) => state.entities.config.filter((entity) => entity.kind === kind),
5866    /* eslint-disable @typescript-eslint/no-unused-vars */
5867    (state, kind) => state.entities.config
5868    /* eslint-enable @typescript-eslint/no-unused-vars */
5869  );
5870  function getEntity(state, kind, name) {
5871    external_wp_deprecated_default()("wp.data.select( 'core' ).getEntity()", {
5872      since: "6.0",
5873      alternative: "wp.data.select( 'core' ).getEntityConfig()"
5874    });
5875    return getEntityConfig(state, kind, name);
5876  }
5877  function getEntityConfig(state, kind, name) {
5878    (0,log_entity_deprecation/* default */.A)(kind, name, "getEntityConfig");
5879    return state.entities.config?.find(
5880      (config) => config.kind === kind && config.name === name
5881    );
5882  }
5883  const getEntityRecord = (0,external_wp_data_.createSelector)(
5884    ((state, kind, name, key, query) => {
5885      (0,log_entity_deprecation/* default */.A)(kind, name, "getEntityRecord");
5886      const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
5887      if (!queriedState) {
5888        return void 0;
5889      }
5890      const context = query?.context ?? "default";
5891      if (!query || !query._fields) {
5892        if (!queriedState.itemIsComplete[context]?.[key]) {
5893          return void 0;
5894        }
5895        return queriedState.items[context][key];
5896      }
5897      const item = queriedState.items[context]?.[key];
5898      if (!item) {
5899        return item;
5900      }
5901      const filteredItem = {};
5902      const fields = (0,get_normalized_comma_separable/* default */.A)(query._fields) ?? [];
5903      for (let f = 0; f < fields.length; f++) {
5904        const field = fields[f].split(".");
5905        let value = item;
5906        field.forEach((fieldName) => {
5907          value = value?.[fieldName];
5908        });
5909        (0,set_nested_value/* default */.A)(filteredItem, field, value);
5910      }
5911      return filteredItem;
5912    }),
5913    (state, kind, name, recordId, query) => {
5914      const context = query?.context ?? "default";
5915      const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
5916      return [
5917        queriedState?.items[context]?.[recordId],
5918        queriedState?.itemIsComplete[context]?.[recordId]
5919      ];
5920    }
5921  );
5922  getEntityRecord.__unstableNormalizeArgs = (args) => {
5923    const newArgs = [...args];
5924    const recordKey = newArgs?.[2];
5925    newArgs[2] = isNumericID(recordKey) ? Number(recordKey) : recordKey;
5926    return newArgs;
5927  };
5928  function hasEntityRecord(state, kind, name, key, query) {
5929    const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
5930    if (!queriedState) {
5931      return false;
5932    }
5933    const context = query?.context ?? "default";
5934    if (!query || !query._fields) {
5935      return !!queriedState.itemIsComplete[context]?.[key];
5936    }
5937    const item = queriedState.items[context]?.[key];
5938    if (!item) {
5939      return false;
5940    }
5941    const fields = (0,get_normalized_comma_separable/* default */.A)(query._fields) ?? [];
5942    for (let i = 0; i < fields.length; i++) {
5943      const path = fields[i].split(".");
5944      let value = item;
5945      for (let p = 0; p < path.length; p++) {
5946        const part = path[p];
5947        if (!value || !Object.hasOwn(value, part)) {
5948          return false;
5949        }
5950        value = value[part];
5951      }
5952    }
5953    return true;
5954  }
5955  function __experimentalGetEntityRecordNoResolver(state, kind, name, key) {
5956    return getEntityRecord(state, kind, name, key);
5957  }
5958  const getRawEntityRecord = (0,external_wp_data_.createSelector)(
5959    (state, kind, name, key) => {
5960      (0,log_entity_deprecation/* default */.A)(kind, name, "getRawEntityRecord");
5961      const record = getEntityRecord(
5962        state,
5963        kind,
5964        name,
5965        key
5966      );
5967      return record && Object.keys(record).reduce((accumulator, _key) => {
5968        if (isRawAttribute(getEntityConfig(state, kind, name), _key)) {
5969          accumulator[_key] = record[_key]?.raw !== void 0 ? record[_key]?.raw : record[_key];
5970        } else {
5971          accumulator[_key] = record[_key];
5972        }
5973        return accumulator;
5974      }, {});
5975    },
5976    (state, kind, name, recordId, query) => {
5977      const context = query?.context ?? "default";
5978      return [
5979        state.entities.config,
5980        state.entities.records?.[kind]?.[name]?.queriedData?.items[context]?.[recordId],
5981        state.entities.records?.[kind]?.[name]?.queriedData?.itemIsComplete[context]?.[recordId]
5982      ];
5983    }
5984  );
5985  function hasEntityRecords(state, kind, name, query) {
5986    (0,log_entity_deprecation/* default */.A)(kind, name, "hasEntityRecords");
5987    return Array.isArray(getEntityRecords(state, kind, name, query));
5988  }
5989  const getEntityRecords = ((state, kind, name, query) => {
5990    (0,log_entity_deprecation/* default */.A)(kind, name, "getEntityRecords");
5991    const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
5992    if (!queriedState) {
5993      return null;
5994    }
5995    return getQueriedItems(queriedState, query);
5996  });
5997  const getEntityRecordsTotalItems = (state, kind, name, query) => {
5998    (0,log_entity_deprecation/* default */.A)(kind, name, "getEntityRecordsTotalItems");
5999    const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
6000    if (!queriedState) {
6001      return null;
6002    }
6003    return getQueriedTotalItems(queriedState, query);
6004  };
6005  const getEntityRecordsTotalPages = (state, kind, name, query) => {
6006    (0,log_entity_deprecation/* default */.A)(kind, name, "getEntityRecordsTotalPages");
6007    const queriedState = state.entities.records?.[kind]?.[name]?.queriedData;
6008    if (!queriedState) {
6009      return null;
6010    }
6011    if (query?.per_page === -1) {
6012      return 1;
6013    }
6014    const totalItems = getQueriedTotalItems(queriedState, query);
6015    if (!totalItems) {
6016      return totalItems;
6017    }
6018    if (!query?.per_page) {
6019      return getQueriedTotalPages(queriedState, query);
6020    }
6021    return Math.ceil(totalItems / query.per_page);
6022  };
6023  const __experimentalGetDirtyEntityRecords = (0,external_wp_data_.createSelector)(
6024    (state) => {
6025      const {
6026        entities: { records }
6027      } = state;
6028      const dirtyRecords = [];
6029      Object.keys(records).forEach((kind) => {
6030        Object.keys(records[kind]).forEach((name) => {
6031          const primaryKeys = Object.keys(records[kind][name].edits).filter(
6032            (primaryKey) => (
6033              // The entity record must exist (not be deleted),
6034              // and it must have edits.
6035              getEntityRecord(state, kind, name, primaryKey) && hasEditsForEntityRecord(state, kind, name, primaryKey)
6036            )
6037          );
6038          if (primaryKeys.length) {
6039            const entityConfig = getEntityConfig(state, kind, name);
6040            primaryKeys.forEach((primaryKey) => {
6041              const entityRecord = getEditedEntityRecord(
6042                state,
6043                kind,
6044                name,
6045                primaryKey
6046              );
6047              dirtyRecords.push({
6048                // We avoid using primaryKey because it's transformed into a string
6049                // when it's used as an object key.
6050                key: entityRecord ? entityRecord[entityConfig.key || entities/* DEFAULT_ENTITY_KEY */.C_] : void 0,
6051                title: entityConfig?.getTitle?.(entityRecord) || "",
6052                name,
6053                kind
6054              });
6055            });
6056          }
6057        });
6058      });
6059      return dirtyRecords;
6060    },
6061    (state) => [state.entities.records]
6062  );
6063  const __experimentalGetEntitiesBeingSaved = (0,external_wp_data_.createSelector)(
6064    (state) => {
6065      const {
6066        entities: { records }
6067      } = state;
6068      const recordsBeingSaved = [];
6069      Object.keys(records).forEach((kind) => {
6070        Object.keys(records[kind]).forEach((name) => {
6071          const primaryKeys = Object.keys(records[kind][name].saving).filter(
6072            (primaryKey) => isSavingEntityRecord(state, kind, name, primaryKey)
6073          );
6074          if (primaryKeys.length) {
6075            const entityConfig = getEntityConfig(state, kind, name);
6076            primaryKeys.forEach((primaryKey) => {
6077              const entityRecord = getEditedEntityRecord(
6078                state,
6079                kind,
6080                name,
6081                primaryKey
6082              );
6083              recordsBeingSaved.push({
6084                // We avoid using primaryKey because it's transformed into a string
6085                // when it's used as an object key.
6086                key: entityRecord ? entityRecord[entityConfig.key || entities/* DEFAULT_ENTITY_KEY */.C_] : void 0,
6087                title: entityConfig?.getTitle?.(entityRecord) || "",
6088                name,
6089                kind
6090              });
6091            });
6092          }
6093        });
6094      });
6095      return recordsBeingSaved;
6096    },
6097    (state) => [state.entities.records]
6098  );
6099  function getEntityRecordEdits(state, kind, name, recordId) {
6100    (0,log_entity_deprecation/* default */.A)(kind, name, "getEntityRecordEdits");
6101    return state.entities.records?.[kind]?.[name]?.edits?.[recordId];
6102  }
6103  const getEntityRecordNonTransientEdits = (0,external_wp_data_.createSelector)(
6104    (state, kind, name, recordId) => {
6105      (0,log_entity_deprecation/* default */.A)(kind, name, "getEntityRecordNonTransientEdits");
6106      const { transientEdits } = getEntityConfig(state, kind, name) || {};
6107      const edits = getEntityRecordEdits(state, kind, name, recordId) || {};
6108      if (!transientEdits) {
6109        return edits;
6110      }
6111      return Object.keys(edits).reduce((acc, key) => {
6112        if (!transientEdits[key]) {
6113          acc[key] = edits[key];
6114        }
6115        return acc;
6116      }, {});
6117    },
6118    (state, kind, name, recordId) => [
6119      state.entities.config,
6120      state.entities.records?.[kind]?.[name]?.edits?.[recordId]
6121    ]
6122  );
6123  function hasEditsForEntityRecord(state, kind, name, recordId) {
6124    (0,log_entity_deprecation/* default */.A)(kind, name, "hasEditsForEntityRecord");
6125    return isSavingEntityRecord(state, kind, name, recordId) || Object.keys(
6126      getEntityRecordNonTransientEdits(state, kind, name, recordId)
6127    ).length > 0;
6128  }
6129  const getEditedEntityRecord = (0,external_wp_data_.createSelector)(
6130    (state, kind, name, recordId) => {
6131      (0,log_entity_deprecation/* default */.A)(kind, name, "getEditedEntityRecord");
6132      const raw = getRawEntityRecord(state, kind, name, recordId);
6133      const edited = getEntityRecordEdits(state, kind, name, recordId);
6134      if (!raw && !edited) {
6135        return false;
6136      }
6137      return {
6138        ...raw,
6139        ...edited
6140      };
6141    },
6142    (state, kind, name, recordId, query) => {
6143      const context = query?.context ?? "default";
6144      return [
6145        state.entities.config,
6146        state.entities.records?.[kind]?.[name]?.queriedData.items[context]?.[recordId],
6147        state.entities.records?.[kind]?.[name]?.queriedData.itemIsComplete[context]?.[recordId],
6148        state.entities.records?.[kind]?.[name]?.edits?.[recordId]
6149      ];
6150    }
6151  );
6152  function isAutosavingEntityRecord(state, kind, name, recordId) {
6153    (0,log_entity_deprecation/* default */.A)(kind, name, "isAutosavingEntityRecord");
6154    const { pending, isAutosave } = state.entities.records?.[kind]?.[name]?.saving?.[recordId] ?? {};
6155    return Boolean(pending && isAutosave);
6156  }
6157  function isSavingEntityRecord(state, kind, name, recordId) {
6158    (0,log_entity_deprecation/* default */.A)(kind, name, "isSavingEntityRecord");
6159    return state.entities.records?.[kind]?.[name]?.saving?.[recordId]?.pending ?? false;
6160  }
6161  function isDeletingEntityRecord(state, kind, name, recordId) {
6162    (0,log_entity_deprecation/* default */.A)(kind, name, "isDeletingEntityRecord");
6163    return state.entities.records?.[kind]?.[name]?.deleting?.[recordId]?.pending ?? false;
6164  }
6165  function getLastEntitySaveError(state, kind, name, recordId) {
6166    (0,log_entity_deprecation/* default */.A)(kind, name, "getLastEntitySaveError");
6167    return state.entities.records?.[kind]?.[name]?.saving?.[recordId]?.error;
6168  }
6169  function getLastEntityDeleteError(state, kind, name, recordId) {
6170    (0,log_entity_deprecation/* default */.A)(kind, name, "getLastEntityDeleteError");
6171    return state.entities.records?.[kind]?.[name]?.deleting?.[recordId]?.error;
6172  }
6173  function getUndoEdit(state) {
6174    external_wp_deprecated_default()("select( 'core' ).getUndoEdit()", {
6175      since: "6.3"
6176    });
6177    return void 0;
6178  }
6179  function getRedoEdit(state) {
6180    external_wp_deprecated_default()("select( 'core' ).getRedoEdit()", {
6181      since: "6.3"
6182    });
6183    return void 0;
6184  }
6185  function hasUndo(state) {
6186    return state.undoManager.hasUndo();
6187  }
6188  function hasRedo(state) {
6189    return state.undoManager.hasRedo();
6190  }
6191  function getCurrentTheme(state) {
6192    if (!state.currentTheme) {
6193      return null;
6194    }
6195    return getEntityRecord(state, "root", "theme", state.currentTheme);
6196  }
6197  function __experimentalGetCurrentGlobalStylesId(state) {
6198    return state.currentGlobalStylesId;
6199  }
6200  function getThemeSupports(state) {
6201    return getCurrentTheme(state)?.theme_supports ?? EMPTY_OBJECT;
6202  }
6203  function getEmbedPreview(state, url) {
6204    return state.embedPreviews[url];
6205  }
6206  function isPreviewEmbedFallback(state, url) {
6207    const preview = state.embedPreviews[url];
6208    const oEmbedLinkCheck = '<a href="' + url + '">' + url + "</a>";
6209    if (!preview) {
6210      return false;
6211    }
6212    return preview.html === oEmbedLinkCheck;
6213  }
6214  function canUser(state, action, resource, id) {
6215    const isEntity = typeof resource === "object";
6216    if (isEntity && (!resource.kind || !resource.name)) {
6217      return false;
6218    }
6219    if (isEntity) {
6220      (0,log_entity_deprecation/* default */.A)(resource.kind, resource.name, "canUser");
6221    }
6222    const key = (0,user_permissions/* getUserPermissionCacheKey */.kC)(action, resource, id);
6223    return state.userPermissions[key];
6224  }
6225  function canUserEditEntityRecord(state, kind, name, recordId) {
6226    external_wp_deprecated_default()(`wp.data.select( 'core' ).canUserEditEntityRecord()`, {
6227      since: "6.7",
6228      alternative: `wp.data.select( 'core' ).canUser( 'update', { kind, name, id } )`
6229    });
6230    return canUser(state, "update", { kind, name, id: recordId });
6231  }
6232  function getAutosaves(state, postType, postId) {
6233    return state.autosaves[postId];
6234  }
6235  function getAutosave(state, postType, postId, authorId) {
6236    if (authorId === void 0) {
6237      return;
6238    }
6239    const autosaves = state.autosaves[postId];
6240    return autosaves?.find(
6241      (autosave) => autosave.author === authorId
6242    );
6243  }
6244  const hasFetchedAutosaves = (0,external_wp_data_.createRegistrySelector)(
6245    (select) => (state, postType, postId) => {
6246      return select(build_module_name/* STORE_NAME */.E).hasFinishedResolution("getAutosaves", [
6247        postType,
6248        postId
6249      ]);
6250    }
6251  );
6252  function getReferenceByDistinctEdits(state) {
6253    return state.editsReference;
6254  }
6255  function __experimentalGetCurrentThemeBaseGlobalStyles(state) {
6256    const currentTheme = getCurrentTheme(state);
6257    if (!currentTheme) {
6258      return null;
6259    }
6260    return state.themeBaseGlobalStyles[currentTheme.stylesheet];
6261  }
6262  function __experimentalGetCurrentThemeGlobalStylesVariations(state) {
6263    const currentTheme = getCurrentTheme(state);
6264    if (!currentTheme) {
6265      return null;
6266    }
6267    return state.themeGlobalStyleVariations[currentTheme.stylesheet];
6268  }
6269  function getBlockPatterns(state) {
6270    return state.blockPatterns;
6271  }
6272  function getBlockPatternCategories(state) {
6273    return state.blockPatternCategories;
6274  }
6275  function getUserPatternCategories(state) {
6276    return state.userPatternCategories;
6277  }
6278  function getCurrentThemeGlobalStylesRevisions(state) {
6279    external_wp_deprecated_default()("select( 'core' ).getCurrentThemeGlobalStylesRevisions()", {
6280      since: "6.5.0",
6281      alternative: "select( 'core' ).getRevisions( 'root', 'globalStyles', ${ recordKey } )"
6282    });
6283    const currentGlobalStylesId = __experimentalGetCurrentGlobalStylesId(state);
6284    if (!currentGlobalStylesId) {
6285      return null;
6286    }
6287    return state.themeGlobalStyleRevisions[currentGlobalStylesId];
6288  }
6289  function getDefaultTemplateId(state, query) {
6290    return state.defaultTemplates[JSON.stringify(query)];
6291  }
6292  const getRevisions = (state, kind, name, recordKey, query) => {
6293    (0,log_entity_deprecation/* default */.A)(kind, name, "getRevisions");
6294    const queriedStateRevisions = state.entities.records?.[kind]?.[name]?.revisions?.[recordKey];
6295    if (!queriedStateRevisions) {
6296      return null;
6297    }
6298    return getQueriedItems(queriedStateRevisions, query);
6299  };
6300  const getRevision = (0,external_wp_data_.createSelector)(
6301    (state, kind, name, recordKey, revisionKey, query) => {
6302      (0,log_entity_deprecation/* default */.A)(kind, name, "getRevision");
6303      const queriedState = state.entities.records?.[kind]?.[name]?.revisions?.[recordKey];
6304      if (!queriedState) {
6305        return void 0;
6306      }
6307      const context = query?.context ?? "default";
6308      if (!query || !query._fields) {
6309        if (!queriedState.itemIsComplete[context]?.[revisionKey]) {
6310          return void 0;
6311        }
6312        return queriedState.items[context][revisionKey];
6313      }
6314      const item = queriedState.items[context]?.[revisionKey];
6315      if (!item) {
6316        return item;
6317      }
6318      const filteredItem = {};
6319      const fields = (0,get_normalized_comma_separable/* default */.A)(query._fields) ?? [];
6320      for (let f = 0; f < fields.length; f++) {
6321        const field = fields[f].split(".");
6322        let value = item;
6323        field.forEach((fieldName) => {
6324          value = value?.[fieldName];
6325        });
6326        (0,set_nested_value/* default */.A)(filteredItem, field, value);
6327      }
6328      return filteredItem;
6329    },
6330    (state, kind, name, recordKey, revisionKey, query) => {
6331      const context = query?.context ?? "default";
6332      const queriedState = state.entities.records?.[kind]?.[name]?.revisions?.[recordKey];
6333      return [
6334        queriedState?.items?.[context]?.[revisionKey],
6335        queriedState?.itemIsComplete?.[context]?.[revisionKey]
6336      ];
6337    }
6338  );
6339  
6340  
6341  
6342  /***/ }),
6343  
6344  /***/ 8537:
6345  /***/ ((module) => {
6346  
6347  "use strict";
6348  module.exports = window["wp"]["htmlEntities"];
6349  
6350  /***/ }),
6351  
6352  /***/ 8582:
6353  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
6354  
6355  "use strict";
6356  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
6357  /* harmony export */   A: () => (/* binding */ dynamicSelectors),
6358  /* harmony export */   B: () => (/* binding */ dynamicActions)
6359  /* harmony export */ });
6360  let dynamicActions;
6361  let dynamicSelectors;
6362  
6363  
6364  
6365  /***/ }),
6366  
6367  /***/ 8741:
6368  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
6369  
6370  "use strict";
6371  __webpack_require__.r(__webpack_exports__);
6372  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
6373  /* harmony export */   getBlockPatternsForPostType: () => (/* binding */ getBlockPatternsForPostType),
6374  /* harmony export */   getEntityRecordPermissions: () => (/* binding */ getEntityRecordPermissions),
6375  /* harmony export */   getEntityRecordsPermissions: () => (/* binding */ getEntityRecordsPermissions),
6376  /* harmony export */   getHomePage: () => (/* binding */ getHomePage),
6377  /* harmony export */   getNavigationFallbackId: () => (/* binding */ getNavigationFallbackId),
6378  /* harmony export */   getPostsPageId: () => (/* binding */ getPostsPageId),
6379  /* harmony export */   getRegisteredPostMeta: () => (/* binding */ getRegisteredPostMeta),
6380  /* harmony export */   getTemplateId: () => (/* binding */ getTemplateId),
6381  /* harmony export */   getUndoManager: () => (/* binding */ getUndoManager)
6382  /* harmony export */ });
6383  /* harmony import */ var _wordpress_data__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7143);
6384  /* harmony import */ var _wordpress_data__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_data__WEBPACK_IMPORTED_MODULE_0__);
6385  /* harmony import */ var _selectors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8368);
6386  /* harmony import */ var _name__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2278);
6387  /* harmony import */ var _lock_unlock__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6378);
6388  /* harmony import */ var _utils_log_entity_deprecation__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9410);
6389  
6390  
6391  
6392  
6393  
6394  function getUndoManager(state) {
6395    return state.undoManager;
6396  }
6397  function getNavigationFallbackId(state) {
6398    return state.navigationFallbackId;
6399  }
6400  const getBlockPatternsForPostType = (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_0__.createRegistrySelector)(
6401    (select) => (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_0__.createSelector)(
6402      (state, postType) => select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E).getBlockPatterns().filter(
6403        ({ postTypes }) => !postTypes || Array.isArray(postTypes) && postTypes.includes(postType)
6404      ),
6405      () => [select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E).getBlockPatterns()]
6406    )
6407  );
6408  const getEntityRecordsPermissions = (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_0__.createRegistrySelector)(
6409    (select) => (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_0__.createSelector)(
6410      (state, kind, name, ids) => {
6411        const normalizedIds = Array.isArray(ids) ? ids : [ids];
6412        return normalizedIds.map((id) => ({
6413          delete: select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E).canUser("delete", {
6414            kind,
6415            name,
6416            id
6417          }),
6418          update: select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E).canUser("update", {
6419            kind,
6420            name,
6421            id
6422          })
6423        }));
6424      },
6425      (state) => [state.userPermissions]
6426    )
6427  );
6428  function getEntityRecordPermissions(state, kind, name, id) {
6429    (0,_utils_log_entity_deprecation__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(kind, name, "getEntityRecordPermissions");
6430    return getEntityRecordsPermissions(state, kind, name, id)[0];
6431  }
6432  function getRegisteredPostMeta(state, postType) {
6433    return state.registeredPostMeta?.[postType] ?? {};
6434  }
6435  function normalizePageId(value) {
6436    if (!value || !["number", "string"].includes(typeof value)) {
6437      return null;
6438    }
6439    if (Number(value) === 0) {
6440      return null;
6441    }
6442    return value.toString();
6443  }
6444  const getHomePage = (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_0__.createRegistrySelector)(
6445    (select) => (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_0__.createSelector)(
6446      () => {
6447        const siteData = select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E).getEntityRecord(
6448          "root",
6449          "__unstableBase"
6450        );
6451        if (!siteData) {
6452          return null;
6453        }
6454        const homepageId = siteData?.show_on_front === "page" ? normalizePageId(siteData.page_on_front) : null;
6455        if (homepageId) {
6456          return { postType: "page", postId: homepageId };
6457        }
6458        const frontPageTemplateId = select(
6459          _name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E
6460        ).getDefaultTemplateId({
6461          slug: "front-page"
6462        });
6463        if (!frontPageTemplateId) {
6464          return null;
6465        }
6466        return { postType: "wp_template", postId: frontPageTemplateId };
6467      },
6468      (state) => [
6469        // Even though getDefaultTemplateId.shouldInvalidate returns true when root/site changes,
6470        // it doesn't seem to invalidate this cache, I'm not sure why.
6471        (0,_selectors__WEBPACK_IMPORTED_MODULE_3__.getEntityRecord)(state, "root", "site"),
6472        (0,_selectors__WEBPACK_IMPORTED_MODULE_3__.getEntityRecord)(state, "root", "__unstableBase"),
6473        (0,_selectors__WEBPACK_IMPORTED_MODULE_3__.getDefaultTemplateId)(state, {
6474          slug: "front-page"
6475        })
6476      ]
6477    )
6478  );
6479  const getPostsPageId = (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_0__.createRegistrySelector)((select) => () => {
6480    const siteData = select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E).getEntityRecord(
6481      "root",
6482      "__unstableBase"
6483    );
6484    return siteData?.show_on_front === "page" ? normalizePageId(siteData.page_for_posts) : null;
6485  });
6486  const getTemplateId = (0,_wordpress_data__WEBPACK_IMPORTED_MODULE_0__.createRegistrySelector)(
6487    (select) => (state, postType, postId) => {
6488      const homepage = (0,_lock_unlock__WEBPACK_IMPORTED_MODULE_4__/* .unlock */ .T)(select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E)).getHomePage();
6489      if (!homepage) {
6490        return;
6491      }
6492      if (postType === "page" && postType === homepage?.postType && postId.toString() === homepage?.postId) {
6493        const templates = select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E).getEntityRecords(
6494          "postType",
6495          "wp_template",
6496          {
6497            per_page: -1
6498          }
6499        );
6500        if (!templates) {
6501          return;
6502        }
6503        const id = templates.find(({ slug }) => slug === "front-page")?.id;
6504        if (id) {
6505          return id;
6506        }
6507      }
6508      const editedEntity = select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E).getEditedEntityRecord(
6509        "postType",
6510        postType,
6511        postId
6512      );
6513      if (!editedEntity) {
6514        return;
6515      }
6516      const postsPageId = (0,_lock_unlock__WEBPACK_IMPORTED_MODULE_4__/* .unlock */ .T)(select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E)).getPostsPageId();
6517      if (postType === "page" && postsPageId === postId.toString()) {
6518        return select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E).getDefaultTemplateId({
6519          slug: "home"
6520        });
6521      }
6522      const currentTemplateSlug = editedEntity.template;
6523      if (currentTemplateSlug) {
6524        const currentTemplate = select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E).getEntityRecords("postType", "wp_template", {
6525          per_page: -1
6526        })?.find(({ slug }) => slug === currentTemplateSlug);
6527        if (currentTemplate) {
6528          return currentTemplate.id;
6529        }
6530      }
6531      let slugToCheck;
6532      if (editedEntity.slug) {
6533        slugToCheck = postType === "page" ? `$postType}-$editedEntity.slug}` : `single-$postType}-$editedEntity.slug}`;
6534      } else {
6535        slugToCheck = postType === "page" ? "page" : `single-$postType}`;
6536      }
6537      return select(_name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E).getDefaultTemplateId({
6538        slug: slugToCheck
6539      });
6540    }
6541  );
6542  
6543  
6544  
6545  /***/ }),
6546  
6547  /***/ 8843:
6548  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
6549  
6550  "use strict";
6551  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
6552  /* harmony export */   D: () => (/* binding */ EntityContext)
6553  /* harmony export */ });
6554  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6087);
6555  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
6556  
6557  const EntityContext = (0,_wordpress_element__WEBPACK_IMPORTED_MODULE_0__.createContext)({});
6558  EntityContext.displayName = "EntityContext";
6559  
6560  
6561  
6562  /***/ }),
6563  
6564  /***/ 9410:
6565  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
6566  
6567  "use strict";
6568  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
6569  /* harmony export */   A: () => (/* binding */ logEntityDeprecation)
6570  /* harmony export */ });
6571  /* harmony import */ var _wordpress_deprecated__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4040);
6572  /* harmony import */ var _wordpress_deprecated__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_deprecated__WEBPACK_IMPORTED_MODULE_0__);
6573  /* harmony import */ var _entities__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5914);
6574  
6575  
6576  let loggedAlready = false;
6577  function logEntityDeprecation(kind, name, functionName, {
6578    alternativeFunctionName,
6579    isShorthandSelector = false
6580  } = {}) {
6581    const deprecation = _entities__WEBPACK_IMPORTED_MODULE_1__/* .deprecatedEntities */ .TK[kind]?.[name];
6582    if (!deprecation) {
6583      return;
6584    }
6585    if (!loggedAlready) {
6586      const { alternative } = deprecation;
6587      const message = isShorthandSelector ? `'$functionName}'` : `The '$kind}', '$name}' entity (used via '$functionName}')`;
6588      let alternativeMessage = `the '$alternative.kind}', '$alternative.name}' entity`;
6589      if (alternativeFunctionName) {
6590        alternativeMessage += ` via the '$alternativeFunctionName}' function`;
6591      }
6592      _wordpress_deprecated__WEBPACK_IMPORTED_MODULE_0___default()(message, {
6593        ...deprecation,
6594        alternative: alternativeMessage
6595      });
6596    }
6597    loggedAlready = true;
6598    setTimeout(() => {
6599      loggedAlready = false;
6600    }, 0);
6601  }
6602  
6603  
6604  
6605  /***/ }),
6606  
6607  /***/ 9424:
6608  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
6609  
6610  "use strict";
6611  __webpack_require__.r(__webpack_exports__);
6612  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
6613  /* harmony export */   editMediaEntity: () => (/* binding */ editMediaEntity),
6614  /* harmony export */   receiveRegisteredPostMeta: () => (/* binding */ receiveRegisteredPostMeta)
6615  /* harmony export */ });
6616  /* harmony import */ var _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1455);
6617  /* harmony import */ var _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0__);
6618  /* harmony import */ var _name__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2278);
6619  
6620  
6621  function receiveRegisteredPostMeta(postType, registeredPostMeta) {
6622    return {
6623      type: "RECEIVE_REGISTERED_POST_META",
6624      postType,
6625      registeredPostMeta
6626    };
6627  }
6628  const editMediaEntity = (recordId, edits = {}, { __unstableFetch = (_wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0___default()), throwOnError = false } = {}) => async ({ dispatch, resolveSelect }) => {
6629    if (!recordId) {
6630      return;
6631    }
6632    const kind = "postType";
6633    const name = "attachment";
6634    const configs = await resolveSelect.getEntitiesConfig(kind);
6635    const entityConfig = configs.find(
6636      (config) => config.kind === kind && config.name === name
6637    );
6638    if (!entityConfig) {
6639      return;
6640    }
6641    const lock = await dispatch.__unstableAcquireStoreLock(
6642      _name__WEBPACK_IMPORTED_MODULE_1__/* .STORE_NAME */ .E,
6643      ["entities", "records", kind, name, recordId],
6644      { exclusive: true }
6645    );
6646    let updatedRecord;
6647    let error;
6648    let hasError = false;
6649    try {
6650      dispatch({
6651        type: "SAVE_ENTITY_RECORD_START",
6652        kind,
6653        name,
6654        recordId
6655      });
6656      try {
6657        const path = `$entityConfig.baseURL}/$recordId}/edit`;
6658        const newRecord = await __unstableFetch({
6659          path,
6660          method: "POST",
6661          data: {
6662            ...edits
6663          }
6664        });
6665        if (newRecord) {
6666          dispatch.receiveEntityRecords(
6667            kind,
6668            name,
6669            [newRecord],
6670            void 0,
6671            true,
6672            void 0,
6673            void 0
6674          );
6675          updatedRecord = newRecord;
6676        }
6677      } catch (e) {
6678        error = e;
6679        hasError = true;
6680      }
6681      dispatch({
6682        type: "SAVE_ENTITY_RECORD_FINISH",
6683        kind,
6684        name,
6685        recordId,
6686        error
6687      });
6688      if (hasError && throwOnError) {
6689        throw error;
6690      }
6691      return updatedRecord;
6692    } finally {
6693      dispatch.__unstableReleaseStoreLock(lock);
6694    }
6695  };
6696  
6697  
6698  
6699  /***/ })
6700  
6701  /******/     });
6702  /************************************************************************/
6703  /******/     // The module cache
6704  /******/     var __webpack_module_cache__ = {};
6705  /******/     
6706  /******/     // The require function
6707  /******/ 	function __webpack_require__(moduleId) {
6708  /******/         // Check if module is in cache
6709  /******/         var cachedModule = __webpack_module_cache__[moduleId];
6710  /******/         if (cachedModule !== undefined) {
6711  /******/             return cachedModule.exports;
6712  /******/         }
6713  /******/         // Create a new module (and put it into the cache)
6714  /******/         var module = __webpack_module_cache__[moduleId] = {
6715  /******/             // no module.id needed
6716  /******/             // no module.loaded needed
6717  /******/             exports: {}
6718  /******/         };
6719  /******/     
6720  /******/         // Execute the module function
6721  /******/         __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
6722  /******/     
6723  /******/         // Return the exports of the module
6724  /******/         return module.exports;
6725  /******/     }
6726  /******/     
6727  /************************************************************************/
6728  /******/     /* webpack/runtime/compat get default export */
6729  /******/     (() => {
6730  /******/         // getDefaultExport function for compatibility with non-harmony modules
6731  /******/         __webpack_require__.n = (module) => {
6732  /******/             var getter = module && module.__esModule ?
6733  /******/                 () => (module['default']) :
6734  /******/                 () => (module);
6735  /******/             __webpack_require__.d(getter, { a: getter });
6736  /******/             return getter;
6737  /******/         };
6738  /******/     })();
6739  /******/     
6740  /******/     /* webpack/runtime/define property getters */
6741  /******/     (() => {
6742  /******/         // define getter functions for harmony exports
6743  /******/         __webpack_require__.d = (exports, definition) => {
6744  /******/             for(var key in definition) {
6745  /******/                 if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
6746  /******/                     Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
6747  /******/                 }
6748  /******/             }
6749  /******/         };
6750  /******/     })();
6751  /******/     
6752  /******/     /* webpack/runtime/hasOwnProperty shorthand */
6753  /******/     (() => {
6754  /******/         __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
6755  /******/     })();
6756  /******/     
6757  /******/     /* webpack/runtime/make namespace object */
6758  /******/     (() => {
6759  /******/         // define __esModule on exports
6760  /******/         __webpack_require__.r = (exports) => {
6761  /******/             if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
6762  /******/                 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
6763  /******/             }
6764  /******/             Object.defineProperty(exports, '__esModule', { value: true });
6765  /******/         };
6766  /******/     })();
6767  /******/     
6768  /************************************************************************/
6769  /******/     
6770  /******/     // startup
6771  /******/     // Load entry module and return exports
6772  /******/     // This entry module is referenced by other modules so it can't be inlined
6773  /******/     var __webpack_exports__ = __webpack_require__(4565);
6774  /******/     (window.wp = window.wp || {}).coreData = __webpack_exports__;
6775  /******/     
6776  /******/ })()
6777  ;