@makeswift/runtime 0.0.0-a500663 → 0.0.0-e0c0445

package/dist/react.cjs2.js

@@ -0,0 +1,821 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var React = require("react");
+var actions = require("./actions.cjs.js");
+var descriptors = require("./descriptors.cjs.js");
+var jsxRuntime = require("react/jsx-runtime");
+function _interopDefaultLegacy(e2) {
+  return e2 && typeof e2 === "object" && "default" in e2 ? e2 : { "default": e2 };
+}
+var React__default = /* @__PURE__ */ _interopDefaultLegacy(React);
+var withSelector = { exports: {} };
+var withSelector_production_min = {};
+var shim = { exports: {} };
+var useSyncExternalStoreShim_production_min = {};
+/** @license React vundefined
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var e = React__default["default"];
+function h$1(a, b) {
+  return a === b && (a !== 0 || 1 / a === 1 / b) || a !== a && b !== b;
+}
+var k = typeof Object.is === "function" ? Object.is : h$1, l = e.useState, m = e.useEffect, n$1 = e.useLayoutEffect, p$1 = e.useDebugValue;
+function q$1(a, b) {
+  var d = b(), f = l({ inst: { value: d, getSnapshot: b } }), c = f[0].inst, g = f[1];
+  n$1(function() {
+    c.value = d;
+    c.getSnapshot = b;
+    r$1(c) && g({ inst: c });
+  }, [a, d, b]);
+  m(function() {
+    r$1(c) && g({ inst: c });
+    return a(function() {
+      r$1(c) && g({ inst: c });
+    });
+  }, [a]);
+  p$1(d);
+  return d;
+}
+function r$1(a) {
+  var b = a.getSnapshot;
+  a = a.value;
+  try {
+    var d = b();
+    return !k(a, d);
+  } catch (f) {
+    return true;
+  }
+}
+function t$1(a, b) {
+  return b();
+}
+var u$1 = typeof window === "undefined" || typeof window.document === "undefined" || typeof window.document.createElement === "undefined" ? t$1 : q$1;
+useSyncExternalStoreShim_production_min.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : u$1;
+{
+  shim.exports = useSyncExternalStoreShim_production_min;
+}
+/** @license React vundefined
+ * use-sync-external-store-shim/with-selector.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var h = React__default["default"], n = shim.exports;
+function p(a, b) {
+  return a === b && (a !== 0 || 1 / a === 1 / b) || a !== a && b !== b;
+}
+var q = typeof Object.is === "function" ? Object.is : p, r = n.useSyncExternalStore, t = h.useRef, u = h.useEffect, v = h.useMemo, w = h.useDebugValue;
+withSelector_production_min.useSyncExternalStoreWithSelector = function(a, b, e2, l2, g) {
+  var c = t(null);
+  if (c.current === null) {
+    var f = { hasValue: false, value: null };
+    c.current = f;
+  } else
+    f = c.current;
+  c = v(function() {
+    function a2(a3) {
+      if (!c2) {
+        c2 = true;
+        d2 = a3;
+        a3 = l2(a3);
+        if (g !== void 0 && f.hasValue) {
+          var b2 = f.value;
+          if (g(b2, a3))
+            return k2 = b2;
+        }
+        return k2 = a3;
+      }
+      b2 = k2;
+      if (q(d2, a3))
+        return b2;
+      var e3 = l2(a3);
+      if (g !== void 0 && g(b2, e3))
+        return b2;
+      d2 = a3;
+      return k2 = e3;
+    }
+    var c2 = false, d2, k2, m2 = e2 === void 0 ? null : e2;
+    return [function() {
+      return a2(b());
+    }, m2 === null ? void 0 : function() {
+      return a2(m2());
+    }];
+  }, [b, e2, l2, g]);
+  var d = r(a, c[0], c[1]);
+  u(function() {
+    f.hasValue = true;
+    f.value = d;
+  }, [d]);
+  w(d);
+  return d;
+};
+{
+  withSelector.exports = withSelector_production_min;
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function formatProdErrorMessage(code) {
+  return "Minified Redux error #" + code + "; visit https://redux.js.org/Errors?code=" + code + " for the full message or use the non-minified dev environment for full errors. ";
+}
+var $$observable = function() {
+  return typeof Symbol === "function" && Symbol.observable || "@@observable";
+}();
+var randomString = function randomString2() {
+  return Math.random().toString(36).substring(7).split("").join(".");
+};
+var ActionTypes = {
+  INIT: "@@redux/INIT" + randomString(),
+  REPLACE: "@@redux/REPLACE" + randomString(),
+  PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {
+    return "@@redux/PROBE_UNKNOWN_ACTION" + randomString();
+  }
+};
+function isPlainObject(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  var proto = obj;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(obj) === proto;
+}
+function createStore(reducer2, preloadedState, enhancer) {
+  var _ref2;
+  if (typeof preloadedState === "function" && typeof enhancer === "function" || typeof enhancer === "function" && typeof arguments[3] === "function") {
+    throw new Error(formatProdErrorMessage(0));
+  }
+  if (typeof preloadedState === "function" && typeof enhancer === "undefined") {
+    enhancer = preloadedState;
+    preloadedState = void 0;
+  }
+  if (typeof enhancer !== "undefined") {
+    if (typeof enhancer !== "function") {
+      throw new Error(formatProdErrorMessage(1));
+    }
+    return enhancer(createStore)(reducer2, preloadedState);
+  }
+  if (typeof reducer2 !== "function") {
+    throw new Error(formatProdErrorMessage(2));
+  }
+  var currentReducer = reducer2;
+  var currentState = preloadedState;
+  var currentListeners = [];
+  var nextListeners = currentListeners;
+  var isDispatching = false;
+  function ensureCanMutateNextListeners() {
+    if (nextListeners === currentListeners) {
+      nextListeners = currentListeners.slice();
+    }
+  }
+  function getState() {
+    if (isDispatching) {
+      throw new Error(formatProdErrorMessage(3));
+    }
+    return currentState;
+  }
+  function subscribe(listener) {
+    if (typeof listener !== "function") {
+      throw new Error(formatProdErrorMessage(4));
+    }
+    if (isDispatching) {
+      throw new Error(formatProdErrorMessage(5));
+    }
+    var isSubscribed = true;
+    ensureCanMutateNextListeners();
+    nextListeners.push(listener);
+    return function unsubscribe() {
+      if (!isSubscribed) {
+        return;
+      }
+      if (isDispatching) {
+        throw new Error(formatProdErrorMessage(6));
+      }
+      isSubscribed = false;
+      ensureCanMutateNextListeners();
+      var index = nextListeners.indexOf(listener);
+      nextListeners.splice(index, 1);
+      currentListeners = null;
+    };
+  }
+  function dispatch(action) {
+    if (!isPlainObject(action)) {
+      throw new Error(formatProdErrorMessage(7));
+    }
+    if (typeof action.type === "undefined") {
+      throw new Error(formatProdErrorMessage(8));
+    }
+    if (isDispatching) {
+      throw new Error(formatProdErrorMessage(9));
+    }
+    try {
+      isDispatching = true;
+      currentState = currentReducer(currentState, action);
+    } finally {
+      isDispatching = false;
+    }
+    var listeners = currentListeners = nextListeners;
+    for (var i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      listener();
+    }
+    return action;
+  }
+  function replaceReducer(nextReducer) {
+    if (typeof nextReducer !== "function") {
+      throw new Error(formatProdErrorMessage(10));
+    }
+    currentReducer = nextReducer;
+    dispatch({
+      type: ActionTypes.REPLACE
+    });
+  }
+  function observable() {
+    var _ref;
+    var outerSubscribe = subscribe;
+    return _ref = {
+      subscribe: function subscribe2(observer) {
+        if (typeof observer !== "object" || observer === null) {
+          throw new Error(formatProdErrorMessage(11));
+        }
+        function observeState() {
+          if (observer.next) {
+            observer.next(getState());
+          }
+        }
+        observeState();
+        var unsubscribe = outerSubscribe(observeState);
+        return {
+          unsubscribe
+        };
+      }
+    }, _ref[$$observable] = function() {
+      return this;
+    }, _ref;
+  }
+  dispatch({
+    type: ActionTypes.INIT
+  });
+  return _ref2 = {
+    dispatch,
+    subscribe,
+    getState,
+    replaceReducer
+  }, _ref2[$$observable] = observable, _ref2;
+}
+function assertReducerShape(reducers) {
+  Object.keys(reducers).forEach(function(key) {
+    var reducer2 = reducers[key];
+    var initialState = reducer2(void 0, {
+      type: ActionTypes.INIT
+    });
+    if (typeof initialState === "undefined") {
+      throw new Error(formatProdErrorMessage(12));
+    }
+    if (typeof reducer2(void 0, {
+      type: ActionTypes.PROBE_UNKNOWN_ACTION()
+    }) === "undefined") {
+      throw new Error(formatProdErrorMessage(13));
+    }
+  });
+}
+function combineReducers(reducers) {
+  var reducerKeys = Object.keys(reducers);
+  var finalReducers = {};
+  for (var i = 0; i < reducerKeys.length; i++) {
+    var key = reducerKeys[i];
+    if (typeof reducers[key] === "function") {
+      finalReducers[key] = reducers[key];
+    }
+  }
+  var finalReducerKeys = Object.keys(finalReducers);
+  var shapeAssertionError;
+  try {
+    assertReducerShape(finalReducers);
+  } catch (e2) {
+    shapeAssertionError = e2;
+  }
+  return function combination(state, action) {
+    if (state === void 0) {
+      state = {};
+    }
+    if (shapeAssertionError) {
+      throw shapeAssertionError;
+    }
+    var hasChanged = false;
+    var nextState = {};
+    for (var _i = 0; _i < finalReducerKeys.length; _i++) {
+      var _key = finalReducerKeys[_i];
+      var reducer2 = finalReducers[_key];
+      var previousStateForKey = state[_key];
+      var nextStateForKey = reducer2(previousStateForKey, action);
+      if (typeof nextStateForKey === "undefined") {
+        action && action.type;
+        throw new Error(formatProdErrorMessage(14));
+      }
+      nextState[_key] = nextStateForKey;
+      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
+    }
+    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
+    return hasChanged ? nextState : state;
+  };
+}
+function compose() {
+  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
+    funcs[_key] = arguments[_key];
+  }
+  if (funcs.length === 0) {
+    return function(arg) {
+      return arg;
+    };
+  }
+  if (funcs.length === 1) {
+    return funcs[0];
+  }
+  return funcs.reduce(function(a, b) {
+    return function() {
+      return a(b.apply(void 0, arguments));
+    };
+  });
+}
+function applyMiddleware() {
+  for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) {
+    middlewares[_key] = arguments[_key];
+  }
+  return function(createStore2) {
+    return function() {
+      var store = createStore2.apply(void 0, arguments);
+      var _dispatch = function dispatch() {
+        throw new Error(formatProdErrorMessage(15));
+      };
+      var middlewareAPI = {
+        getState: store.getState,
+        dispatch: function dispatch() {
+          return _dispatch.apply(void 0, arguments);
+        }
+      };
+      var chain = middlewares.map(function(middleware) {
+        return middleware(middlewareAPI);
+      });
+      _dispatch = compose.apply(void 0, chain)(store.dispatch);
+      return _objectSpread2(_objectSpread2({}, store), {}, {
+        dispatch: _dispatch
+      });
+    };
+  };
+}
+function createThunkMiddleware(extraArgument) {
+  var middleware = function middleware2(_ref) {
+    var dispatch = _ref.dispatch, getState = _ref.getState;
+    return function(next) {
+      return function(action) {
+        if (typeof action === "function") {
+          return action(dispatch, getState, extraArgument);
+        }
+        return next(action);
+      };
+    };
+  };
+  return middleware;
+}
+var thunk = createThunkMiddleware();
+thunk.withExtraArgument = createThunkMiddleware;
+var thunk$1 = thunk;
+function isElementReference(element) {
+  return !("props" in element);
+}
+function createDocument(rootElement) {
+  return { rootElement };
+}
+function getInitialState$3({
+  rootElements = new Map()
+} = {}) {
+  const initialState = new Map();
+  rootElements.forEach((rootElement, elementKey) => {
+    initialState.set(elementKey, createDocument(rootElement));
+  });
+  return initialState;
+}
+function getDocuments(state) {
+  return state;
+}
+function getDocument(state, documentKey) {
+  var _a;
+  return (_a = getDocuments(state).get(documentKey)) != null ? _a : null;
+}
+function getDocumentRootElement$1(state, documentKey) {
+  var _a, _b;
+  return (_b = (_a = getDocument(state, documentKey)) == null ? void 0 : _a.rootElement) != null ? _b : null;
+}
+function reducer$4(state = getInitialState$3(), _action) {
+  return state;
+}
+function getInitialState$2({
+  reactComponents = new Map()
+} = {}) {
+  return reactComponents;
+}
+function getReactComponents(state) {
+  return state;
+}
+function getReactComponent$1(state, type) {
+  var _a;
+  return (_a = getReactComponents(state).get(type)) != null ? _a : null;
+}
+function reducer$3(state = getInitialState$2(), action) {
+  switch (action.type) {
+    case actions.ActionTypes.REGISTER_REACT_COMPONENT:
+      return new Map(state).set(action.payload.type, action.payload.component);
+    case actions.ActionTypes.UNREGISTER_REACT_COMPONENT: {
+      const nextState = new Map(state);
+      const deleted = nextState.delete(action.payload.type);
+      return deleted ? nextState : state;
+    }
+    default:
+      return state;
+  }
+}
+function getInitialState$1({
+  componentsMeta = new Map()
+} = {}) {
+  return componentsMeta;
+}
+function getComponentsMeta(state) {
+  return state;
+}
+function reducer$2(state = getInitialState$1(), action) {
+  switch (action.type) {
+    case actions.ActionTypes.REGISTER_COMPONENT:
+      return new Map(state).set(action.payload.type, action.payload.meta);
+    case actions.ActionTypes.UNREGISTER_COMPONENT: {
+      const nextState = new Map(state);
+      const deleted = nextState.delete(action.payload.type);
+      return deleted ? nextState : state;
+    }
+    default:
+      return state;
+  }
+}
+function getInitialState({
+  propControllerDescriptors = new Map()
+} = {}) {
+  return propControllerDescriptors;
+}
+function getPropControllerDescriptors$1(state) {
+  return state;
+}
+function getComponentPropControllerDescriptors$1(state, componentType) {
+  var _a;
+  return (_a = getPropControllerDescriptors$1(state).get(componentType)) != null ? _a : null;
+}
+function reducer$1(state = getInitialState(), action) {
+  switch (action.type) {
+    case actions.ActionTypes.REGISTER_COMPONENT:
+      return new Map(state).set(action.payload.type, action.payload.propControllerDescriptors);
+    case actions.ActionTypes.UNREGISTER_COMPONENT: {
+      const nextState = new Map(state);
+      const deleted = nextState.delete(action.payload.type);
+      return deleted ? nextState : state;
+    }
+    default:
+      return state;
+  }
+}
+function getElementChildren(descriptor, prop) {
+  if (prop == null)
+    return [];
+  switch (descriptor.type) {
+    case descriptors.Types.Grid:
+      return prop.elements;
+    default:
+      return [];
+  }
+}
+function getElementId$1(descriptor, prop) {
+  if (prop == null)
+    return null;
+  switch (descriptor.type) {
+    case descriptors.Types.ElementID:
+      return prop;
+    default:
+      return null;
+  }
+}
+const reducer = combineReducers({
+  documents: reducer$4,
+  reactComponents: reducer$3,
+  componentsMeta: reducer$2,
+  propControllers: reducer$1,
+  isInBuilder: (state = false, _action) => state
+});
+function getDocumentsStateSlice(state) {
+  return state.documents;
+}
+function getDocumentRootElement(state, documentKey) {
+  return getDocumentRootElement$1(getDocumentsStateSlice(state), documentKey);
+}
+function getReactComponentsStateSlice(state) {
+  return state.reactComponents;
+}
+function getReactComponent(state, type) {
+  return getReactComponent$1(getReactComponentsStateSlice(state), type);
+}
+function getPropControllersStateSlice(state) {
+  return state.propControllers;
+}
+function getPropControllerDescriptors(state) {
+  return getPropControllerDescriptors$1(getPropControllersStateSlice(state));
+}
+function getComponentPropControllerDescriptors(state, componentType) {
+  return getComponentPropControllerDescriptors$1(getPropControllersStateSlice(state), componentType);
+}
+function normalizeElement(element, descriptors2) {
+  const elements = new Map();
+  const remaining = [element];
+  let current;
+  while (current = remaining.pop()) {
+    elements.set(current.key, current);
+    if (isElementReference(current))
+      continue;
+    const elementDescriptors = descriptors2.get(element.type);
+    if (elementDescriptors == null)
+      continue;
+    const parent = current;
+    const children = Object.entries(elementDescriptors).reduce((acc, [propName, descriptor]) => {
+      return [...acc, ...getElementChildren(descriptor, parent.props[propName])];
+    }, []);
+    remaining.push(...children);
+  }
+  return elements;
+}
+function getDocumentElements(state, documentKey) {
+  const rootElement = getDocumentRootElement(state, documentKey);
+  const descriptors2 = getPropControllerDescriptors(state);
+  if (rootElement == null)
+    return new Map();
+  return normalizeElement(rootElement, descriptors2);
+}
+function getElement(state, documentKey, elementKey) {
+  var _a;
+  return (_a = getDocumentElements(state, documentKey).get(elementKey)) != null ? _a : null;
+}
+function getElementId(state, documentKey, elementKey) {
+  const element = getElement(state, documentKey, elementKey);
+  if (element == null || isElementReference(element))
+    return null;
+  const descriptors2 = getComponentPropControllerDescriptors(state, element.type);
+  if (descriptors2 == null)
+    return null;
+  const elementId = Object.entries(descriptors2).reduce((acc, [propName, descriptor]) => {
+    if (acc != null)
+      return acc;
+    return getElementId$1(descriptor, element.props[propName]);
+  }, null);
+  return elementId;
+}
+function getIsInBuilder(state) {
+  return state.isInBuilder;
+}
+function configureStore({
+  rootElements,
+  preloadedState
+} = {}) {
+  return createStore(reducer, __spreadProps(__spreadValues({}, preloadedState), { documents: getInitialState$3({ rootElements }) }), applyMiddleware(thunk$1));
+}
+const contextDefaultValue = configureStore();
+const ReactRuntime = {
+  registerComponent(component, {
+    type,
+    label,
+    icon = "Cube40",
+    hidden = false,
+    props
+  }) {
+    const unregisterComponent = contextDefaultValue.dispatch(actions.registerComponentEffect(type, {
+      label,
+      icon,
+      hidden
+    }, props != null ? props : {}));
+    const unregisterReactComponent = contextDefaultValue.dispatch(actions.registerReactComponentEffect(type, component));
+    return () => {
+      unregisterComponent();
+      unregisterReactComponent();
+    };
+  }
+};
+const Context = React.createContext(contextDefaultValue);
+function RuntimeProvider({
+  children,
+  defaultRootElements
+}) {
+  const [store, setStore] = React.useState(() => configureStore({
+    preloadedState: contextDefaultValue.getState(),
+    rootElements: defaultRootElements
+  }));
+  React.useEffect(() => {
+    const isInBuilder = window.parent !== window;
+    if (!isInBuilder)
+      return;
+    const initializePromise = initializeReactBuilderPreview();
+    return () => {
+      initializePromise.then((cleanUp) => {
+        cleanUp();
+      });
+    };
+    async function initializeReactBuilderPreview() {
+      const ReactBuilderPreview = await Promise.resolve().then(function() {
+        return require("./react-builder-preview.cjs.js");
+      });
+      const store2 = await new Promise((resolve) => {
+        setStore((store3) => {
+          const nextStore = ReactBuilderPreview.configureStore({
+            preloadedState: store3.getState()
+          });
+          resolve(nextStore);
+          return nextStore;
+        });
+      });
+      return store2.dispatch(ReactBuilderPreview.initialize());
+    }
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, {
+    value: store,
+    children
+  });
+}
+const DocumentContext = React.createContext(null);
+function useDocumentKey() {
+  return React.useContext(DocumentContext);
+}
+function useSelector(selector) {
+  const store = React.useContext(Context);
+  return withSelector.exports.useSyncExternalStoreWithSelector(store.subscribe, store.getState, store.getState, selector);
+}
+function useComponent(type) {
+  return useSelector((state) => getReactComponent(state, type));
+}
+function useElementId(elementKey) {
+  const documentKey = useDocumentKey();
+  return useSelector((state) => documentKey == null || elementKey == null ? null : getElementId(state, documentKey, elementKey));
+}
+function useDocumentRootElement(documentKey) {
+  return useSelector((state) => getDocumentRootElement(state, documentKey));
+}
+function useIsInBuilder() {
+  return useSelector((state) => getIsInBuilder(state));
+}
+function useDispatch() {
+  const store = React.useContext(Context);
+  return store.dispatch;
+}
+const ElementData = React.memo(React.forwardRef(function ElementData2({
+  elementData
+}, ref) {
+  const Component = useComponent(elementData.type);
+  if (Component == null) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", {
+      ref,
+      children: [/* @__PURE__ */ jsxRuntime.jsx("p", {
+        children: "Component Not Found"
+      }), /* @__PURE__ */ jsxRuntime.jsx("pre", {
+        children: /* @__PURE__ */ jsxRuntime.jsx("code", {
+          children: JSON.stringify(elementData, null, 2)
+        })
+      })]
+    });
+  }
+  return /* @__PURE__ */ React.createElement(Component, __spreadProps(__spreadValues({}, elementData.props), {
+    key: elementData.key,
+    ref
+  }));
+}));
+const ElementReference = React.memo(React.forwardRef(function ElementReference2({
+  elementReference
+}, ref) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", {
+    ref,
+    children: [/* @__PURE__ */ jsxRuntime.jsx("p", {
+      children: "Not Implemented"
+    }), /* @__PURE__ */ jsxRuntime.jsx("pre", {
+      children: /* @__PURE__ */ jsxRuntime.jsx("code", {
+        children: JSON.stringify(elementReference, null, 2)
+      })
+    })]
+  });
+}));
+const Element = React.memo(function Element2({
+  element
+}) {
+  const elementKey = element.key;
+  const dispatch = useDispatch();
+  const ref = React.useCallback((handle) => {
+    dispatch(actions.changeComponentHandle(elementKey, handle));
+  }, [dispatch, elementKey]);
+  React.useEffect(() => dispatch(actions.mountComponentEffect(elementKey)), [dispatch, elementKey]);
+  return isElementReference(element) ? /* @__PURE__ */ jsxRuntime.jsx(ElementReference, {
+    ref,
+    elementReference: element
+  }, elementKey) : /* @__PURE__ */ jsxRuntime.jsx(ElementData, {
+    ref,
+    elementData: element
+  }, elementKey);
+});
+const Document = React.memo(function Document2({
+  documentKey
+}) {
+  const documentRootElement = useDocumentRootElement(documentKey);
+  if (documentRootElement == null) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", {
+      children: [/* @__PURE__ */ jsxRuntime.jsx("p", {
+        children: "Document Not Found"
+      }), /* @__PURE__ */ jsxRuntime.jsx("pre", {
+        children: /* @__PURE__ */ jsxRuntime.jsx("code", {
+          children: JSON.stringify({
+            documentKey
+          }, null, 2)
+        })
+      })]
+    });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(DocumentContext.Provider, {
+    value: documentKey,
+    children: /* @__PURE__ */ jsxRuntime.jsx(Element, {
+      element: documentRootElement
+    })
+  });
+});
+exports.Document = Document;
+exports.Element = Element;
+exports.ReactRuntime = ReactRuntime;
+exports.RuntimeProvider = RuntimeProvider;
+exports.applyMiddleware = applyMiddleware;
+exports.combineReducers = combineReducers;
+exports.createDocument = createDocument;
+exports.createStore = createStore;
+exports.getComponentPropControllerDescriptors = getComponentPropControllerDescriptors$1;
+exports.getComponentsMeta = getComponentsMeta;
+exports.getDocumentRootElement = getDocumentRootElement$1;
+exports.getInitialState = getInitialState$3;
+exports.reducer = reducer$3;
+exports.reducer$1 = reducer$2;
+exports.reducer$2 = reducer$1;
+exports.thunk = thunk$1;
+exports.useElementId = useElementId;
+exports.useIsInBuilder = useIsInBuilder;
+//# sourceMappingURL=react.cjs2.js.map