@juo/blocks 1.0.0

package/dist/theme-state-BZplRS92.js

@@ -0,0 +1,886 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const createContext = (key) => key;
+class ContextRequestEvent extends Event {
+  constructor(context, callback, subscribe) {
+    super("context-request", { bubbles: true, composed: true });
+    this.context = context;
+    this.callback = callback;
+    this.subscribe = subscribe;
+  }
+}
+class ContextProvideEvent extends Event {
+  constructor(context, value, subscribe) {
+    super("context-provide", { bubbles: true, composed: true });
+    this.context = context;
+    this.value = value;
+    this.subscribe = subscribe;
+  }
+}
+function provideContext(target, context, init) {
+  console.log("context:provide", context, target);
+  const ev = new ContextProvideEvent(context, init);
+  target.dispatchEvent(ev);
+}
+function injectContext(target, context) {
+  let value = void 0;
+  console.log("context:inject", context, target);
+  const ev = new ContextRequestEvent(context, (received) => {
+    value = received;
+  });
+  target.dispatchEvent(ev);
+  if (value === void 0) {
+    throw new Error(`Context '${context}' not defined`);
+  }
+  return value;
+}
+function subscribeContext(target, context, callback) {
+  let unsubscribeFunction = null;
+  console.log("context:subscribe", context, target);
+  const protocolCallback = (value, unsubscribe) => {
+    if (unsubscribe) {
+      unsubscribeFunction = unsubscribe;
+    }
+    callback(value);
+  };
+  const ev = new ContextRequestEvent(context, protocolCallback, true);
+  target.dispatchEvent(ev);
+  return () => {
+    if (unsubscribeFunction) {
+      unsubscribeFunction();
+    }
+  };
+}
+class ContextRoot extends HTMLElement {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "store", /* @__PURE__ */ new Map());
+    __publicField(this, "callbacks", /* @__PURE__ */ new Map());
+  }
+  connectedCallback() {
+    this.addEventListener("context-provide", (ev) => {
+      ev.stopPropagation();
+      console.log("context-root:provide", ev.context, ev.value);
+      this.store.set(ev.context, ev.value);
+      const registeredCallbacks = this.callbacks.get(ev.context) ?? [];
+      console.log("callbacks", registeredCallbacks);
+      registeredCallbacks.forEach((cb) => {
+        const unsubscribe = () => {
+          const callbacks = this.callbacks.get(ev.context);
+          if (callbacks) {
+            const cbIndex = callbacks.indexOf(cb);
+            if (cbIndex > -1) {
+              callbacks.splice(cbIndex, 1);
+            }
+          }
+          console.log("context-root:unsubscribed", ev.context);
+        };
+        cb(ev.value, unsubscribe);
+      });
+    });
+    this.addEventListener("context-request", (ev) => {
+      ev.stopPropagation();
+      console.log("context-root:request", ev.context, ev);
+      const storedValue = this.store.get(ev.context);
+      if (ev.subscribe) {
+        let callbacks = this.callbacks.get(ev.context);
+        if (!callbacks) {
+          callbacks = [];
+          this.callbacks.set(ev.context, callbacks);
+        }
+        const unsubscribe = () => {
+          const currentCallbacks = this.callbacks.get(ev.context);
+          if (currentCallbacks) {
+            const index = currentCallbacks.indexOf(ev.callback);
+            if (index > -1) {
+              currentCallbacks.splice(index, 1);
+            }
+          }
+          console.log("context-root:unsubscribed", ev.context);
+        };
+        callbacks.push(ev.callback);
+        if (storedValue !== void 0) {
+          ev.callback(storedValue, unsubscribe);
+        }
+      } else {
+        if (storedValue !== void 0) {
+          ev.callback(storedValue);
+        } else {
+          console.warn("Context not present in store: " + String(ev.context));
+        }
+      }
+    });
+    console.log("context-root:ready");
+  }
+}
+var i = Symbol.for("preact-signals");
+function t() {
+  if (!(s > 1)) {
+    var i2, t2 = false;
+    while (void 0 !== h) {
+      var r = h;
+      h = void 0;
+      f++;
+      while (void 0 !== r) {
+        var o2 = r.o;
+        r.o = void 0;
+        r.f &= -3;
+        if (!(8 & r.f) && c(r)) try {
+          r.c();
+        } catch (r2) {
+          if (!t2) {
+            i2 = r2;
+            t2 = true;
+          }
+        }
+        r = o2;
+      }
+    }
+    f = 0;
+    s--;
+    if (t2) throw i2;
+  } else s--;
+}
+var o = void 0;
+function n(i2) {
+  var t2 = o;
+  o = void 0;
+  try {
+    return i2();
+  } finally {
+    o = t2;
+  }
+}
+var h = void 0, s = 0, f = 0, v = 0;
+function e(i2) {
+  if (void 0 !== o) {
+    var t2 = i2.n;
+    if (void 0 === t2 || t2.t !== o) {
+      t2 = { i: 0, S: i2, p: o.s, n: void 0, t: o, e: void 0, x: void 0, r: t2 };
+      if (void 0 !== o.s) o.s.n = t2;
+      o.s = t2;
+      i2.n = t2;
+      if (32 & o.f) i2.S(t2);
+      return t2;
+    } else if (-1 === t2.i) {
+      t2.i = 0;
+      if (void 0 !== t2.n) {
+        t2.n.p = t2.p;
+        if (void 0 !== t2.p) t2.p.n = t2.n;
+        t2.p = o.s;
+        t2.n = void 0;
+        o.s.n = t2;
+        o.s = t2;
+      }
+      return t2;
+    }
+  }
+}
+function u(i2, t2) {
+  this.v = i2;
+  this.i = 0;
+  this.n = void 0;
+  this.t = void 0;
+  this.W = null == t2 ? void 0 : t2.watched;
+  this.Z = null == t2 ? void 0 : t2.unwatched;
+}
+u.prototype.brand = i;
+u.prototype.h = function() {
+  return true;
+};
+u.prototype.S = function(i2) {
+  var t2 = this, r = this.t;
+  if (r !== i2 && void 0 === i2.e) {
+    i2.x = r;
+    this.t = i2;
+    if (void 0 !== r) r.e = i2;
+    else n(function() {
+      var i3;
+      null == (i3 = t2.W) || i3.call(t2);
+    });
+  }
+};
+u.prototype.U = function(i2) {
+  var t2 = this;
+  if (void 0 !== this.t) {
+    var r = i2.e, o2 = i2.x;
+    if (void 0 !== r) {
+      r.x = o2;
+      i2.e = void 0;
+    }
+    if (void 0 !== o2) {
+      o2.e = r;
+      i2.x = void 0;
+    }
+    if (i2 === this.t) {
+      this.t = o2;
+      if (void 0 === o2) n(function() {
+        var i3;
+        null == (i3 = t2.Z) || i3.call(t2);
+      });
+    }
+  }
+};
+u.prototype.subscribe = function(i2) {
+  var t2 = this;
+  return E(function() {
+    var r = t2.value, n2 = o;
+    o = void 0;
+    try {
+      i2(r);
+    } finally {
+      o = n2;
+    }
+  });
+};
+u.prototype.valueOf = function() {
+  return this.value;
+};
+u.prototype.toString = function() {
+  return this.value + "";
+};
+u.prototype.toJSON = function() {
+  return this.value;
+};
+u.prototype.peek = function() {
+  var i2 = o;
+  o = void 0;
+  try {
+    return this.value;
+  } finally {
+    o = i2;
+  }
+};
+Object.defineProperty(u.prototype, "value", { get: function() {
+  var i2 = e(this);
+  if (void 0 !== i2) i2.i = this.i;
+  return this.v;
+}, set: function(i2) {
+  if (i2 !== this.v) {
+    if (f > 100) throw new Error("Cycle detected");
+    this.v = i2;
+    this.i++;
+    v++;
+    s++;
+    try {
+      for (var r = this.t; void 0 !== r; r = r.x) r.t.N();
+    } finally {
+      t();
+    }
+  }
+} });
+function d(i2, t2) {
+  return new u(i2, t2);
+}
+function c(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) if (t2.S.i !== t2.i || !t2.S.h() || t2.S.i !== t2.i) return true;
+  return false;
+}
+function a(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) {
+    var r = t2.S.n;
+    if (void 0 !== r) t2.r = r;
+    t2.S.n = t2;
+    t2.i = -1;
+    if (void 0 === t2.n) {
+      i2.s = t2;
+      break;
+    }
+  }
+}
+function l(i2) {
+  var t2 = i2.s, r = void 0;
+  while (void 0 !== t2) {
+    var o2 = t2.p;
+    if (-1 === t2.i) {
+      t2.S.U(t2);
+      if (void 0 !== o2) o2.n = t2.n;
+      if (void 0 !== t2.n) t2.n.p = o2;
+    } else r = t2;
+    t2.S.n = t2.r;
+    if (void 0 !== t2.r) t2.r = void 0;
+    t2 = o2;
+  }
+  i2.s = r;
+}
+function y(i2, t2) {
+  u.call(this, void 0);
+  this.x = i2;
+  this.s = void 0;
+  this.g = v - 1;
+  this.f = 4;
+  this.W = null == t2 ? void 0 : t2.watched;
+  this.Z = null == t2 ? void 0 : t2.unwatched;
+}
+y.prototype = new u();
+y.prototype.h = function() {
+  this.f &= -3;
+  if (1 & this.f) return false;
+  if (32 == (36 & this.f)) return true;
+  this.f &= -5;
+  if (this.g === v) return true;
+  this.g = v;
+  this.f |= 1;
+  if (this.i > 0 && !c(this)) {
+    this.f &= -2;
+    return true;
+  }
+  var i2 = o;
+  try {
+    a(this);
+    o = this;
+    var t2 = this.x();
+    if (16 & this.f || this.v !== t2 || 0 === this.i) {
+      this.v = t2;
+      this.f &= -17;
+      this.i++;
+    }
+  } catch (i3) {
+    this.v = i3;
+    this.f |= 16;
+    this.i++;
+  }
+  o = i2;
+  l(this);
+  this.f &= -2;
+  return true;
+};
+y.prototype.S = function(i2) {
+  if (void 0 === this.t) {
+    this.f |= 36;
+    for (var t2 = this.s; void 0 !== t2; t2 = t2.n) t2.S.S(t2);
+  }
+  u.prototype.S.call(this, i2);
+};
+y.prototype.U = function(i2) {
+  if (void 0 !== this.t) {
+    u.prototype.U.call(this, i2);
+    if (void 0 === this.t) {
+      this.f &= -33;
+      for (var t2 = this.s; void 0 !== t2; t2 = t2.n) t2.S.U(t2);
+    }
+  }
+};
+y.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (var i2 = this.t; void 0 !== i2; i2 = i2.x) i2.t.N();
+  }
+};
+Object.defineProperty(y.prototype, "value", { get: function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  var i2 = e(this);
+  this.h();
+  if (void 0 !== i2) i2.i = this.i;
+  if (16 & this.f) throw this.v;
+  return this.v;
+} });
+function w(i2, t2) {
+  return new y(i2, t2);
+}
+function _(i2) {
+  var r = i2.u;
+  i2.u = void 0;
+  if ("function" == typeof r) {
+    s++;
+    var n2 = o;
+    o = void 0;
+    try {
+      r();
+    } catch (t2) {
+      i2.f &= -2;
+      i2.f |= 8;
+      b(i2);
+      throw t2;
+    } finally {
+      o = n2;
+      t();
+    }
+  }
+}
+function b(i2) {
+  for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) t2.S.U(t2);
+  i2.x = void 0;
+  i2.s = void 0;
+  _(i2);
+}
+function g(i2) {
+  if (o !== this) throw new Error("Out-of-order effect");
+  l(this);
+  o = i2;
+  this.f &= -2;
+  if (8 & this.f) b(this);
+  t();
+}
+function p(i2) {
+  this.x = i2;
+  this.u = void 0;
+  this.s = void 0;
+  this.o = void 0;
+  this.f = 32;
+}
+p.prototype.c = function() {
+  var i2 = this.S();
+  try {
+    if (8 & this.f) return;
+    if (void 0 === this.x) return;
+    var t2 = this.x();
+    if ("function" == typeof t2) this.u = t2;
+  } finally {
+    i2();
+  }
+};
+p.prototype.S = function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  this.f |= 1;
+  this.f &= -9;
+  _(this);
+  a(this);
+  s++;
+  var i2 = o;
+  o = this;
+  return g.bind(this, i2);
+};
+p.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 2;
+    this.o = h;
+    h = this;
+  }
+};
+p.prototype.d = function() {
+  this.f |= 8;
+  if (!(1 & this.f)) b(this);
+};
+p.prototype.dispose = function() {
+  this.d();
+};
+function E(i2) {
+  var t2 = new p(i2);
+  try {
+    t2.c();
+  } catch (i3) {
+    t2.d();
+    throw i3;
+  }
+  var r = t2.d.bind(t2);
+  r[Symbol.dispose] = r;
+  return r;
+}
+function serializeBlocks(blocks) {
+  return blocks.map((block) => serializeBlock(block));
+}
+function serializeBlock(block) {
+  return {
+    id: block.id,
+    type: block.type,
+    props: JSON.parse(JSON.stringify(block.props)),
+    slots: Object.fromEntries(
+      Object.entries(block.slots ?? {}).map(([key, value]) => [
+        key,
+        Array.isArray(value) ? value.map(
+          (v2) => typeof v2 === "string" ? v2 : serializeBlock(v2)
+        ) : typeof value === "string" ? value : serializeBlock(value)
+      ])
+    )
+  };
+}
+function createSelectedBlock() {
+  const selected = d(null);
+  function setSelection(block) {
+    selected.value = null;
+    selected.value = block;
+  }
+  function clearSelection(block) {
+    var _a;
+    if (block == null || ((_a = selected.value) == null ? void 0 : _a.id) === block.id) {
+      selected.value = null;
+    }
+  }
+  return { selected, setSelection, clearSelection };
+}
+const SelectedBlockContext = createContext("selectedBlock");
+const blockDefinitions = (() => {
+  if (typeof window !== "undefined") {
+    window._juoBlocks = window._juoBlocks || /* @__PURE__ */ new Map();
+    return window._juoBlocks;
+  }
+  return /* @__PURE__ */ new Map();
+})();
+class BlockWrapperEvent extends Event {
+  constructor(block, callback) {
+    super("juo:block-wrapper-render", {
+      bubbles: true,
+      composed: true,
+      cancelable: true
+    });
+    this.block = block;
+    this.callback = callback;
+  }
+}
+function isInEditorIframe() {
+  if (typeof window === "undefined") return false;
+  const params = new URLSearchParams(window.location.search);
+  return params.get("editor") === "true";
+}
+function withWrapper(fn) {
+  let wrapper = null;
+  return (block) => {
+    var _a;
+    let rendered = fn(block);
+    if (wrapper === null) {
+      if (isInEditorIframe()) {
+        wrapper = document.createElement("juo-editor-block-wrapper");
+        wrapper.setAttribute("data-block-id", block.id);
+        (_a = wrapper.setBlock) == null ? void 0 : _a.call(wrapper, block);
+        wrapper.appendChild(rendered);
+      } else {
+        const evt = new BlockWrapperEvent(block, (evtWrapper) => {
+          wrapper = evtWrapper;
+        });
+        document.dispatchEvent(evt);
+      }
+    }
+    if (!wrapper) {
+      return rendered;
+    }
+    wrapper.replaceChildren(rendered);
+    return wrapper;
+  };
+}
+const registerBlockListeners = [];
+function registerBlock(block) {
+  blockDefinitions.set(block.name, block);
+  registerBlockListeners.forEach((cb) => cb(block.name, block));
+}
+function onRegisterBlock(cb) {
+  registerBlockListeners.push(cb);
+}
+function defineBlock(name, opts) {
+  const definition = {
+    name,
+    group: opts.group,
+    schema: opts.schema,
+    initialValue: opts.initialValue,
+    render: opts.renderer,
+    presets: opts.presets,
+    locales: opts.locales
+  };
+  return definition;
+}
+function defineBlockRuntime(name, opts) {
+  const definition = {
+    name,
+    group: opts.group,
+    schema: {},
+    initialValue() {
+      throw new Error("Initial value cannot be called in runtime mode");
+    },
+    render: opts.renderer
+  };
+  return definition;
+}
+function getDefinedBlocks() {
+  return [...blockDefinitions.values()];
+}
+function createCeRenderer(name) {
+  function renderSlots(slots, block) {
+    if (!slots) {
+      return slots;
+    }
+    return Object.entries(slots).flatMap(([key, value]) => {
+      const values = Array.isArray(value) ? value : [value];
+      return values.map((value2) => {
+        if (typeof value2 === "string") {
+          const el2 = document.createElement("span");
+          if (key !== "default") {
+            el2.slot = key;
+          }
+          el2.innerText = value2;
+          return el2;
+        }
+        const el = value2.definition.render({
+          ...value2,
+          props: {
+            ...value2.props,
+            parentProps: block.props
+          }
+        });
+        if (key !== "default") {
+          el.slot = key;
+        }
+        return el;
+      });
+    });
+  }
+  return (block) => {
+    const wrapper = document.createElement("div");
+    wrapper.setAttribute("data-block-id", block.id);
+    wrapper.setAttribute("data-block-type", block.type);
+    const el = document.createElement(name);
+    el.setAttribute("data-block-id", block.id);
+    el.setAttribute("data-block-type", block.type);
+    Object.entries(block.props).forEach(([key, value]) => {
+      el[key] = value;
+    });
+    el.replaceChildren(...renderSlots(block.slots, block));
+    wrapper.append(el);
+    return wrapper;
+  };
+}
+function getDefinitionByName(name) {
+  const definition = blockDefinitions.get(name);
+  if (definition == null) {
+    throw new Error(`Definition for block '${name} does not exists`);
+  }
+  return definition;
+}
+function createBlockInstance(name, opts) {
+  const initialValue = (() => {
+    const value = getDefinitionByName(name).initialValue ?? {};
+    if (typeof value === "function") {
+      return value();
+    }
+    return value;
+  })();
+  if ((opts == null ? void 0 : opts.props) == null && initialValue == null) {
+    throw new Error(
+      `Block '${name} cannot be created without value in runtime mode`
+    );
+  }
+  const slots = {
+    ...initialValue.slots,
+    ...(opts == null ? void 0 : opts.slots) ?? {}
+  };
+  const props = {
+    ...initialValue.props ?? {},
+    ...(opts == null ? void 0 : opts.props) ?? {}
+  };
+  return {
+    // TODO: This should be unique
+    id: (opts == null ? void 0 : opts.id) ?? Math.round(1e3 * Math.random()).toString(10),
+    type: name,
+    props,
+    slots,
+    get definition() {
+      return getDefinitionByName(name);
+    }
+  };
+}
+function createBlockInstanceFromObject(input) {
+  const { id, type, props, slots } = input;
+  return createBlockInstance(type, {
+    props,
+    slots: Object.fromEntries(
+      Object.entries(slots).map(([key, value]) => [
+        key,
+        (Array.isArray(value) ? value : [value]).map(
+          (child) => createBlockInstanceFromObject(child)
+        )
+      ])
+    ),
+    id
+  });
+}
+function createBlockInstanceFromJSON(input) {
+  return createBlockInstanceFromObject(JSON.parse(input));
+}
+const DEFAULT_GLOBAL_STYLES = {
+  volume: "comfort",
+  style: "ghost",
+  corners: "round",
+  buttonCorners: "round",
+  thumbnailCorners: "circle",
+  theme: "preset",
+  themeType: "neutral",
+  colors: {
+    accent: "#000000",
+    secondary: "#000000",
+    tint: "#111111",
+    callout: "#F5F5F5",
+    success: "#287a25",
+    error: "#a93c3c",
+    information: "#0075a3",
+    warning: "#8a5e00",
+    background: "#FFFFFF"
+  }
+};
+const ThemeStateContext = createContext("theme-state");
+function normalizeLocale(locale) {
+  return locale.trim().toLowerCase().split("-")[0] || "en";
+}
+function toStringRecord(input) {
+  if (input == null) return {};
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => typeof value === "string")
+  );
+}
+function parseBlockLocaleFile(file) {
+  if (file == null) {
+    return { defaults: {}, modes: {} };
+  }
+  const entries = Object.entries(file).filter(
+    ([key, value]) => key !== "overrides" && typeof value === "string"
+  );
+  const topLevel = Object.fromEntries(entries);
+  const overrides = toStringRecord(file.overrides);
+  return {
+    defaults: { ...topLevel, ...overrides },
+    modes: {
+      ...Object.fromEntries(
+        Object.keys(topLevel).map((key) => [key, "default"])
+      ),
+      ...Object.fromEntries(
+        Object.keys(overrides).map((key) => [key, "override"])
+      )
+    }
+  };
+}
+function indexOverrides(overrides) {
+  const indexed = {
+    theme: {},
+    blocks: {}
+  };
+  for (const item of overrides) {
+    if (item.scope.kind === "theme") {
+      indexed.theme[item.key] = item.value;
+      continue;
+    }
+    if (indexed.blocks[item.scope.blockId] == null) {
+      indexed.blocks[item.scope.blockId] = {};
+    }
+    indexed.blocks[item.scope.blockId][item.key] = item.value;
+  }
+  return indexed;
+}
+function createThemeState(deps) {
+  const surfaces = {
+    page: { blocks: d([]) },
+    overlay: { blocks: d([]) }
+  };
+  const locale = d("en");
+  const catalogs = d(null);
+  const globalStyles = d(
+    deps.initialGlobalStyles ?? DEFAULT_GLOBAL_STYLES
+  );
+  function setGlobalStyles(styles) {
+    globalStyles.value = styles;
+  }
+  async function collectBlockDefaults(loc) {
+    const nextDefaults = {};
+    const nextModes = {};
+    for (const block of getDefinedBlocks()) {
+      if (block.locales == null) continue;
+      let file = null;
+      try {
+        file = await block.locales.load(loc);
+      } catch {
+        file = null;
+      }
+      const parsed = parseBlockLocaleFile(file);
+      nextDefaults[block.name] = parsed.defaults;
+      nextModes[block.name] = parsed.modes;
+    }
+    return { defaults: nextDefaults, modes: nextModes };
+  }
+  async function setLocale(nextLocaleRaw) {
+    var _a;
+    const nextLocale = normalizeLocale(nextLocaleRaw);
+    const [blockData, loadedOverrides] = await Promise.all([
+      collectBlockDefaults(nextLocale),
+      ((_a = deps.translations) == null ? void 0 : _a.resolveTranslations(nextLocale).catch(() => [])) ?? Promise.resolve([])
+    ]);
+    const overrides = loadedOverrides.filter(
+      (item) => normalizeLocale(item.locale) === nextLocale
+    );
+    const indexed = indexOverrides(overrides);
+    catalogs.value = {
+      theme: {
+        defaults: {},
+        overrides: indexed.theme
+      },
+      blocks: {
+        defaults: blockData.defaults,
+        modes: blockData.modes,
+        overrides: indexed.blocks
+      }
+    };
+    locale.value = nextLocale;
+  }
+  async function resolve(surface, id, defaultBlock) {
+    surfaces[surface].blocks.value = [];
+    const result = await deps.resolve(surface, id, defaultBlock);
+    surfaces[surface].blocks.value = [
+      ...result.blocks.map((block) => createBlockInstanceFromObject(block))
+    ];
+    return result;
+  }
+  onRegisterBlock(async (_2, block) => {
+    if (block.locales == null || catalogs.value == null) return;
+    const localeAtLoadStart = locale.value;
+    let file = null;
+    try {
+      file = await block.locales.load(localeAtLoadStart);
+    } catch {
+      file = null;
+    }
+    if (catalogs.value == null || locale.value !== localeAtLoadStart) return;
+    const parsed = parseBlockLocaleFile(file);
+    const current = catalogs.value;
+    catalogs.value = {
+      ...current,
+      blocks: {
+        ...current.blocks,
+        defaults: {
+          ...current.blocks.defaults,
+          [block.name]: parsed.defaults
+        },
+        modes: {
+          ...current.blocks.modes,
+          [block.name]: parsed.modes
+        }
+      }
+    };
+  });
+  return {
+    page: surfaces.page,
+    overlay: surfaces.overlay,
+    locales: { locale, catalogs, setLocale },
+    globalStyles,
+    setGlobalStyles,
+    resolve
+  };
+}
+export {
+  BlockWrapperEvent as B,
+  ContextRequestEvent as C,
+  DEFAULT_GLOBAL_STYLES as D,
+  E,
+  SelectedBlockContext as S,
+  ThemeStateContext as T,
+  createBlockInstance as a,
+  createBlockInstanceFromJSON as b,
+  createContext as c,
+  d,
+  createBlockInstanceFromObject as e,
+  createCeRenderer as f,
+  defineBlock as g,
+  defineBlockRuntime as h,
+  getDefinedBlocks as i,
+  withWrapper as j,
+  createSelectedBlock as k,
+  createThemeState as l,
+  indexOverrides as m,
+  ContextProvideEvent as n,
+  onRegisterBlock as o,
+  injectContext as p,
+  provideContext as q,
+  registerBlock as r,
+  serializeBlocks as s,
+  subscribeContext as t,
+  u,
+  n as v,
+  w,
+  ContextRoot as x
+};