1 /******/ var __webpack_modules__ = ({

     2 

     3 /***/ 380:

     4 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

     5 

     6 

     7 // EXPORTS

     8 __webpack_require__.d(__webpack_exports__, {

     9   zj: () => (/* reexport */ getConfig),

    10   SD: () => (/* reexport */ getContext),

    11   V6: () => (/* reexport */ getElement),

    12   $K: () => (/* reexport */ getServerContext),

    13   vT: () => (/* reexport */ getServerState),

    14   jb: () => (/* binding */ privateApis),

    15   yT: () => (/* reexport */ splitTask),

    16   M_: () => (/* reexport */ store),

    17   hb: () => (/* reexport */ useCallback),

    18   vJ: () => (/* reexport */ useEffect),

    19   ip: () => (/* reexport */ useInit),

    20   Nf: () => (/* reexport */ useLayoutEffect),

    21   Kr: () => (/* reexport */ useMemo),

    22   li: () => (/* reexport */ A),

    23   J0: () => (/* reexport */ d),

    24   FH: () => (/* reexport */ useWatch),

    25   v4: () => (/* reexport */ withScope),

    26   mh: () => (/* reexport */ withSyncEvent)

    27 });

    28 

    29 // EXTERNAL MODULE: ./node_modules/preact/dist/preact.module.js

    30 var preact_module = __webpack_require__(622);

    31 ;// ./node_modules/preact/hooks/dist/hooks.module.js

    32 var hooks_module_t,r,hooks_module_u,i,hooks_module_o=0,hooks_module_f=[],hooks_module_c=preact_module/* options */.fF,e=hooks_module_c.__b,a=hooks_module_c.__r,v=hooks_module_c.diffed,l=hooks_module_c.__c,m=hooks_module_c.unmount,s=hooks_module_c.__;function p(n,t){hooks_module_c.__h&&hooks_module_c.__h(r,n,hooks_module_o||t),hooks_module_o=0;var u=r.__H||(r.__H={__:[],__h:[]});return n>=u.__.length&&u.__.push({}),u.__[n]}function d(n){return hooks_module_o=1,h(D,n)}function h(n,u,i){var o=p(hooks_module_t++,2);if(o.t=n,!o.__c&&(o.__=[i?i(u):D(void 0,u),function(n){var t=o.__N?o.__N[0]:o.__[0],r=o.t(t,n);t!==r&&(o.__N=[r,o.__[1]],o.__c.setState({}))}],o.__c=r,!r.__f)){var f=function(n,t,r){if(!o.__c.__H)return!0;var u=o.__c.__H.__.filter(function(n){return!!n.__c});if(u.every(function(n){return!n.__N}))return!c||c.call(this,n,t,r);var i=o.__c.props!==n;return u.forEach(function(n){if(n.__N){var t=n.__[0];n.__=n.__N,n.__N=void 0,t!==n.__[0]&&(i=!0)}}),c&&c.call(this,n,t,r)||i};r.__f=!0;var c=r.shouldComponentUpdate,e=r.componentWillUpdate;r.componentWillUpdate=function(n,t,r){if(this.__e){var u=c;c=void 0,f(n,t,r),c=u}e&&e.call(this,n,t,r)},r.shouldComponentUpdate=f}return o.__N||o.__}function y(n,u){var i=p(hooks_module_t++,3);!hooks_module_c.__s&&C(i.__H,u)&&(i.__=n,i.u=u,r.__H.__h.push(i))}function _(n,u){var i=p(hooks_module_t++,4);!hooks_module_c.__s&&C(i.__H,u)&&(i.__=n,i.u=u,r.__h.push(i))}function A(n){return hooks_module_o=5,T(function(){return{current:n}},[])}function F(n,t,r){hooks_module_o=6,_(function(){if("function"==typeof n){var r=n(t());return function(){n(null),r&&"function"==typeof r&&r()}}if(n)return n.current=t(),function(){return n.current=null}},null==r?r:r.concat(n))}function T(n,r){var u=p(hooks_module_t++,7);return C(u.__H,r)&&(u.__=n(),u.__H=r,u.__h=n),u.__}function q(n,t){return hooks_module_o=8,T(function(){return n},t)}function x(n){var u=r.context[n.__c],i=p(hooks_module_t++,9);return i.c=n,u?(null==i.__&&(i.__=!0,u.sub(r)),u.props.value):n.__}function P(n,t){hooks_module_c.useDebugValue&&hooks_module_c.useDebugValue(t?t(n):n)}function b(n){var u=p(hooks_module_t++,10),i=d();return u.__=n,r.componentDidCatch||(r.componentDidCatch=function(n,t){u.__&&u.__(n,t),i[1](n)}),[i[0],function(){i[1](void 0)}]}function g(){var n=p(hooks_module_t++,11);if(!n.__){for(var u=r.__v;null!==u&&!u.__m&&null!==u.__;)u=u.__;var i=u.__m||(u.__m=[0,0]);n.__="P"+i[0]+"-"+i[1]++}return n.__}function j(){for(var n;n=hooks_module_f.shift();)if(n.__P&&n.__H)try{n.__H.__h.forEach(z),n.__H.__h.forEach(B),n.__H.__h=[]}catch(t){n.__H.__h=[],hooks_module_c.__e(t,n.__v)}}hooks_module_c.__b=function(n){r=null,e&&e(n)},hooks_module_c.__=function(n,t){n&&t.__k&&t.__k.__m&&(n.__m=t.__k.__m),s&&s(n,t)},hooks_module_c.__r=function(n){a&&a(n),hooks_module_t=0;var i=(r=n.__c).__H;i&&(hooks_module_u===r?(i.__h=[],r.__h=[],i.__.forEach(function(n){n.__N&&(n.__=n.__N),n.u=n.__N=void 0})):(i.__h.forEach(z),i.__h.forEach(B),i.__h=[],hooks_module_t=0)),hooks_module_u=r},hooks_module_c.diffed=function(n){v&&v(n);var t=n.__c;t&&t.__H&&(t.__H.__h.length&&(1!==hooks_module_f.push(t)&&i===hooks_module_c.requestAnimationFrame||((i=hooks_module_c.requestAnimationFrame)||w)(j)),t.__H.__.forEach(function(n){n.u&&(n.__H=n.u),n.u=void 0})),hooks_module_u=r=null},hooks_module_c.__c=function(n,t){t.some(function(n){try{n.__h.forEach(z),n.__h=n.__h.filter(function(n){return!n.__||B(n)})}catch(r){t.some(function(n){n.__h&&(n.__h=[])}),t=[],hooks_module_c.__e(r,n.__v)}}),l&&l(n,t)},hooks_module_c.unmount=function(n){m&&m(n);var t,r=n.__c;r&&r.__H&&(r.__H.__.forEach(function(n){try{z(n)}catch(n){t=n}}),r.__H=void 0,t&&hooks_module_c.__e(t,r.__v))};var k="function"==typeof requestAnimationFrame;function w(n){var t,r=function(){clearTimeout(u),k&&cancelAnimationFrame(t),setTimeout(n)},u=setTimeout(r,100);k&&(t=requestAnimationFrame(r))}function z(n){var t=r,u=n.__c;"function"==typeof u&&(n.__c=void 0,u()),r=t}function B(n){var t=r;n.__c=n.__(),r=t}function C(n,t){return!n||n.length!==t.length||t.some(function(t,r){return t!==n[r]})}function D(n,t){return"function"==typeof t?t(n):t}

    33 

    34 ;// ./node_modules/@preact/signals-core/dist/signals-core.module.js

    35 var signals_core_module_i=Symbol.for("preact-signals");function signals_core_module_t(){if(!(signals_core_module_s>1)){var i,t=!1;while(void 0!==signals_core_module_h){var r=signals_core_module_h;signals_core_module_h=void 0;signals_core_module_f++;while(void 0!==r){var o=r.o;r.o=void 0;r.f&=-3;if(!(8&r.f)&&signals_core_module_c(r))try{r.c()}catch(r){if(!t){i=r;t=!0}}r=o}}signals_core_module_f=0;signals_core_module_s--;if(t)throw i}else signals_core_module_s--}function signals_core_module_r(i){if(signals_core_module_s>0)return i();signals_core_module_s++;try{return i()}finally{signals_core_module_t()}}var signals_core_module_o=void 0;function n(i){var t=signals_core_module_o;signals_core_module_o=void 0;try{return i()}finally{signals_core_module_o=t}}var signals_core_module_h=void 0,signals_core_module_s=0,signals_core_module_f=0,signals_core_module_v=0;function signals_core_module_e(i){if(void 0!==signals_core_module_o){var t=i.n;if(void 0===t||t.t!==signals_core_module_o){t={i:0,S:i,p:signals_core_module_o.s,n:void 0,t:signals_core_module_o,e:void 0,x:void 0,r:t};if(void 0!==signals_core_module_o.s)signals_core_module_o.s.n=t;signals_core_module_o.s=t;i.n=t;if(32&signals_core_module_o.f)i.S(t);return t}else if(-1===t.i){t.i=0;if(void 0!==t.n){t.n.p=t.p;if(void 0!==t.p)t.p.n=t.n;t.p=signals_core_module_o.s;t.n=void 0;signals_core_module_o.s.n=t;signals_core_module_o.s=t}return t}}}function signals_core_module_u(i){this.v=i;this.i=0;this.n=void 0;this.t=void 0}signals_core_module_u.prototype.brand=signals_core_module_i;signals_core_module_u.prototype.h=function(){return!0};signals_core_module_u.prototype.S=function(i){if(this.t!==i&&void 0===i.e){i.x=this.t;if(void 0!==this.t)this.t.e=i;this.t=i}};signals_core_module_u.prototype.U=function(i){if(void 0!==this.t){var t=i.e,r=i.x;if(void 0!==t){t.x=r;i.e=void 0}if(void 0!==r){r.e=t;i.x=void 0}if(i===this.t)this.t=r}};signals_core_module_u.prototype.subscribe=function(i){var t=this;return E(function(){var r=t.value,n=signals_core_module_o;signals_core_module_o=void 0;try{i(r)}finally{signals_core_module_o=n}})};signals_core_module_u.prototype.valueOf=function(){return this.value};signals_core_module_u.prototype.toString=function(){return this.value+""};signals_core_module_u.prototype.toJSON=function(){return this.value};signals_core_module_u.prototype.peek=function(){var i=signals_core_module_o;signals_core_module_o=void 0;try{return this.value}finally{signals_core_module_o=i}};Object.defineProperty(signals_core_module_u.prototype,"value",{get:function(){var i=signals_core_module_e(this);if(void 0!==i)i.i=this.i;return this.v},set:function(i){if(i!==this.v){if(signals_core_module_f>100)throw new Error("Cycle detected");this.v=i;this.i++;signals_core_module_v++;signals_core_module_s++;try{for(var r=this.t;void 0!==r;r=r.x)r.t.N()}finally{signals_core_module_t()}}}});function signals_core_module_d(i){return new signals_core_module_u(i)}function signals_core_module_c(i){for(var t=i.s;void 0!==t;t=t.n)if(t.S.i!==t.i||!t.S.h()||t.S.i!==t.i)return!0;return!1}function signals_core_module_a(i){for(var t=i.s;void 0!==t;t=t.n){var r=t.S.n;if(void 0!==r)t.r=r;t.S.n=t;t.i=-1;if(void 0===t.n){i.s=t;break}}}function signals_core_module_l(i){var t=i.s,r=void 0;while(void 0!==t){var o=t.p;if(-1===t.i){t.S.U(t);if(void 0!==o)o.n=t.n;if(void 0!==t.n)t.n.p=o}else r=t;t.S.n=t.r;if(void 0!==t.r)t.r=void 0;t=o}i.s=r}function signals_core_module_y(i){signals_core_module_u.call(this,void 0);this.x=i;this.s=void 0;this.g=signals_core_module_v-1;this.f=4}(signals_core_module_y.prototype=new signals_core_module_u).h=function(){this.f&=-3;if(1&this.f)return!1;if(32==(36&this.f))return!0;this.f&=-5;if(this.g===signals_core_module_v)return!0;this.g=signals_core_module_v;this.f|=1;if(this.i>0&&!signals_core_module_c(this)){this.f&=-2;return!0}var i=signals_core_module_o;try{signals_core_module_a(this);signals_core_module_o=this;var t=this.x();if(16&this.f||this.v!==t||0===this.i){this.v=t;this.f&=-17;this.i++}}catch(i){this.v=i;this.f|=16;this.i++}signals_core_module_o=i;signals_core_module_l(this);this.f&=-2;return!0};signals_core_module_y.prototype.S=function(i){if(void 0===this.t){this.f|=36;for(var t=this.s;void 0!==t;t=t.n)t.S.S(t)}signals_core_module_u.prototype.S.call(this,i)};signals_core_module_y.prototype.U=function(i){if(void 0!==this.t){signals_core_module_u.prototype.U.call(this,i);if(void 0===this.t){this.f&=-33;for(var t=this.s;void 0!==t;t=t.n)t.S.U(t)}}};signals_core_module_y.prototype.N=function(){if(!(2&this.f)){this.f|=6;for(var i=this.t;void 0!==i;i=i.x)i.t.N()}};Object.defineProperty(signals_core_module_y.prototype,"value",{get:function(){if(1&this.f)throw new Error("Cycle detected");var i=signals_core_module_e(this);this.h();if(void 0!==i)i.i=this.i;if(16&this.f)throw this.v;return this.v}});function signals_core_module_w(i){return new signals_core_module_y(i)}function signals_core_module_(i){var r=i.u;i.u=void 0;if("function"==typeof r){signals_core_module_s++;var n=signals_core_module_o;signals_core_module_o=void 0;try{r()}catch(t){i.f&=-2;i.f|=8;signals_core_module_g(i);throw t}finally{signals_core_module_o=n;signals_core_module_t()}}}function signals_core_module_g(i){for(var t=i.s;void 0!==t;t=t.n)t.S.U(t);i.x=void 0;i.s=void 0;signals_core_module_(i)}function signals_core_module_p(i){if(signals_core_module_o!==this)throw new Error("Out-of-order effect");signals_core_module_l(this);signals_core_module_o=i;this.f&=-2;if(8&this.f)signals_core_module_g(this);signals_core_module_t()}function signals_core_module_b(i){this.x=i;this.u=void 0;this.s=void 0;this.o=void 0;this.f=32}signals_core_module_b.prototype.c=function(){var i=this.S();try{if(8&this.f)return;if(void 0===this.x)return;var t=this.x();if("function"==typeof t)this.u=t}finally{i()}};signals_core_module_b.prototype.S=function(){if(1&this.f)throw new Error("Cycle detected");this.f|=1;this.f&=-9;signals_core_module_(this);signals_core_module_a(this);signals_core_module_s++;var i=signals_core_module_o;signals_core_module_o=this;return signals_core_module_p.bind(this,i)};signals_core_module_b.prototype.N=function(){if(!(2&this.f)){this.f|=2;this.o=signals_core_module_h;signals_core_module_h=this}};signals_core_module_b.prototype.d=function(){this.f|=8;if(!(1&this.f))signals_core_module_g(this)};function E(i){var t=new signals_core_module_b(i);try{t.c()}catch(i){t.d();throw i}return t.d.bind(t)}

    36 ;// ./node_modules/@preact/signals/dist/signals.module.js

    37 var signals_module_v,signals_module_s;function signals_module_l(i,n){preact_module/* options */.fF[i]=n.bind(null,preact_module/* options */.fF[i]||function(){})}function signals_module_d(i){if(signals_module_s)signals_module_s();signals_module_s=i&&i.S()}function signals_module_h(i){var r=this,f=i.data,o=useSignal(f);o.value=f;var e=T(function(){var i=r.__v;while(i=i.__)if(i.__c){i.__c.__$f|=4;break}r.__$u.c=function(){var i,t=r.__$u.S(),f=e.value;t();if((0,preact_module/* isValidElement */.zO)(f)||3!==(null==(i=r.base)?void 0:i.nodeType)){r.__$f|=1;r.setState({})}else r.base.data=f};return signals_core_module_w(function(){var i=o.value.value;return 0===i?0:!0===i?"":i||""})},[]);return e.value}signals_module_h.displayName="_st";Object.defineProperties(signals_core_module_u.prototype,{constructor:{configurable:!0,value:void 0},type:{configurable:!0,value:signals_module_h},props:{configurable:!0,get:function(){return{data:this}}},__b:{configurable:!0,value:1}});signals_module_l("__b",function(i,r){if("string"==typeof r.type){var n,t=r.props;for(var f in t)if("children"!==f){var o=t[f];if(o instanceof signals_core_module_u){if(!n)r.__np=n={};n[f]=o;t[f]=o.peek()}}}i(r)});signals_module_l("__r",function(i,r){signals_module_d();var n,t=r.__c;if(t){t.__$f&=-2;if(void 0===(n=t.__$u))t.__$u=n=function(i){var r;E(function(){r=this});r.c=function(){t.__$f|=1;t.setState({})};return r}()}signals_module_v=t;signals_module_d(n);i(r)});signals_module_l("__e",function(i,r,n,t){signals_module_d();signals_module_v=void 0;i(r,n,t)});signals_module_l("diffed",function(i,r){signals_module_d();signals_module_v=void 0;var n;if("string"==typeof r.type&&(n=r.__e)){var t=r.__np,f=r.props;if(t){var o=n.U;if(o)for(var e in o){var u=o[e];if(void 0!==u&&!(e in t)){u.d();o[e]=void 0}}else n.U=o={};for(var a in t){var c=o[a],s=t[a];if(void 0===c){c=signals_module_p(n,a,s,f);o[a]=c}else c.o(s,f)}}}i(r)});function signals_module_p(i,r,n,t){var f=r in i&&void 0===i.ownerSVGElement,o=signals_core_module_d(n);return{o:function(i,r){o.value=i;t=r},d:E(function(){var n=o.value.value;if(t[r]!==n){t[r]=n;if(f)i[r]=n;else if(n)i.setAttribute(r,n);else i.removeAttribute(r)}})}}signals_module_l("unmount",function(i,r){if("string"==typeof r.type){var n=r.__e;if(n){var t=n.U;if(t){n.U=void 0;for(var f in t){var o=t[f];if(o)o.d()}}}}else{var e=r.__c;if(e){var u=e.__$u;if(u){e.__$u=void 0;u.d()}}}i(r)});signals_module_l("__h",function(i,r,n,t){if(t<3||9===t)r.__$f|=2;i(r,n,t)});preact_module/* Component */.uA.prototype.shouldComponentUpdate=function(i,r){var n=this.__$u,t=n&&void 0!==n.s;for(var f in r)return!0;if(this.__f||"boolean"==typeof this.u&&!0===this.u){if(!(t||2&this.__$f||4&this.__$f))return!0;if(1&this.__$f)return!0}else{if(!(t||4&this.__$f))return!0;if(3&this.__$f)return!0}for(var o in i)if("__source"!==o&&i[o]!==this.props[o])return!0;for(var e in this.props)if(!(e in i))return!0;return!1};function useSignal(i){return T(function(){return signals_core_module_d(i)},[])}function useComputed(i){var r=f(i);r.current=i;signals_module_v.__$f|=4;return t(function(){return u(function(){return r.current()})},[])}function useSignalEffect(i){var r=f(i);r.current=i;o(function(){return c(function(){return r.current()})},[])}

    38 ;// ./node_modules/@wordpress/interactivity/build-module/namespaces.js

    39 const namespaceStack = [];

    40 const getNamespace = () => namespaceStack.slice(-1)[0];

    41 const setNamespace = namespace => {

    42   namespaceStack.push(namespace);

    43 };

    44 const resetNamespace = () => {

    45   namespaceStack.pop();

    46 };

    47 

    48 ;// ./node_modules/@wordpress/interactivity/build-module/scopes.js

    49 /**

    50  * External dependencies

    51  */

    52 

    53 /**

    54  * Internal dependencies

    55  */

    56 

    57 // Store stacks for the current scope and the default namespaces and export APIs

    58 // to interact with them.

    59 const scopeStack = [];

    60 const getScope = () => scopeStack.slice(-1)[0];

    61 const setScope = scope => {

    62   scopeStack.push(scope);

    63 };

    64 const resetScope = () => {

    65   scopeStack.pop();

    66 };

    67 

    68 // Wrap the element props to prevent modifications.

    69 const immutableMap = new WeakMap();

    70 const immutableError = () => {

    71   throw new Error('Please use `data-wp-bind` to modify the attributes of an element.');

    72 };

    73 const immutableHandlers = {

    74   get(target, key, receiver) {

    75     const value = Reflect.get(target, key, receiver);

    76     return !!value && typeof value === 'object' ? deepImmutable(value) : value;

    77   },

    78   set: immutableError,

    79   deleteProperty: immutableError

    80 };

    81 const deepImmutable = target => {

    82   if (!immutableMap.has(target)) {

    83     immutableMap.set(target, new Proxy(target, immutableHandlers));

    84   }

    85   return immutableMap.get(target);

    86 };

    87 

    88 /**

    89  * Retrieves the context inherited by the element evaluating a function from the

    90  * store. The returned value depends on the element and the namespace where the

    91  * function calling `getContext()` exists.

    92  *

    93  * @param namespace Store namespace. By default, the namespace where the calling

    94  *                  function exists is used.

    95  * @return The context content.

    96  */

    97 const getContext = namespace => {

    98   const scope = getScope();

    99   if (true) {

   100     if (!scope) {

   101       throw Error('Cannot call `getContext()` when there is no scope. If you are using an async function, please consider using a generator instead. If you are using some sort of async callbacks, like `setTimeout`, please wrap the callback with `withScope(callback)`.');

   102     }

   103   }

   104   return scope.context[namespace || getNamespace()];

   105 };

   106 

   107 /**

   108  * Retrieves a representation of the element where a function from the store

   109  * is being evaluated. Such representation is read-only, and contains a

   110  * reference to the DOM element, its props and a local reactive state.

   111  *

   112  * @return Element representation.

   113  */

   114 const getElement = () => {

   115   const scope = getScope();

   116   if (true) {

   117     if (!scope) {

   118       throw Error('Cannot call `getElement()` when there is no scope. If you are using an async function, please consider using a generator instead. If you are using some sort of async callbacks, like `setTimeout`, please wrap the callback with `withScope(callback)`.');

   119     }

   120   }

   121   const {

   122     ref,

   123     attributes

   124   } = scope;

   125   return Object.freeze({

   126     ref: ref.current,

   127     attributes: deepImmutable(attributes)

   128   });

   129 };

   130 

   131 /**

   132  * Retrieves the part of the inherited context defined and updated from the

   133  * server.

   134  *

   135  * The object returned is read-only, and includes the context defined in PHP

   136  * with `wp_interactivity_data_wp_context()`, including the corresponding

   137  * inherited properties. When `actions.navigate()` is called, this object is

   138  * updated to reflect the changes in the new visited page, without affecting the

   139  * context returned by `getContext()`. Directives can subscribe to those changes

   140  * to update the context if needed.

   141  *

   142  * @example

   143  * ```js

   144  *  store('...', {

   145  *    callbacks: {

   146  *      updateServerContext() {

   147  *        const context = getContext();

   148  *        const serverContext = getServerContext();

   149  *        // Override some property with the new value that came from the server.

   150  *        context.overridableProp = serverContext.overridableProp;

   151  *      },

   152  *    },

   153  *  });

   154  * ```

   155  *

   156  * @param namespace Store namespace. By default, the namespace where the calling

   157  *                  function exists is used.

   158  * @return The server context content.

   159  */

   160 const getServerContext = namespace => {

   161   const scope = getScope();

   162   if (true) {

   163     if (!scope) {

   164       throw Error('Cannot call `getServerContext()` when there is no scope. If you are using an async function, please consider using a generator instead. If you are using some sort of async callbacks, like `setTimeout`, please wrap the callback with `withScope(callback)`.');

   165     }

   166   }

   167   return scope.serverContext[namespace || getNamespace()];

   168 };

   169 

   170 ;// ./node_modules/@wordpress/interactivity/build-module/utils.js

   171 /**

   172  * External dependencies

   173  */

   174 

   175 

   176 

   177 /**

   178  * Internal dependencies

   179  */

   180 

   181 

   182 /**

   183  * Executes a callback function after the next frame is rendered.

   184  *

   185  * @param callback The callback function to be executed.

   186  * @return A promise that resolves after the callback function is executed.

   187  */

   188 const afterNextFrame = callback => {

   189   return new Promise(resolve => {

   190     const done = () => {

   191       clearTimeout(timeout);

   192       window.cancelAnimationFrame(raf);

   193       setTimeout(() => {

   194         callback();

   195         resolve();

   196       });

   197     };

   198     const timeout = setTimeout(done, 100);

   199     const raf = window.requestAnimationFrame(done);

   200   });

   201 };

   202 

   203 /**

   204  * Returns a promise that resolves after yielding to main.

   205  *

   206  * @return Promise<void>

   207  */

   208 const splitTask = typeof window.scheduler?.yield === 'function' ? window.scheduler.yield.bind(window.scheduler) : () => {

   209   return new Promise(resolve => {

   210     setTimeout(resolve, 0);

   211   });

   212 };

   213 

   214 /**

   215  * Creates a Flusher object that can be used to flush computed values and notify listeners.

   216  *

   217  * Using the mangled properties:

   218  * this.c: this._callback

   219  * this.x: this._compute

   220  * https://github.com/preactjs/signals/blob/main/mangle.json

   221  *

   222  * @param compute The function that computes the value to be flushed.

   223  * @param notify  The function that notifies listeners when the value is flushed.

   224  * @return The Flusher object with `flush` and `dispose` properties.

   225  */

   226 function createFlusher(compute, notify) {

   227   let flush = () => undefined;

   228   const dispose = E(function () {

   229     flush = this.c.bind(this);

   230     this.x = compute;

   231     this.c = notify;

   232     return compute();

   233   });

   234   return {

   235     flush,

   236     dispose

   237   };

   238 }

   239 

   240 /**

   241  * Custom hook that executes a callback function whenever a signal is triggered.

   242  * Version of `useSignalEffect` with a `useEffect`-like execution. This hook

   243  * implementation comes from this PR, but we added short-cirtuiting to avoid

   244  * infinite loops: https://github.com/preactjs/signals/pull/290

   245  *

   246  * @param callback The callback function to be executed.

   247  */

   248 function utils_useSignalEffect(callback) {

   249   y(() => {

   250     let eff = null;

   251     let isExecuting = false;

   252     const notify = async () => {

   253       if (eff && !isExecuting) {

   254         isExecuting = true;

   255         await afterNextFrame(eff.flush);

   256         isExecuting = false;

   257       }

   258     };

   259     eff = createFlusher(callback, notify);

   260     return eff.dispose;

   261   }, []);

   262 }

   263 

   264 /**

   265  * Returns the passed function wrapped with the current scope so it is

   266  * accessible whenever the function runs. This is primarily to make the scope

   267  * available inside hook callbacks.

   268  *

   269  * Asynchronous functions should use generators that yield promises instead of awaiting them.

   270  * See the documentation for details: https://developer.wordpress.org/block-editor/reference-guides/packages/packages-interactivity/packages-interactivity-api-reference/#the-store

   271  *

   272  * @param func The passed function.

   273  * @return The wrapped function.

   274  */

   275 

   276 function withScope(func) {

   277   const scope = getScope();

   278   const ns = getNamespace();

   279   let wrapped;

   280   if (func?.constructor?.name === 'GeneratorFunction') {

   281     wrapped = async (...args) => {

   282       const gen = func(...args);

   283       let value;

   284       let it;

   285       while (true) {

   286         setNamespace(ns);

   287         setScope(scope);

   288         try {

   289           it = gen.next(value);

   290         } finally {

   291           resetScope();

   292           resetNamespace();

   293         }

   294         try {

   295           value = await it.value;

   296         } catch (e) {

   297           setNamespace(ns);

   298           setScope(scope);

   299           gen.throw(e);

   300         } finally {

   301           resetScope();

   302           resetNamespace();

   303         }

   304         if (it.done) {

   305           break;

   306         }

   307       }

   308       return value;

   309     };

   310   } else {

   311     wrapped = (...args) => {

   312       setNamespace(ns);

   313       setScope(scope);

   314       try {

   315         return func(...args);

   316       } finally {

   317         resetNamespace();

   318         resetScope();

   319       }

   320     };

   321   }

   322 

   323   // If function was annotated via `withSyncEvent()`, maintain the annotation.

   324   const syncAware = func;

   325   if (syncAware.sync) {

   326     const syncAwareWrapped = wrapped;

   327     syncAwareWrapped.sync = true;

   328     return syncAwareWrapped;

   329   }

   330   return wrapped;

   331 }

   332 

   333 /**

   334  * Accepts a function that contains imperative code which runs whenever any of

   335  * the accessed _reactive_ properties (e.g., values from the global state or the

   336  * context) is modified.

   337  *

   338  * This hook makes the element's scope available so functions like

   339  * `getElement()` and `getContext()` can be used inside the passed callback.

   340  *

   341  * @param callback The hook callback.

   342  */

   343 function useWatch(callback) {

   344   utils_useSignalEffect(withScope(callback));

   345 }

   346 

   347 /**

   348  * Accepts a function that contains imperative code which runs only after the

   349  * element's first render, mainly useful for initialization logic.

   350  *

   351  * This hook makes the element's scope available so functions like

   352  * `getElement()` and `getContext()` can be used inside the passed callback.

   353  *

   354  * @param callback The hook callback.

   355  */

   356 function useInit(callback) {

   357   y(withScope(callback), []);

   358 }

   359 

   360 /**

   361  * Accepts a function that contains imperative, possibly effectful code. The

   362  * effects run after browser paint, without blocking it.

   363  *

   364  * This hook is equivalent to Preact's `useEffect` and makes the element's scope

   365  * available so functions like `getElement()` and `getContext()` can be used

   366  * inside the passed callback.

   367  *

   368  * @param callback Imperative function that can return a cleanup

   369  *                 function.

   370  * @param inputs   If present, effect will only activate if the

   371  *                 values in the list change (using `===`).

   372  */

   373 function useEffect(callback, inputs) {

   374   y(withScope(callback), inputs);

   375 }

   376 

   377 /**

   378  * Accepts a function that contains imperative, possibly effectful code. Use

   379  * this to read layout from the DOM and synchronously re-render.

   380  *

   381  * This hook is equivalent to Preact's `useLayoutEffect` and makes the element's

   382  * scope available so functions like `getElement()` and `getContext()` can be

   383  * used inside the passed callback.

   384  *

   385  * @param callback Imperative function that can return a cleanup

   386  *                 function.

   387  * @param inputs   If present, effect will only activate if the

   388  *                 values in the list change (using `===`).

   389  */

   390 function useLayoutEffect(callback, inputs) {

   391   _(withScope(callback), inputs);

   392 }

   393 

   394 /**

   395  * Returns a memoized version of the callback that only changes if one of the

   396  * inputs has changed (using `===`).

   397  *

   398  * This hook is equivalent to Preact's `useCallback` and makes the element's

   399  * scope available so functions like `getElement()` and `getContext()` can be

   400  * used inside the passed callback.

   401  *

   402  * @param callback Callback function.

   403  * @param inputs   If present, the callback will only be updated if the

   404  *                 values in the list change (using `===`).

   405  *

   406  * @return The callback function.

   407  */

   408 function useCallback(callback, inputs) {

   409   return q(withScope(callback), inputs);

   410 }

   411 

   412 /**

   413  * Pass a factory function and an array of inputs. `useMemo` will only recompute

   414  * the memoized value when one of the inputs has changed.

   415  *

   416  * This hook is equivalent to Preact's `useMemo` and makes the element's scope

   417  * available so functions like `getElement()` and `getContext()` can be used

   418  * inside the passed factory function.

   419  *

   420  * @param factory Factory function that returns that value for memoization.

   421  * @param inputs  If present, the factory will only be run to recompute if

   422  *                the values in the list change (using `===`).

   423  *

   424  * @return The memoized value.

   425  */

   426 function useMemo(factory, inputs) {

   427   return T(withScope(factory), inputs);

   428 }

   429 

   430 /**

   431  * Creates a root fragment by replacing a node or an array of nodes in a parent element.

   432  * For wrapperless hydration.

   433  * See https://gist.github.com/developit/f4c67a2ede71dc2fab7f357f39cff28c

   434  *

   435  * @param parent      The parent element where the nodes will be replaced.

   436  * @param replaceNode The node or array of nodes to replace in the parent element.

   437  * @return The created root fragment.

   438  */

   439 const createRootFragment = (parent, replaceNode) => {

   440   replaceNode = [].concat(replaceNode);

   441   const sibling = replaceNode[replaceNode.length - 1].nextSibling;

   442   function insert(child, root) {

   443     parent.insertBefore(child, root || sibling);

   444   }

   445   return parent.__k = {

   446     nodeType: 1,

   447     parentNode: parent,

   448     firstChild: replaceNode[0],

   449     childNodes: replaceNode,

   450     insertBefore: insert,

   451     appendChild: insert,

   452     removeChild(c) {

   453       parent.removeChild(c);

   454     }

   455   };

   456 };

   457 

   458 /**

   459  * Transforms a kebab-case string to camelCase.

   460  *

   461  * @param str The kebab-case string to transform to camelCase.

   462  * @return The transformed camelCase string.

   463  */

   464 function kebabToCamelCase(str) {

   465   return str.replace(/^-+|-+$/g, '').toLowerCase().replace(/-([a-z])/g, function (_match, group1) {

   466     return group1.toUpperCase();

   467   });

   468 }

   469 const logged = new Set();

   470 

   471 /**

   472  * Shows a warning with `message` if environment is not `production`.

   473  *

   474  * Based on the `@wordpress/warning` package.

   475  *

   476  * @param message Message to show in the warning.

   477  */

   478 const warn = message => {

   479   if (true) {

   480     if (logged.has(message)) {

   481       return;

   482     }

   483 

   484     // eslint-disable-next-line no-console

   485     console.warn(message);

   486 

   487     // Throwing an error and catching it immediately to improve debugging

   488     // A consumer can use 'pause on caught exceptions'

   489     try {

   490       throw Error(message);

   491     } catch (e) {

   492       // Do nothing.

   493     }

   494     logged.add(message);

   495   }

   496 };

   497 

   498 /**

   499  * Checks if the passed `candidate` is a plain object with just the `Object`

   500  * prototype.

   501  *

   502  * @param candidate The item to check.

   503  * @return Whether `candidate` is a plain object.

   504  */

   505 const isPlainObject = candidate => Boolean(candidate && typeof candidate === 'object' && candidate.constructor === Object);

   506 

   507 /**

   508  * Indicates that the passed `callback` requires synchronous access to the event object.

   509  *

   510  * @param callback The event callback.

   511  * @return Altered event callback.

   512  */

   513 function withSyncEvent(callback) {

   514   const syncAware = callback;

   515   syncAware.sync = true;

   516   return syncAware;

   517 }

   518 

   519 ;// ./node_modules/@wordpress/interactivity/build-module/proxies/registry.js

   520 /**

   521  * Proxies for each object.

   522  */

   523 const objToProxy = new WeakMap();

   524 const proxyToObj = new WeakMap();

   525 

   526 /**

   527  * Namespaces for each created proxy.

   528  */

   529 const proxyToNs = new WeakMap();

   530 

   531 /**

   532  * Object types that can be proxied.

   533  */

   534 const supported = new Set([Object, Array]);

   535 

   536 /**

   537  * Returns a proxy to the passed object with the given handlers, assigning the

   538  * specified namespace to it. If a proxy for the passed object was created

   539  * before, that proxy is returned.

   540  *

   541  * @param namespace The namespace that will be associated to this proxy.

   542  * @param obj       The object to proxify.

   543  * @param handlers  Handlers that the proxy will use.

   544  *

   545  * @throws Error if the object cannot be proxified. Use {@link shouldProxy} to

   546  *         check if a proxy can be created for a specific object.

   547  *

   548  * @return The created proxy.

   549  */

   550 const createProxy = (namespace, obj, handlers) => {

   551   if (!shouldProxy(obj)) {

   552     throw Error('This object cannot be proxified.');

   553   }

   554   if (!objToProxy.has(obj)) {

   555     const proxy = new Proxy(obj, handlers);

   556     objToProxy.set(obj, proxy);

   557     proxyToObj.set(proxy, obj);

   558     proxyToNs.set(proxy, namespace);

   559   }

   560   return objToProxy.get(obj);

   561 };

   562 

   563 /**

   564  * Returns the proxy for the given object. If there is no associated proxy, the

   565  * function returns `undefined`.

   566  *

   567  * @param obj Object from which to know the proxy.

   568  * @return Associated proxy or `undefined`.

   569  */

   570 const getProxyFromObject = obj => objToProxy.get(obj);

   571 

   572 /**

   573  * Gets the namespace associated with the given proxy.

   574  *

   575  * Proxies have a namespace assigned upon creation. See {@link createProxy}.

   576  *

   577  * @param proxy Proxy.

   578  * @return Namespace.

   579  */

   580 const getNamespaceFromProxy = proxy => proxyToNs.get(proxy);

   581 

   582 /**

   583  * Checks if a given object can be proxied.

   584  *

   585  * @param candidate Object to know whether it can be proxied.

   586  * @return True if the passed instance can be proxied.

   587  */

   588 const shouldProxy = candidate => {

   589   if (typeof candidate !== 'object' || candidate === null) {

   590     return false;

   591   }

   592   return !proxyToNs.has(candidate) && supported.has(candidate.constructor);

   593 };

   594 

   595 /**

   596  * Returns the target object for the passed proxy. If the passed object is not a registered proxy, the

   597  * function returns `undefined`.

   598  *

   599  * @param proxy Proxy from which to know the target.

   600  * @return The target object or `undefined`.

   601  */

   602 const getObjectFromProxy = proxy => proxyToObj.get(proxy);

   603 

   604 ;// ./node_modules/@wordpress/interactivity/build-module/proxies/signals.js

   605 /**

   606  * External dependencies

   607  */

   608 

   609 

   610 /**

   611  * Internal dependencies

   612  */

   613 

   614 

   615 

   616 

   617 

   618 /**

   619  * Identifier for property computeds not associated to any scope.

   620  */

   621 const NO_SCOPE = {};

   622 

   623 /**

   624  * Structure that manages reactivity for a property in a state object. It uses

   625  * signals to keep track of property value or getter modifications.

   626  */

   627 class PropSignal {

   628   /**

   629    * Proxy that holds the property this PropSignal is associated with.

   630    */

   631 

   632   /**

   633    * Relation of computeds by scope. These computeds are read-only signals

   634    * that depend on whether the property is a value or a getter and,

   635    * therefore, can return different values depending on the scope in which

   636    * the getter is accessed.

   637    */

   638 

   639   /**

   640    * Signal with the value assigned to the related property.

   641    */

   642 

   643   /**

   644    * Signal with the getter assigned to the related property.

   645    */

   646 

   647   /**

   648    * Structure that manages reactivity for a property in a state object, using

   649    * signals to keep track of property value or getter modifications.

   650    *

   651    * @param owner Proxy that holds the property this instance is associated

   652    *              with.

   653    */

   654   constructor(owner) {

   655     this.owner = owner;

   656     this.computedsByScope = new WeakMap();

   657   }

   658 

   659   /**

   660    * Changes the internal value. If a getter was set before, it is set to

   661    * `undefined`.

   662    *

   663    * @param value New value.

   664    */

   665   setValue(value) {

   666     this.update({

   667       value

   668     });

   669   }

   670 

   671   /**

   672    * Changes the internal getter. If a value was set before, it is set to

   673    * `undefined`.

   674    *

   675    * @param getter New getter.

   676    */

   677   setGetter(getter) {

   678     this.update({

   679       get: getter

   680     });

   681   }

   682 

   683   /**

   684    * Returns the computed that holds the result of evaluating the prop in the

   685    * current scope.

   686    *

   687    * These computeds are read-only signals that depend on whether the property

   688    * is a value or a getter and, therefore, can return different values

   689    * depending on the scope in which the getter is accessed.

   690    *

   691    * @return Computed that depends on the scope.

   692    */

   693   getComputed() {

   694     const scope = getScope() || NO_SCOPE;

   695     if (!this.valueSignal && !this.getterSignal) {

   696       this.update({});

   697     }

   698     if (!this.computedsByScope.has(scope)) {

   699       const callback = () => {

   700         const getter = this.getterSignal?.value;

   701         return getter ? getter.call(this.owner) : this.valueSignal?.value;

   702       };

   703       setNamespace(getNamespaceFromProxy(this.owner));

   704       this.computedsByScope.set(scope, signals_core_module_w(withScope(callback)));

   705       resetNamespace();

   706     }

   707     return this.computedsByScope.get(scope);

   708   }

   709 

   710   /**

   711    *  Update the internal signals for the value and the getter of the

   712    *  corresponding prop.

   713    *

   714    * @param param0

   715    * @param param0.get   New getter.

   716    * @param param0.value New value.

   717    */

   718   update({

   719     get,

   720     value

   721   }) {

   722     if (!this.valueSignal) {

   723       this.valueSignal = signals_core_module_d(value);

   724       this.getterSignal = signals_core_module_d(get);

   725     } else if (value !== this.valueSignal.peek() || get !== this.getterSignal.peek()) {

   726       signals_core_module_r(() => {

   727         this.valueSignal.value = value;

   728         this.getterSignal.value = get;

   729       });

   730     }

   731   }

   732 }

   733 

   734 ;// ./node_modules/@wordpress/interactivity/build-module/proxies/state.js

   735 /**

   736  * External dependencies

   737  */

   738 

   739 

   740 /**

   741  * Internal dependencies

   742  */

   743 

   744 

   745 

   746 

   747 

   748 /**

   749  * Set of built-in symbols.

   750  */

   751 const wellKnownSymbols = new Set(Object.getOwnPropertyNames(Symbol).map(key => Symbol[key]).filter(value => typeof value === 'symbol'));

   752 

   753 /**

   754  * Relates each proxy with a map of {@link PropSignal} instances, representing

   755  * the proxy's accessed properties.

   756  */

   757 const proxyToProps = new WeakMap();

   758 

   759 /**

   760  *  Checks whether a {@link PropSignal | `PropSignal`} instance exists for the

   761  *  given property in the passed proxy.

   762  *

   763  * @param proxy Proxy of a state object or array.

   764  * @param key   The property key.

   765  * @return `true` when it exists; false otherwise.

   766  */

   767 const hasPropSignal = (proxy, key) => proxyToProps.has(proxy) && proxyToProps.get(proxy).has(key);

   768 const readOnlyProxies = new WeakSet();

   769 

   770 /**

   771  * Returns the {@link PropSignal | `PropSignal`} instance associated with the

   772  * specified prop in the passed proxy.

   773  *

   774  * The `PropSignal` instance is generated if it doesn't exist yet, using the

   775  * `initial` parameter to initialize the internal signals.

   776  *

   777  * @param proxy   Proxy of a state object or array.

   778  * @param key     The property key.

   779  * @param initial Initial data for the `PropSignal` instance.

   780  * @return The `PropSignal` instance.

   781  */

   782 const getPropSignal = (proxy, key, initial) => {

   783   if (!proxyToProps.has(proxy)) {

   784     proxyToProps.set(proxy, new Map());

   785   }

   786   key = typeof key === 'number' ? `${key}` : key;

   787   const props = proxyToProps.get(proxy);

   788   if (!props.has(key)) {

   789     const ns = getNamespaceFromProxy(proxy);

   790     const prop = new PropSignal(proxy);

   791     props.set(key, prop);

   792     if (initial) {

   793       const {

   794         get,

   795         value

   796       } = initial;

   797       if (get) {

   798         prop.setGetter(get);

   799       } else {

   800         const readOnly = readOnlyProxies.has(proxy);

   801         prop.setValue(shouldProxy(value) ? proxifyState(ns, value, {

   802           readOnly

   803         }) : value);

   804       }

   805     }

   806   }

   807   return props.get(key);

   808 };

   809 

   810 /**

   811  * Relates each proxied object (i.e., the original object) with a signal that

   812  * tracks changes in the number of properties.

   813  */

   814 const objToIterable = new WeakMap();

   815 

   816 /**

   817  * When this flag is `true`, it avoids any signal subscription, overriding state

   818  * props' "reactive" behavior.

   819  */

   820 let peeking = false;

   821 

   822 /**

   823  * Handlers for reactive objects and arrays in the state.

   824  */

   825 const stateHandlers = {

   826   get(target, key, receiver) {

   827     /*

   828      * The property should not be reactive for the following cases:

   829      * 1. While using the `peek` function to read the property.

   830      * 2. The property exists but comes from the Object or Array prototypes.

   831      * 3. The property key is a known symbol.

   832      */

   833     if (peeking || !target.hasOwnProperty(key) && key in target || typeof key === 'symbol' && wellKnownSymbols.has(key)) {

   834       return Reflect.get(target, key, receiver);

   835     }

   836 

   837     // At this point, the property should be reactive.

   838     const desc = Object.getOwnPropertyDescriptor(target, key);

   839     const prop = getPropSignal(receiver, key, desc);

   840     const result = prop.getComputed().value;

   841 

   842     /*

   843      * Check if the property is a synchronous function. If it is, set the

   844      * default namespace. Synchronous functions always run in the proper scope,

   845      * which is set by the Directives component.

   846      */

   847     if (typeof result === 'function') {

   848       const ns = getNamespaceFromProxy(receiver);

   849       return (...args) => {

   850         setNamespace(ns);

   851         try {

   852           return result.call(receiver, ...args);

   853         } finally {

   854           resetNamespace();

   855         }

   856       };

   857     }

   858     return result;

   859   },

   860   set(target, key, value, receiver) {

   861     if (readOnlyProxies.has(receiver)) {

   862       return false;

   863     }

   864     setNamespace(getNamespaceFromProxy(receiver));

   865     try {

   866       return Reflect.set(target, key, value, receiver);

   867     } finally {

   868       resetNamespace();

   869     }

   870   },

   871   defineProperty(target, key, desc) {

   872     if (readOnlyProxies.has(getProxyFromObject(target))) {

   873       return false;

   874     }

   875     const isNew = !(key in target);

   876     const result = Reflect.defineProperty(target, key, desc);

   877     if (result) {

   878       const receiver = getProxyFromObject(target);

   879       const prop = getPropSignal(receiver, key);

   880       const {

   881         get,

   882         value

   883       } = desc;

   884       if (get) {

   885         prop.setGetter(get);

   886       } else {

   887         const ns = getNamespaceFromProxy(receiver);

   888         prop.setValue(shouldProxy(value) ? proxifyState(ns, value) : value);

   889       }

   890       if (isNew && objToIterable.has(target)) {

   891         objToIterable.get(target).value++;

   892       }

   893 

   894       /*

   895        * Modify the `length` property value only if the related

   896        * `PropSignal` exists, which means that there are subscriptions to

   897        * this property.

   898        */

   899       if (Array.isArray(target) && proxyToProps.get(receiver)?.has('length')) {

   900         const length = getPropSignal(receiver, 'length');

   901         length.setValue(target.length);

   902       }

   903     }

   904     return result;

   905   },

   906   deleteProperty(target, key) {

   907     if (readOnlyProxies.has(getProxyFromObject(target))) {

   908       return false;

   909     }

   910     const result = Reflect.deleteProperty(target, key);

   911     if (result) {

   912       const prop = getPropSignal(getProxyFromObject(target), key);

   913       prop.setValue(undefined);

   914       if (objToIterable.has(target)) {

   915         objToIterable.get(target).value++;

   916       }

   917     }

   918     return result;

   919   },

   920   ownKeys(target) {

   921     if (!objToIterable.has(target)) {

   922       objToIterable.set(target, signals_core_module_d(0));

   923     }

   924     /*

   925      *This subscribes to the signal while preventing the minifier from

   926      * deleting this line in production.

   927      */

   928     objToIterable._ = objToIterable.get(target).value;

   929     return Reflect.ownKeys(target);

   930   }

   931 };

   932 

   933 /**

   934  * Returns the proxy associated with the given state object, creating it if it

   935  * does not exist.

   936  *

   937  * @param namespace        The namespace that will be associated to this proxy.

   938  * @param obj              The object to proxify.

   939  * @param options          Options.

   940  * @param options.readOnly Read-only.

   941  *

   942  * @throws Error if the object cannot be proxified. Use {@link shouldProxy} to

   943  *         check if a proxy can be created for a specific object.

   944  *

   945  * @return The associated proxy.

   946  */

   947 const proxifyState = (namespace, obj, options) => {

   948   const proxy = createProxy(namespace, obj, stateHandlers);

   949   if (options?.readOnly) {

   950     readOnlyProxies.add(proxy);

   951   }

   952   return proxy;

   953 };

   954 

   955 /**

   956  * Reads the value of the specified property without subscribing to it.

   957  *

   958  * @param obj The object to read the property from.

   959  * @param key The property key.

   960  * @return The property value.

   961  */

   962 const peek = (obj, key) => {

   963   peeking = true;

   964   try {

   965     return obj[key];

   966   } finally {

   967     peeking = false;

   968   }

   969 };

   970 

   971 /**

   972  * Internal recursive implementation for {@link deepMerge | `deepMerge`}.

   973  *

   974  * @param target   The target object.

   975  * @param source   The source object containing new values and props.

   976  * @param override Whether existing props should be overwritten or not (`true`

   977  *                 by default).

   978  */

   979 const deepMergeRecursive = (target, source, override = true) => {

   980   // If target is not a plain object and the source is, we don't need to merge

   981   // them because the source will be used as the new value of the target.

   982   if (!(isPlainObject(target) && isPlainObject(source))) {

   983     return;

   984   }

   985   let hasNewKeys = false;

   986   for (const key in source) {

   987     const isNew = !(key in target);

   988     hasNewKeys = hasNewKeys || isNew;

   989     const desc = Object.getOwnPropertyDescriptor(source, key);

   990     const proxy = getProxyFromObject(target);

   991     const propSignal = !!proxy && hasPropSignal(proxy, key) && getPropSignal(proxy, key);

   992 

   993     // Handle getters and setters

   994     if (typeof desc.get === 'function' || typeof desc.set === 'function') {

   995       if (override || isNew) {

   996         // Because we are setting a getter or setter, we need to use

   997         // Object.defineProperty to define the property on the target object.

   998         Object.defineProperty(target, key, {

   999           ...desc,

  1000           configurable: true,

  1001           enumerable: true

  1002         });

  1003         // Update the getter in the property signal if it exists

  1004         if (desc.get && propSignal) {

  1005           propSignal.setGetter(desc.get);

  1006         }

  1007       }

  1008 

  1009       // Handle nested objects

  1010     } else if (isPlainObject(source[key])) {

  1011       const targetValue = Object.getOwnPropertyDescriptor(target, key)?.value;

  1012       if (isNew || override && !isPlainObject(targetValue)) {

  1013         // Create a new object if the property is new or needs to be overridden

  1014         target[key] = {};

  1015         if (propSignal) {

  1016           // Create a new proxified state for the nested object

  1017           const ns = getNamespaceFromProxy(proxy);

  1018           propSignal.setValue(proxifyState(ns, target[key]));

  1019         }

  1020         deepMergeRecursive(target[key], source[key], override);

  1021       }

  1022       // Both target and source are plain objects, merge them recursively

  1023       else if (isPlainObject(targetValue)) {

  1024         deepMergeRecursive(target[key], source[key], override);

  1025       }

  1026 

  1027       // Handle primitive values and non-plain objects

  1028     } else if (override || isNew) {

  1029       Object.defineProperty(target, key, desc);

  1030       if (propSignal) {

  1031         const {

  1032           value

  1033         } = desc;

  1034         const ns = getNamespaceFromProxy(proxy);

  1035         // Proxify the value if necessary before setting it in the signal

  1036         propSignal.setValue(shouldProxy(value) ? proxifyState(ns, value) : value);

  1037       }

  1038     }

  1039   }

  1040   if (hasNewKeys && objToIterable.has(target)) {

  1041     objToIterable.get(target).value++;

  1042   }

  1043 };

  1044 

  1045 /**

  1046  * Recursively update prop values inside the passed `target` and nested plain

  1047  * objects, using the values present in `source`. References to plain objects

  1048  * are kept, only updating props containing primitives or arrays. Arrays are

  1049  * replaced instead of merged or concatenated.

  1050  *

  1051  * If the `override` parameter is set to `false`, then all values in `target`

  1052  * are preserved, and only new properties from `source` are added.

  1053  *

  1054  * @param target   The target object.

  1055  * @param source   The source object containing new values and props.

  1056  * @param override Whether existing props should be overwritten or not (`true`

  1057  *                 by default).

  1058  */

  1059 const deepMerge = (target, source, override = true) => signals_core_module_r(() => deepMergeRecursive(getObjectFromProxy(target) || target, source, override));

  1060 

  1061 ;// ./node_modules/@wordpress/interactivity/build-module/proxies/store.js

  1062 /**

  1063  * Internal dependencies

  1064  */

  1065 

  1066 /**

  1067  * External dependencies

  1068  */

  1069 

  1070 

  1071 

  1072 /**

  1073  * Identifies the store proxies handling the root objects of each store.

  1074  */

  1075 const storeRoots = new WeakSet();

  1076 

  1077 /**

  1078  * Handlers for store proxies.

  1079  */

  1080 const storeHandlers = {

  1081   get: (target, key, receiver) => {

  1082     const result = Reflect.get(target, key);

  1083     const ns = getNamespaceFromProxy(receiver);

  1084 

  1085     /*

  1086      * Check if the proxy is the store root and no key with that name exist. In

  1087      * that case, return an empty object for the requested key.

  1088      */

  1089     if (typeof result === 'undefined' && storeRoots.has(receiver)) {

  1090       const obj = {};

  1091       Reflect.set(target, key, obj);

  1092       return proxifyStore(ns, obj, false);

  1093     }

  1094 

  1095     /*

  1096      * Check if the property is a function. If it is, add the store

  1097      * namespace to the stack and wrap the function with the current scope.

  1098      * The `withScope` util handles both synchronous functions and generator

  1099      * functions.

  1100      */

  1101     if (typeof result === 'function') {

  1102       setNamespace(ns);

  1103       const scoped = withScope(result);

  1104       resetNamespace();

  1105       return scoped;

  1106     }

  1107 

  1108     // Check if the property is an object. If it is, proxyify it.

  1109     if (isPlainObject(result) && shouldProxy(result)) {

  1110       return proxifyStore(ns, result, false);

  1111     }

  1112     return result;

  1113   }

  1114 };

  1115 

  1116 /**

  1117  * Returns the proxy associated with the given store object, creating it if it

  1118  * does not exist.

  1119  *

  1120  * @param namespace The namespace that will be associated to this proxy.

  1121  * @param obj       The object to proxify.

  1122  *

  1123  * @param isRoot    Whether the passed object is the store root object.

  1124  * @throws Error if the object cannot be proxified. Use {@link shouldProxy} to

  1125  *         check if a proxy can be created for a specific object.

  1126  *

  1127  * @return The associated proxy.

  1128  */

  1129 const proxifyStore = (namespace, obj, isRoot = true) => {

  1130   const proxy = createProxy(namespace, obj, storeHandlers);

  1131   if (proxy && isRoot) {

  1132     storeRoots.add(proxy);

  1133   }

  1134   return proxy;

  1135 };

  1136