@measured/puck-plugin-heading-analyzer 0.18.3-canary.b44056f → 0.19.0-canary.0308d24

package/dist/index.mjs

@@ -21,6 +21,12 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -36,7 +42,7 @@ var __objRest = (source, exclude) => {
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require() {
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -55,6 +61,26 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 
 // ../tsup-config/react-import.js
 import React from "react";
@@ -126,19 +152,338 @@ var require_classnames = __commonJS({
   }
 });
 
+// ../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js
+var require_use_sync_external_store_shim_production = __commonJS({
+  "../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js"(exports) {
+    "use strict";
+    init_react_import();
+    var React2 = __require("react");
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    var objectIs = "function" === typeof Object.is ? Object.is : is;
+    var useState2 = React2.useState;
+    var useEffect7 = React2.useEffect;
+    var useLayoutEffect = React2.useLayoutEffect;
+    var useDebugValue2 = React2.useDebugValue;
+    function useSyncExternalStore$2(subscribe, getSnapshot) {
+      var value = getSnapshot(), _useState = useState2({ inst: { value, getSnapshot } }), inst = _useState[0].inst, forceUpdate = _useState[1];
+      useLayoutEffect(
+        function() {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot;
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        },
+        [subscribe, value, getSnapshot]
+      );
+      useEffect7(
+        function() {
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          return subscribe(function() {
+            checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          });
+        },
+        [subscribe]
+      );
+      useDebugValue2(value);
+      return value;
+    }
+    function checkIfSnapshotChanged(inst) {
+      var latestGetSnapshot = inst.getSnapshot;
+      inst = inst.value;
+      try {
+        var nextValue = latestGetSnapshot();
+        return !objectIs(inst, nextValue);
+      } catch (error) {
+        return true;
+      }
+    }
+    function useSyncExternalStore$1(subscribe, getSnapshot) {
+      return getSnapshot();
+    }
+    var shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+    exports.useSyncExternalStore = void 0 !== React2.useSyncExternalStore ? React2.useSyncExternalStore : shim;
+  }
+});
+
+// ../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
+var require_use_sync_external_store_shim_development = __commonJS({
+  "../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js"(exports) {
+    "use strict";
+    init_react_import();
+    "production" !== process.env.NODE_ENV && function() {
+      function is(x, y) {
+        return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+      }
+      function useSyncExternalStore$2(subscribe, getSnapshot) {
+        didWarnOld18Alpha || void 0 === React2.startTransition || (didWarnOld18Alpha = true, console.error(
+          "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+        ));
+        var value = getSnapshot();
+        if (!didWarnUncachedGetSnapshot) {
+          var cachedValue = getSnapshot();
+          objectIs(value, cachedValue) || (console.error(
+            "The result of getSnapshot should be cached to avoid an infinite loop"
+          ), didWarnUncachedGetSnapshot = true);
+        }
+        cachedValue = useState2({
+          inst: { value, getSnapshot }
+        });
+        var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
+        useLayoutEffect(
+          function() {
+            inst.value = value;
+            inst.getSnapshot = getSnapshot;
+            checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          },
+          [subscribe, value, getSnapshot]
+        );
+        useEffect7(
+          function() {
+            checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+            return subscribe(function() {
+              checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+            });
+          },
+          [subscribe]
+        );
+        useDebugValue2(value);
+        return value;
+      }
+      function checkIfSnapshotChanged(inst) {
+        var latestGetSnapshot = inst.getSnapshot;
+        inst = inst.value;
+        try {
+          var nextValue = latestGetSnapshot();
+          return !objectIs(inst, nextValue);
+        } catch (error) {
+          return true;
+        }
+      }
+      function useSyncExternalStore$1(subscribe, getSnapshot) {
+        return getSnapshot();
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var React2 = __require("react"), objectIs = "function" === typeof Object.is ? Object.is : is, useState2 = React2.useState, useEffect7 = React2.useEffect, useLayoutEffect = React2.useLayoutEffect, useDebugValue2 = React2.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+      exports.useSyncExternalStore = void 0 !== React2.useSyncExternalStore ? React2.useSyncExternalStore : shim;
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    }();
+  }
+});
+
+// ../../node_modules/use-sync-external-store/shim/index.js
+var require_shim = __commonJS({
+  "../../node_modules/use-sync-external-store/shim/index.js"(exports, module) {
+    "use strict";
+    init_react_import();
+    if (process.env.NODE_ENV === "production") {
+      module.exports = require_use_sync_external_store_shim_production();
+    } else {
+      module.exports = require_use_sync_external_store_shim_development();
+    }
+  }
+});
+
+// ../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.js
+var require_with_selector_production = __commonJS({
+  "../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.js"(exports) {
+    "use strict";
+    init_react_import();
+    var React2 = __require("react");
+    var shim = require_shim();
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    var objectIs = "function" === typeof Object.is ? Object.is : is;
+    var useSyncExternalStore = shim.useSyncExternalStore;
+    var useRef = React2.useRef;
+    var useEffect7 = React2.useEffect;
+    var useMemo2 = React2.useMemo;
+    var useDebugValue2 = React2.useDebugValue;
+    exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+      var instRef = useRef(null);
+      if (null === instRef.current) {
+        var inst = { hasValue: false, value: null };
+        instRef.current = inst;
+      } else inst = instRef.current;
+      instRef = useMemo2(
+        function() {
+          function memoizedSelector(nextSnapshot) {
+            if (!hasMemo) {
+              hasMemo = true;
+              memoizedSnapshot = nextSnapshot;
+              nextSnapshot = selector(nextSnapshot);
+              if (void 0 !== isEqual && inst.hasValue) {
+                var currentSelection = inst.value;
+                if (isEqual(currentSelection, nextSnapshot))
+                  return memoizedSelection = currentSelection;
+              }
+              return memoizedSelection = nextSnapshot;
+            }
+            currentSelection = memoizedSelection;
+            if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+            var nextSelection = selector(nextSnapshot);
+            if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
+              return memoizedSnapshot = nextSnapshot, currentSelection;
+            memoizedSnapshot = nextSnapshot;
+            return memoizedSelection = nextSelection;
+          }
+          var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+          return [
+            function() {
+              return memoizedSelector(getSnapshot());
+            },
+            null === maybeGetServerSnapshot ? void 0 : function() {
+              return memoizedSelector(maybeGetServerSnapshot());
+            }
+          ];
+        },
+        [getSnapshot, getServerSnapshot, selector, isEqual]
+      );
+      var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+      useEffect7(
+        function() {
+          inst.hasValue = true;
+          inst.value = value;
+        },
+        [value]
+      );
+      useDebugValue2(value);
+      return value;
+    };
+  }
+});
+
+// ../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js
+var require_with_selector_development = __commonJS({
+  "../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js"(exports) {
+    "use strict";
+    init_react_import();
+    "production" !== process.env.NODE_ENV && function() {
+      function is(x, y) {
+        return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var React2 = __require("react"), shim = require_shim(), objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = shim.useSyncExternalStore, useRef = React2.useRef, useEffect7 = React2.useEffect, useMemo2 = React2.useMemo, useDebugValue2 = React2.useDebugValue;
+      exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+        var instRef = useRef(null);
+        if (null === instRef.current) {
+          var inst = { hasValue: false, value: null };
+          instRef.current = inst;
+        } else inst = instRef.current;
+        instRef = useMemo2(
+          function() {
+            function memoizedSelector(nextSnapshot) {
+              if (!hasMemo) {
+                hasMemo = true;
+                memoizedSnapshot = nextSnapshot;
+                nextSnapshot = selector(nextSnapshot);
+                if (void 0 !== isEqual && inst.hasValue) {
+                  var currentSelection = inst.value;
+                  if (isEqual(currentSelection, nextSnapshot))
+                    return memoizedSelection = currentSelection;
+                }
+                return memoizedSelection = nextSnapshot;
+              }
+              currentSelection = memoizedSelection;
+              if (objectIs(memoizedSnapshot, nextSnapshot))
+                return currentSelection;
+              var nextSelection = selector(nextSnapshot);
+              if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
+                return memoizedSnapshot = nextSnapshot, currentSelection;
+              memoizedSnapshot = nextSnapshot;
+              return memoizedSelection = nextSelection;
+            }
+            var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+            return [
+              function() {
+                return memoizedSelector(getSnapshot());
+              },
+              null === maybeGetServerSnapshot ? void 0 : function() {
+                return memoizedSelector(maybeGetServerSnapshot());
+              }
+            ];
+          },
+          [getSnapshot, getServerSnapshot, selector, isEqual]
+        );
+        var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+        useEffect7(
+          function() {
+            inst.hasValue = true;
+            inst.value = value;
+          },
+          [value]
+        );
+        useDebugValue2(value);
+        return value;
+      };
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    }();
+  }
+});
+
+// ../../node_modules/use-sync-external-store/shim/with-selector.js
+var require_with_selector = __commonJS({
+  "../../node_modules/use-sync-external-store/shim/with-selector.js"(exports, module) {
+    "use strict";
+    init_react_import();
+    if (process.env.NODE_ENV === "production") {
+      module.exports = require_with_selector_production();
+    } else {
+      module.exports = require_with_selector_development();
+    }
+  }
+});
+
+// ../../node_modules/fast-deep-equal/index.js
+var require_fast_deep_equal = __commonJS({
+  "../../node_modules/fast-deep-equal/index.js"(exports, module) {
+    "use strict";
+    init_react_import();
+    module.exports = function equal(a, b) {
+      if (a === b) return true;
+      if (a && b && typeof a == "object" && typeof b == "object") {
+        if (a.constructor !== b.constructor) return false;
+        var length, i, keys;
+        if (Array.isArray(a)) {
+          length = a.length;
+          if (length != b.length) return false;
+          for (i = length; i-- !== 0; )
+            if (!equal(a[i], b[i])) return false;
+          return true;
+        }
+        if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+        keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length) return false;
+        for (i = length; i-- !== 0; )
+          if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+        for (i = length; i-- !== 0; ) {
+          var key = keys[i];
+          if (!equal(a[key], b[key])) return false;
+        }
+        return true;
+      }
+      return a !== a && b !== b;
+    };
+  }
+});
+
 // index.ts
 init_react_import();
 
 // src/HeadingAnalyzer.tsx
 init_react_import();
-import { useEffect as useEffect4, useState as useState5 } from "react";
+import { useEffect as useEffect6, useState } from "react";
 
 // css-module:/home/runner/work/puck/puck/packages/plugin-heading-analyzer/src/HeadingAnalyzer.module.css#css-module
 init_react_import();
 var HeadingAnalyzer_module_default = { "HeadingAnalyzer": "_HeadingAnalyzer_116v6_1", "HeadingAnalyzer-cssWarning": "_HeadingAnalyzer-cssWarning_116v6_5", "HeadingAnalyzerItem": "_HeadingAnalyzerItem_116v6_9", "HeadingAnalyzerItem--missing": "_HeadingAnalyzerItem--missing_116v6_13" };
 
 // src/HeadingAnalyzer.tsx
-import { usePuck } from "@measured/puck";
+import { createUsePuck } from "@measured/puck";
 
 // ../core/components/SidebarSection/index.tsx
 init_react_import();
@@ -292,142 +637,523 @@ var ChevronRight = createLucideIcon("ChevronRight", [
 
 // ../core/lib/use-breadcrumbs.ts
 init_react_import();
-import { useContext as useContext2, useMemo as useMemo2 } from "react";
+import { useMemo } from "react";
 
-// ../core/components/DropZone/context.tsx
+// ../core/store/index.ts
 init_react_import();
-import {
-  createContext as createContext2,
-  useCallback as useCallback3,
-  useMemo,
-  useState as useState4
-} from "react";
 
-// ../core/components/Puck/context.tsx
+// ../core/reducer/index.ts
 init_react_import();
-import {
-  createContext,
-  useContext,
-  useEffect as useEffect3,
-  useState as useState3
-} from "react";
 
-// ../core/lib/get-item.ts
+// ../core/reducer/data.ts
+init_react_import();
+
+// ../core/lib/reorder.ts
 init_react_import();
+var reorder = (list, startIndex, endIndex) => {
+  const result = Array.from(list);
+  const [removed] = result.splice(startIndex, 1);
+  result.splice(endIndex, 0, removed);
+  return result;
+};
 
 // ../core/lib/root-droppable-id.ts
 init_react_import();
-var rootDroppableId = "default-zone";
+var rootAreaId = "root";
+var rootZone = "default-zone";
+var rootDroppableId = `${rootAreaId}:${rootZone}`;
+
+// ../core/lib/insert.ts
+init_react_import();
+var insert = (list, index, item) => {
+  const result = Array.from(list);
+  result.splice(index, 0, item);
+  return result;
+};
+
+// ../core/lib/remove.ts
+init_react_import();
+var remove = (list, index) => {
+  const result = Array.from(list);
+  result.splice(index, 1);
+  return result;
+};
 
 // ../core/lib/setup-zone.ts
 init_react_import();
+var setupZone = (data, zoneKey) => {
+  if (zoneKey === rootDroppableId) {
+    return data;
+  }
+  const newData = __spreadProps(__spreadValues({}, data), {
+    zones: data.zones ? __spreadValues({}, data.zones) : {}
+  });
+  newData.zones[zoneKey] = newData.zones[zoneKey] || [];
+  return newData;
+};
 
-// ../core/components/ViewportControls/default-viewports.ts
+// ../core/lib/replace.ts
 init_react_import();
-var defaultViewports = [
-  { width: 360, height: "auto", icon: "Smartphone", label: "Small" },
-  { width: 768, height: "auto", icon: "Tablet", label: "Medium" },
-  { width: 1280, height: "auto", icon: "Monitor", label: "Large" }
-];
+var replace = (list, index, newItem) => {
+  const result = Array.from(list);
+  result.splice(index, 1);
+  result.splice(index, 0, newItem);
+  return result;
+};
 
-// ../core/lib/use-resolved-permissions.ts
+// ../core/lib/get-item.ts
 init_react_import();
-import { useCallback, useEffect, useState } from "react";
+function getItem(selector, data, dynamicProps = {}) {
+  if (!selector.zone || selector.zone === rootDroppableId) {
+    const item2 = data.content[selector.index];
+    return (item2 == null ? void 0 : item2.props) ? __spreadProps(__spreadValues({}, item2), { props: dynamicProps[item2.props.id] || item2.props }) : void 0;
+  }
+  const item = setupZone(data, selector.zone).zones[selector.zone][selector.index];
+  return (item == null ? void 0 : item.props) ? __spreadProps(__spreadValues({}, item), { props: dynamicProps[item.props.id] || item.props }) : void 0;
+}
 
-// ../core/lib/flatten-data.ts
+// ../core/lib/reduce-related-zones.ts
 init_react_import();
 
-// ../core/lib/get-changed.ts
+// ../core/lib/generate-id.ts
 init_react_import();
 
-// ../core/lib/use-resolved-data.ts
+// ../../node_modules/uuid/dist/esm-node/index.js
 init_react_import();
-import { useCallback as useCallback2, useEffect as useEffect2, useState as useState2 } from "react";
 
-// ../core/lib/resolve-component-data.ts
+// ../../node_modules/uuid/dist/esm-node/rng.js
 init_react_import();
+import crypto from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
 
-// ../core/lib/apply-dynamic-props.ts
+// ../../node_modules/uuid/dist/esm-node/stringify.js
 init_react_import();
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
 
-// ../core/lib/resolve-root-data.ts
+// ../../node_modules/uuid/dist/esm-node/v4.js
 init_react_import();
 
-// ../core/components/Puck/context.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
-var defaultAppState = {
-  data: { content: [], root: {} },
-  ui: {
-    leftSideBarVisible: true,
-    rightSideBarVisible: true,
-    arrayState: {},
-    itemSelector: null,
-    componentList: {},
-    isDragging: false,
-    previewMode: "edit",
-    viewports: {
-      current: {
-        width: defaultViewports[0].width,
-        height: defaultViewports[0].height || "auto"
+// ../../node_modules/uuid/dist/esm-node/native.js
+init_react_import();
+import crypto2 from "crypto";
+var native_default = {
+  randomUUID: crypto2.randomUUID
+};
+
+// ../../node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// ../core/lib/generate-id.ts
+var generateId = (type) => type ? `${type}-${v4_default()}` : v4_default();
+
+// ../core/lib/get-zone-id.ts
+init_react_import();
+var getZoneId = (zoneCompound) => {
+  if (!zoneCompound) {
+    return [];
+  }
+  if (zoneCompound && zoneCompound.indexOf(":") > -1) {
+    return zoneCompound.split(":");
+  }
+  return [rootDroppableId, zoneCompound];
+};
+
+// ../core/lib/reduce-related-zones.ts
+function reduceRelatedZones(item, data, fn) {
+  return __spreadProps(__spreadValues({}, data), {
+    zones: Object.keys(data.zones || {}).reduce(
+      (acc, key) => {
+        const [parentId] = getZoneId(key);
+        if (parentId === item.props.id) {
+          const zones = data.zones;
+          return fn(acc, key, zones[key]);
+        }
+        return __spreadProps(__spreadValues({}, acc), { [key]: data.zones[key] });
       },
-      options: [],
-      controlsVisible: true
+      {}
+    )
+  });
+}
+var findRelatedByZoneId = (zoneId, data) => {
+  const [zoneParentId] = getZoneId(zoneId);
+  return (data.zones[zoneId] || []).reduce(
+    (acc, zoneItem) => {
+      const related = findRelatedByItem(zoneItem, data);
+      if (zoneItem.props.id === zoneParentId) {
+        return __spreadProps(__spreadValues(__spreadValues({}, acc), related), { [zoneId]: zoneItem });
+      }
+      return __spreadValues(__spreadValues({}, acc), related);
     },
-    field: { focus: null }
+    {}
+  );
+};
+var findRelatedByItem = (item, data) => {
+  return Object.keys(data.zones || {}).reduce(
+    (acc, zoneId) => {
+      const [zoneParentId] = getZoneId(zoneId);
+      if (item.props.id === zoneParentId) {
+        const related = findRelatedByZoneId(zoneId, data);
+        return __spreadProps(__spreadValues(__spreadValues({}, acc), related), {
+          [zoneId]: data.zones[zoneId]
+        });
+      }
+      return acc;
+    },
+    {}
+  );
+};
+var removeRelatedZones = (item, data) => {
+  const newData = __spreadValues({}, data);
+  const related = findRelatedByItem(item, data);
+  Object.keys(related).forEach((key) => {
+    delete newData.zones[key];
+  });
+  return newData;
+};
+function duplicateRelatedZones(item, data, newId) {
+  return reduceRelatedZones(item, data, (acc, key, zone) => {
+    const dupedZone = zone.map((zoneItem) => __spreadProps(__spreadValues({}, zoneItem), {
+      props: __spreadProps(__spreadValues({}, zoneItem.props), { id: generateId(zoneItem.type) })
+    }));
+    const dupeOfDupes = dupedZone.reduce(
+      (dupeOfDupes2, item2, index) => __spreadValues(__spreadValues({}, dupeOfDupes2), duplicateRelatedZones(zone[index], data, item2.props.id).zones),
+      acc
+    );
+    const [_, zoneId] = getZoneId(key);
+    return __spreadProps(__spreadValues({}, dupeOfDupes), {
+      [key]: zone,
+      [`${newId}:${zoneId}`]: dupedZone
+    });
+  });
+}
+
+// ../core/reducer/data.ts
+var zoneCache = {};
+var replaceAction = (data, action) => {
+  if (action.destinationZone === rootDroppableId) {
+    return __spreadProps(__spreadValues({}, data), {
+      content: replace(data.content, action.destinationIndex, action.data)
+    });
   }
+  const newData = setupZone(data, action.destinationZone);
+  return __spreadProps(__spreadValues({}, newData), {
+    zones: __spreadProps(__spreadValues({}, newData.zones), {
+      [action.destinationZone]: replace(
+        newData.zones[action.destinationZone],
+        action.destinationIndex,
+        action.data
+      )
+    })
+  });
 };
-var defaultContext = {
-  state: defaultAppState,
-  dispatch: () => null,
-  config: { components: {} },
-  componentState: {},
-  setComponentState: () => {
-  },
-  resolveData: () => {
-  },
-  plugins: [],
-  overrides: {},
-  history: {},
-  viewports: defaultViewports,
-  zoomConfig: {
-    autoZoom: 1,
-    rootHeight: 0,
-    zoom: 1
-  },
-  setZoomConfig: () => null,
-  status: "LOADING",
-  setStatus: () => null,
-  iframe: {},
-  globalPermissions: {},
-  getPermissions: () => ({}),
-  refreshPermissions: () => null
-};
-var appContext = createContext(defaultContext);
-function useAppContext() {
-  const mainContext = useContext(appContext);
-  return __spreadProps(__spreadValues({}, mainContext), {
-    // Helpers
-    setUi: (ui, recordHistory) => {
-      return mainContext.dispatch({
-        type: "setUi",
-        ui,
-        recordHistory
+function insertAction(data, action, config) {
+  const emptyComponentData = {
+    type: action.componentType,
+    props: __spreadProps(__spreadValues({}, config.components[action.componentType].defaultProps || {}), {
+      id: action.id || generateId(action.componentType)
+    })
+  };
+  if (action.destinationZone === rootDroppableId) {
+    return __spreadProps(__spreadValues({}, data), {
+      content: insert(
+        data.content,
+        action.destinationIndex,
+        emptyComponentData
+      )
+    });
+  }
+  const newData = setupZone(data, action.destinationZone);
+  return __spreadProps(__spreadValues({}, data), {
+    zones: __spreadProps(__spreadValues({}, newData.zones), {
+      [action.destinationZone]: insert(
+        newData.zones[action.destinationZone],
+        action.destinationIndex,
+        emptyComponentData
+      )
+    })
+  });
+}
+var reorderAction = (data, action) => {
+  if (action.destinationZone === rootDroppableId) {
+    return __spreadProps(__spreadValues({}, data), {
+      content: reorder(
+        data.content,
+        action.sourceIndex,
+        action.destinationIndex
+      )
+    });
+  }
+  const newData = setupZone(data, action.destinationZone);
+  return __spreadProps(__spreadValues({}, data), {
+    zones: __spreadProps(__spreadValues({}, newData.zones), {
+      [action.destinationZone]: reorder(
+        newData.zones[action.destinationZone],
+        action.sourceIndex,
+        action.destinationIndex
+      )
+    })
+  });
+};
+function reduceData(data, action, config) {
+  if (action.type === "insert") {
+    return insertAction(data, action, config);
+  }
+  if (action.type === "duplicate") {
+    const item = getItem(
+      { index: action.sourceIndex, zone: action.sourceZone },
+      data
+    );
+    const newItem = __spreadProps(__spreadValues({}, item), {
+      props: __spreadProps(__spreadValues({}, item.props), {
+        id: generateId(item.type)
+      })
+    });
+    const dataWithRelatedDuplicated = duplicateRelatedZones(
+      item,
+      data,
+      newItem.props.id
+    );
+    if (action.sourceZone === rootDroppableId) {
+      return __spreadProps(__spreadValues({}, dataWithRelatedDuplicated), {
+        content: insert(data.content, action.sourceIndex + 1, newItem)
       });
     }
-  });
+    return __spreadProps(__spreadValues({}, dataWithRelatedDuplicated), {
+      zones: __spreadProps(__spreadValues({}, dataWithRelatedDuplicated.zones), {
+        [action.sourceZone]: insert(
+          dataWithRelatedDuplicated.zones[action.sourceZone],
+          action.sourceIndex + 1,
+          newItem
+        )
+      })
+    });
+  }
+  if (action.type === "reorder") {
+    return reorderAction(data, action);
+  }
+  if (action.type === "move") {
+    if (action.sourceZone === action.destinationZone && action.sourceIndex === action.destinationIndex) {
+      return data;
+    }
+    const newData = setupZone(
+      setupZone(data, action.sourceZone),
+      action.destinationZone
+    );
+    const item = getItem(
+      { zone: action.sourceZone, index: action.sourceIndex },
+      newData
+    );
+    if (action.sourceZone === action.destinationZone) {
+      return reorderAction(data, __spreadProps(__spreadValues({}, action), { type: "reorder" }));
+    }
+    if (action.sourceZone === rootDroppableId) {
+      return __spreadProps(__spreadValues({}, newData), {
+        content: remove(newData.content, action.sourceIndex),
+        zones: __spreadProps(__spreadValues({}, newData.zones), {
+          [action.destinationZone]: insert(
+            newData.zones[action.destinationZone],
+            action.destinationIndex,
+            item
+          )
+        })
+      });
+    }
+    if (action.destinationZone === rootDroppableId) {
+      return __spreadProps(__spreadValues({}, newData), {
+        content: insert(newData.content, action.destinationIndex, item),
+        zones: __spreadProps(__spreadValues({}, newData.zones), {
+          [action.sourceZone]: remove(
+            newData.zones[action.sourceZone],
+            action.sourceIndex
+          )
+        })
+      });
+    }
+    return __spreadProps(__spreadValues({}, newData), {
+      zones: __spreadProps(__spreadValues({}, newData.zones), {
+        [action.sourceZone]: remove(
+          newData.zones[action.sourceZone],
+          action.sourceIndex
+        ),
+        [action.destinationZone]: insert(
+          newData.zones[action.destinationZone],
+          action.destinationIndex,
+          item
+        )
+      })
+    });
+  }
+  if (action.type === "replace") {
+    return replaceAction(data, action);
+  }
+  if (action.type === "remove") {
+    const item = getItem({ index: action.index, zone: action.zone }, data);
+    const dataWithRelatedRemoved = setupZone(
+      removeRelatedZones(item, data),
+      action.zone
+    );
+    if (action.zone === rootDroppableId) {
+      return __spreadProps(__spreadValues({}, dataWithRelatedRemoved), {
+        content: remove(data.content, action.index)
+      });
+    }
+    return __spreadProps(__spreadValues({}, dataWithRelatedRemoved), {
+      zones: __spreadProps(__spreadValues({}, dataWithRelatedRemoved.zones), {
+        [action.zone]: remove(
+          dataWithRelatedRemoved.zones[action.zone],
+          action.index
+        )
+      })
+    });
+  }
+  if (action.type === "registerZone") {
+    if (zoneCache[action.zone]) {
+      return __spreadProps(__spreadValues({}, data), {
+        zones: __spreadProps(__spreadValues({}, data.zones), {
+          [action.zone]: zoneCache[action.zone]
+        })
+      });
+    }
+    return setupZone(data, action.zone);
+  }
+  if (action.type === "unregisterZone") {
+    const _zones = __spreadValues({}, data.zones || {});
+    if (_zones[action.zone]) {
+      zoneCache[action.zone] = _zones[action.zone];
+      delete _zones[action.zone];
+    }
+    return __spreadProps(__spreadValues({}, data), { zones: _zones });
+  }
+  if (action.type === "setData") {
+    if (typeof action.data === "object") {
+      return __spreadValues(__spreadValues({}, data), action.data);
+    }
+    return __spreadValues(__spreadValues({}, data), action.data(data));
+  }
+  return data;
+}
+
+// ../core/reducer/state.ts
+init_react_import();
+var reduceUi = (ui, action) => {
+  if (action.type === "setUi") {
+    if (typeof action.ui === "object") {
+      return __spreadValues(__spreadValues({}, ui), action.ui);
+    }
+    return __spreadValues(__spreadValues({}, ui), action.ui(ui));
+  }
+  if (action.type === "duplicate") {
+    return __spreadProps(__spreadValues({}, ui), {
+      itemSelector: { index: action.sourceIndex + 1, zone: action.sourceZone }
+    });
+  }
+  if (action.type === "remove") {
+    return __spreadProps(__spreadValues({}, ui), {
+      itemSelector: null
+    });
+  }
+  return ui;
+};
+
+// ../core/reducer/actions.tsx
+init_react_import();
+
+// ../core/reducer/index.ts
+function storeInterceptor(reducer, record, onAction) {
+  return (state, action) => {
+    const newAppState = reducer(state, action);
+    const isValidType = ![
+      "registerZone",
+      "unregisterZone",
+      "setData",
+      "setUi",
+      "set"
+    ].includes(action.type);
+    if (typeof action.recordHistory !== "undefined" ? action.recordHistory : isValidType) {
+      if (record) record(newAppState);
+    }
+    onAction == null ? void 0 : onAction(action, newAppState, state);
+    return newAppState;
+  };
+}
+var setAction = (state, action) => {
+  if (typeof action.state === "object") {
+    return __spreadValues(__spreadValues({}, state), action.state);
+  }
+  return __spreadValues(__spreadValues({}, state), action.state(state));
+};
+function createReducer({
+  config,
+  record,
+  onAction
+}) {
+  return storeInterceptor(
+    (state, action) => {
+      const data = reduceData(state.data, action, config);
+      const ui = reduceUi(state.ui, action);
+      if (action.type === "set") {
+        return setAction(state, action);
+      }
+      return { data, ui };
+    },
+    record,
+    onAction
+  );
 }
 
+// ../core/components/ViewportControls/default-viewports.ts
+init_react_import();
+var defaultViewports = [
+  { width: 360, height: "auto", icon: "Smartphone", label: "Small" },
+  { width: 768, height: "auto", icon: "Tablet", label: "Medium" },
+  { width: 1280, height: "auto", icon: "Monitor", label: "Large" }
+];
+
+// ../../node_modules/zustand/esm/index.mjs
+init_react_import();
+
 // ../../node_modules/zustand/esm/vanilla.mjs
 init_react_import();
 var import_meta = {};
 var createStoreImpl = (createState) => {
   let state;
   const listeners = /* @__PURE__ */ new Set();
-  const setState = (partial, replace) => {
+  const setState = (partial, replace2) => {
     const nextState = typeof partial === "function" ? partial(state) : partial;
     if (!Object.is(nextState, state)) {
       const previousState = state;
-      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      state = (replace2 != null ? replace2 : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
       listeners.forEach((listener) => listener(state, previousState));
     }
   };
@@ -451,94 +1177,718 @@ var createStoreImpl = (createState) => {
 };
 var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
 
-// ../core/components/DropZone/context.tsx
-import { Fragment, jsx as jsx3 } from "react/jsx-runtime";
-var dropZoneContext = createContext2(null);
-var ZoneStoreContext = createContext2(
-  createStore(() => ({
-    zoneDepthIndex: {},
-    nextZoneDepthIndex: {},
-    areaDepthIndex: {},
-    nextAreaDepthIndex: {},
-    draggedItem: null,
-    previewIndex: {}
-  }))
-);
-
-// ../core/lib/get-zone-id.ts
-init_react_import();
-var getZoneId = (zoneCompound) => {
-  if (!zoneCompound) {
-    return [];
+// ../../node_modules/zustand/esm/index.mjs
+var import_with_selector = __toESM(require_with_selector(), 1);
+import ReactExports from "react";
+var import_meta2 = {};
+var { useDebugValue } = ReactExports;
+var { useSyncExternalStoreWithSelector } = import_with_selector.default;
+var didWarnAboutEqualityFn = false;
+var identity = (arg) => arg;
+function useStore(api, selector = identity, equalityFn) {
+  if ((import_meta2.env ? import_meta2.env.MODE : void 0) !== "production" && equalityFn && !didWarnAboutEqualityFn) {
+    console.warn(
+      "[DEPRECATED] Use `createWithEqualityFn` instead of `create` or use `useStoreWithEqualityFn` instead of `useStore`. They can be imported from 'zustand/traditional'. https://github.com/pmndrs/zustand/discussions/1937"
+    );
+    didWarnAboutEqualityFn = true;
   }
-  if (zoneCompound && zoneCompound.indexOf(":") > -1) {
-    return zoneCompound.split(":");
+  const slice = useSyncExternalStoreWithSelector(
+    api.subscribe,
+    api.getState,
+    api.getServerState || api.getInitialState,
+    selector,
+    equalityFn
+  );
+  useDebugValue(slice);
+  return slice;
+}
+var createImpl = (createState) => {
+  if ((import_meta2.env ? import_meta2.env.MODE : void 0) !== "production" && typeof createState !== "function") {
+    console.warn(
+      "[DEPRECATED] Passing a vanilla store will be unsupported in a future version. Instead use `import { useStore } from 'zustand'`."
+    );
   }
-  return [rootDroppableId, zoneCompound];
+  const api = typeof createState === "function" ? createStore(createState) : createState;
+  const useBoundStore = (selector, equalityFn) => useStore(api, selector, equalityFn);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
 };
+var create = (createState) => createState ? createImpl(createState) : createImpl;
 
-// ../core/lib/use-breadcrumbs.ts
-var convertPathDataToBreadcrumbs = (selectedItem, pathData, data) => {
-  const id = selectedItem ? selectedItem == null ? void 0 : selectedItem.props.id : "";
-  const currentPathData = pathData && id && pathData[id] ? __spreadValues({}, pathData[id]) : { label: "Page", path: [] };
-  if (!id) {
-    return [];
-  }
-  return currentPathData == null ? void 0 : currentPathData.path.reduce((acc, zoneCompound) => {
-    const [area] = getZoneId(zoneCompound);
-    if (area === rootDroppableId) {
-      return [
-        {
-          label: "Page",
-          selector: null
+// ../../node_modules/zustand/esm/middleware.mjs
+init_react_import();
+var subscribeWithSelectorImpl = (fn) => (set, get, api) => {
+  const origSubscribe = api.subscribe;
+  api.subscribe = (selector, optListener, options) => {
+    let listener = selector;
+    if (optListener) {
+      const equalityFn = (options == null ? void 0 : options.equalityFn) || Object.is;
+      let currentSlice = selector(api.getState());
+      listener = (state) => {
+        const nextSlice = selector(state);
+        if (!equalityFn(currentSlice, nextSlice)) {
+          const previousSlice = currentSlice;
+          optListener(currentSlice = nextSlice, previousSlice);
         }
-      ];
+      };
+      if (options == null ? void 0 : options.fireImmediately) {
+        optListener(currentSlice, currentSlice);
+      }
     }
-    const parentZoneCompound = acc.length > 0 ? acc[acc.length - 1].zoneCompound : rootDroppableId;
-    let parentZone = data.content;
-    if (parentZoneCompound && parentZoneCompound !== rootDroppableId) {
-      parentZone = data.zones[parentZoneCompound];
+    return origSubscribe(listener);
+  };
+  const initialState = fn(set, get, api);
+  return initialState;
+};
+var subscribeWithSelector = subscribeWithSelectorImpl;
+
+// ../core/lib/resolve-data.ts
+init_react_import();
+
+// ../core/lib/resolve-component-data.ts
+init_react_import();
+
+// ../core/lib/get-changed.ts
+init_react_import();
+var getChanged = (newItem, oldItem) => {
+  return newItem ? Object.keys(newItem.props || {}).reduce((acc, item) => {
+    const newItemProps = (newItem == null ? void 0 : newItem.props) || {};
+    const oldItemProps = (oldItem == null ? void 0 : oldItem.props) || {};
+    return __spreadProps(__spreadValues({}, acc), {
+      [item]: oldItemProps[item] !== newItemProps[item]
+    });
+  }, {}) : {};
+};
+
+// ../core/lib/resolve-component-data.ts
+var cache = { lastChange: {} };
+var resolveComponentData = (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (item, config, metadata = {}, onResolveStart, onResolveEnd) {
+  const configForItem = config.components[item.type];
+  if (configForItem.resolveData) {
+    const { item: oldItem = null, resolved = {} } = cache.lastChange[item.props.id] || {};
+    if (item && item === oldItem) {
+      return resolved;
     }
-    if (!parentZone) {
-      return acc;
+    const changed = getChanged(item, oldItem);
+    if (onResolveStart) {
+      onResolveStart(item);
     }
-    const itemIndex = parentZone.findIndex(
-      (queryItem) => queryItem.props.id === area
+    const { props: resolvedProps, readOnly = {} } = yield configForItem.resolveData(item, {
+      changed,
+      lastData: oldItem,
+      metadata
+    });
+    const resolvedItem = __spreadProps(__spreadValues({}, item), {
+      props: __spreadValues(__spreadValues({}, item.props), resolvedProps)
+    });
+    if (Object.keys(readOnly).length) {
+      resolvedItem.readOnly = readOnly;
+    }
+    cache.lastChange[item.props.id] = {
+      item,
+      resolved: resolvedItem
+    };
+    if (onResolveEnd) {
+      onResolveEnd(resolvedItem);
+    }
+    return resolvedItem;
+  }
+  return item;
+});
+
+// ../core/lib/apply-dynamic-props.ts
+init_react_import();
+var applyDynamicProps = (data, dynamicProps, rootData) => {
+  return __spreadProps(__spreadValues({}, data), {
+    root: rootData ? __spreadValues(__spreadValues({}, data.root), rootData ? rootData : {}) : data.root,
+    content: data.content.map((item) => {
+      return dynamicProps[item.props.id] ? __spreadValues(__spreadValues({}, item), dynamicProps[item.props.id]) : item;
+    }),
+    zones: Object.keys(data.zones || {}).reduce((acc, zoneKey) => {
+      return __spreadProps(__spreadValues({}, acc), {
+        [zoneKey]: data.zones[zoneKey].map((item) => {
+          return dynamicProps[item.props.id] ? __spreadValues(__spreadValues({}, item), dynamicProps[item.props.id]) : item;
+        })
+      });
+    }, {})
+  });
+};
+
+// ../core/lib/resolve-root-data.ts
+init_react_import();
+var cache2 = {};
+function resolveRootData(data, config, metadata) {
+  return __async(this, null, function* () {
+    var _a, _b, _c, _d, _e;
+    if (((_a = config.root) == null ? void 0 : _a.resolveData) && data.root.props) {
+      if (((_b = cache2.lastChange) == null ? void 0 : _b.original) === data.root) {
+        return cache2.lastChange.resolved;
+      }
+      const changed = getChanged(data.root, (_c = cache2.lastChange) == null ? void 0 : _c.original);
+      const rootWithProps = data.root;
+      const resolvedRoot = yield (_e = config.root) == null ? void 0 : _e.resolveData(rootWithProps, {
+        changed,
+        lastData: ((_d = cache2.lastChange) == null ? void 0 : _d.original) || {},
+        metadata: metadata || {}
+      });
+      cache2.lastChange = {
+        original: data.root,
+        resolved: resolvedRoot
+      };
+      return __spreadProps(__spreadValues(__spreadValues({}, data.root), resolvedRoot), {
+        props: __spreadValues(__spreadValues({}, data.root.props), resolvedRoot.props)
+      });
+    }
+    return data.root;
+  });
+}
+
+// ../core/lib/flatten-data.ts
+init_react_import();
+var flattenData = (data) => {
+  return Object.keys(data.zones || {}).reduce(
+    (acc, zone) => [...acc, ...data.zones[zone]],
+    data.content
+  );
+};
+
+// ../core/lib/resolve-data.ts
+var import_fast_deep_equal = __toESM(require_fast_deep_equal());
+var resolveData = (newAppState, appStoreData) => {
+  const {
+    state: appState,
+    config,
+    dispatch,
+    resolveDataRuns,
+    setComponentLoading,
+    unsetComponentLoading,
+    metadata,
+    permissions
+  } = appStoreData;
+  const deferredSetStates = {};
+  const _setComponentLoading = (id, loading, defer = 0) => {
+    if (deferredSetStates[id]) {
+      clearTimeout(deferredSetStates[id]);
+      delete deferredSetStates[id];
+    }
+    deferredSetStates[id] = setTimeout(() => {
+      if (loading) {
+        setComponentLoading(id);
+      } else {
+        unsetComponentLoading(id);
+      }
+      delete deferredSetStates[id];
+    }, defer);
+  };
+  const runResolvers = () => __async(void 0, null, function* () {
+    const newData = newAppState.data;
+    const flatContent = flattenData(newData).filter(
+      (item) => {
+        var _a;
+        return !!((_a = config.components[item.type]) == null ? void 0 : _a.resolveData);
+      }
     );
-    const item = parentZone[itemIndex];
-    if (!item) {
-      return acc;
+    const applyIfChange = (dynamicDataMap, dynamicRoot) => {
+      const processed = applyDynamicProps(
+        __spreadValues({}, appState.data),
+        dynamicDataMap,
+        dynamicRoot
+      );
+      const processedAppState = __spreadProps(__spreadValues({}, appState), { data: processed });
+      const containsChanges = !(0, import_fast_deep_equal.default)(appState, processedAppState);
+      if (containsChanges) {
+        dispatch({
+          type: "set",
+          state: (prev) => __spreadProps(__spreadValues({}, prev), {
+            data: applyDynamicProps(prev.data, dynamicDataMap, dynamicRoot),
+            ui: resolveDataRuns > 0 ? __spreadValues(__spreadValues({}, prev.ui), newAppState.ui) : prev.ui
+          }),
+          recordHistory: resolveDataRuns > 0
+        });
+      }
+    };
+    const promises = [];
+    promises.push(
+      (() => __async(void 0, null, function* () {
+        _setComponentLoading("puck-root", true, 50);
+        const dynamicRoot = yield resolveRootData(newData, config, metadata);
+        applyIfChange({}, dynamicRoot);
+        _setComponentLoading("puck-root", false);
+      }))()
+    );
+    flatContent.forEach((item) => {
+      promises.push(
+        (() => __async(void 0, null, function* () {
+          permissions.resolvePermissions({ item }, true);
+          const dynamicData = yield resolveComponentData(
+            item,
+            config,
+            metadata,
+            (item2) => {
+              _setComponentLoading(item2.props.id, true, 50);
+            },
+            (item2) => {
+              deferredSetStates[item2.props.id];
+              _setComponentLoading(item2.props.id, false);
+            }
+          );
+          const dynamicDataMap = { [item.props.id]: dynamicData };
+          applyIfChange(dynamicDataMap);
+        }))()
+      );
+    });
+    yield Promise.all(promises);
+  });
+  return runResolvers();
+};
+
+// ../core/store/index.ts
+import { createContext, useContext } from "react";
+
+// ../core/store/slices/history.ts
+init_react_import();
+import { useEffect as useEffect2 } from "react";
+
+// ../core/lib/use-hotkey.ts
+init_react_import();
+import { useEffect } from "react";
+var useHotkeyStore = create()(
+  subscribeWithSelector((set) => ({
+    held: {},
+    hold: (key) => set((s) => s.held[key] ? s : { held: __spreadProps(__spreadValues({}, s.held), { [key]: true }) }),
+    release: (key) => set((s) => s.held[key] ? { held: __spreadProps(__spreadValues({}, s.held), { [key]: false }) } : s),
+    reset: (held = {}) => set(() => ({ held })),
+    triggers: {}
+  }))
+);
+
+// ../core/store/slices/history.ts
+var EMPTY_HISTORY_INDEX = 0;
+function debounce(func, timeout = 300) {
+  let timer;
+  return (...args) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      func(...args);
+    }, timeout);
+  };
+}
+var tidyState = (state) => {
+  return __spreadProps(__spreadValues({}, state), {
+    ui: __spreadProps(__spreadValues({}, state.ui), {
+      field: {
+        focus: null
+      }
+    })
+  });
+};
+var createHistorySlice = (set, get) => {
+  const record = debounce((state) => {
+    const { histories, index } = get().history;
+    const history = {
+      state,
+      id: generateId("history")
+    };
+    const newHistories = [...histories.slice(0, index + 1), history];
+    set({
+      history: __spreadProps(__spreadValues({}, get().history), {
+        histories: newHistories,
+        index: newHistories.length - 1
+      })
+    });
+  }, 250);
+  return {
+    initialAppState: {},
+    index: EMPTY_HISTORY_INDEX,
+    histories: [],
+    hasPast: () => get().history.index > EMPTY_HISTORY_INDEX,
+    hasFuture: () => get().history.index < get().history.histories.length - 1,
+    prevHistory: () => {
+      const { history } = get();
+      return history.hasPast() ? history.histories[history.index - 1] : null;
+    },
+    nextHistory: () => {
+      const s = get().history;
+      return s.hasFuture() ? s.histories[s.index + 1] : null;
+    },
+    currentHistory: () => get().history.histories[get().history.index],
+    back: () => {
+      var _a;
+      const { history, dispatch } = get();
+      if (history.hasPast()) {
+        const state = tidyState(
+          ((_a = history.prevHistory()) == null ? void 0 : _a.state) || history.initialAppState
+        );
+        dispatch({
+          type: "set",
+          state
+        });
+        set({ history: __spreadProps(__spreadValues({}, history), { index: history.index - 1 }) });
+      }
+    },
+    forward: () => {
+      var _a;
+      const { history, dispatch } = get();
+      if (history.hasFuture()) {
+        const state = (_a = history.nextHistory()) == null ? void 0 : _a.state;
+        dispatch({ type: "set", state: state ? tidyState(state) : {} });
+        set({ history: __spreadProps(__spreadValues({}, history), { index: history.index + 1 }) });
+      }
+    },
+    setHistories: (histories) => {
+      var _a;
+      const { dispatch, history } = get();
+      dispatch({
+        type: "set",
+        state: ((_a = history.histories[history.histories.length - 1]) == null ? void 0 : _a.state) || history.initialAppState
+      });
+      set({ history: __spreadProps(__spreadValues({}, history), { histories, index: histories.length - 1 }) });
+    },
+    setHistoryIndex: (index) => {
+      var _a;
+      const { dispatch, history } = get();
+      dispatch({
+        type: "set",
+        state: ((_a = history.histories[history.index]) == null ? void 0 : _a.state) || history.initialAppState
+      });
+      set({ history: __spreadProps(__spreadValues({}, history), { index }) });
+    },
+    record
+  };
+};
+
+// ../core/store/slices/nodes.ts
+init_react_import();
+var import_fast_deep_equal2 = __toESM(require_fast_deep_equal());
+import { useEffect as useEffect3 } from "react";
+var partialDeepEqual = (newItem, existingItem) => {
+  const filteredExistingItem = Object.keys(newItem).reduce(
+    (acc, key) => __spreadProps(__spreadValues({}, acc), { [key]: existingItem[key] }),
+    {}
+  );
+  return (0, import_fast_deep_equal2.default)(newItem, filteredExistingItem);
+};
+var createNodesSlice = (set, get) => ({
+  nodes: {},
+  registerNode: (id, node) => {
+    const s = get().nodes;
+    if (s.nodes[id] && partialDeepEqual(node, s.nodes[id])) {
+      return;
     }
-    return [
-      ...acc,
-      {
-        label: item.type.toString(),
-        selector: {
-          index: itemIndex,
-          zone: parentZoneCompound
+    const emptyNode = {
+      id,
+      methods: { sync: () => null },
+      data: { props: { id }, type: "unknown" },
+      parentId: "",
+      zone: "",
+      path: [],
+      element: null,
+      index: -1
+    };
+    const existingNode = s.nodes[id];
+    set({
+      nodes: __spreadProps(__spreadValues({}, s), {
+        nodes: __spreadProps(__spreadValues({}, s.nodes), {
+          [id]: __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, emptyNode), existingNode), node), {
+            id
+          })
+        })
+      })
+    });
+  },
+  unregisterNode: (id) => {
+    const s = get().nodes;
+    const existingNode = s.nodes[id];
+    if (existingNode) {
+      const newNodes = __spreadValues({}, s.nodes);
+      delete newNodes[id];
+      set({
+        nodes: __spreadProps(__spreadValues({}, s), {
+          nodes: newNodes
+        })
+      });
+    }
+  }
+});
+
+// ../core/store/slices/permissions.ts
+init_react_import();
+import { useEffect as useEffect4 } from "react";
+var createPermissionsSlice = (set, get) => {
+  const resolvePermissions = (..._0) => __async(void 0, [..._0], function* (params = {}, force) {
+    const { state, permissions } = get();
+    const { cache: cache3, globalPermissions } = permissions;
+    const resolveDataForItem = (item2, force2 = false) => __async(void 0, null, function* () {
+      var _a, _b, _c;
+      const {
+        config,
+        state: appState,
+        setComponentLoading,
+        unsetComponentLoading
+      } = get();
+      const componentConfig = item2.type === "root" ? config.root : config.components[item2.type];
+      if (!componentConfig) {
+        return;
+      }
+      const initialPermissions = __spreadValues(__spreadValues({}, globalPermissions), componentConfig.permissions);
+      if (componentConfig.resolvePermissions) {
+        const changed = getChanged(item2, (_a = cache3[item2.props.id]) == null ? void 0 : _a.lastData);
+        if (Object.values(changed).some((el) => el === true) || force2) {
+          setComponentLoading(item2.props.id);
+          const resolvedPermissions = yield componentConfig.resolvePermissions(
+            item2,
+            {
+              changed,
+              lastPermissions: ((_b = cache3[item2.props.id]) == null ? void 0 : _b.lastPermissions) || null,
+              permissions: initialPermissions,
+              appState,
+              lastData: ((_c = cache3[item2.props.id]) == null ? void 0 : _c.lastData) || null
+            }
+          );
+          const latest = get().permissions;
+          set({
+            permissions: __spreadProps(__spreadValues({}, latest), {
+              cache: __spreadProps(__spreadValues({}, latest.cache), {
+                [item2.props.id]: {
+                  lastData: item2,
+                  lastPermissions: resolvedPermissions
+                }
+              }),
+              resolvedPermissions: __spreadProps(__spreadValues({}, latest.resolvedPermissions), {
+                [item2.props.id]: resolvedPermissions
+              })
+            })
+          });
+          unsetComponentLoading(item2.props.id);
+        }
+      }
+    });
+    const resolveDataForRoot = (force2 = false) => {
+      const { state: appState } = get();
+      resolveDataForItem(
+        // Shim the root data in by conforming to component data shape
+        {
+          type: "root",
+          props: __spreadProps(__spreadValues({}, appState.data.root.props), { id: "puck-root" })
         },
-        zoneCompound
+        force2
+      );
+    };
+    const { item, type, root } = params;
+    if (item) {
+      yield resolveDataForItem(item, force);
+    } else if (type) {
+      flattenData(state.data).filter((item2) => item2.type === type).map((item2) => __async(void 0, null, function* () {
+        yield resolveDataForItem(item2, force);
+      }));
+    } else if (root) {
+      resolveDataForRoot(force);
+    } else {
+      resolveDataForRoot(force);
+      flattenData(state.data).map((item2) => __async(void 0, null, function* () {
+        yield resolveDataForItem(item2, force);
+      }));
+    }
+  });
+  const refreshPermissions = (params) => resolvePermissions(params, true);
+  return {
+    cache: {},
+    globalPermissions: {
+      drag: true,
+      edit: true,
+      delete: true,
+      duplicate: true,
+      insert: true
+    },
+    resolvedPermissions: {},
+    getPermissions: ({ item, type, root } = {}) => {
+      const { config, permissions } = get();
+      const { globalPermissions, resolvedPermissions } = permissions;
+      if (item) {
+        const componentConfig = config.components[item.type];
+        const initialPermissions = __spreadValues(__spreadValues({}, globalPermissions), componentConfig == null ? void 0 : componentConfig.permissions);
+        const resolvedForItem = resolvedPermissions[item.props.id];
+        return resolvedForItem ? __spreadValues(__spreadValues({}, globalPermissions), resolvedForItem) : initialPermissions;
+      } else if (type) {
+        const componentConfig = config.components[type];
+        return __spreadValues(__spreadValues({}, globalPermissions), componentConfig == null ? void 0 : componentConfig.permissions);
+      } else if (root) {
+        const rootConfig = config.root;
+        const initialPermissions = __spreadValues(__spreadValues({}, globalPermissions), rootConfig == null ? void 0 : rootConfig.permissions);
+        const resolvedForItem = resolvedPermissions["puck-root"];
+        return resolvedForItem ? __spreadValues(__spreadValues({}, globalPermissions), resolvedForItem) : initialPermissions;
       }
-    ];
-  }, []);
+      return globalPermissions;
+    },
+    resolvePermissions,
+    refreshPermissions
+  };
 };
+
+// ../core/store/slices/fields.ts
+init_react_import();
+import { useCallback, useEffect as useEffect5 } from "react";
+var createFieldsStore = (_set, _get) => {
+  return {
+    fields: {},
+    loading: false,
+    lastResolvedData: {}
+  };
+};
+
+// ../core/store/index.ts
+var defaultAppState = {
+  data: { content: [], root: {}, zones: {} },
+  ui: {
+    leftSideBarVisible: true,
+    rightSideBarVisible: true,
+    arrayState: {},
+    itemSelector: null,
+    componentList: {},
+    isDragging: false,
+    previewMode: "edit",
+    viewports: {
+      current: {
+        width: defaultViewports[0].width,
+        height: defaultViewports[0].height || "auto"
+      },
+      options: [],
+      controlsVisible: true
+    },
+    field: { focus: null }
+  }
+};
+var defaultPageFields = {
+  title: { type: "text" }
+};
+var createAppStore = (initialAppStore) => create()(
+  subscribeWithSelector((set, get) => __spreadProps(__spreadValues({
+    state: defaultAppState,
+    config: { components: {} },
+    componentState: {},
+    plugins: [],
+    overrides: {},
+    viewports: defaultViewports,
+    zoomConfig: {
+      autoZoom: 1,
+      rootHeight: 0,
+      zoom: 1
+    },
+    status: "LOADING",
+    iframe: {},
+    metadata: {}
+  }, initialAppStore), {
+    fields: createFieldsStore(set, get),
+    history: createHistorySlice(set, get),
+    nodes: createNodesSlice(set, get),
+    permissions: createPermissionsSlice(set, get),
+    getComponentConfig: (type) => {
+      var _a;
+      const { config, selectedItem } = get();
+      const rootFields = ((_a = config.root) == null ? void 0 : _a.fields) || defaultPageFields;
+      return type && type !== "root" ? config.components[type] : selectedItem ? config.components[selectedItem.type] : __spreadProps(__spreadValues({}, config.root), { fields: rootFields });
+    },
+    dispatch: (action) => set((s) => {
+      var _a, _b;
+      const { record } = get().history;
+      const dispatch = createReducer({ config: s.config, record });
+      const state = dispatch(s.state, action);
+      const selectedItem = state.ui.itemSelector ? getItem(state.ui.itemSelector, state.data) : null;
+      (_b = (_a = get()).onAction) == null ? void 0 : _b.call(_a, action, state, get().state);
+      return __spreadProps(__spreadValues({}, s), { state, selectedItem });
+    }),
+    setZoomConfig: (zoomConfig) => set({ zoomConfig }),
+    setStatus: (status) => set({ status }),
+    setComponentState: (componentState) => set({ componentState }),
+    setComponentLoading: (id) => {
+      var _a;
+      const { setComponentState, componentState } = get();
+      setComponentState(__spreadProps(__spreadValues({}, componentState), {
+        [id]: __spreadProps(__spreadValues({}, componentState[id]), {
+          loadingCount: (((_a = componentState[id]) == null ? void 0 : _a.loadingCount) || 0) + 1
+        })
+      }));
+    },
+    unsetComponentLoading: (id) => {
+      var _a;
+      const { setComponentState, componentState } = get();
+      setComponentState(__spreadProps(__spreadValues({}, componentState), {
+        [id]: __spreadProps(__spreadValues({}, componentState[id]), {
+          loadingCount: Math.max(
+            (((_a = componentState[id]) == null ? void 0 : _a.loadingCount) || 0) - 1,
+            0
+          )
+        })
+      }));
+    },
+    // Helper
+    setUi: (ui, recordHistory) => set((s) => {
+      const dispatch = createReducer({
+        config: s.config,
+        record: () => {
+        }
+      });
+      const state = dispatch(s.state, {
+        type: "setUi",
+        ui,
+        recordHistory
+      });
+      const selectedItem = state.ui.itemSelector ? getItem(state.ui.itemSelector, state.data) : null;
+      return __spreadProps(__spreadValues({}, s), { state, selectedItem });
+    }),
+    resolveDataRuns: 0,
+    resolveData: (newAppState) => set((s) => {
+      resolveData(newAppState, get());
+      return __spreadProps(__spreadValues({}, s), { resolveDataRuns: s.resolveDataRuns + 1 });
+    })
+  }))
+);
+var appStoreContext = createContext(createAppStore());
+function useAppStore(selector) {
+  const context = useContext(appStoreContext);
+  return useStore(context, selector);
+}
+function useAppStoreApi() {
+  return useContext(appStoreContext);
+}
+
+// ../core/lib/use-breadcrumbs.ts
 var useBreadcrumbs = (renderCount) => {
-  const {
-    state: { data },
-    selectedItem
-  } = useAppContext();
-  const dzContext = useContext2(dropZoneContext);
-  return useMemo2(() => {
-    const breadcrumbs = convertPathDataToBreadcrumbs(
-      selectedItem,
-      dzContext == null ? void 0 : dzContext.pathData,
-      data
-    );
+  const selectedId = useAppStore((s) => {
+    var _a;
+    return (_a = s.selectedItem) == null ? void 0 : _a.props.id;
+  });
+  const config = useAppStore((s) => s.config);
+  const path = useAppStore((s) => {
+    var _a;
+    return (_a = s.nodes.nodes[selectedId]) == null ? void 0 : _a.path;
+  });
+  const appStore = useAppStoreApi();
+  return useMemo(() => {
+    const breadcrumbs = (path == null ? void 0 : path.map((zoneCompound) => {
+      var _a, _b;
+      const [componentId] = zoneCompound.split(":");
+      if (componentId === "root") {
+        return {
+          label: "Page",
+          selector: null
+        };
+      }
+      const node = appStore.getState().nodes.nodes[componentId];
+      const label = node ? (_b = (_a = config.components[node.data.type]) == null ? void 0 : _a.label) != null ? _b : node.data.type : "Component";
+      return {
+        label,
+        selector: node ? {
+          index: node.index,
+          zone: node.path[node.path.length - 1]
+        } : null
+      };
+    })) || [];
     if (renderCount) {
       return breadcrumbs.slice(breadcrumbs.length - renderCount);
     }
     return breadcrumbs;
-  }, [selectedItem, dzContext == null ? void 0 : dzContext.pathData, renderCount]);
+  }, [path, renderCount]);
 };
 
 // ../core/components/Loader/index.tsx
@@ -550,18 +1900,12 @@ init_react_import();
 // ../core/lib/filter.ts
 init_react_import();
 
-// ../core/lib/reorder.ts
-init_react_import();
-
-// ../core/lib/replace.ts
-init_react_import();
-
 // css-module:/home/runner/work/puck/puck/packages/core/components/Loader/styles.module.css#css-module
 init_react_import();
 var styles_module_default3 = { "Loader": "_Loader_nacdm_13", "loader-animation": "_loader-animation_nacdm_1" };
 
 // ../core/components/Loader/index.tsx
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { jsx as jsx2 } from "react/jsx-runtime";
 var getClassName2 = get_class_name_factory_default("Loader", styles_module_default3);
 var Loader = (_a) => {
   var _b = _a, {
@@ -571,7 +1915,7 @@ var Loader = (_a) => {
     "color",
     "size"
   ]);
-  return /* @__PURE__ */ jsx4(
+  return /* @__PURE__ */ jsx2(
     "span",
     __spreadValues({
       className: getClassName2(),
@@ -586,7 +1930,7 @@ var Loader = (_a) => {
 };
 
 // ../core/components/SidebarSection/index.tsx
-import { jsx as jsx5, jsxs } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
 var getClassName3 = get_class_name_factory_default("SidebarSection", styles_module_default);
 var SidebarSection = ({
   children,
@@ -597,7 +1941,7 @@ var SidebarSection = ({
   noPadding,
   isLoading
 }) => {
-  const { setUi } = useAppContext();
+  const setUi = useAppStore((s) => s.setUi);
   const breadcrumbs = useBreadcrumbs(1);
   return /* @__PURE__ */ jsxs(
     "div",
@@ -605,9 +1949,9 @@ var SidebarSection = ({
       className: getClassName3({ noBorderTop, noPadding }),
       style: { background },
       children: [
-        /* @__PURE__ */ jsx5("div", { className: getClassName3("title"), children: /* @__PURE__ */ jsxs("div", { className: getClassName3("breadcrumbs"), children: [
+        /* @__PURE__ */ jsx3("div", { className: getClassName3("title"), children: /* @__PURE__ */ jsxs("div", { className: getClassName3("breadcrumbs"), children: [
           showBreadcrumbs ? breadcrumbs.map((breadcrumb, i) => /* @__PURE__ */ jsxs("div", { className: getClassName3("breadcrumb"), children: [
-            /* @__PURE__ */ jsx5(
+            /* @__PURE__ */ jsx3(
               "button",
               {
                 type: "button",
@@ -616,12 +1960,12 @@ var SidebarSection = ({
                 children: breadcrumb.label
               }
             ),
-            /* @__PURE__ */ jsx5(ChevronRight, { size: 16 })
+            /* @__PURE__ */ jsx3(ChevronRight, { size: 16 })
           ] }, i)) : null,
-          /* @__PURE__ */ jsx5("div", { className: getClassName3("heading"), children: /* @__PURE__ */ jsx5(Heading, { rank: "2", size: "xs", children: title }) })
+          /* @__PURE__ */ jsx3("div", { className: getClassName3("heading"), children: /* @__PURE__ */ jsx3(Heading, { rank: "2", size: "xs", children: title }) })
         ] }) }),
-        /* @__PURE__ */ jsx5("div", { className: getClassName3("content"), children }),
-        isLoading && /* @__PURE__ */ jsx5("div", { className: getClassName3("loadingOverlay"), children: /* @__PURE__ */ jsx5(Loader, { size: 32 }) })
+        /* @__PURE__ */ jsx3("div", { className: getClassName3("content"), children }),
+        isLoading && /* @__PURE__ */ jsx3("div", { className: getClassName3("loadingOverlay"), children: /* @__PURE__ */ jsx3(Loader, { size: 32 }) })
       ]
     }
   );
@@ -635,18 +1979,18 @@ init_react_import();
 var styles_module_default4 = { "OutlineList": "_OutlineList_w4lzv_1", "OutlineListItem": "_OutlineListItem_w4lzv_25", "OutlineListItem--clickable": "_OutlineListItem--clickable_w4lzv_45" };
 
 // ../core/components/OutlineList/index.tsx
-import { jsx as jsx6 } from "react/jsx-runtime";
+import { jsx as jsx4 } from "react/jsx-runtime";
 var getClassName4 = get_class_name_factory_default("OutlineList", styles_module_default4);
 var getClassNameItem = get_class_name_factory_default("OutlineListItem", styles_module_default4);
 var OutlineList = ({ children }) => {
-  return /* @__PURE__ */ jsx6("ul", { className: getClassName4(), children });
+  return /* @__PURE__ */ jsx4("ul", { className: getClassName4(), children });
 };
-OutlineList.Clickable = ({ children }) => /* @__PURE__ */ jsx6("div", { className: getClassNameItem({ clickable: true }), children });
+OutlineList.Clickable = ({ children }) => /* @__PURE__ */ jsx4("div", { className: getClassNameItem({ clickable: true }), children });
 OutlineList.Item = ({
   children,
   onClick
 }) => {
-  return /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsx4(
     "li",
     {
       className: getClassNameItem({ clickable: !!onClick }),
@@ -680,7 +2024,7 @@ var getFrame = () => {
 
 // src/HeadingAnalyzer.tsx
 import ReactFromJSONModule from "react-from-json";
-import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs2 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
 var getClassName5 = get_class_name_factory_default("HeadingAnalyzer", HeadingAnalyzer_module_default);
 var getClassNameItem2 = get_class_name_factory_default("HeadingAnalyzerItem", HeadingAnalyzer_module_default);
 var ReactFromJSON = ReactFromJSONModule.default || ReactFromJSONModule;
@@ -733,10 +2077,11 @@ function buildHierarchy(frame) {
   }
   return root.children;
 }
+var usePuck = createUsePuck();
 var HeadingAnalyzer = () => {
-  const { appState } = usePuck();
-  const [hierarchy, setHierarchy] = useState5([]);
-  useEffect4(() => {
+  const data = usePuck((s) => s.appState.data);
+  const [hierarchy, setHierarchy] = useState([]);
+  useEffect6(() => {
     const frame = getFrame();
     const entry = frame == null ? void 0 : frame.querySelector(`[data-puck-entry]`);
     if (!entry) return;
@@ -748,7 +2093,7 @@ var HeadingAnalyzer = () => {
     return () => {
       observer.disconnect();
     };
-  }, [appState.data]);
+  }, [data]);
   return /* @__PURE__ */ jsxs2("div", { className: getClassName5(), children: [
     /* @__PURE__ */ jsxs2(
       "small",
@@ -762,19 +2107,19 @@ var HeadingAnalyzer = () => {
         children: [
           "Heading analyzer styles not loaded. Please review the",
           " ",
-          /* @__PURE__ */ jsx7("a", { href: "https://github.com/measuredco/puck/blob/main/packages/plugin-heading-analyzer/README.md", children: "README" }),
+          /* @__PURE__ */ jsx5("a", { href: "https://github.com/measuredco/puck/blob/main/packages/plugin-heading-analyzer/README.md", children: "README" }),
           "."
         ]
       }
     ),
-    hierarchy.length === 0 && /* @__PURE__ */ jsx7("div", { children: "No headings." }),
-    /* @__PURE__ */ jsx7(OutlineList, { children: /* @__PURE__ */ jsx7(
+    hierarchy.length === 0 && /* @__PURE__ */ jsx5("div", { children: "No headings." }),
+    /* @__PURE__ */ jsx5(OutlineList, { children: /* @__PURE__ */ jsx5(
       ReactFromJSON,
       {
         mapping: {
-          Root: (props) => /* @__PURE__ */ jsx7(Fragment2, { children: props.children }),
+          Root: (props) => /* @__PURE__ */ jsx5(Fragment, { children: props.children }),
           OutlineListItem: (props) => /* @__PURE__ */ jsxs2(OutlineList.Item, { children: [
-            /* @__PURE__ */ jsx7(OutlineList.Clickable, { children: /* @__PURE__ */ jsx7(
+            /* @__PURE__ */ jsx5(OutlineList.Clickable, { children: /* @__PURE__ */ jsx5(
               "small",
               {
                 className: getClassNameItem2({ missing: props.missing }),
@@ -792,13 +2137,13 @@ var HeadingAnalyzer = () => {
                     }, 2e3);
                   }
                 },
-                children: props.missing ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+                children: props.missing ? /* @__PURE__ */ jsxs2(Fragment, { children: [
                   /* @__PURE__ */ jsxs2("b", { children: [
                     "H",
                     props.rank
                   ] }),
                   ": Missing"
-                ] }) : /* @__PURE__ */ jsxs2(Fragment2, { children: [
+                ] }) : /* @__PURE__ */ jsxs2(Fragment, { children: [
                   /* @__PURE__ */ jsxs2("b", { children: [
                     "H",
                     props.rank
@@ -808,7 +2153,7 @@ var HeadingAnalyzer = () => {
                 ] })
               }
             ) }),
-            /* @__PURE__ */ jsx7(OutlineList, { children: props.children })
+            /* @__PURE__ */ jsx5(OutlineList, { children: props.children })
           ] })
         },
         entry: {
@@ -830,9 +2175,9 @@ var HeadingAnalyzer = () => {
 };
 var headingAnalyzer = {
   overrides: {
-    fields: ({ children, itemSelector }) => /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    fields: ({ children, itemSelector }) => /* @__PURE__ */ jsxs2(Fragment, { children: [
       children,
-      /* @__PURE__ */ jsx7("div", { style: { display: itemSelector ? "none" : "block" }, children: /* @__PURE__ */ jsx7(SidebarSection, { title: "Heading Outline", children: /* @__PURE__ */ jsx7(HeadingAnalyzer, {}) }) })
+      /* @__PURE__ */ jsx5("div", { style: { display: itemSelector ? "none" : "block" }, children: /* @__PURE__ */ jsx5(SidebarSection, { title: "Heading Outline", children: /* @__PURE__ */ jsx5(HeadingAnalyzer, {}) }) })
     ] })
   }
 };
@@ -849,6 +2194,50 @@ classnames/index.js:
   	http://jedwatson.github.io/classnames
   *)
 
+use-sync-external-store/cjs/use-sync-external-store-shim.production.js:
+  (**
+   * @license React
+   * use-sync-external-store-shim.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+use-sync-external-store/cjs/use-sync-external-store-shim.development.js:
+  (**
+   * @license React
+   * use-sync-external-store-shim.development.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.js:
+  (**
+   * @license React
+   * use-sync-external-store-shim/with-selector.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js:
+  (**
+   * @license React
+   * use-sync-external-store-shim/with-selector.development.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
 lucide-react/dist/esm/shared/src/utils.js:
   (**
    * @license lucide-react v0.468.0 - ISC