@makeswift/runtime 0.0.0-018e17a

package/dist/react.es2.js

@@ -0,0 +1,810 @@
+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));
+import require$$0, { createContext, memo, forwardRef, createElement, useCallback, useEffect, useState, useContext } from "react";
+import { A as ActionTypes$1, b as changeComponentHandle, m as mountComponentEffect, r as registerComponentEffect, d as registerReactComponentEffect } from "./actions.es.js";
+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 = require$$0;
+function h$2(a, b) {
+  return a === b && (a !== 0 || 1 / a === 1 / b) || a !== a && b !== b;
+}
+var k = typeof Object.is === "function" ? Object.is : h$2, l = e.useState, m$1 = e.useEffect, n$2 = e.useLayoutEffect, p$2 = e.useDebugValue;
+function q$2(a, b) {
+  var d = b(), f2 = l({ inst: { value: d, getSnapshot: b } }), c = f2[0].inst, g2 = f2[1];
+  n$2(function() {
+    c.value = d;
+    c.getSnapshot = b;
+    r$1(c) && g2({ inst: c });
+  }, [a, d, b]);
+  m$1(function() {
+    r$1(c) && g2({ inst: c });
+    return a(function() {
+      r$1(c) && g2({ inst: c });
+    });
+  }, [a]);
+  p$2(d);
+  return d;
+}
+function r$1(a) {
+  var b = a.getSnapshot;
+  a = a.value;
+  try {
+    var d = b();
+    return !k(a, d);
+  } catch (f2) {
+    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$2;
+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$1 = require$$0, n$1 = shim.exports;
+function p$1(a, b) {
+  return a === b && (a !== 0 || 1 / a === 1 / b) || a !== a && b !== b;
+}
+var q$1 = typeof Object.is === "function" ? Object.is : p$1, r = n$1.useSyncExternalStore, t = h$1.useRef, u = h$1.useEffect, v = h$1.useMemo, w = h$1.useDebugValue;
+withSelector_production_min.useSyncExternalStoreWithSelector = function(a, b, e2, l2, g2) {
+  var c = t(null);
+  if (c.current === null) {
+    var f2 = { hasValue: false, value: null };
+    c.current = f2;
+  } else
+    f2 = c.current;
+  c = v(function() {
+    function a2(a3) {
+      if (!c2) {
+        c2 = true;
+        d2 = a3;
+        a3 = l2(a3);
+        if (g2 !== void 0 && f2.hasValue) {
+          var b2 = f2.value;
+          if (g2(b2, a3))
+            return k2 = b2;
+        }
+        return k2 = a3;
+      }
+      b2 = k2;
+      if (q$1(d2, a3))
+        return b2;
+      var e3 = l2(a3);
+      if (g2 !== void 0 && g2(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, g2]);
+  var d = r(a, c[0], c[1]);
+  u(function() {
+    f2.hasValue = true;
+    f2.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 = /* @__PURE__ */ new Map()
+} = {}) {
+  const initialState = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 ActionTypes$1.REGISTER_REACT_COMPONENT:
+      return new Map(state).set(action.payload.type, action.payload.component);
+    case ActionTypes$1.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 = /* @__PURE__ */ new Map()
+} = {}) {
+  return componentsMeta;
+}
+function getComponentsMeta(state) {
+  return state;
+}
+function reducer$2(state = getInitialState$1(), action) {
+  switch (action.type) {
+    case ActionTypes$1.REGISTER_COMPONENT:
+      return new Map(state).set(action.payload.type, action.payload.meta);
+    case ActionTypes$1.UNREGISTER_COMPONENT: {
+      const nextState = new Map(state);
+      const deleted = nextState.delete(action.payload.type);
+      return deleted ? nextState : state;
+    }
+    default:
+      return state;
+  }
+}
+function getInitialState({
+  propControllerDescriptors = /* @__PURE__ */ new Map()
+} = {}) {
+  return propControllerDescriptors;
+}
+function getPropControllerDescriptors(state) {
+  return state;
+}
+function getComponentPropControllerDescriptors(state, componentType) {
+  var _a;
+  return (_a = getPropControllerDescriptors(state).get(componentType)) != null ? _a : null;
+}
+function reducer$1(state = getInitialState(), action) {
+  switch (action.type) {
+    case ActionTypes$1.REGISTER_COMPONENT:
+      return new Map(state).set(action.payload.type, action.payload.propControllerDescriptors);
+    case ActionTypes$1.UNREGISTER_COMPONENT: {
+      const nextState = new Map(state);
+      const deleted = nextState.delete(action.payload.type);
+      return deleted ? nextState : state;
+    }
+    default:
+      return state;
+  }
+}
+const reducer = combineReducers({
+  documents: reducer$4,
+  reactComponents: reducer$3,
+  componentsMeta: reducer$2,
+  propControllers: reducer$1
+});
+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 configureStore({
+  rootElements,
+  preloadedState
+} = {}) {
+  return createStore(reducer, __spreadProps(__spreadValues({}, preloadedState), { documents: getInitialState$3({ rootElements }) }), applyMiddleware(thunk$1));
+}
+var jsxRuntime = { exports: {} };
+var reactJsxRuntime_production_min = {};
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+function toObject(val) {
+  if (val === null || val === void 0) {
+    throw new TypeError("Object.assign cannot be called with null or undefined");
+  }
+  return Object(val);
+}
+function shouldUseNative() {
+  try {
+    if (!Object.assign) {
+      return false;
+    }
+    var test1 = new String("abc");
+    test1[5] = "de";
+    if (Object.getOwnPropertyNames(test1)[0] === "5") {
+      return false;
+    }
+    var test2 = {};
+    for (var i = 0; i < 10; i++) {
+      test2["_" + String.fromCharCode(i)] = i;
+    }
+    var order2 = Object.getOwnPropertyNames(test2).map(function(n2) {
+      return test2[n2];
+    });
+    if (order2.join("") !== "0123456789") {
+      return false;
+    }
+    var test3 = {};
+    "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+      test3[letter] = letter;
+    });
+    if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
+      return false;
+    }
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+shouldUseNative() ? Object.assign : function(target, source) {
+  var from;
+  var to = toObject(target);
+  var symbols;
+  for (var s = 1; s < arguments.length; s++) {
+    from = Object(arguments[s]);
+    for (var key in from) {
+      if (hasOwnProperty.call(from, key)) {
+        to[key] = from[key];
+      }
+    }
+    if (getOwnPropertySymbols) {
+      symbols = getOwnPropertySymbols(from);
+      for (var i = 0; i < symbols.length; i++) {
+        if (propIsEnumerable.call(from, symbols[i])) {
+          to[symbols[i]] = from[symbols[i]];
+        }
+      }
+    }
+  }
+  return to;
+};
+/** @license React v17.0.2
+ * react-jsx-runtime.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 f = require$$0, g = 60103;
+reactJsxRuntime_production_min.Fragment = 60107;
+if (typeof Symbol === "function" && Symbol.for) {
+  var h = Symbol.for;
+  g = h("react.element");
+  reactJsxRuntime_production_min.Fragment = h("react.fragment");
+}
+var m = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, n = Object.prototype.hasOwnProperty, p = { key: true, ref: true, __self: true, __source: true };
+function q(c, a, k2) {
+  var b, d = {}, e2 = null, l2 = null;
+  k2 !== void 0 && (e2 = "" + k2);
+  a.key !== void 0 && (e2 = "" + a.key);
+  a.ref !== void 0 && (l2 = a.ref);
+  for (b in a)
+    n.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]);
+  if (c && c.defaultProps)
+    for (b in a = c.defaultProps, a)
+      d[b] === void 0 && (d[b] = a[b]);
+  return { $$typeof: g, type: c, key: e2, ref: l2, props: d, _owner: m.current };
+}
+reactJsxRuntime_production_min.jsx = q;
+reactJsxRuntime_production_min.jsxs = q;
+{
+  jsxRuntime.exports = reactJsxRuntime_production_min;
+}
+const jsx = jsxRuntime.exports.jsx;
+const jsxs = jsxRuntime.exports.jsxs;
+const Fragment = jsxRuntime.exports.Fragment;
+const contextDefaultValue = configureStore();
+const ReactRuntime = {
+  registerComponent(component, {
+    type,
+    label,
+    icon = "Cube40",
+    hidden = false,
+    props
+  }) {
+    const unregisterComponent = contextDefaultValue.dispatch(registerComponentEffect(type, {
+      label,
+      icon,
+      hidden
+    }, props != null ? props : {}));
+    const unregisterReactComponent = contextDefaultValue.dispatch(registerReactComponentEffect(type, component));
+    return () => {
+      unregisterComponent();
+      unregisterReactComponent();
+    };
+  }
+};
+const Context = createContext(contextDefaultValue);
+function RuntimeProvider({
+  children,
+  defaultRootElements
+}) {
+  const [store, setStore] = useState(() => configureStore({
+    preloadedState: contextDefaultValue.getState(),
+    rootElements: defaultRootElements
+  }));
+  useEffect(() => {
+    const isInBuilder = window.parent !== window;
+    if (!isInBuilder)
+      return;
+    const initializePromise = initializeReactBuilderPreview();
+    return () => {
+      initializePromise.then((cleanUp) => {
+        cleanUp();
+      });
+    };
+    async function initializeReactBuilderPreview() {
+      const ReactBuilderPreview = await import("./react-builder-preview.es.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__ */ jsx(Context.Provider, {
+    value: store,
+    children
+  });
+}
+function useSelector(selector) {
+  const store = useContext(Context);
+  return withSelector.exports.useSyncExternalStoreWithSelector(store.subscribe, store.getState, store.getState, selector);
+}
+function useComponent(type) {
+  return useSelector((state) => getReactComponent(state, type));
+}
+function useDocumentRootElement(documentKey) {
+  return useSelector((state) => getDocumentRootElement(state, documentKey));
+}
+function useDispatch() {
+  const store = useContext(Context);
+  return store.dispatch;
+}
+const ElementData = memo(forwardRef(function ElementData2({
+  elementData
+}, ref) {
+  const Component = useComponent(elementData.type);
+  if (Component == null) {
+    return /* @__PURE__ */ jsxs("div", {
+      ref,
+      children: [/* @__PURE__ */ jsx("p", {
+        children: "Component Not Found"
+      }), /* @__PURE__ */ jsx("pre", {
+        children: /* @__PURE__ */ jsx("code", {
+          children: JSON.stringify(elementData, null, 2)
+        })
+      })]
+    });
+  }
+  return /* @__PURE__ */ createElement(Component, __spreadProps(__spreadValues({}, elementData.props), {
+    key: elementData.key,
+    ref
+  }));
+}));
+const ElementReference = memo(forwardRef(function ElementReference2({
+  elementReference
+}, ref) {
+  return /* @__PURE__ */ jsxs("div", {
+    ref,
+    children: [/* @__PURE__ */ jsx("p", {
+      children: "Not Implemented"
+    }), /* @__PURE__ */ jsx("pre", {
+      children: /* @__PURE__ */ jsx("code", {
+        children: JSON.stringify(elementReference, null, 2)
+      })
+    })]
+  });
+}));
+const Element = memo(function Element2({
+  element
+}) {
+  const elementKey = element.key;
+  const dispatch = useDispatch();
+  const ref = useCallback((handle) => {
+    dispatch(changeComponentHandle(elementKey, handle));
+  }, [dispatch, elementKey]);
+  useEffect(() => dispatch(mountComponentEffect(elementKey)), [dispatch, elementKey]);
+  return isElementReference(element) ? /* @__PURE__ */ jsx(ElementReference, {
+    ref,
+    elementReference: element
+  }, elementKey) : /* @__PURE__ */ jsx(ElementData, {
+    ref,
+    elementData: element
+  }, elementKey);
+});
+const Document = memo(function Document2({
+  documentKey
+}) {
+  const documentRootElement = useDocumentRootElement(documentKey);
+  if (documentRootElement == null) {
+    return /* @__PURE__ */ jsxs("div", {
+      children: [/* @__PURE__ */ jsx("p", {
+        children: "Document Not Found"
+      }), /* @__PURE__ */ jsx("pre", {
+        children: /* @__PURE__ */ jsx("code", {
+          children: JSON.stringify({
+            documentKey
+          }, null, 2)
+        })
+      })]
+    });
+  }
+  return /* @__PURE__ */ jsx(Element, {
+    element: documentRootElement
+  });
+});
+export { Document as D, Element as E, Fragment as F, RuntimeProvider as R, ReactRuntime as a, jsxs as b, getDocumentRootElement$1 as c, createDocument as d, combineReducers as e, reducer$2 as f, getInitialState$3 as g, reducer$1 as h, getComponentsMeta as i, jsx as j, getComponentPropControllerDescriptors as k, createStore as l, applyMiddleware as m, reducer$3 as r, thunk$1 as t };
+//# sourceMappingURL=react.es2.js.map