PluginProbe
Gutenberg / 24.1.0
Gutenberg v24.1.0
24.1.0 24.0.0 23.9.1 23.9.0 23.8.0 23.7.2 23.7.1 23.7.0 23.6.1 23.6.2 23.6.0 23.5.3 23.5.2 23.5.1 23.5.0 23.4.0 23.3.2 23.3.1 23.3.0 23.2.0 23.2.1 23.2.2 23.1.1 23.1.0 23.0.1 All 404 releases
← All changes | build/modules/interactivity/index.js +624 -606 23.5.2 → 24.1.0 View file →
@@ -1198,11 +1198,38 @@
1198 1198 return d3(n3);
1199 1199 }, []);
1200 1200 }
1201 1201
1202 -// packages/interactivity/build-module/directives.mjs
1202 +// packages/interactivity/build-module/hooks.mjs
1203 1203 init_preact_module();
1204 1204
1205 +// packages/interactivity/build-module/proxies/registry.mjs
1206 +var objToProxy = /* @__PURE__ */ new WeakMap();
1207 +var proxyToObj = /* @__PURE__ */ new WeakMap();
1208 +var proxyToNs = /* @__PURE__ */ new WeakMap();
1209 +var supported = /* @__PURE__ */ new Set([Object, Array]);
1210 +var createProxy = (namespace, obj, handlers) => {
1211 + if (!shouldProxy(obj)) {
1212 + throw Error("This object cannot be proxified.");
1213 + }
1214 + if (!objToProxy.has(obj)) {
1215 + const proxy = new Proxy(obj, handlers);
1216 + objToProxy.set(obj, proxy);
1217 + proxyToObj.set(proxy, obj);
1218 + proxyToNs.set(proxy, namespace);
1219 + }
1220 + return objToProxy.get(obj);
1221 +};
1222 +var getProxyFromObject = (obj) => objToProxy.get(obj);
1223 +var getNamespaceFromProxy = (proxy) => proxyToNs.get(proxy);
1224 +var shouldProxy = (candidate) => {
1225 + if (typeof candidate !== "object" || candidate === null) {
1226 + return false;
1227 + }
1228 + return !proxyToNs.has(candidate) && supported.has(candidate.constructor);
1229 +};
1230 +var getObjectFromProxy = (proxy) => proxyToObj.get(proxy);
1231 +
1205 1232 // packages/interactivity/build-module/namespaces.mjs
1206 1233 var namespaceStack = [];
1207 1234 var getNamespace = () => namespaceStack.slice(-1)[0];
1208 1235 var setNamespace = (namespace) => {
@@ -1211,61 +1238,8 @@
1211 1238 var resetNamespace = () => {
1212 1239 namespaceStack.pop();
1213 1240 };
1214 1241
1215 -// packages/interactivity/build-module/scopes.mjs
1216 -var scopeStack = [];
1217 -var getScope = () => scopeStack.slice(-1)[0];
1218 -var setScope = (scope) => {
1219 - scopeStack.push(scope);
1220 -};
1221 -var resetScope = () => {
1222 - scopeStack.pop();
1223 -};
1224 -var throwNotInScope = (method) => {
1225 - throw Error(
1226 - `Cannot call \`${method}()\` 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)\`.`
1227 - );
1228 -};
1229 -var getContext = (namespace) => {
1230 - const scope = getScope();
1231 - if (true) {
1232 - if (!scope) {
1233 - throwNotInScope("getContext");
1234 - }
1235 - }
1236 - return scope.context[namespace || getNamespace()];
1237 -};
1238 -var getElement = () => {
1239 - const scope = getScope();
1240 - let deepReadOnlyOptions = {};
1241 - if (true) {
1242 - if (!scope) {
1243 - throwNotInScope("getElement");
1244 - }
1245 - deepReadOnlyOptions = {
1246 - errorMessage: "Don't mutate the attributes from `getElement`, use `data-wp-bind` to modify the attributes of an element instead."
1247 - };
1248 - }
1249 - const { ref, attributes } = scope;
1250 - return Object.freeze({
1251 - ref: ref.current,
1252 - attributes: deepReadOnly(attributes, deepReadOnlyOptions)
1253 - });
1254 -};
1255 -var navigationContextSignal = d3(0);
1256 -function getServerContext(namespace) {
1257 - const scope = getScope();
1258 - if (true) {
1259 - if (!scope) {
1260 - throwNotInScope("getServerContext");
1261 - }
1262 - }
1263 - getServerContext.subscribe = navigationContextSignal.value;
1264 - return deepClone(scope.serverContext[namespace || getNamespace()]);
1265 -}
1266 -getServerContext.subscribe = 0;
1267 -
1268 1242 // packages/interactivity/build-module/utils.mjs
1269 1243 var afterNextFrame = (callback) => {
1270 1244 return new Promise((resolve2) => {
1271 1245 const done = () => {
@@ -1486,37 +1460,60 @@
1486 1460 }
1487 1461 return source;
1488 1462 }
1489 1463
1490 -// packages/interactivity/build-module/hooks.mjs
1491 -init_preact_module();
1492 -
1493 -// packages/interactivity/build-module/proxies/registry.mjs
1494 -var objToProxy = /* @__PURE__ */ new WeakMap();
1495 -var proxyToObj = /* @__PURE__ */ new WeakMap();
1496 -var proxyToNs = /* @__PURE__ */ new WeakMap();
1497 -var supported = /* @__PURE__ */ new Set([Object, Array]);
1498 -var createProxy = (namespace, obj, handlers) => {
1499 - if (!shouldProxy(obj)) {
1500 - throw Error("This object cannot be proxified.");
1464 +// packages/interactivity/build-module/scopes.mjs
1465 +var scopeStack = [];
1466 +var getScope = () => scopeStack.slice(-1)[0];
1467 +var setScope = (scope) => {
1468 + scopeStack.push(scope);
1469 +};
1470 +var resetScope = () => {
1471 + scopeStack.pop();
1472 +};
1473 +var throwNotInScope = (method) => {
1474 + throw Error(
1475 + `Cannot call \`${method}()\` 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)\`.`
1476 + );
1477 +};
1478 +var getContext = (namespace) => {
1479 + const scope = getScope();
1480 + if (true) {
1481 + if (!scope) {
1482 + throwNotInScope("getContext");
1483 + }
1501 1484 }
1502 - if (!objToProxy.has(obj)) {
1503 - const proxy = new Proxy(obj, handlers);
1504 - objToProxy.set(obj, proxy);
1505 - proxyToObj.set(proxy, obj);
1506 - proxyToNs.set(proxy, namespace);
1485 + return scope.context[namespace || getNamespace()];
1486 +};
1487 +var getElement = () => {
1488 + const scope = getScope();
1489 + let deepReadOnlyOptions = {};
1490 + if (true) {
1491 + if (!scope) {
1492 + throwNotInScope("getElement");
1493 + }
1494 + deepReadOnlyOptions = {
1495 + errorMessage: "Don't mutate the attributes from `getElement`, use `data-wp-bind` to modify the attributes of an element instead."
1496 + };
1507 1497 }
1508 - return objToProxy.get(obj);
1498 + const { ref, attributes } = scope;
1499 + return Object.freeze({
1500 + ref: ref.current,
1501 + attributes: deepReadOnly(attributes, deepReadOnlyOptions)
1502 + });
1509 1503 };
1510 -var getProxyFromObject = (obj) => objToProxy.get(obj);
1511 -var getNamespaceFromProxy = (proxy) => proxyToNs.get(proxy);
1512 -var shouldProxy = (candidate) => {
1513 - if (typeof candidate !== "object" || candidate === null) {
1514 - return false;
1504 +var navigationContextSignal = d3(0);
1505 +function getServerContext(namespace) {
1506 + const scope = getScope();
1507 + if (true) {
1508 + if (!scope) {
1509 + throwNotInScope("getServerContext");
1510 + }
1515 1511 }
1516 - return !proxyToNs.has(candidate) && supported.has(candidate.constructor);
1517 -};
1518 -var getObjectFromProxy = (proxy) => proxyToObj.get(proxy);
1512 + getServerContext.subscribe = navigationContextSignal.value;
1513 + return deepClone(scope.serverContext[namespace || getNamespace()]);
1514 +}
1515 +getServerContext.subscribe = 0;
1519 1516
1520 1517 // packages/interactivity/build-module/proxies/signals.mjs
1521 1518 var NO_SCOPE = {};
1522 1519 var PropSignal = class {
@@ -1788,9 +1785,12 @@
1788 1785 propSignal.setPendingGetter(desc.get);
1789 1786 }
1790 1787 }
1791 1788 } else if (isPlainObject(source[key])) {
1792 - const targetValue = Object.getOwnPropertyDescriptor(target, key)?.value;
1789 + const targetValue = Object.getOwnPropertyDescriptor(
1790 + target,
1791 + key
1792 + )?.value;
1793 1793 if (isNew || override && !isPlainObject(targetValue)) {
1794 1794 target[key] = {};
1795 1795 if (propSignal) {
1796 1796 const ns = getNamespaceFromProxy(proxy);
@@ -2165,9 +2165,9 @@
2165 2165 old(vnode);
2166 2166 }
2167 2167 };
2168 2168
2169 -// packages/interactivity/build-module/directives.mjs
2169 +// packages/interactivity/build-module/directives/utils/warnings.mjs
2170 2170 var warnUniqueIdWithTwoHyphens = (prefix, suffix, uniqueId) => {
2171 2171 if (true) {
2172 2172 warn(
2173 2173 `The usage of data-wp-${prefix}--${suffix}${uniqueId ? `--${uniqueId}` : ""} (two hyphens for unique ID) is deprecated and will stop working in WordPress 7.1. Please use data-wp-${prefix}${uniqueId ? `--${suffix}---${uniqueId}` : `---${suffix}`} (three hyphens for unique ID) from now on.`
@@ -2187,8 +2187,351 @@
2187 2187 `The usage of data-wp-${wrongPrefix} is deprecated and will stop working in WordPress 7.0. Please, use data-wp-${rightPrefix} with the withSyncEvent() helper from now on.`
2188 2188 );
2189 2189 }
2190 2190 };
2191 +
2192 +// packages/interactivity/build-module/directives/bind.mjs
2193 +directive("bind", ({ directives: { bind }, element, evaluate }) => {
2194 + bind.filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2195 + if (entry.uniqueId) {
2196 + if (true) {
2197 + warnUniqueIdNotSupported("bind", entry.uniqueId);
2198 + }
2199 + return;
2200 + }
2201 + const attribute = entry.suffix;
2202 + let result = evaluate(entry);
2203 + if (result === PENDING_GETTER) {
2204 + return;
2205 + }
2206 + if (typeof result === "function") {
2207 + result = result();
2208 + }
2209 + element.props[attribute] = result;
2210 + useInit(() => {
2211 + const el = element.ref.current;
2212 + if (attribute === "style") {
2213 + if (typeof result === "string") {
2214 + el.style.cssText = result;
2215 + }
2216 + return;
2217 + } else if (attribute !== "width" && attribute !== "height" && attribute !== "href" && attribute !== "list" && attribute !== "form" && /*
2218 + * The value for `tabindex` follows the parsing rules for an
2219 + * integer. If that fails, or if the attribute isn't present, then
2220 + * the browsers should "follow platform conventions to determine if
2221 + * the element should be considered as a focusable area",
2222 + * practically meaning that most elements get a default of `-1` (not
2223 + * focusable), but several also get a default of `0` (focusable in
2224 + * order after all elements with a positive `tabindex` value).
2225 + *
2226 + * @see https://html.spec.whatwg.org/#tabindex-value
2227 + */
2228 + attribute !== "tabIndex" && attribute !== "download" && attribute !== "rowSpan" && attribute !== "colSpan" && attribute !== "role" && attribute !== "popover" && attribute in el) {
2229 + try {
2230 + el[attribute] = result === null || result === void 0 ? "" : result;
2231 + return;
2232 + } catch {
2233 + }
2234 + }
2235 + if (result !== null && result !== void 0 && (result !== false || attribute[4] === "-")) {
2236 + el.setAttribute(
2237 + attribute,
2238 + attribute === "popover" && result === true ? "" : result
2239 + );
2240 + } else {
2241 + el.removeAttribute(attribute);
2242 + }
2243 + });
2244 + });
2245 +});
2246 +
2247 +// packages/interactivity/build-module/directives/class.mjs
2248 +directive(
2249 + "class",
2250 + ({ directives: { class: classNames }, element, evaluate }) => {
2251 + classNames.filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2252 + const className = entry.uniqueId ? `${entry.suffix}---${entry.uniqueId}` : entry.suffix;
2253 + let result = evaluate(entry);
2254 + if (result === PENDING_GETTER) {
2255 + return;
2256 + }
2257 + if (typeof result === "function") {
2258 + result = result();
2259 + }
2260 + const currentClass = element.props.class || "";
2261 + const classFinder = new RegExp(
2262 + `(^|\\s)${className}(\\s|$)`,
2263 + "g"
2264 + );
2265 + if (!result) {
2266 + element.props.class = currentClass.replace(classFinder, " ").trim();
2267 + } else if (!classFinder.test(currentClass)) {
2268 + element.props.class = currentClass ? `${currentClass} ${className}` : className;
2269 + }
2270 + useInit(() => {
2271 + if (!result) {
2272 + element.ref.current.classList.remove(className);
2273 + } else {
2274 + element.ref.current.classList.add(className);
2275 + }
2276 + });
2277 + });
2278 + }
2279 +);
2280 +
2281 +// packages/interactivity/build-module/directives/context.mjs
2282 +init_preact_module();
2283 +directive(
2284 + "context",
2285 + ({
2286 + directives: { context: context2 },
2287 + props: { children },
2288 + context: inheritedContext
2289 + }) => {
2290 + const entries = context2.filter(isDefaultDirectiveSuffix).reverse();
2291 + if (!entries.length) {
2292 + if (true) {
2293 + warn(
2294 + "The usage of data-wp-context--unique-id (two hyphens) is not supported. To add a unique ID to the directive, please use data-wp-context---unique-id (three hyphens) instead."
2295 + );
2296 + }
2297 + return;
2298 + }
2299 + const { Provider } = inheritedContext;
2300 + const { client: inheritedClient, server: inheritedServer } = x2(inheritedContext);
2301 + const client = A2({});
2302 + const server = {};
2303 + const result = {
2304 + client: { ...inheritedClient },
2305 + server: { ...inheritedServer }
2306 + };
2307 + const namespaces2 = /* @__PURE__ */ new Set();
2308 + entries.forEach(({ value, namespace, uniqueId }) => {
2309 + if (!isPlainObject(value)) {
2310 + if (true) {
2311 + warn(
2312 + `The value of data-wp-context${uniqueId ? `---${uniqueId}` : ""} on the ${namespace} namespace must be a valid stringified JSON object.`
2313 + );
2314 + }
2315 + return;
2316 + }
2317 + if (!client.current[namespace]) {
2318 + client.current[namespace] = proxifyState(namespace, {});
2319 + }
2320 + deepMerge(client.current[namespace], deepClone(value), false);
2321 + server[namespace] = value;
2322 + namespaces2.add(namespace);
2323 + });
2324 + namespaces2.forEach((namespace) => {
2325 + result.client[namespace] = proxifyContext(
2326 + client.current[namespace],
2327 + inheritedClient[namespace]
2328 + );
2329 + result.server[namespace] = proxifyContext(
2330 + server[namespace],
2331 + inheritedServer[namespace]
2332 + );
2333 + });
2334 + return k(Provider, { value: result }, children);
2335 + },
2336 + { priority: 5 }
2337 +);
2338 +
2339 +// packages/interactivity/build-module/directives/each.mjs
2340 +init_preact_module();
2341 +var evaluateItemKey = (inheritedValue, namespace, item, itemProp, eachKey) => {
2342 + const clientContextWithItem = {
2343 + ...inheritedValue.client,
2344 + [namespace]: {
2345 + ...inheritedValue.client[namespace],
2346 + [itemProp]: item
2347 + }
2348 + };
2349 + const scope = {
2350 + ...getScope(),
2351 + context: clientContextWithItem,
2352 + serverContext: inheritedValue.server
2353 + };
2354 + return eachKey ? getEvaluate({ scope })(eachKey) : item;
2355 +};
2356 +var useItemContexts = function* (inheritedValue, namespace, items, itemProp, eachKey) {
2357 + const { current: itemContexts } = A2(/* @__PURE__ */ new Map());
2358 + for (const item of items) {
2359 + const key = evaluateItemKey(
2360 + inheritedValue,
2361 + namespace,
2362 + item,
2363 + itemProp,
2364 + eachKey
2365 + );
2366 + if (!itemContexts.has(key)) {
2367 + itemContexts.set(
2368 + key,
2369 + proxifyContext(
2370 + proxifyState(namespace, {
2371 + // Inits the item prop in the context to shadow it in case
2372 + // it was inherited from the parent context. The actual
2373 + // value is set in the `wp-each` directive later on.
2374 + [itemProp]: void 0
2375 + }),
2376 + inheritedValue.client[namespace]
2377 + )
2378 + );
2379 + }
2380 + yield [item, itemContexts.get(key), key];
2381 + }
2382 +};
2383 +directive(
2384 + "each",
2385 + ({
2386 + directives: { each, "each-key": eachKey },
2387 + context: inheritedContext,
2388 + element,
2389 + evaluate
2390 + }) => {
2391 + if (element.type !== "template") {
2392 + if (true) {
2393 + warn(
2394 + "The data-wp-each directive can only be used on <template> elements."
2395 + );
2396 + }
2397 + return;
2398 + }
2399 + const { Provider } = inheritedContext;
2400 + const inheritedValue = x2(inheritedContext);
2401 + const [entry] = each;
2402 + const { namespace, suffix, uniqueId } = entry;
2403 + if (each.length > 1) {
2404 + if (true) {
2405 + warn(
2406 + "The usage of multiple data-wp-each directives on the same element is not supported. Please pick only one."
2407 + );
2408 + }
2409 + return;
2410 + }
2411 + if (uniqueId) {
2412 + if (true) {
2413 + warnUniqueIdNotSupported("each", uniqueId);
2414 + }
2415 + return;
2416 + }
2417 + let iterable = evaluate(entry);
2418 + if (iterable === PENDING_GETTER) {
2419 + return;
2420 + }
2421 + if (typeof iterable === "function") {
2422 + iterable = iterable();
2423 + }
2424 + if (typeof iterable?.[Symbol.iterator] !== "function") {
2425 + return;
2426 + }
2427 + const itemProp = suffix ? kebabToCamelCase(suffix) : "item";
2428 + const result = [];
2429 + const itemContexts = useItemContexts(
2430 + inheritedValue,
2431 + namespace,
2432 + iterable,
2433 + itemProp,
2434 + eachKey?.[0]
2435 + );
2436 + for (const [item, itemContext, key] of itemContexts) {
2437 + const mergedContext = {
2438 + client: {
2439 + ...inheritedValue.client,
2440 + [namespace]: itemContext
2441 + },
2442 + server: { ...inheritedValue.server }
2443 + };
2444 + mergedContext.client[namespace][itemProp] = item;
2445 + result.push(
2446 + k(
2447 + Provider,
2448 + { value: mergedContext, key },
2449 + element.props.content
2450 + )
2451 + );
2452 + }
2453 + return result;
2454 + },
2455 + { priority: 20 }
2456 +);
2457 +directive(
2458 + "each-child",
2459 + ({ directives: { "each-child": eachChild }, element, evaluate }) => {
2460 + const entry = eachChild.find(isDefaultDirectiveSuffix);
2461 + if (!entry) {
2462 + return;
2463 + }
2464 + const iterable = evaluate(entry);
2465 + return iterable === PENDING_GETTER ? element : null;
2466 + },
2467 + { priority: 1 }
2468 +);
2469 +
2470 +// packages/interactivity/build-module/directives/ignore.mjs
2471 +init_preact_module();
2472 +directive(
2473 + "ignore",
2474 + ({
2475 + element: {
2476 + type: Type,
2477 + props: { innerHTML, ...rest }
2478 + }
2479 + }) => {
2480 + if (true) {
2481 + warn(
2482 + "The data-wp-ignore directive is deprecated and will be removed in version 7.0."
2483 + );
2484 + }
2485 + const cached = T2(() => innerHTML, []);
2486 + return k(Type, {
2487 + dangerouslySetInnerHTML: { __html: cached },
2488 + ...rest
2489 + });
2490 + }
2491 +);
2492 +
2493 +// packages/interactivity/build-module/directives/init.mjs
2494 +directive("init", ({ directives: { init }, evaluate }) => {
2495 + init.forEach((entry) => {
2496 + if (true) {
2497 + if (entry.suffix) {
2498 + warnUniqueIdWithTwoHyphens("init", entry.suffix);
2499 + }
2500 + }
2501 + useInit(() => {
2502 + let start;
2503 + if (true) {
2504 + if (true) {
2505 + start = performance.now();
2506 + }
2507 + }
2508 + let result = evaluate(entry);
2509 + if (typeof result === "function") {
2510 + result = result();
2511 + }
2512 + if (true) {
2513 + if (true) {
2514 + performance.measure(
2515 + `interactivity api init ${entry.namespace}`,
2516 + {
2517 + start,
2518 + end: performance.now(),
2519 + detail: {
2520 + devtools: {
2521 + track: `IA: init ${entry.namespace}`
2522 + }
2523 + }
2524 + }
2525 + );
2526 + }
2527 + }
2528 + return result;
2529 + });
2530 + });
2531 +});
2532 +
2533 +// packages/interactivity/build-module/directives/on.mjs
2191 2534 function wrapEventAsync(event) {
2192 2535 const handler = {
2193 2536 get(target, prop, receiver) {
2194 2537 const value = target[prop];
@@ -2222,27 +2565,8 @@
2222 2565 }
2223 2566 };
2224 2567 return new Proxy(event, handler);
2225 2568 }
2226 -var newRule = /(?:([\u0080-\uFFFF\w-%@]+) *:? *([^{;]+?);|([^;}{]*?) *{)|(}\s*)/g;
2227 -var ruleClean = /\/\*[^]*?\*\/| +/g;
2228 -var ruleNewline = /\n+/g;
2229 -var empty = " ";
2230 -var cssStringToObject = (val) => {
2231 - const tree = [{}];
2232 - let block, left;
2233 - while (block = newRule.exec(val.replace(ruleClean, ""))) {
2234 - if (block[4]) {
2235 - tree.shift();
2236 - } else if (block[3]) {
2237 - left = block[3].replace(ruleNewline, empty).trim();
2238 - tree.unshift(tree[0][left] = tree[0][left] || {});
2239 - } else {
2240 - tree[0][block[1]] = block[2].replace(ruleNewline, empty).trim();
2241 - }
2242 - }
2243 - return tree[0];
2244 -};
2245 2569 var getGlobalEventDirective = (type) => {
2246 2570 return ({ directives, evaluate }) => {
2247 2571 directives[`on-${type}`].filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2248 2572 const suffixParts = entry.suffix.split("--", 2);
@@ -2272,50 +2596,8 @@
2272 2596 });
2273 2597 });
2274 2598 };
2275 2599 };
2276 -var evaluateItemKey = (inheritedValue, namespace, item, itemProp, eachKey) => {
2277 - const clientContextWithItem = {
2278 - ...inheritedValue.client,
2279 - [namespace]: {
2280 - ...inheritedValue.client[namespace],
2281 - [itemProp]: item
2282 - }
2283 - };
2284 - const scope = {
2285 - ...getScope(),
2286 - context: clientContextWithItem,
2287 - serverContext: inheritedValue.server
2288 - };
2289 - return eachKey ? getEvaluate({ scope })(eachKey) : item;
2290 -};
2291 -var useItemContexts = function* (inheritedValue, namespace, items, itemProp, eachKey) {
2292 - const { current: itemContexts } = A2(/* @__PURE__ */ new Map());
2293 - for (const item of items) {
2294 - const key = evaluateItemKey(
2295 - inheritedValue,
2296 - namespace,
2297 - item,
2298 - itemProp,
2299 - eachKey
2300 - );
2301 - if (!itemContexts.has(key)) {
2302 - itemContexts.set(
2303 - key,
2304 - proxifyContext(
2305 - proxifyState(namespace, {
2306 - // Inits the item prop in the context to shadow it in case
2307 - // it was inherited from the parent context. The actual
2308 - // value is set in the `wp-each` directive later on.
2309 - [itemProp]: void 0
2310 - }),
2311 - inheritedValue.client[namespace]
2312 - )
2313 - );
2314 - }
2315 - yield [item, itemContexts.get(key), key];
2316 - }
2317 -};
2318 2600 var getGlobalAsyncEventDirective = (type) => {
2319 2601 return ({ directives, evaluate }) => {
2320 2602 directives[`on-async-${type}`].filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2321 2603 if (true) {
@@ -2338,115 +2620,33 @@
2338 2620 });
2339 2621 });
2340 2622 };
2341 2623 };
2342 -var routerRegions = /* @__PURE__ */ new Map();
2343 -var directives_default = () => {
2344 - directive(
2345 - "context",
2346 - ({
2347 - directives: { context: context2 },
2348 - props: { children },
2349 - context: inheritedContext
2350 - }) => {
2351 - const entries = context2.filter(isDefaultDirectiveSuffix).reverse();
2352 - if (!entries.length) {
2353 - if (true) {
2354 - warn(
2355 - "The usage of data-wp-context--unique-id (two hyphens) is not supported. To add a unique ID to the directive, please use data-wp-context---unique-id (three hyphens) instead."
2356 - );
2357 - }
2358 - return;
2359 - }
2360 - const { Provider } = inheritedContext;
2361 - const { client: inheritedClient, server: inheritedServer } = x2(inheritedContext);
2362 - const client = A2({});
2363 - const server = {};
2364 - const result = {
2365 - client: { ...inheritedClient },
2366 - server: { ...inheritedServer }
2367 - };
2368 - const namespaces2 = /* @__PURE__ */ new Set();
2369 - entries.forEach(({ value, namespace, uniqueId }) => {
2370 - if (!isPlainObject(value)) {
2371 - if (true) {
2372 - warn(
2373 - `The value of data-wp-context${uniqueId ? `---${uniqueId}` : ""} on the ${namespace} namespace must be a valid stringified JSON object.`
2374 - );
2375 - }
2376 - return;
2377 - }
2378 - if (!client.current[namespace]) {
2379 - client.current[namespace] = proxifyState(namespace, {});
2380 - }
2381 - deepMerge(
2382 - client.current[namespace],
2383 - deepClone(value),
2384 - false
2624 +directive("on", ({ directives: { on }, element, evaluate }) => {
2625 + const events = /* @__PURE__ */ new Map();
2626 + on.filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2627 + const suffixParts = entry.suffix.split("--", 2);
2628 + if (true) {
2629 + if (suffixParts[1]) {
2630 + warnUniqueIdWithTwoHyphens(
2631 + "on",
2632 + suffixParts[0],
2633 + suffixParts[1]
2385 2634 );
2386 - server[namespace] = value;
2387 - namespaces2.add(namespace);
2388 - });
2389 - namespaces2.forEach((namespace) => {
2390 - result.client[namespace] = proxifyContext(
2391 - client.current[namespace],
2392 - inheritedClient[namespace]
2393 - );
2394 - result.server[namespace] = proxifyContext(
2395 - server[namespace],
2396 - inheritedServer[namespace]
2397 - );
2398 - });
2399 - return k(Provider, { value: result }, children);
2400 - },
2401 - { priority: 5 }
2402 - );
2403 - directive("watch", ({ directives: { watch: watch2 }, evaluate }) => {
2404 - watch2.forEach((entry) => {
2405 - if (true) {
2406 - if (entry.suffix) {
2407 - warnUniqueIdWithTwoHyphens("watch", entry.suffix);
2408 - }
2409 2635 }
2410 - useWatch(() => {
2411 - let start;
2412 - if (true) {
2413 - if (true) {
2414 - start = performance.now();
2415 - }
2416 - }
2417 - let result = evaluate(entry);
2418 - if (typeof result === "function") {
2419 - result = result();
2420 - }
2421 - if (true) {
2422 - if (true) {
2423 - performance.measure(
2424 - `interactivity api watch ${entry.namespace}`,
2425 - {
2426 - start,
2427 - end: performance.now(),
2428 - detail: {
2429 - devtools: {
2430 - track: `IA: watch ${entry.namespace}`
2431 - }
2432 - }
2433 - }
2434 - );
2435 - }
2436 - }
2437 - return result;
2438 - });
2439 - });
2636 + }
2637 + if (!events.has(suffixParts[0])) {
2638 + events.set(suffixParts[0], /* @__PURE__ */ new Set());
2639 + }
2640 + events.get(suffixParts[0]).add(entry);
2440 2641 });
2441 - directive("init", ({ directives: { init }, evaluate }) => {
2442 - init.forEach((entry) => {
2443 - if (true) {
2444 - if (entry.suffix) {
2445 - warnUniqueIdWithTwoHyphens("init", entry.suffix);
2446 - }
2642 + events.forEach((entries, eventType) => {
2643 + const existingHandler = element.props[`on${eventType}`];
2644 + element.props[`on${eventType}`] = (event) => {
2645 + if (existingHandler) {
2646 + existingHandler(event);
2447 2647 }
2448 - useInit(() => {
2648 + entries.forEach((entry) => {
2449 2649 let start;
2450 2650 if (true) {
2451 2651 if (true) {
2452 2652 start = performance.now();
@@ -2451,22 +2651,25 @@
2451 2651 if (true) {
2452 2652 start = performance.now();
2453 2653 }
2454 2654 }
2455 - let result = evaluate(entry);
2655 + const result = evaluate(entry);
2456 2656 if (typeof result === "function") {
2457 - result = result();
2657 + if (!result?.sync) {
2658 + event = wrapEventAsync(event);
2659 + }
2660 + result(event);
2458 2661 }
2459 2662 if (true) {
2460 2663 if (true) {
2461 2664 performance.measure(
2462 - `interactivity api init ${entry.namespace}`,
2665 + `interactivity api on ${entry.namespace}`,
2463 2666 {
2464 2667 start,
2465 2668 end: performance.now(),
2466 2669 detail: {
2467 2670 devtools: {
2468 - track: `IA: init ${entry.namespace}`
2671 + track: `IA: on ${entry.namespace}`
2469 2672 }
2470 2673 }
2471 2674 }
2472 2675 );
@@ -2471,29 +2674,25 @@
2471 2674 }
2472 2675 );
2473 2676 }
2474 2677 }
2475 - return result;
2476 2678 });
2477 - });
2679 + };
2478 2680 });
2479 - directive("on", ({ directives: { on }, element, evaluate }) => {
2681 +});
2682 +directive(
2683 + "on-async",
2684 + ({ directives: { "on-async": onAsync }, element, evaluate }) => {
2685 + if (true) {
2686 + warnWithSyncEvent("on-async", "on");
2687 + }
2480 2688 const events = /* @__PURE__ */ new Map();
2481 - on.filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2482 - const suffixParts = entry.suffix.split("--", 2);
2483 - if (true) {
2484 - if (suffixParts[1]) {
2485 - warnUniqueIdWithTwoHyphens(
2486 - "on",
2487 - suffixParts[0],
2488 - suffixParts[1]
2489 - );
2490 - }
2689 + onAsync.filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2690 + const event = entry.suffix.split("--", 1)[0];
2691 + if (!events.has(event)) {
2692 + events.set(event, /* @__PURE__ */ new Set());
2491 2693 }
2492 - if (!events.has(suffixParts[0])) {
2493 - events.set(suffixParts[0], /* @__PURE__ */ new Set());
2494 - }
2495 - events.get(suffixParts[0]).add(entry);
2694 + events.get(event).add(entry);
2496 2695 });
2497 2696 events.forEach((entries, eventType) => {
2498 2697 const existingHandler = element.props[`on${eventType}`];
2499 2698 element.props[`on${eventType}`] = (event) => {
@@ -2499,155 +2698,157 @@
2499 2698 element.props[`on${eventType}`] = (event) => {
2500 2699 if (existingHandler) {
2501 2700 existingHandler(event);
2502 2701 }
2503 - entries.forEach((entry) => {
2504 - let start;
2505 - if (true) {
2506 - if (true) {
2507 - start = performance.now();
2508 - }
2509 - }
2702 + entries.forEach(async (entry) => {
2703 + await splitTask();
2510 2704 const result = evaluate(entry);
2511 2705 if (typeof result === "function") {
2512 - if (!result?.sync) {
2513 - event = wrapEventAsync(event);
2514 - }
2515 2706 result(event);
2516 2707 }
2517 - if (true) {
2518 - if (true) {
2519 - performance.measure(
2520 - `interactivity api on ${entry.namespace}`,
2521 - {
2522 - start,
2523 - end: performance.now(),
2524 - detail: {
2525 - devtools: {
2526 - track: `IA: on ${entry.namespace}`
2527 - }
2528 - }
2529 - }
2530 - );
2531 - }
2532 - }
2533 2708 });
2534 2709 };
2535 2710 });
2536 - });
2537 - directive(
2538 - "on-async",
2539 - ({ directives: { "on-async": onAsync }, element, evaluate }) => {
2711 + }
2712 +);
2713 +directive("on-window", getGlobalEventDirective("window"));
2714 +directive("on-document", getGlobalEventDirective("document"));
2715 +directive("on-async-window", getGlobalAsyncEventDirective("window"));
2716 +directive("on-async-document", getGlobalAsyncEventDirective("document"));
2717 +
2718 +// packages/interactivity/build-module/directives/router-region.mjs
2719 +init_preact_module();
2720 +var routerRegions = /* @__PURE__ */ new Map();
2721 +directive(
2722 + "router-region",
2723 + ({ directives: { "router-region": routerRegion } }) => {
2724 + const entry = routerRegion.find(isDefaultDirectiveSuffix);
2725 + if (!entry) {
2726 + return;
2727 + }
2728 + if (entry.suffix) {
2540 2729 if (true) {
2541 - warnWithSyncEvent("on-async", "on");
2730 + warn(
2731 + `Suffixes for the data-wp-router-region directive are not supported. Ignoring the directive with suffix "${entry.suffix}".`
2732 + );
2542 2733 }
2543 - const events = /* @__PURE__ */ new Map();
2544 - onAsync.filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2545 - const event = entry.suffix.split("--", 1)[0];
2546 - if (!events.has(event)) {
2547 - events.set(event, /* @__PURE__ */ new Set());
2548 - }
2549 - events.get(event).add(entry);
2550 - });
2551 - events.forEach((entries, eventType) => {
2552 - const existingHandler = element.props[`on${eventType}`];
2553 - element.props[`on${eventType}`] = (event) => {
2554 - if (existingHandler) {
2555 - existingHandler(event);
2556 - }
2557 - entries.forEach(async (entry) => {
2558 - await splitTask();
2559 - const result = evaluate(entry);
2560 - if (typeof result === "function") {
2561 - result(event);
2562 - }
2563 - });
2564 - };
2565 - });
2734 + return;
2566 2735 }
2567 - );
2568 - directive("on-window", getGlobalEventDirective("window"));
2569 - directive("on-document", getGlobalEventDirective("document"));
2570 - directive("on-async-window", getGlobalAsyncEventDirective("window"));
2571 - directive(
2572 - "on-async-document",
2573 - getGlobalAsyncEventDirective("document")
2574 - );
2575 - directive(
2576 - "class",
2577 - ({ directives: { class: classNames }, element, evaluate }) => {
2578 - classNames.filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2579 - const className = entry.uniqueId ? `${entry.suffix}---${entry.uniqueId}` : entry.suffix;
2580 - let result = evaluate(entry);
2581 - if (result === PENDING_GETTER) {
2582 - return;
2583 - }
2584 - if (typeof result === "function") {
2585 - result = result();
2586 - }
2587 - const currentClass = element.props.class || "";
2588 - const classFinder = new RegExp(
2589 - `(^|\\s)${className}(\\s|$)`,
2590 - "g"
2591 - );
2592 - if (!result) {
2593 - element.props.class = currentClass.replace(classFinder, " ").trim();
2594 - } else if (!classFinder.test(currentClass)) {
2595 - element.props.class = currentClass ? `${currentClass} ${className}` : className;
2596 - }
2597 - useInit(() => {
2598 - if (!result) {
2599 - element.ref.current.classList.remove(className);
2600 - } else {
2601 - element.ref.current.classList.add(className);
2602 - }
2603 - });
2604 - });
2736 + if (entry.uniqueId) {
2737 + if (true) {
2738 + warnUniqueIdNotSupported("router-region", entry.uniqueId);
2739 + }
2740 + return;
2605 2741 }
2606 - );
2607 - directive("style", ({ directives: { style }, element, evaluate }) => {
2608 - style.filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2609 - if (entry.uniqueId) {
2610 - if (true) {
2611 - warnUniqueIdNotSupported("style", entry.uniqueId);
2612 - }
2613 - return;
2742 + const regionId = typeof entry.value === "string" ? entry.value : entry.value.id;
2743 + if (!routerRegions.has(regionId)) {
2744 + routerRegions.set(regionId, d3());
2745 + }
2746 + const vdom = routerRegions.get(regionId).value;
2747 + _2(() => {
2748 + if (vdom && typeof vdom.type !== "string") {
2749 + navigationContextSignal.value = navigationContextSignal.peek() + 1;
2614 2750 }
2615 - const styleProp = entry.suffix;
2616 - let result = evaluate(entry);
2617 - if (result === PENDING_GETTER) {
2618 - return;
2751 + }, [vdom]);
2752 + if (vdom && typeof vdom.type !== "string") {
2753 + const previousScope = getScope();
2754 + return W(vdom, { previousScope });
2755 + }
2756 + return vdom;
2757 + },
2758 + { priority: 1 }
2759 +);
2760 +
2761 +// packages/interactivity/build-module/directives/run.mjs
2762 +directive("run", ({ directives: { run }, evaluate }) => {
2763 + run.forEach((entry) => {
2764 + if (true) {
2765 + if (entry.suffix) {
2766 + warnUniqueIdWithTwoHyphens("run", entry.suffix);
2619 2767 }
2620 - if (typeof result === "function") {
2621 - result = result();
2768 + }
2769 + let result = evaluate(entry);
2770 + if (typeof result === "function") {
2771 + result = result();
2772 + }
2773 + return result;
2774 + });
2775 +});
2776 +
2777 +// packages/interactivity/build-module/directives/style.mjs
2778 +var newRule = /(?:([\u0080-\uFFFF\w-%@]+) *:? *([^{;]+?);|([^;}{]*?) *{)|(}\s*)/g;
2779 +var ruleClean = /\/\*[^]*?\*\/| +/g;
2780 +var ruleNewline = /\n+/g;
2781 +var empty = " ";
2782 +var cssStringToObject = (val) => {
2783 + const tree = [{}];
2784 + let block, left;
2785 + while (block = newRule.exec(val.replace(ruleClean, ""))) {
2786 + if (block[4]) {
2787 + tree.shift();
2788 + } else if (block[3]) {
2789 + left = block[3].replace(ruleNewline, empty).trim();
2790 + tree.unshift(tree[0][left] = tree[0][left] || {});
2791 + } else {
2792 + tree[0][block[1]] = block[2].replace(ruleNewline, empty).trim();
2793 + }
2794 + }
2795 + return tree[0];
2796 +};
2797 +directive("style", ({ directives: { style }, element, evaluate }) => {
2798 + style.filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2799 + if (entry.uniqueId) {
2800 + if (true) {
2801 + warnUniqueIdNotSupported("style", entry.uniqueId);
2622 2802 }
2623 - element.props.style = element.props.style || {};
2624 - if (typeof element.props.style === "string") {
2625 - element.props.style = cssStringToObject(element.props.style);
2626 - }
2803 + return;
2804 + }
2805 + const styleProp = entry.suffix;
2806 + let result = evaluate(entry);
2807 + if (result === PENDING_GETTER) {
2808 + return;
2809 + }
2810 + if (typeof result === "function") {
2811 + result = result();
2812 + }
2813 + element.props.style = element.props.style || {};
2814 + if (typeof element.props.style === "string") {
2815 + element.props.style = cssStringToObject(element.props.style);
2816 + }
2817 + if (!result) {
2818 + delete element.props.style[styleProp];
2819 + } else {
2820 + element.props.style[styleProp] = result;
2821 + }
2822 + useInit(() => {
2627 2823 if (!result) {
2628 - delete element.props.style[styleProp];
2824 + element.ref.current.style.removeProperty(styleProp);
2629 2825 } else {
2630 - element.props.style[styleProp] = result;
2826 + element.ref.current.style.setProperty(styleProp, result);
2631 2827 }
2632 - useInit(() => {
2633 - if (!result) {
2634 - element.ref.current.style.removeProperty(styleProp);
2635 - } else {
2636 - element.ref.current.style.setProperty(styleProp, result);
2637 - }
2638 - });
2639 2828 });
2640 2829 });
2641 - directive("bind", ({ directives: { bind }, element, evaluate }) => {
2642 - bind.filter(isNonDefaultDirectiveSuffix).forEach((entry) => {
2643 - if (entry.uniqueId) {
2644 - if (true) {
2645 - warnUniqueIdNotSupported("bind", entry.uniqueId);
2646 - }
2647 - return;
2830 +});
2831 +
2832 +// packages/interactivity/build-module/directives/text.mjs
2833 +directive("text", ({ directives: { text }, element, evaluate }) => {
2834 + const entries = text.filter(isDefaultDirectiveSuffix);
2835 + if (!entries.length) {
2836 + if (true) {
2837 + warn(
2838 + "The usage of data-wp-text--suffix is not supported. Please use data-wp-text instead."
2839 + );
2840 + }
2841 + return;
2842 + }
2843 + entries.forEach((entry) => {
2844 + if (entry.uniqueId) {
2845 + if (true) {
2846 + warnUniqueIdNotSupported("text", entry.uniqueId);
2648 2847 }
2649 - const attribute = entry.suffix;
2848 + return;
2849 + }
2850 + try {
2650 2851 let result = evaluate(entry);
2651 2852 if (result === PENDING_GETTER) {
2652 2853 return;
2653 2854 }
@@ -2653,236 +2854,54 @@
2653 2854 }
2654 2855 if (typeof result === "function") {
2655 2856 result = result();
2656 2857 }
2657 - element.props[attribute] = result;
2658 - useInit(() => {
2659 - const el = element.ref.current;
2660 - if (attribute === "style") {
2661 - if (typeof result === "string") {
2662 - el.style.cssText = result;
2663 - }
2664 - return;
2665 - } else if (attribute !== "width" && attribute !== "height" && attribute !== "href" && attribute !== "list" && attribute !== "form" && /*
2666 - * The value for `tabindex` follows the parsing rules for an
2667 - * integer. If that fails, or if the attribute isn't present, then
2668 - * the browsers should "follow platform conventions to determine if
2669 - * the element should be considered as a focusable area",
2670 - * practically meaning that most elements get a default of `-1` (not
2671 - * focusable), but several also get a default of `0` (focusable in
2672 - * order after all elements with a positive `tabindex` value).
2673 - *
2674 - * @see https://html.spec.whatwg.org/#tabindex-value
2675 - */
2676 - attribute !== "tabIndex" && attribute !== "download" && attribute !== "rowSpan" && attribute !== "colSpan" && attribute !== "role" && attribute !== "popover" && attribute in el) {
2677 - try {
2678 - el[attribute] = result === null || result === void 0 ? "" : result;
2679 - return;
2680 - } catch {
2681 - }
2682 - }
2683 - if (result !== null && result !== void 0 && (result !== false || attribute[4] === "-")) {
2684 - el.setAttribute(
2685 - attribute,
2686 - attribute === "popover" && result === true ? "" : result
2687 - );
2688 - } else {
2689 - el.removeAttribute(attribute);
2690 - }
2691 - });
2692 - });
2858 + element.props.children = typeof result === "object" ? null : result.toString();
2859 + } catch {
2860 + element.props.children = null;
2861 + }
2693 2862 });
2694 - directive(
2695 - "ignore",
2696 - ({
2697 - element: {
2698 - type: Type,
2699 - props: { innerHTML, ...rest }
2863 +});
2864 +
2865 +// packages/interactivity/build-module/directives/watch.mjs
2866 +directive("watch", ({ directives: { watch: watch2 }, evaluate }) => {
2867 + watch2.forEach((entry) => {
2868 + if (true) {
2869 + if (entry.suffix) {
2870 + warnUniqueIdWithTwoHyphens("watch", entry.suffix);
2700 2871 }
2701 - }) => {
2702 - if (true) {
2703 - warn(
2704 - "The data-wp-ignore directive is deprecated and will be removed in version 7.0."
2705 - );
2706 - }
2707 - const cached = T2(() => innerHTML, []);
2708 - return k(Type, {
2709 - dangerouslySetInnerHTML: { __html: cached },
2710 - ...rest
2711 - });
2712 2872 }
2713 - );
2714 - directive("text", ({ directives: { text }, element, evaluate }) => {
2715 - const entries = text.filter(isDefaultDirectiveSuffix);
2716 - if (!entries.length) {
2873 + useWatch(() => {
2874 + let start;
2717 2875 if (true) {
2718 - warn(
2719 - "The usage of data-wp-text--suffix is not supported. Please use data-wp-text instead."
2720 - );
2721 - }
2722 - return;
2723 - }
2724 - entries.forEach((entry) => {
2725 - if (entry.uniqueId) {
2726 2876 if (true) {
2727 - warnUniqueIdNotSupported("text", entry.uniqueId);
2877 + start = performance.now();
2728 2878 }
2729 - return;
2730 2879 }
2731 - try {
2732 - let result = evaluate(entry);
2733 - if (result === PENDING_GETTER) {
2734 - return;
2735 - }
2736 - if (typeof result === "function") {
2737 - result = result();
2738 - }
2739 - element.props.children = typeof result === "object" ? null : result.toString();
2740 - } catch {
2741 - element.props.children = null;
2742 - }
2743 - });
2744 - });
2745 - directive("run", ({ directives: { run }, evaluate }) => {
2746 - run.forEach((entry) => {
2747 - if (true) {
2748 - if (entry.suffix) {
2749 - warnUniqueIdWithTwoHyphens("run", entry.suffix);
2750 - }
2751 - }
2752 2880 let result = evaluate(entry);
2753 2881 if (typeof result === "function") {
2754 2882 result = result();
2755 2883 }
2756 - return result;
2757 - });
2758 - });
2759 - directive(
2760 - "each",
2761 - ({
2762 - directives: { each, "each-key": eachKey },
2763 - context: inheritedContext,
2764 - element,
2765 - evaluate
2766 - }) => {
2767 - if (element.type !== "template") {
2884 + if (true) {
2768 2885 if (true) {
2769 - warn(
2770 - "The data-wp-each directive can only be used on <template> elements."
2886 + performance.measure(
2887 + `interactivity api watch ${entry.namespace}`,
2888 + {
2889 + start,
2890 + end: performance.now(),
2891 + detail: {
2892 + devtools: {
2893 + track: `IA: watch ${entry.namespace}`
2894 + }
2895 + }
2896 + }
2771 2897 );
2772 2898 }
2773 - return;
2774 2899 }
2775 - const { Provider } = inheritedContext;
2776 - const inheritedValue = x2(inheritedContext);
2777 - const [entry] = each;
2778 - const { namespace, suffix, uniqueId } = entry;
2779 - if (each.length > 1) {
2780 - if (true) {
2781 - warn(
2782 - "The usage of multiple data-wp-each directives on the same element is not supported. Please pick only one."
2783 - );
2784 - }
2785 - return;
2786 - }
2787 - if (uniqueId) {
2788 - if (true) {
2789 - warnUniqueIdNotSupported("each", uniqueId);
2790 - }
2791 - return;
2792 - }
2793 - let iterable = evaluate(entry);
2794 - if (iterable === PENDING_GETTER) {
2795 - return;
2796 - }
2797 - if (typeof iterable === "function") {
2798 - iterable = iterable();
2799 - }
2800 - if (typeof iterable?.[Symbol.iterator] !== "function") {
2801 - return;
2802 - }
2803 - const itemProp = suffix ? kebabToCamelCase(suffix) : "item";
2804 - const result = [];
2805 - const itemContexts = useItemContexts(
2806 - inheritedValue,
2807 - namespace,
2808 - iterable,
2809 - itemProp,
2810 - eachKey?.[0]
2811 - );
2812 - for (const [item, itemContext, key] of itemContexts) {
2813 - const mergedContext = {
2814 - client: {
2815 - ...inheritedValue.client,
2816 - [namespace]: itemContext
2817 - },
2818 - server: { ...inheritedValue.server }
2819 - };
2820 - mergedContext.client[namespace][itemProp] = item;
2821 - result.push(
2822 - k(
2823 - Provider,
2824 - { value: mergedContext, key },
2825 - element.props.content
2826 - )
2827 - );
2828 - }
2829 2900 return result;
2830 - },
2831 - { priority: 20 }
2832 - );
2833 - directive(
2834 - "each-child",
2835 - ({ directives: { "each-child": eachChild }, element, evaluate }) => {
2836 - const entry = eachChild.find(isDefaultDirectiveSuffix);
2837 - if (!entry) {
2838 - return;
2839 - }
2840 - const iterable = evaluate(entry);
2841 - return iterable === PENDING_GETTER ? element : null;
2842 - },
2843 - { priority: 1 }
2844 - );
2845 - directive(
2846 - "router-region",
2847 - ({ directives: { "router-region": routerRegion } }) => {
2848 - const entry = routerRegion.find(isDefaultDirectiveSuffix);
2849 - if (!entry) {
2850 - return;
2851 - }
2852 - if (entry.suffix) {
2853 - if (true) {
2854 - warn(
2855 - `Suffixes for the data-wp-router-region directive are not supported. Ignoring the directive with suffix "${entry.suffix}".`
2856 - );
2857 - }
2858 - return;
2859 - }
2860 - if (entry.uniqueId) {
2861 - if (true) {
2862 - warnUniqueIdNotSupported("router-region", entry.uniqueId);
2863 - }
2864 - return;
2865 - }
2866 - const regionId = typeof entry.value === "string" ? entry.value : entry.value.id;
2867 - if (!routerRegions.has(regionId)) {
2868 - routerRegions.set(regionId, d3());
2869 - }
2870 - const vdom = routerRegions.get(regionId).value;
2871 - _2(() => {
2872 - if (vdom && typeof vdom.type !== "string") {
2873 - navigationContextSignal.value = navigationContextSignal.peek() + 1;
2874 - }
2875 - }, [vdom]);
2876 - if (vdom && typeof vdom.type !== "string") {
2877 - const previousScope = getScope();
2878 - return W(vdom, { previousScope });
2879 - }
2880 - return vdom;
2881 - },
2882 - { priority: 1 }
2883 - );
2884 -};
2901 + });
2902 + });
2903 +});
2885 2904
2886 2905 // packages/interactivity/build-module/hydration.mjs
2887 2906 init_preact_module();
2888 2907
@@ -3135,9 +3154,8 @@
3135 3154 }
3136 3155 throw new Error("Forbidden access.");
3137 3156 };
3138 3157 populateServerData(parseServerData());
3139 -directives_default();
3140 3158 onDOMReady(hydrateRegions);
3141 3159 window.history.replaceState(
3142 3160 { ...window.history.state, wpInteractivityId: sessionId },
3143 3161 ""