@syntrologie/adapt-faq 2.17.0 → 2.19.0

package/dist/editor.js

@@ -1,5 +1,4449 @@
+import {
+  backdropBlur,
+  colors,
+  colors_default,
+  elevationShadows,
+  focusRings,
+  glowShadows,
+  overlay,
+  panel_shell_default,
+  shadows
+} from "./chunk-S6WIENQP.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-5WRI5ZAA.js";
+
+// ../../../node_modules/react/cjs/react.development.js
+var require_react_development = __commonJS({
+  "../../../node_modules/react/cjs/react.development.js"(exports, module) {
+    "use strict";
+    (function() {
+      function defineDeprecationWarning(methodName, info) {
+        Object.defineProperty(Component.prototype, methodName, {
+          get: function() {
+            console.warn(
+              "%s(...) is deprecated in plain JavaScript React classes. %s",
+              info[0],
+              info[1]
+            );
+          }
+        });
+      }
+      function getIteratorFn(maybeIterable) {
+        if (null === maybeIterable || "object" !== typeof maybeIterable)
+          return null;
+        maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+        return "function" === typeof maybeIterable ? maybeIterable : null;
+      }
+      function warnNoop(publicInstance, callerName) {
+        publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
+        var warningKey = publicInstance + "." + callerName;
+        didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error(
+          "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
+          callerName,
+          publicInstance
+        ), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
+      }
+      function Component(props, context, updater) {
+        this.props = props;
+        this.context = context;
+        this.refs = emptyObject;
+        this.updater = updater || ReactNoopUpdateQueue;
+      }
+      function ComponentDummy() {
+      }
+      function PureComponent(props, context, updater) {
+        this.props = props;
+        this.context = context;
+        this.refs = emptyObject;
+        this.updater = updater || ReactNoopUpdateQueue;
+      }
+      function noop() {
+      }
+      function testStringCoercion(value) {
+        return "" + value;
+      }
+      function checkKeyStringCoercion(value) {
+        try {
+          testStringCoercion(value);
+          var JSCompiler_inline_result = false;
+        } catch (e) {
+          JSCompiler_inline_result = true;
+        }
+        if (JSCompiler_inline_result) {
+          JSCompiler_inline_result = console;
+          var JSCompiler_temp_const = JSCompiler_inline_result.error;
+          var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+          JSCompiler_temp_const.call(
+            JSCompiler_inline_result,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            JSCompiler_inline_result$jscomp$0
+          );
+          return testStringCoercion(value);
+        }
+      }
+      function getComponentNameFromType(type) {
+        if (null == type) return null;
+        if ("function" === typeof type)
+          return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+        if ("string" === typeof type) return type;
+        switch (type) {
+          case REACT_FRAGMENT_TYPE:
+            return "Fragment";
+          case REACT_PROFILER_TYPE:
+            return "Profiler";
+          case REACT_STRICT_MODE_TYPE:
+            return "StrictMode";
+          case REACT_SUSPENSE_TYPE:
+            return "Suspense";
+          case REACT_SUSPENSE_LIST_TYPE:
+            return "SuspenseList";
+          case REACT_ACTIVITY_TYPE:
+            return "Activity";
+        }
+        if ("object" === typeof type)
+          switch ("number" === typeof type.tag && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), type.$$typeof) {
+            case REACT_PORTAL_TYPE:
+              return "Portal";
+            case REACT_CONTEXT_TYPE:
+              return type.displayName || "Context";
+            case REACT_CONSUMER_TYPE:
+              return (type._context.displayName || "Context") + ".Consumer";
+            case REACT_FORWARD_REF_TYPE:
+              var innerType = type.render;
+              type = type.displayName;
+              type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+              return type;
+            case REACT_MEMO_TYPE:
+              return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+            case REACT_LAZY_TYPE:
+              innerType = type._payload;
+              type = type._init;
+              try {
+                return getComponentNameFromType(type(innerType));
+              } catch (x) {
+              }
+          }
+        return null;
+      }
+      function getTaskName(type) {
+        if (type === REACT_FRAGMENT_TYPE) return "<>";
+        if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
+          return "<...>";
+        try {
+          var name = getComponentNameFromType(type);
+          return name ? "<" + name + ">" : "<...>";
+        } catch (x) {
+          return "<...>";
+        }
+      }
+      function getOwner() {
+        var dispatcher = ReactSharedInternals.A;
+        return null === dispatcher ? null : dispatcher.getOwner();
+      }
+      function UnknownOwner() {
+        return Error("react-stack-top-frame");
+      }
+      function hasValidKey(config) {
+        if (hasOwnProperty.call(config, "key")) {
+          var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+          if (getter && getter.isReactWarning) return false;
+        }
+        return void 0 !== config.key;
+      }
+      function defineKeyPropWarningGetter(props, displayName) {
+        function warnAboutAccessingKey() {
+          specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            displayName
+          ));
+        }
+        warnAboutAccessingKey.isReactWarning = true;
+        Object.defineProperty(props, "key", {
+          get: warnAboutAccessingKey,
+          configurable: true
+        });
+      }
+      function elementRefGetterWithDeprecationWarning() {
+        var componentName = getComponentNameFromType(this.type);
+        didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        ));
+        componentName = this.props.ref;
+        return void 0 !== componentName ? componentName : null;
+      }
+      function ReactElement(type, key, props, owner, debugStack, debugTask) {
+        var refProp = props.ref;
+        type = {
+          $$typeof: REACT_ELEMENT_TYPE,
+          type,
+          key,
+          props,
+          _owner: owner
+        };
+        null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+          enumerable: false,
+          get: elementRefGetterWithDeprecationWarning
+        }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+        type._store = {};
+        Object.defineProperty(type._store, "validated", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: 0
+        });
+        Object.defineProperty(type, "_debugInfo", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: null
+        });
+        Object.defineProperty(type, "_debugStack", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: debugStack
+        });
+        Object.defineProperty(type, "_debugTask", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: debugTask
+        });
+        Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+        return type;
+      }
+      function cloneAndReplaceKey(oldElement, newKey) {
+        newKey = ReactElement(
+          oldElement.type,
+          newKey,
+          oldElement.props,
+          oldElement._owner,
+          oldElement._debugStack,
+          oldElement._debugTask
+        );
+        oldElement._store && (newKey._store.validated = oldElement._store.validated);
+        return newKey;
+      }
+      function validateChildKeys(node) {
+        isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+      }
+      function isValidElement(object) {
+        return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+      }
+      function escape2(key) {
+        var escaperLookup = { "=": "=0", ":": "=2" };
+        return "$" + key.replace(/[=:]/g, function(match) {
+          return escaperLookup[match];
+        });
+      }
+      function getElementKey(element, index) {
+        return "object" === typeof element && null !== element && null != element.key ? (checkKeyStringCoercion(element.key), escape2("" + element.key)) : index.toString(36);
+      }
+      function resolveThenable(thenable) {
+        switch (thenable.status) {
+          case "fulfilled":
+            return thenable.value;
+          case "rejected":
+            throw thenable.reason;
+          default:
+            switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(
+              function(fulfilledValue) {
+                "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+              },
+              function(error) {
+                "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+              }
+            )), thenable.status) {
+              case "fulfilled":
+                return thenable.value;
+              case "rejected":
+                throw thenable.reason;
+            }
+        }
+        throw thenable;
+      }
+      function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+        var type = typeof children;
+        if ("undefined" === type || "boolean" === type) children = null;
+        var invokeCallback = false;
+        if (null === children) invokeCallback = true;
+        else
+          switch (type) {
+            case "bigint":
+            case "string":
+            case "number":
+              invokeCallback = true;
+              break;
+            case "object":
+              switch (children.$$typeof) {
+                case REACT_ELEMENT_TYPE:
+                case REACT_PORTAL_TYPE:
+                  invokeCallback = true;
+                  break;
+                case REACT_LAZY_TYPE:
+                  return invokeCallback = children._init, mapIntoArray(
+                    invokeCallback(children._payload),
+                    array,
+                    escapedPrefix,
+                    nameSoFar,
+                    callback
+                  );
+              }
+          }
+        if (invokeCallback) {
+          invokeCallback = children;
+          callback = callback(invokeCallback);
+          var childKey = "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
+          isArrayImpl(callback) ? (escapedPrefix = "", null != childKey && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
+            return c;
+          })) : null != callback && (isValidElement(callback) && (null != callback.key && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(
+            callback,
+            escapedPrefix + (null == callback.key || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(
+              userProvidedKeyEscapeRegex,
+              "$&/"
+            ) + "/") + childKey
+          ), "" !== nameSoFar && null != invokeCallback && isValidElement(invokeCallback) && null == invokeCallback.key && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
+          return 1;
+        }
+        invokeCallback = 0;
+        childKey = "" === nameSoFar ? "." : nameSoFar + ":";
+        if (isArrayImpl(children))
+          for (var i = 0; i < children.length; i++)
+            nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(
+              nameSoFar,
+              array,
+              escapedPrefix,
+              type,
+              callback
+            );
+        else if (i = getIteratorFn(children), "function" === typeof i)
+          for (i === children.entries && (didWarnAboutMaps || console.warn(
+            "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
+          ), didWarnAboutMaps = true), children = i.call(children), i = 0; !(nameSoFar = children.next()).done; )
+            nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(
+              nameSoFar,
+              array,
+              escapedPrefix,
+              type,
+              callback
+            );
+        else if ("object" === type) {
+          if ("function" === typeof children.then)
+            return mapIntoArray(
+              resolveThenable(children),
+              array,
+              escapedPrefix,
+              nameSoFar,
+              callback
+            );
+          array = String(children);
+          throw Error(
+            "Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead."
+          );
+        }
+        return invokeCallback;
+      }
+      function mapChildren(children, func, context) {
+        if (null == children) return children;
+        var result = [], count = 0;
+        mapIntoArray(children, result, "", "", function(child) {
+          return func.call(context, child, count++);
+        });
+        return result;
+      }
+      function lazyInitializer(payload) {
+        if (-1 === payload._status) {
+          var ioInfo = payload._ioInfo;
+          null != ioInfo && (ioInfo.start = ioInfo.end = performance.now());
+          ioInfo = payload._result;
+          var thenable = ioInfo();
+          thenable.then(
+            function(moduleObject) {
+              if (0 === payload._status || -1 === payload._status) {
+                payload._status = 1;
+                payload._result = moduleObject;
+                var _ioInfo = payload._ioInfo;
+                null != _ioInfo && (_ioInfo.end = performance.now());
+                void 0 === thenable.status && (thenable.status = "fulfilled", thenable.value = moduleObject);
+              }
+            },
+            function(error) {
+              if (0 === payload._status || -1 === payload._status) {
+                payload._status = 2;
+                payload._result = error;
+                var _ioInfo2 = payload._ioInfo;
+                null != _ioInfo2 && (_ioInfo2.end = performance.now());
+                void 0 === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+              }
+            }
+          );
+          ioInfo = payload._ioInfo;
+          if (null != ioInfo) {
+            ioInfo.value = thenable;
+            var displayName = thenable.displayName;
+            "string" === typeof displayName && (ioInfo.name = displayName);
+          }
+          -1 === payload._status && (payload._status = 0, payload._result = thenable);
+        }
+        if (1 === payload._status)
+          return ioInfo = payload._result, void 0 === ioInfo && console.error(
+            "lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))\n\nDid you accidentally put curly braces around the import?",
+            ioInfo
+          ), "default" in ioInfo || console.error(
+            "lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))",
+            ioInfo
+          ), ioInfo.default;
+        throw payload._result;
+      }
+      function resolveDispatcher() {
+        var dispatcher = ReactSharedInternals.H;
+        null === dispatcher && console.error(
+          "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem."
+        );
+        return dispatcher;
+      }
+      function releaseAsyncTransition() {
+        ReactSharedInternals.asyncTransitions--;
+      }
+      function enqueueTask(task) {
+        if (null === enqueueTaskImpl)
+          try {
+            var requireString = ("require" + Math.random()).slice(0, 7);
+            enqueueTaskImpl = (module && module[requireString]).call(
+              module,
+              "timers"
+            ).setImmediate;
+          } catch (_err) {
+            enqueueTaskImpl = function(callback) {
+              false === didWarnAboutMessageChannel && (didWarnAboutMessageChannel = true, "undefined" === typeof MessageChannel && console.error(
+                "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
+              ));
+              var channel = new MessageChannel();
+              channel.port1.onmessage = callback;
+              channel.port2.postMessage(void 0);
+            };
+          }
+        return enqueueTaskImpl(task);
+      }
+      function aggregateErrors(errors) {
+        return 1 < errors.length && "function" === typeof AggregateError ? new AggregateError(errors) : errors[0];
+      }
+      function popActScope(prevActQueue, prevActScopeDepth) {
+        prevActScopeDepth !== actScopeDepth - 1 && console.error(
+          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
+        );
+        actScopeDepth = prevActScopeDepth;
+      }
+      function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+        var queue = ReactSharedInternals.actQueue;
+        if (null !== queue)
+          if (0 !== queue.length)
+            try {
+              flushActQueue(queue);
+              enqueueTask(function() {
+                return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+              });
+              return;
+            } catch (error) {
+              ReactSharedInternals.thrownErrors.push(error);
+            }
+          else ReactSharedInternals.actQueue = null;
+        0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
+      }
+      function flushActQueue(queue) {
+        if (!isFlushing) {
+          isFlushing = true;
+          var i = 0;
+          try {
+            for (; i < queue.length; i++) {
+              var callback = queue[i];
+              do {
+                ReactSharedInternals.didUsePromise = false;
+                var continuation = callback(false);
+                if (null !== continuation) {
+                  if (ReactSharedInternals.didUsePromise) {
+                    queue[i] = callback;
+                    queue.splice(0, i);
+                    return;
+                  }
+                  callback = continuation;
+                } else break;
+              } while (1);
+            }
+            queue.length = 0;
+          } catch (error) {
+            queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
+          } finally {
+            isFlushing = false;
+          }
+        }
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
+        isMounted: function() {
+          return false;
+        },
+        enqueueForceUpdate: function(publicInstance) {
+          warnNoop(publicInstance, "forceUpdate");
+        },
+        enqueueReplaceState: function(publicInstance) {
+          warnNoop(publicInstance, "replaceState");
+        },
+        enqueueSetState: function(publicInstance) {
+          warnNoop(publicInstance, "setState");
+        }
+      }, assign = Object.assign, emptyObject = {};
+      Object.freeze(emptyObject);
+      Component.prototype.isReactComponent = {};
+      Component.prototype.setState = function(partialState, callback) {
+        if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState)
+          throw Error(
+            "takes an object of state variables to update or a function which returns an object of state variables."
+          );
+        this.updater.enqueueSetState(this, partialState, callback, "setState");
+      };
+      Component.prototype.forceUpdate = function(callback) {
+        this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+      };
+      var deprecatedAPIs = {
+        isMounted: [
+          "isMounted",
+          "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+        ],
+        replaceState: [
+          "replaceState",
+          "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+        ]
+      };
+      for (fnName in deprecatedAPIs)
+        deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+      ComponentDummy.prototype = Component.prototype;
+      deprecatedAPIs = PureComponent.prototype = new ComponentDummy();
+      deprecatedAPIs.constructor = PureComponent;
+      assign(deprecatedAPIs, Component.prototype);
+      deprecatedAPIs.isPureReactComponent = true;
+      var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference"), ReactSharedInternals = {
+        H: null,
+        A: null,
+        T: null,
+        S: null,
+        actQueue: null,
+        asyncTransitions: 0,
+        isBatchingLegacy: false,
+        didScheduleLegacyUpdate: false,
+        didUsePromise: false,
+        thrownErrors: [],
+        getCurrentStack: null,
+        recentlyCreatedOwnerStacks: 0
+      }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      deprecatedAPIs = {
+        react_stack_bottom_frame: function(callStackForError) {
+          return callStackForError();
+        }
+      };
+      var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
+      var didWarnAboutElementRef = {};
+      var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(
+        deprecatedAPIs,
+        UnknownOwner
+      )();
+      var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+      var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
+        if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+          var event = new window.ErrorEvent("error", {
+            bubbles: true,
+            cancelable: true,
+            message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+            error
+          });
+          if (!window.dispatchEvent(event)) return;
+        } else if ("object" === typeof process && "function" === typeof process.emit) {
+          process.emit("uncaughtException", error);
+          return;
+        }
+        console.error(error);
+      }, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = "function" === typeof queueMicrotask ? function(callback) {
+        queueMicrotask(function() {
+          return queueMicrotask(callback);
+        });
+      } : enqueueTask;
+      deprecatedAPIs = Object.freeze({
+        __proto__: null,
+        c: function(size) {
+          return resolveDispatcher().useMemoCache(size);
+        }
+      });
+      var fnName = {
+        map: mapChildren,
+        forEach: function(children, forEachFunc, forEachContext) {
+          mapChildren(
+            children,
+            function() {
+              forEachFunc.apply(this, arguments);
+            },
+            forEachContext
+          );
+        },
+        count: function(children) {
+          var n = 0;
+          mapChildren(children, function() {
+            n++;
+          });
+          return n;
+        },
+        toArray: function(children) {
+          return mapChildren(children, function(child) {
+            return child;
+          }) || [];
+        },
+        only: function(children) {
+          if (!isValidElement(children))
+            throw Error(
+              "React.Children.only expected to receive a single React element child."
+            );
+          return children;
+        }
+      };
+      exports.Activity = REACT_ACTIVITY_TYPE;
+      exports.Children = fnName;
+      exports.Component = Component;
+      exports.Fragment = REACT_FRAGMENT_TYPE;
+      exports.Profiler = REACT_PROFILER_TYPE;
+      exports.PureComponent = PureComponent;
+      exports.StrictMode = REACT_STRICT_MODE_TYPE;
+      exports.Suspense = REACT_SUSPENSE_TYPE;
+      exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+      exports.__COMPILER_RUNTIME = deprecatedAPIs;
+      exports.act = function(callback) {
+        var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
+        actScopeDepth++;
+        var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [], didAwaitActCall = false;
+        try {
+          var result = callback();
+        } catch (error) {
+          ReactSharedInternals.thrownErrors.push(error);
+        }
+        if (0 < ReactSharedInternals.thrownErrors.length)
+          throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+        if (null !== result && "object" === typeof result && "function" === typeof result.then) {
+          var thenable = result;
+          queueSeveralMicrotasks(function() {
+            didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error(
+              "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
+            ));
+          });
+          return {
+            then: function(resolve, reject) {
+              didAwaitActCall = true;
+              thenable.then(
+                function(returnValue) {
+                  popActScope(prevActQueue, prevActScopeDepth);
+                  if (0 === prevActScopeDepth) {
+                    try {
+                      flushActQueue(queue), enqueueTask(function() {
+                        return recursivelyFlushAsyncActWork(
+                          returnValue,
+                          resolve,
+                          reject
+                        );
+                      });
+                    } catch (error$0) {
+                      ReactSharedInternals.thrownErrors.push(error$0);
+                    }
+                    if (0 < ReactSharedInternals.thrownErrors.length) {
+                      var _thrownError = aggregateErrors(
+                        ReactSharedInternals.thrownErrors
+                      );
+                      ReactSharedInternals.thrownErrors.length = 0;
+                      reject(_thrownError);
+                    }
+                  } else resolve(returnValue);
+                },
+                function(error) {
+                  popActScope(prevActQueue, prevActScopeDepth);
+                  0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(
+                    ReactSharedInternals.thrownErrors
+                  ), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
+                }
+              );
+            }
+          };
+        }
+        var returnValue$jscomp$0 = result;
+        popActScope(prevActQueue, prevActScopeDepth);
+        0 === prevActScopeDepth && (flushActQueue(queue), 0 !== queue.length && queueSeveralMicrotasks(function() {
+          didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error(
+            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
+          ));
+        }), ReactSharedInternals.actQueue = null);
+        if (0 < ReactSharedInternals.thrownErrors.length)
+          throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+        return {
+          then: function(resolve, reject) {
+            didAwaitActCall = true;
+            0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
+              return recursivelyFlushAsyncActWork(
+                returnValue$jscomp$0,
+                resolve,
+                reject
+              );
+            })) : resolve(returnValue$jscomp$0);
+          }
+        };
+      };
+      exports.cache = function(fn) {
+        return function() {
+          return fn.apply(null, arguments);
+        };
+      };
+      exports.cacheSignal = function() {
+        return null;
+      };
+      exports.captureOwnerStack = function() {
+        var getCurrentStack = ReactSharedInternals.getCurrentStack;
+        return null === getCurrentStack ? null : getCurrentStack();
+      };
+      exports.cloneElement = function(element, config, children) {
+        if (null === element || void 0 === element)
+          throw Error(
+            "The argument must be a React element, but you passed " + element + "."
+          );
+        var props = assign({}, element.props), key = element.key, owner = element._owner;
+        if (null != config) {
+          var JSCompiler_inline_result;
+          a: {
+            if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(
+              config,
+              "ref"
+            ).get) && JSCompiler_inline_result.isReactWarning) {
+              JSCompiler_inline_result = false;
+              break a;
+            }
+            JSCompiler_inline_result = void 0 !== config.ref;
+          }
+          JSCompiler_inline_result && (owner = getOwner());
+          hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
+          for (propName in config)
+            !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
+        }
+        var propName = arguments.length - 2;
+        if (1 === propName) props.children = children;
+        else if (1 < propName) {
+          JSCompiler_inline_result = Array(propName);
+          for (var i = 0; i < propName; i++)
+            JSCompiler_inline_result[i] = arguments[i + 2];
+          props.children = JSCompiler_inline_result;
+        }
+        props = ReactElement(
+          element.type,
+          key,
+          props,
+          owner,
+          element._debugStack,
+          element._debugTask
+        );
+        for (key = 2; key < arguments.length; key++)
+          validateChildKeys(arguments[key]);
+        return props;
+      };
+      exports.createContext = function(defaultValue) {
+        defaultValue = {
+          $$typeof: REACT_CONTEXT_TYPE,
+          _currentValue: defaultValue,
+          _currentValue2: defaultValue,
+          _threadCount: 0,
+          Provider: null,
+          Consumer: null
+        };
+        defaultValue.Provider = defaultValue;
+        defaultValue.Consumer = {
+          $$typeof: REACT_CONSUMER_TYPE,
+          _context: defaultValue
+        };
+        defaultValue._currentRenderer = null;
+        defaultValue._currentRenderer2 = null;
+        return defaultValue;
+      };
+      exports.createElement = function(type, config, children) {
+        for (var i = 2; i < arguments.length; i++)
+          validateChildKeys(arguments[i]);
+        i = {};
+        var key = null;
+        if (null != config)
+          for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = true, console.warn(
+            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
+          )), hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key), config)
+            hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (i[propName] = config[propName]);
+        var childrenLength = arguments.length - 2;
+        if (1 === childrenLength) i.children = children;
+        else if (1 < childrenLength) {
+          for (var childArray = Array(childrenLength), _i = 0; _i < childrenLength; _i++)
+            childArray[_i] = arguments[_i + 2];
+          Object.freeze && Object.freeze(childArray);
+          i.children = childArray;
+        }
+        if (type && type.defaultProps)
+          for (propName in childrenLength = type.defaultProps, childrenLength)
+            void 0 === i[propName] && (i[propName] = childrenLength[propName]);
+        key && defineKeyPropWarningGetter(
+          i,
+          "function" === typeof type ? type.displayName || type.name || "Unknown" : type
+        );
+        var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+        return ReactElement(
+          type,
+          key,
+          i,
+          getOwner(),
+          propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+          propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+        );
+      };
+      exports.createRef = function() {
+        var refObject = { current: null };
+        Object.seal(refObject);
+        return refObject;
+      };
+      exports.forwardRef = function(render) {
+        null != render && render.$$typeof === REACT_MEMO_TYPE ? console.error(
+          "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
+        ) : "function" !== typeof render ? console.error(
+          "forwardRef requires a render function but was given %s.",
+          null === render ? "null" : typeof render
+        ) : 0 !== render.length && 2 !== render.length && console.error(
+          "forwardRef render functions accept exactly two parameters: props and ref. %s",
+          1 === render.length ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
+        );
+        null != render && null != render.defaultProps && console.error(
+          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
+        );
+        var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
+        Object.defineProperty(elementType, "displayName", {
+          enumerable: false,
+          configurable: true,
+          get: function() {
+            return ownName;
+          },
+          set: function(name) {
+            ownName = name;
+            render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
+          }
+        });
+        return elementType;
+      };
+      exports.isValidElement = isValidElement;
+      exports.lazy = function(ctor) {
+        ctor = { _status: -1, _result: ctor };
+        var lazyType = {
+          $$typeof: REACT_LAZY_TYPE,
+          _payload: ctor,
+          _init: lazyInitializer
+        }, ioInfo = {
+          name: "lazy",
+          start: -1,
+          end: -1,
+          value: null,
+          owner: null,
+          debugStack: Error("react-stack-top-frame"),
+          debugTask: console.createTask ? console.createTask("lazy()") : null
+        };
+        ctor._ioInfo = ioInfo;
+        lazyType._debugInfo = [{ awaited: ioInfo }];
+        return lazyType;
+      };
+      exports.memo = function(type, compare) {
+        null == type && console.error(
+          "memo: The first argument must be a component. Instead received: %s",
+          null === type ? "null" : typeof type
+        );
+        compare = {
+          $$typeof: REACT_MEMO_TYPE,
+          type,
+          compare: void 0 === compare ? null : compare
+        };
+        var ownName;
+        Object.defineProperty(compare, "displayName", {
+          enumerable: false,
+          configurable: true,
+          get: function() {
+            return ownName;
+          },
+          set: function(name) {
+            ownName = name;
+            type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
+          }
+        });
+        return compare;
+      };
+      exports.startTransition = function(scope) {
+        var prevTransition = ReactSharedInternals.T, currentTransition = {};
+        currentTransition._updatedFibers = /* @__PURE__ */ new Set();
+        ReactSharedInternals.T = currentTransition;
+        try {
+          var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
+          null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+          "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError));
+        } catch (error) {
+          reportGlobalError(error);
+        } finally {
+          null === prevTransition && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn(
+            "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
+          )), null !== prevTransition && null !== currentTransition.types && (null !== prevTransition.types && prevTransition.types !== currentTransition.types && console.error(
+            "We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."
+          ), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+        }
+      };
+      exports.unstable_useCacheRefresh = function() {
+        return resolveDispatcher().useCacheRefresh();
+      };
+      exports.use = function(usable) {
+        return resolveDispatcher().use(usable);
+      };
+      exports.useActionState = function(action, initialState, permalink) {
+        return resolveDispatcher().useActionState(
+          action,
+          initialState,
+          permalink
+        );
+      };
+      exports.useCallback = function(callback, deps) {
+        return resolveDispatcher().useCallback(callback, deps);
+      };
+      exports.useContext = function(Context) {
+        var dispatcher = resolveDispatcher();
+        Context.$$typeof === REACT_CONSUMER_TYPE && console.error(
+          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
+        );
+        return dispatcher.useContext(Context);
+      };
+      exports.useDebugValue = function(value, formatterFn) {
+        return resolveDispatcher().useDebugValue(value, formatterFn);
+      };
+      exports.useDeferredValue = function(value, initialValue) {
+        return resolveDispatcher().useDeferredValue(value, initialValue);
+      };
+      exports.useEffect = function(create, deps) {
+        null == create && console.warn(
+          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        );
+        return resolveDispatcher().useEffect(create, deps);
+      };
+      exports.useEffectEvent = function(callback) {
+        return resolveDispatcher().useEffectEvent(callback);
+      };
+      exports.useId = function() {
+        return resolveDispatcher().useId();
+      };
+      exports.useImperativeHandle = function(ref, create, deps) {
+        return resolveDispatcher().useImperativeHandle(ref, create, deps);
+      };
+      exports.useInsertionEffect = function(create, deps) {
+        null == create && console.warn(
+          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        );
+        return resolveDispatcher().useInsertionEffect(create, deps);
+      };
+      exports.useLayoutEffect = function(create, deps) {
+        null == create && console.warn(
+          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        );
+        return resolveDispatcher().useLayoutEffect(create, deps);
+      };
+      exports.useMemo = function(create, deps) {
+        return resolveDispatcher().useMemo(create, deps);
+      };
+      exports.useOptimistic = function(passthrough, reducer) {
+        return resolveDispatcher().useOptimistic(passthrough, reducer);
+      };
+      exports.useReducer = function(reducer, initialArg, init) {
+        return resolveDispatcher().useReducer(reducer, initialArg, init);
+      };
+      exports.useRef = function(initialValue) {
+        return resolveDispatcher().useRef(initialValue);
+      };
+      exports.useState = function(initialState) {
+        return resolveDispatcher().useState(initialState);
+      };
+      exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
+        return resolveDispatcher().useSyncExternalStore(
+          subscribe,
+          getSnapshot,
+          getServerSnapshot
+        );
+      };
+      exports.useTransition = function() {
+        return resolveDispatcher().useTransition();
+      };
+      exports.version = "19.2.1";
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+  }
+});
+
+// ../../../node_modules/react/index.js
+var require_react = __commonJS({
+  "../../../node_modules/react/index.js"(exports, module) {
+    "use strict";
+    if (false) {
+      module.exports = null;
+    } else {
+      module.exports = require_react_development();
+    }
+  }
+});
+
+// ../../../node_modules/react/cjs/react-jsx-runtime.development.js
+var require_react_jsx_runtime_development = __commonJS({
+  "../../../node_modules/react/cjs/react-jsx-runtime.development.js"(exports) {
+    "use strict";
+    (function() {
+      function getComponentNameFromType(type) {
+        if (null == type) return null;
+        if ("function" === typeof type)
+          return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+        if ("string" === typeof type) return type;
+        switch (type) {
+          case REACT_FRAGMENT_TYPE:
+            return "Fragment";
+          case REACT_PROFILER_TYPE:
+            return "Profiler";
+          case REACT_STRICT_MODE_TYPE:
+            return "StrictMode";
+          case REACT_SUSPENSE_TYPE:
+            return "Suspense";
+          case REACT_SUSPENSE_LIST_TYPE:
+            return "SuspenseList";
+          case REACT_ACTIVITY_TYPE:
+            return "Activity";
+        }
+        if ("object" === typeof type)
+          switch ("number" === typeof type.tag && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), type.$$typeof) {
+            case REACT_PORTAL_TYPE:
+              return "Portal";
+            case REACT_CONTEXT_TYPE:
+              return type.displayName || "Context";
+            case REACT_CONSUMER_TYPE:
+              return (type._context.displayName || "Context") + ".Consumer";
+            case REACT_FORWARD_REF_TYPE:
+              var innerType = type.render;
+              type = type.displayName;
+              type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+              return type;
+            case REACT_MEMO_TYPE:
+              return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+            case REACT_LAZY_TYPE:
+              innerType = type._payload;
+              type = type._init;
+              try {
+                return getComponentNameFromType(type(innerType));
+              } catch (x) {
+              }
+          }
+        return null;
+      }
+      function testStringCoercion(value) {
+        return "" + value;
+      }
+      function checkKeyStringCoercion(value) {
+        try {
+          testStringCoercion(value);
+          var JSCompiler_inline_result = false;
+        } catch (e) {
+          JSCompiler_inline_result = true;
+        }
+        if (JSCompiler_inline_result) {
+          JSCompiler_inline_result = console;
+          var JSCompiler_temp_const = JSCompiler_inline_result.error;
+          var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+          JSCompiler_temp_const.call(
+            JSCompiler_inline_result,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            JSCompiler_inline_result$jscomp$0
+          );
+          return testStringCoercion(value);
+        }
+      }
+      function getTaskName(type) {
+        if (type === REACT_FRAGMENT_TYPE) return "<>";
+        if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
+          return "<...>";
+        try {
+          var name = getComponentNameFromType(type);
+          return name ? "<" + name + ">" : "<...>";
+        } catch (x) {
+          return "<...>";
+        }
+      }
+      function getOwner() {
+        var dispatcher = ReactSharedInternals.A;
+        return null === dispatcher ? null : dispatcher.getOwner();
+      }
+      function UnknownOwner() {
+        return Error("react-stack-top-frame");
+      }
+      function hasValidKey(config) {
+        if (hasOwnProperty.call(config, "key")) {
+          var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+          if (getter && getter.isReactWarning) return false;
+        }
+        return void 0 !== config.key;
+      }
+      function defineKeyPropWarningGetter(props, displayName) {
+        function warnAboutAccessingKey() {
+          specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            displayName
+          ));
+        }
+        warnAboutAccessingKey.isReactWarning = true;
+        Object.defineProperty(props, "key", {
+          get: warnAboutAccessingKey,
+          configurable: true
+        });
+      }
+      function elementRefGetterWithDeprecationWarning() {
+        var componentName = getComponentNameFromType(this.type);
+        didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        ));
+        componentName = this.props.ref;
+        return void 0 !== componentName ? componentName : null;
+      }
+      function ReactElement(type, key, props, owner, debugStack, debugTask) {
+        var refProp = props.ref;
+        type = {
+          $$typeof: REACT_ELEMENT_TYPE,
+          type,
+          key,
+          props,
+          _owner: owner
+        };
+        null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+          enumerable: false,
+          get: elementRefGetterWithDeprecationWarning
+        }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+        type._store = {};
+        Object.defineProperty(type._store, "validated", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: 0
+        });
+        Object.defineProperty(type, "_debugInfo", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: null
+        });
+        Object.defineProperty(type, "_debugStack", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: debugStack
+        });
+        Object.defineProperty(type, "_debugTask", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: debugTask
+        });
+        Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+        return type;
+      }
+      function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+        var children = config.children;
+        if (void 0 !== children)
+          if (isStaticChildren)
+            if (isArrayImpl(children)) {
+              for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
+                validateChildKeys(children[isStaticChildren]);
+              Object.freeze && Object.freeze(children);
+            } else
+              console.error(
+                "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+              );
+          else validateChildKeys(children);
+        if (hasOwnProperty.call(config, "key")) {
+          children = getComponentNameFromType(type);
+          var keys = Object.keys(config).filter(function(k) {
+            return "key" !== k;
+          });
+          isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+          didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
+            'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
+            isStaticChildren,
+            children,
+            keys,
+            children
+          ), didWarnAboutKeySpread[children + isStaticChildren] = true);
+        }
+        children = null;
+        void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+        hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+        if ("key" in config) {
+          maybeKey = {};
+          for (var propName in config)
+            "key" !== propName && (maybeKey[propName] = config[propName]);
+        } else maybeKey = config;
+        children && defineKeyPropWarningGetter(
+          maybeKey,
+          "function" === typeof type ? type.displayName || type.name || "Unknown" : type
+        );
+        return ReactElement(
+          type,
+          children,
+          maybeKey,
+          getOwner(),
+          debugStack,
+          debugTask
+        );
+      }
+      function validateChildKeys(node) {
+        isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+      }
+      function isValidElement(object) {
+        return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+      }
+      var React = require_react(), REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      React = {
+        react_stack_bottom_frame: function(callStackForError) {
+          return callStackForError();
+        }
+      };
+      var specialPropKeyWarningShown;
+      var didWarnAboutElementRef = {};
+      var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(
+        React,
+        UnknownOwner
+      )();
+      var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+      var didWarnAboutKeySpread = {};
+      exports.Fragment = REACT_FRAGMENT_TYPE;
+      exports.jsx = function(type, config, maybeKey) {
+        var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+        return jsxDEVImpl(
+          type,
+          config,
+          maybeKey,
+          false,
+          trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+          trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+        );
+      };
+      exports.jsxs = function(type, config, maybeKey) {
+        var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+        return jsxDEVImpl(
+          type,
+          config,
+          maybeKey,
+          true,
+          trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+          trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+        );
+      };
+    })();
+  }
+});
+
+// ../../../node_modules/react/jsx-runtime.js
+var require_jsx_runtime = __commonJS({
+  "../../../node_modules/react/jsx-runtime.js"(exports, module) {
+    "use strict";
+    if (false) {
+      module.exports = null;
+    } else {
+      module.exports = require_react_jsx_runtime_development();
+    }
+  }
+});
+
+// ../../../node_modules/react-dom/cjs/react-dom.development.js
+var require_react_dom_development = __commonJS({
+  "../../../node_modules/react-dom/cjs/react-dom.development.js"(exports) {
+    "use strict";
+    (function() {
+      function noop() {
+      }
+      function testStringCoercion(value) {
+        return "" + value;
+      }
+      function createPortal$1(children, containerInfo, implementation) {
+        var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+        try {
+          testStringCoercion(key);
+          var JSCompiler_inline_result = false;
+        } catch (e) {
+          JSCompiler_inline_result = true;
+        }
+        JSCompiler_inline_result && (console.error(
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          "function" === typeof Symbol && Symbol.toStringTag && key[Symbol.toStringTag] || key.constructor.name || "Object"
+        ), testStringCoercion(key));
+        return {
+          $$typeof: REACT_PORTAL_TYPE,
+          key: null == key ? null : "" + key,
+          children,
+          containerInfo,
+          implementation
+        };
+      }
+      function getCrossOriginStringAs(as, input) {
+        if ("font" === as) return "";
+        if ("string" === typeof input)
+          return "use-credentials" === input ? input : "";
+      }
+      function getValueDescriptorExpectingObjectForWarning(thing) {
+        return null === thing ? "`null`" : void 0 === thing ? "`undefined`" : "" === thing ? "an empty string" : 'something with type "' + typeof thing + '"';
+      }
+      function getValueDescriptorExpectingEnumForWarning(thing) {
+        return null === thing ? "`null`" : void 0 === thing ? "`undefined`" : "" === thing ? "an empty string" : "string" === typeof thing ? JSON.stringify(thing) : "number" === typeof thing ? "`" + thing + "`" : 'something with type "' + typeof thing + '"';
+      }
+      function resolveDispatcher() {
+        var dispatcher = ReactSharedInternals.H;
+        null === dispatcher && console.error(
+          "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem."
+        );
+        return dispatcher;
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var React = require_react(), Internals = {
+        d: {
+          f: noop,
+          r: function() {
+            throw Error(
+              "Invalid form element. requestFormReset must be passed a form that was rendered by React."
+            );
+          },
+          D: noop,
+          C: noop,
+          L: noop,
+          m: noop,
+          X: noop,
+          S: noop,
+          M: noop
+        },
+        p: 0,
+        findDOMNode: null
+      }, REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+      "function" === typeof Map && null != Map.prototype && "function" === typeof Map.prototype.forEach && "function" === typeof Set && null != Set.prototype && "function" === typeof Set.prototype.clear && "function" === typeof Set.prototype.forEach || console.error(
+        "React depends on Map and Set built-in types. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills"
+      );
+      exports.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = Internals;
+      exports.createPortal = function(children, container) {
+        var key = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
+        if (!container || 1 !== container.nodeType && 9 !== container.nodeType && 11 !== container.nodeType)
+          throw Error("Target container is not a DOM element.");
+        return createPortal$1(children, container, null, key);
+      };
+      exports.flushSync = function(fn) {
+        var previousTransition = ReactSharedInternals.T, previousUpdatePriority = Internals.p;
+        try {
+          if (ReactSharedInternals.T = null, Internals.p = 2, fn)
+            return fn();
+        } finally {
+          ReactSharedInternals.T = previousTransition, Internals.p = previousUpdatePriority, Internals.d.f() && console.error(
+            "flushSync was called from inside a lifecycle method. React cannot flush when React is already rendering. Consider moving this call to a scheduler task or micro task."
+          );
+        }
+      };
+      exports.preconnect = function(href, options) {
+        "string" === typeof href && href ? null != options && "object" !== typeof options ? console.error(
+          "ReactDOM.preconnect(): Expected the `options` argument (second) to be an object but encountered %s instead. The only supported option at this time is `crossOrigin` which accepts a string.",
+          getValueDescriptorExpectingEnumForWarning(options)
+        ) : null != options && "string" !== typeof options.crossOrigin && console.error(
+          "ReactDOM.preconnect(): Expected the `crossOrigin` option (second argument) to be a string but encountered %s instead. Try removing this option or passing a string value instead.",
+          getValueDescriptorExpectingObjectForWarning(options.crossOrigin)
+        ) : console.error(
+          "ReactDOM.preconnect(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+          getValueDescriptorExpectingObjectForWarning(href)
+        );
+        "string" === typeof href && (options ? (options = options.crossOrigin, options = "string" === typeof options ? "use-credentials" === options ? options : "" : void 0) : options = null, Internals.d.C(href, options));
+      };
+      exports.prefetchDNS = function(href) {
+        if ("string" !== typeof href || !href)
+          console.error(
+            "ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+            getValueDescriptorExpectingObjectForWarning(href)
+          );
+        else if (1 < arguments.length) {
+          var options = arguments[1];
+          "object" === typeof options && options.hasOwnProperty("crossOrigin") ? console.error(
+            "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. It looks like the you are attempting to set a crossOrigin property for this DNS lookup hint. Browsers do not perform DNS queries using CORS and setting this attribute on the resource hint has no effect. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+            getValueDescriptorExpectingEnumForWarning(options)
+          ) : console.error(
+            "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+            getValueDescriptorExpectingEnumForWarning(options)
+          );
+        }
+        "string" === typeof href && Internals.d.D(href);
+      };
+      exports.preinit = function(href, options) {
+        "string" === typeof href && href ? null == options || "object" !== typeof options ? console.error(
+          "ReactDOM.preinit(): Expected the `options` argument (second) to be an object with an `as` property describing the type of resource to be preinitialized but encountered %s instead.",
+          getValueDescriptorExpectingEnumForWarning(options)
+        ) : "style" !== options.as && "script" !== options.as && console.error(
+          'ReactDOM.preinit(): Expected the `as` property in the `options` argument (second) to contain a valid value describing the type of resource to be preinitialized but encountered %s instead. Valid values for `as` are "style" and "script".',
+          getValueDescriptorExpectingEnumForWarning(options.as)
+        ) : console.error(
+          "ReactDOM.preinit(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+          getValueDescriptorExpectingObjectForWarning(href)
+        );
+        if ("string" === typeof href && options && "string" === typeof options.as) {
+          var as = options.as, crossOrigin = getCrossOriginStringAs(as, options.crossOrigin), integrity = "string" === typeof options.integrity ? options.integrity : void 0, fetchPriority = "string" === typeof options.fetchPriority ? options.fetchPriority : void 0;
+          "style" === as ? Internals.d.S(
+            href,
+            "string" === typeof options.precedence ? options.precedence : void 0,
+            {
+              crossOrigin,
+              integrity,
+              fetchPriority
+            }
+          ) : "script" === as && Internals.d.X(href, {
+            crossOrigin,
+            integrity,
+            fetchPriority,
+            nonce: "string" === typeof options.nonce ? options.nonce : void 0
+          });
+        }
+      };
+      exports.preinitModule = function(href, options) {
+        var encountered = "";
+        "string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
+        void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "script" !== options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingEnumForWarning(options.as) + ".");
+        if (encountered)
+          console.error(
+            "ReactDOM.preinitModule(): Expected up to two arguments, a non-empty `href` string and, optionally, an `options` object with a valid `as` property.%s",
+            encountered
+          );
+        else
+          switch (encountered = options && "string" === typeof options.as ? options.as : "script", encountered) {
+            case "script":
+              break;
+            default:
+              encountered = getValueDescriptorExpectingEnumForWarning(encountered), console.error(
+                'ReactDOM.preinitModule(): Currently the only supported "as" type for this function is "script" but received "%s" instead. This warning was generated for `href` "%s". In the future other module types will be supported, aligning with the import-attributes proposal. Learn more here: (https://github.com/tc39/proposal-import-attributes)',
+                encountered,
+                href
+              );
+          }
+        if ("string" === typeof href)
+          if ("object" === typeof options && null !== options) {
+            if (null == options.as || "script" === options.as)
+              encountered = getCrossOriginStringAs(
+                options.as,
+                options.crossOrigin
+              ), Internals.d.M(href, {
+                crossOrigin: encountered,
+                integrity: "string" === typeof options.integrity ? options.integrity : void 0,
+                nonce: "string" === typeof options.nonce ? options.nonce : void 0
+              });
+          } else null == options && Internals.d.M(href);
+      };
+      exports.preload = function(href, options) {
+        var encountered = "";
+        "string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
+        null == options || "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : "string" === typeof options.as && options.as || (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
+        encountered && console.error(
+          'ReactDOM.preload(): Expected two arguments, a non-empty `href` string and an `options` object with an `as` property valid for a `<link rel="preload" as="..." />` tag.%s',
+          encountered
+        );
+        if ("string" === typeof href && "object" === typeof options && null !== options && "string" === typeof options.as) {
+          encountered = options.as;
+          var crossOrigin = getCrossOriginStringAs(
+            encountered,
+            options.crossOrigin
+          );
+          Internals.d.L(href, encountered, {
+            crossOrigin,
+            integrity: "string" === typeof options.integrity ? options.integrity : void 0,
+            nonce: "string" === typeof options.nonce ? options.nonce : void 0,
+            type: "string" === typeof options.type ? options.type : void 0,
+            fetchPriority: "string" === typeof options.fetchPriority ? options.fetchPriority : void 0,
+            referrerPolicy: "string" === typeof options.referrerPolicy ? options.referrerPolicy : void 0,
+            imageSrcSet: "string" === typeof options.imageSrcSet ? options.imageSrcSet : void 0,
+            imageSizes: "string" === typeof options.imageSizes ? options.imageSizes : void 0,
+            media: "string" === typeof options.media ? options.media : void 0
+          });
+        }
+      };
+      exports.preloadModule = function(href, options) {
+        var encountered = "";
+        "string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
+        void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "string" !== typeof options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
+        encountered && console.error(
+          'ReactDOM.preloadModule(): Expected two arguments, a non-empty `href` string and, optionally, an `options` object with an `as` property valid for a `<link rel="modulepreload" as="..." />` tag.%s',
+          encountered
+        );
+        "string" === typeof href && (options ? (encountered = getCrossOriginStringAs(
+          options.as,
+          options.crossOrigin
+        ), Internals.d.m(href, {
+          as: "string" === typeof options.as && "script" !== options.as ? options.as : void 0,
+          crossOrigin: encountered,
+          integrity: "string" === typeof options.integrity ? options.integrity : void 0
+        })) : Internals.d.m(href));
+      };
+      exports.requestFormReset = function(form) {
+        Internals.d.r(form);
+      };
+      exports.unstable_batchedUpdates = function(fn, a) {
+        return fn(a);
+      };
+      exports.useFormState = function(action, initialState, permalink) {
+        return resolveDispatcher().useFormState(action, initialState, permalink);
+      };
+      exports.useFormStatus = function() {
+        return resolveDispatcher().useHostTransitionStatus();
+      };
+      exports.version = "19.2.1";
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+  }
+});
+
+// ../../../node_modules/react-dom/index.js
+var require_react_dom = __commonJS({
+  "../../../node_modules/react-dom/index.js"(exports, module) {
+    "use strict";
+    if (false) {
+      checkDCE();
+      module.exports = null;
+    } else {
+      module.exports = require_react_dom_development();
+    }
+  }
+});
+
+// ../../shared-editor-ui/dist/components/AnchorPicker.js
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+var import_react = __toESM(require_react(), 1);
+var import_react_dom = __toESM(require_react_dom(), 1);
+
+// ../../../node_modules/css-selector-generator/esm/utilities-iselement.js
+function isElement(input) {
+  return typeof input === "object" && input !== null && input.nodeType === Node.ELEMENT_NODE;
+}
+
+// ../../../node_modules/css-selector-generator/esm/types.js
+var OPERATOR = {
+  NONE: "",
+  DESCENDANT: " ",
+  CHILD: " > "
+};
+var CSS_SELECTOR_TYPE = {
+  id: "id",
+  class: "class",
+  tag: "tag",
+  attribute: "attribute",
+  nthchild: "nthchild",
+  nthoftype: "nthoftype"
+};
+
+// ../../../node_modules/css-selector-generator/esm/utilities-typescript.js
+function isEnumValue(haystack, needle) {
+  return Object.values(haystack).includes(needle);
+}
+
+// ../../../node_modules/css-selector-generator/esm/utilities-messages.js
+var libraryName = "CssSelectorGenerator";
+function showWarning(id = "unknown problem", ...args) {
+  console.warn(`${libraryName}: ${id}`, ...args);
+}
+
+// ../../../node_modules/css-selector-generator/esm/utilities-options.js
+var DEFAULT_OPTIONS = {
+  selectors: [
+    CSS_SELECTOR_TYPE.id,
+    CSS_SELECTOR_TYPE.class,
+    CSS_SELECTOR_TYPE.tag,
+    CSS_SELECTOR_TYPE.attribute
+  ],
+  // if set to true, always include tag name
+  includeTag: false,
+  whitelist: [],
+  blacklist: [],
+  combineWithinSelector: true,
+  combineBetweenSelectors: true,
+  root: null,
+  maxCombinations: Number.POSITIVE_INFINITY,
+  maxCandidates: Number.POSITIVE_INFINITY,
+  useScope: false
+};
+function sanitizeSelectorTypes(input) {
+  if (!Array.isArray(input)) {
+    return [];
+  }
+  return input.filter((item) => isEnumValue(CSS_SELECTOR_TYPE, item));
+}
+function isRegExp(input) {
+  return input instanceof RegExp;
+}
+function isCssSelectorMatch(input) {
+  return ["string", "function"].includes(typeof input) || isRegExp(input);
+}
+function sanitizeCssSelectorMatchList(input) {
+  if (!Array.isArray(input)) {
+    return [];
+  }
+  return input.filter(isCssSelectorMatch);
+}
+function isNode(input) {
+  return input instanceof Node;
+}
+function isParentNode(input) {
+  const validParentNodeTypes = [
+    Node.DOCUMENT_NODE,
+    Node.DOCUMENT_FRAGMENT_NODE,
+    // this includes Shadow DOM root
+    Node.ELEMENT_NODE
+  ];
+  return isNode(input) && validParentNodeTypes.includes(input.nodeType);
+}
+function sanitizeRoot(input, element) {
+  if (isParentNode(input)) {
+    if (!input.contains(element)) {
+      showWarning("element root mismatch", "Provided root does not contain the element. This will most likely result in producing a fallback selector using element's real root node. If you plan to use the selector using provided root (e.g. `root.querySelector`), it will not work as intended.");
+    }
+    return input;
+  }
+  const rootNode = element.getRootNode({ composed: false });
+  if (isParentNode(rootNode)) {
+    if (rootNode !== document) {
+      showWarning("shadow root inferred", "You did not provide a root and the element is a child of Shadow DOM. This will produce a selector using ShadowRoot as a root. If you plan to use the selector using document as a root (e.g. `document.querySelector`), it will not work as intended.");
+    }
+    return rootNode;
+  }
+  return getRootNode(element);
+}
+function sanitizeMaxNumber(input) {
+  return typeof input === "number" ? input : Number.POSITIVE_INFINITY;
+}
+function sanitizeOptions(element, custom_options = {}) {
+  const options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), custom_options);
+  return {
+    selectors: sanitizeSelectorTypes(options.selectors),
+    whitelist: sanitizeCssSelectorMatchList(options.whitelist),
+    blacklist: sanitizeCssSelectorMatchList(options.blacklist),
+    root: sanitizeRoot(options.root, element),
+    combineWithinSelector: !!options.combineWithinSelector,
+    combineBetweenSelectors: !!options.combineBetweenSelectors,
+    includeTag: !!options.includeTag,
+    maxCombinations: sanitizeMaxNumber(options.maxCombinations),
+    maxCandidates: sanitizeMaxNumber(options.maxCandidates),
+    useScope: !!options.useScope,
+    maxResults: sanitizeMaxNumber(options.maxResults)
+  };
+}
+
+// ../../../node_modules/css-selector-generator/esm/utilities-data.js
+function getIntersection(items = []) {
+  const [firstItem = [], ...otherItems] = items;
+  if (otherItems.length === 0) {
+    return firstItem;
+  }
+  return otherItems.reduce((accumulator, currentValue) => {
+    return accumulator.filter((item) => currentValue.includes(item));
+  }, firstItem);
+}
+function flattenArray(input) {
+  return [].concat(...input);
+}
+function wildcardToRegExp(input) {
+  return input.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".+");
+}
+function createPatternMatcher(list) {
+  const matchFunctions = list.map((item) => {
+    if (isRegExp(item)) {
+      return (input) => item.test(input);
+    }
+    if (typeof item === "function") {
+      return (input) => {
+        const result = item(input);
+        if (typeof result !== "boolean") {
+          showWarning("pattern matcher function invalid", "Provided pattern matching function does not return boolean. It's result will be ignored.", item);
+          return false;
+        }
+        return result;
+      };
+    }
+    if (typeof item === "string") {
+      const re = new RegExp("^" + wildcardToRegExp(item) + "$");
+      return (input) => re.test(input);
+    }
+    showWarning("pattern matcher invalid", "Pattern matching only accepts strings, regular expressions and/or functions. This item is invalid and will be ignored.", item);
+    return () => false;
+  });
+  return (input) => matchFunctions.some((matchFunction) => matchFunction(input));
+}
+
+// ../../../node_modules/css-selector-generator/esm/utilities-dom.js
+function testSelector(elements, selector, root) {
+  const result = Array.from(sanitizeRoot(root, elements[0]).querySelectorAll(selector));
+  return result.length === elements.length && elements.every((element) => result.includes(element));
+}
+function getElementParents(element, root) {
+  root = root !== null && root !== void 0 ? root : getRootNode(element);
+  const result = [];
+  let parent = element;
+  while (isElement(parent) && parent !== root) {
+    result.push(parent);
+    parent = parent.parentElement;
+  }
+  return result;
+}
+function getParents(elements, root) {
+  return getIntersection(elements.map((element) => getElementParents(element, root)));
+}
+function getRootNode(element) {
+  return element.ownerDocument.querySelector(":root");
+}
+
+// ../../../node_modules/css-selector-generator/esm/constants.js
+var SELECTOR_SEPARATOR = ", ";
+var INVALID_ID_RE = new RegExp([
+  "^$",
+  // empty or not set
+  "\\s"
+  // contains whitespace
+].join("|"));
+var INVALID_CLASS_RE = new RegExp([
+  "^$"
+  // empty or not set
+].join("|"));
+var SELECTOR_PATTERN = [
+  CSS_SELECTOR_TYPE.nthoftype,
+  CSS_SELECTOR_TYPE.tag,
+  CSS_SELECTOR_TYPE.id,
+  CSS_SELECTOR_TYPE.class,
+  CSS_SELECTOR_TYPE.attribute,
+  CSS_SELECTOR_TYPE.nthchild
+];
+
+// ../../../node_modules/css-selector-generator/esm/selector-attribute.js
+var attributeBlacklistMatch = createPatternMatcher([
+  "class",
+  "id",
+  // Angular attributes
+  "ng-*"
+]);
+function attributeNodeToSimplifiedSelector({ name }) {
+  return `[${name}]`;
+}
+function attributeNodeToSelector({ name, value }) {
+  return `[${name}='${value}']`;
+}
+function isValidAttributeNode({ nodeName, nodeValue }, element) {
+  const tagName = element.tagName.toLowerCase();
+  if (["input", "option"].includes(tagName) && nodeName === "value") {
+    return false;
+  }
+  if (nodeName === "src" && (nodeValue === null || nodeValue === void 0 ? void 0 : nodeValue.startsWith("data:"))) {
+    return false;
+  }
+  return !attributeBlacklistMatch(nodeName);
+}
+function sanitizeAttributeData({ nodeName, nodeValue }) {
+  return {
+    name: sanitizeSelectorItem(nodeName),
+    value: sanitizeSelectorItem(nodeValue !== null && nodeValue !== void 0 ? nodeValue : void 0)
+  };
+}
+function getElementAttributeSelectors(element) {
+  const validAttributes = Array.from(element.attributes).filter((attributeNode) => isValidAttributeNode(attributeNode, element)).map(sanitizeAttributeData);
+  return [
+    ...validAttributes.map(attributeNodeToSimplifiedSelector),
+    ...validAttributes.map(attributeNodeToSelector)
+  ];
+}
+function getAttributeSelectors(elements) {
+  const elementSelectors = elements.map(getElementAttributeSelectors);
+  return getIntersection(elementSelectors);
+}
+
+// ../../../node_modules/css-selector-generator/esm/selector-class.js
+function getElementClassSelectors(element) {
+  var _a;
+  return ((_a = element.getAttribute("class")) !== null && _a !== void 0 ? _a : "").trim().split(/\s+/).filter((item) => !INVALID_CLASS_RE.test(item)).map((item) => `.${sanitizeSelectorItem(item)}`);
+}
+function getClassSelectors(elements) {
+  const elementSelectors = elements.map(getElementClassSelectors);
+  return getIntersection(elementSelectors);
+}
+
+// ../../../node_modules/css-selector-generator/esm/selector-id.js
+function getElementIdSelectors(element) {
+  var _a;
+  const id = (_a = element.getAttribute("id")) !== null && _a !== void 0 ? _a : "";
+  const selector = `#${sanitizeSelectorItem(id)}`;
+  const rootNode = element.getRootNode({ composed: false });
+  return !INVALID_ID_RE.test(id) && testSelector([element], selector, rootNode) ? [selector] : [];
+}
+function getIdSelector(elements) {
+  return elements.length === 0 || elements.length > 1 ? [] : getElementIdSelectors(elements[0]);
+}
+
+// ../../../node_modules/css-selector-generator/esm/selector-nth-child.js
+function getElementNthChildSelector(element) {
+  var _a;
+  const siblings = (_a = element.parentElement) === null || _a === void 0 ? void 0 : _a.children;
+  if (siblings) {
+    for (let i = 0; i < siblings.length; i++) {
+      if (siblings[i] === element) {
+        return [`:nth-child(${String(i + 1)})`];
+      }
+    }
+  }
+  return [];
+}
+function getNthChildSelector(elements) {
+  return getIntersection(elements.map(getElementNthChildSelector));
+}
+
+// ../../../node_modules/css-selector-generator/esm/selector-tag.js
+function getElementTagSelectors(element) {
+  return [
+    sanitizeSelectorItem(element.tagName.toLowerCase())
+  ];
+}
+function getTagSelector(elements) {
+  const selectors = [
+    ...new Set(flattenArray(elements.map(getElementTagSelectors)))
+  ];
+  return selectors.length === 0 || selectors.length > 1 ? [] : [selectors[0]];
+}
+
+// ../../../node_modules/css-selector-generator/esm/selector-nth-of-type.js
+function getElementNthOfTypeSelector(element) {
+  const tag = getTagSelector([element])[0];
+  const parentElement = element.parentElement;
+  if (parentElement) {
+    const siblings = Array.from(parentElement.children).filter((element2) => element2.tagName.toLowerCase() === tag);
+    const elementIndex = siblings.indexOf(element);
+    if (elementIndex > -1) {
+      return [
+        `${tag}:nth-of-type(${String(elementIndex + 1)})`
+      ];
+    }
+  }
+  return [];
+}
+function getNthOfTypeSelector(elements) {
+  return getIntersection(elements.map(getElementNthOfTypeSelector));
+}
+
+// ../../../node_modules/css-selector-generator/esm/utilities-powerset.js
+function* powerSetGenerator(input = [], { maxResults = Number.POSITIVE_INFINITY } = {}) {
+  let resultCounter = 0;
+  let offsets = generateOffsets(1);
+  while (offsets.length <= input.length && resultCounter < maxResults) {
+    resultCounter += 1;
+    const result = offsets.map((offset) => input[offset]);
+    yield result;
+    offsets = bumpOffsets(offsets, input.length - 1);
+  }
+}
+function getPowerSet(input = [], { maxResults = Number.POSITIVE_INFINITY } = {}) {
+  return Array.from(powerSetGenerator(input, { maxResults }));
+}
+function bumpOffsets(offsets = [], maxValue = 0) {
+  const size = offsets.length;
+  if (size === 0) {
+    return [];
+  }
+  const result = [...offsets];
+  result[size - 1] += 1;
+  for (let index = size - 1; index >= 0; index--) {
+    if (result[index] > maxValue) {
+      if (index === 0) {
+        return generateOffsets(size + 1);
+      } else {
+        result[index - 1]++;
+        result[index] = result[index - 1] + 1;
+      }
+    }
+  }
+  if (result[size - 1] > maxValue) {
+    return generateOffsets(size + 1);
+  }
+  return result;
+}
+function generateOffsets(size = 1) {
+  return Array.from(Array(size).keys());
+}
+
+// ../../../node_modules/css-selector-generator/esm/utilities-cartesian.js
+function* cartesianProductGenerator(input = {}) {
+  const entries = Object.entries(input);
+  if (entries.length === 0)
+    return;
+  const stack = [
+    { index: entries.length - 1, partial: {} }
+  ];
+  while (stack.length > 0) {
+    const item = stack.pop();
+    if (!item)
+      break;
+    const { index, partial } = item;
+    if (index < 0) {
+      yield partial;
+      continue;
+    }
+    const [key, values] = entries[index];
+    for (let i = values.length - 1; i >= 0; i--) {
+      stack.push({
+        index: index - 1,
+        partial: Object.assign(Object.assign({}, partial), { [key]: values[i] })
+      });
+    }
+  }
+}
+
+// ../../../node_modules/css-selector-generator/esm/utilities-selectors.js
+var ESCAPED_COLON = ":".charCodeAt(0).toString(16).toUpperCase();
+var SPECIAL_CHARACTERS_RE = /[ !"#$%&'()\[\]{|}<>*+,./;=?@^`~\\]/;
+function sanitizeSelectorItem(input = "") {
+  return CSS ? CSS.escape(input) : legacySanitizeSelectorItem(input);
+}
+function legacySanitizeSelectorItem(input = "") {
+  return input.split("").map((character) => {
+    if (character === ":") {
+      return `\\${ESCAPED_COLON} `;
+    }
+    if (SPECIAL_CHARACTERS_RE.test(character)) {
+      return `\\${character}`;
+    }
+    return escape(character).replace(/%/g, "\\");
+  }).join("");
+}
+var SELECTOR_TYPE_GETTERS = {
+  tag: getTagSelector,
+  id: getIdSelector,
+  class: getClassSelectors,
+  attribute: getAttributeSelectors,
+  nthchild: getNthChildSelector,
+  nthoftype: getNthOfTypeSelector
+};
+var ELEMENT_SELECTOR_TYPE_GETTERS = {
+  tag: getElementTagSelectors,
+  id: getElementIdSelectors,
+  class: getElementClassSelectors,
+  attribute: getElementAttributeSelectors,
+  nthchild: getElementNthChildSelector,
+  nthoftype: getElementNthOfTypeSelector
+};
+function getElementSelectorsByType(element, selectorType) {
+  return ELEMENT_SELECTOR_TYPE_GETTERS[selectorType](element);
+}
+function getSelectorsByType(elements, selector_type) {
+  const getter = SELECTOR_TYPE_GETTERS[selector_type];
+  return getter(elements);
+}
+function filterSelectors(list = [], matchBlacklist, matchWhitelist) {
+  return list.filter((item) => matchWhitelist(item) || !matchBlacklist(item));
+}
+function orderSelectors(list = [], matchWhitelist) {
+  return list.sort((a, b) => {
+    const a_is_whitelisted = matchWhitelist(a);
+    const b_is_whitelisted = matchWhitelist(b);
+    if (a_is_whitelisted && !b_is_whitelisted) {
+      return -1;
+    }
+    if (!a_is_whitelisted && b_is_whitelisted) {
+      return 1;
+    }
+    return 0;
+  });
+}
+function* allSelectorsGenerator(elements, options) {
+  const yieldedSelectors = /* @__PURE__ */ new Set();
+  const selectors_list = getSelectorsList(elements, options);
+  for (const selector of selectorTypeCombinationsGenerator(selectors_list, options)) {
+    if (!yieldedSelectors.has(selector)) {
+      yieldedSelectors.add(selector);
+      yield selector;
+    }
+  }
+}
+function getSelectorsList(elements, options) {
+  const { blacklist, whitelist, combineWithinSelector, maxCombinations } = options;
+  const matchBlacklist = createPatternMatcher(blacklist);
+  const matchWhitelist = createPatternMatcher(whitelist);
+  const reducer = (data, selector_type) => {
+    const selectors_by_type = getSelectorsByType(elements, selector_type);
+    const filtered_selectors = filterSelectors(selectors_by_type, matchBlacklist, matchWhitelist);
+    const found_selectors = orderSelectors(filtered_selectors, matchWhitelist);
+    data[selector_type] = combineWithinSelector ? Array.from(powerSetGenerator(found_selectors, { maxResults: maxCombinations })) : found_selectors.map((item) => [item]);
+    return data;
+  };
+  return getSelectorsToGet(options).reduce(reducer, {});
+}
+function getSelectorsToGet(options) {
+  const { selectors, includeTag } = options;
+  const selectors_to_get = [...selectors];
+  if (includeTag && !selectors_to_get.includes("tag")) {
+    selectors_to_get.push("tag");
+  }
+  return selectors_to_get;
+}
+function addTagTypeIfNeeded(list) {
+  return list.includes(CSS_SELECTOR_TYPE.tag) || list.includes(CSS_SELECTOR_TYPE.nthoftype) ? [...list] : [...list, CSS_SELECTOR_TYPE.tag];
+}
+function combineSelectorTypes(options) {
+  const { selectors, combineBetweenSelectors, includeTag, maxCandidates } = options;
+  const combinations = combineBetweenSelectors ? getPowerSet(selectors, { maxResults: maxCandidates }) : selectors.map((item) => [item]);
+  return includeTag ? combinations.map(addTagTypeIfNeeded) : combinations;
+}
+function* selectorTypeCombinationsGenerator(selectors_list, options) {
+  for (const item of combineSelectorTypes(options)) {
+    yield* constructedSelectorsGenerator(item, selectors_list);
+  }
+}
+function* constructedSelectorsGenerator(selector_types, selectors_by_type) {
+  const data = {};
+  for (const selector_type of selector_types) {
+    const selector_variants = selectors_by_type[selector_type];
+    if (selector_variants && selector_variants.length > 0) {
+      data[selector_type] = selector_variants;
+    }
+  }
+  for (const combination of cartesianProductGenerator(data)) {
+    yield constructSelector(combination);
+  }
+}
+function constructSelectorType(selector_type, selectors_data) {
+  return selectors_data[selector_type] ? selectors_data[selector_type].join("") : "";
+}
+function constructSelector(selectorData = {}) {
+  const pattern = [...SELECTOR_PATTERN];
+  if (selectorData[CSS_SELECTOR_TYPE.tag] && selectorData[CSS_SELECTOR_TYPE.nthoftype]) {
+    pattern.splice(pattern.indexOf(CSS_SELECTOR_TYPE.tag), 1);
+  }
+  return pattern.map((type) => constructSelectorType(type, selectorData)).join("");
+}
+function generateCandidateCombinations(selectors, rootSelector) {
+  return [
+    ...selectors.map((selector) => rootSelector + OPERATOR.DESCENDANT + selector),
+    ...selectors.map((selector) => rootSelector + OPERATOR.CHILD + selector)
+  ];
+}
+function* candidatesGenerator(selectors, rootSelector) {
+  if (rootSelector === "") {
+    yield* selectors;
+  } else {
+    for (const selector of selectors) {
+      yield* generateCandidateCombinations([selector], rootSelector);
+    }
+  }
+}
+function* selectorWithinRootGenerator(elements, root, rootSelector = "", options) {
+  const elementSelectorsIterator = allSelectorsGenerator(elements, options);
+  for (const candidateSelector of candidatesGenerator(elementSelectorsIterator, rootSelector)) {
+    if (testSelector(elements, candidateSelector, root)) {
+      yield candidateSelector;
+    }
+  }
+  return;
+}
+function* closestIdentifiableParentGenerator(elements, root, rootSelector = "", options) {
+  if (elements.length === 0) {
+    return null;
+  }
+  const candidatesList = [
+    elements.length > 1 ? elements : [],
+    ...getParents(elements, root).map((element) => [element])
+  ];
+  for (const currentElements of candidatesList) {
+    for (const selectorWithinRoot of selectorWithinRootGenerator(currentElements, root, rootSelector, options)) {
+      yield {
+        foundElements: currentElements,
+        selector: selectorWithinRoot
+      };
+    }
+  }
+}
+function* selectorGenerator({ elements, root, rootSelector = "", options }) {
+  let currentRoot = root;
+  let partialSelector = rootSelector;
+  let shouldContinue = true;
+  while (shouldContinue) {
+    let foundAny = false;
+    for (const item of closestIdentifiableParentGenerator(elements, currentRoot, partialSelector, options)) {
+      const { foundElements, selector } = item;
+      foundAny = true;
+      if (testSelector(elements, selector, root)) {
+        yield selector;
+      } else {
+        currentRoot = foundElements[0];
+        partialSelector = selector;
+        break;
+      }
+    }
+    if (!foundAny) {
+      shouldContinue = false;
+    }
+  }
+}
+function sanitizeSelectorNeedle(needle) {
+  if (needle instanceof NodeList || needle instanceof HTMLCollection) {
+    needle = Array.from(needle);
+  }
+  const elements = (Array.isArray(needle) ? needle : [needle]).filter(isElement);
+  return [...new Set(elements)];
+}
+
+// ../../../node_modules/css-selector-generator/esm/utilities-element-data.js
+function createElementSelectorData(selector) {
+  return {
+    value: selector,
+    include: false
+  };
+}
+function createElementData(element, selectorTypes, operator = OPERATOR.NONE) {
+  const selectors = {};
+  selectorTypes.forEach((selectorType) => {
+    Reflect.set(selectors, selectorType, getElementSelectorsByType(element, selectorType).map(createElementSelectorData));
+  });
+  return {
+    element,
+    operator,
+    selectors
+  };
+}
+function constructElementSelector({ selectors, operator }) {
+  let pattern = [...SELECTOR_PATTERN];
+  if (selectors[CSS_SELECTOR_TYPE.tag] && selectors[CSS_SELECTOR_TYPE.nthoftype]) {
+    pattern = pattern.filter((item) => item !== CSS_SELECTOR_TYPE.tag);
+  }
+  let selector = "";
+  pattern.forEach((selectorType) => {
+    var _a;
+    const selectorsOfType = (_a = selectors[selectorType]) !== null && _a !== void 0 ? _a : [];
+    selectorsOfType.forEach(({ value, include }) => {
+      if (include) {
+        selector += value;
+      }
+    });
+  });
+  return operator + selector;
+}
+
+// ../../../node_modules/css-selector-generator/esm/selector-fallback.js
+function getElementFallbackSelector(element, root) {
+  const parentElements = getElementParents(element, root).reverse();
+  const elementsData = parentElements.map((element2) => {
+    var _a;
+    const elementData = createElementData(element2, [CSS_SELECTOR_TYPE.nthchild], OPERATOR.CHILD);
+    ((_a = elementData.selectors.nthchild) !== null && _a !== void 0 ? _a : []).forEach((selectorData) => {
+      selectorData.include = true;
+    });
+    return elementData;
+  });
+  return [
+    root ? ":scope" : ":root",
+    ...elementsData.map(constructElementSelector)
+  ].join("");
+}
+function getFallbackSelector(elements, root) {
+  return elements.map((element) => getElementFallbackSelector(element, root)).join(SELECTOR_SEPARATOR);
+}
+
+// ../../../node_modules/css-selector-generator/esm/index.js
+function getCssSelector(needle, custom_options = {}) {
+  const options = Object.assign(Object.assign({}, custom_options), { maxResults: 1 });
+  const generator = cssSelectorGenerator(needle, options);
+  const firstResult = generator.next();
+  return firstResult.value;
+}
+function* cssSelectorGenerator(needle, custom_options = {}) {
+  var _a;
+  const elements = sanitizeSelectorNeedle(needle);
+  const options = sanitizeOptions(elements[0], custom_options);
+  const root = (_a = options.root) !== null && _a !== void 0 ? _a : getRootNode(elements[0]);
+  let foundResults = 0;
+  for (const selector of selectorGenerator({
+    elements,
+    options,
+    root,
+    rootSelector: ""
+  })) {
+    yield selector;
+    foundResults++;
+    if (foundResults >= options.maxResults) {
+      return;
+    }
+  }
+  if (elements.length > 1) {
+    yield elements.map((element) => getCssSelector(element, options)).join(SELECTOR_SEPARATOR);
+    foundResults++;
+    if (foundResults >= options.maxResults) {
+      return;
+    }
+  }
+  yield getFallbackSelector(elements, options.useScope ? root : void 0);
+}
+
+// ../../shared-editor-ui/dist/components/BeforeAfterToggle.js
+var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
+
+// ../../shared-editor-ui/dist/components/ConditionStatusLine.js
+var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
+var import_react2 = __toESM(require_react(), 1);
+
+// ../../shared-editor-ui/dist/components/DetectionBadge.js
+var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
+
+// ../../shared-editor-ui/dist/components/DismissedSection.js
+var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
+var import_react3 = __toESM(require_react(), 1);
+
+// ../../shared-editor-ui/dist/components/EditBackButton.js
+var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
+
+// ../../shared-editor-ui/dist/components/EditorBody.js
+var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
+
+// ../../shared-editor-ui/dist/components/EditorCard.js
+var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
+
+// ../../shared-editor-ui/dist/components/EditorFooter.js
+var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
+
+// ../../shared-editor-ui/dist/components/EditorHeader.js
+var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
+
+// ../../shared-editor-ui/dist/components/EditorInput.js
+var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
+var import_react4 = __toESM(require_react(), 1);
+
+// ../../shared-editor-ui/dist/components/EditorLayout.js
+var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
+
+// ../../shared-editor-ui/dist/components/EditorPanelShell.js
+var import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
+
+// ../../design-system/dist/tailwind-preset.js
+var syntroPreset = {
+  darkMode: ["class"],
+  theme: {
+    extend: {
+      colors: {
+        // Base colors
+        white: colors.base.white,
+        black: colors.base.black,
+        // Brand scale
+        brand: {
+          0: colors.brand[0],
+          1: colors.brand[1],
+          2: colors.brand[2],
+          3: colors.brand[3],
+          4: colors.brand[4],
+          5: colors.brand[5],
+          6: colors.brand[6],
+          7: colors.brand[7],
+          8: colors.brand[8],
+          9: colors.brand[9],
+          DEFAULT: colors.brand[3]
+        },
+        // Neutral scale (Slate Grey)
+        "slate-grey": {
+          0: colors.slateGrey[0],
+          1: colors.slateGrey[1],
+          2: colors.slateGrey[2],
+          3: colors.slateGrey[3],
+          4: colors.slateGrey[4],
+          5: colors.slateGrey[5],
+          6: colors.slateGrey[6],
+          7: colors.slateGrey[7],
+          8: colors.slateGrey[8],
+          9: colors.slateGrey[9],
+          10: colors.slateGrey[10],
+          11: colors.slateGrey[11],
+          12: colors.slateGrey[12],
+          DEFAULT: colors.slateGrey[6]
+        },
+        // Semantic color scales
+        green: {
+          0: colors.green[0],
+          1: colors.green[1],
+          2: colors.green[2],
+          3: colors.green[3],
+          4: colors.green[4],
+          5: colors.green[5],
+          6: colors.green[6],
+          7: colors.green[7],
+          8: colors.green[8],
+          9: colors.green[9],
+          DEFAULT: colors.green[4]
+        },
+        yellow: {
+          0: colors.yellow[0],
+          1: colors.yellow[1],
+          2: colors.yellow[2],
+          3: colors.yellow[3],
+          4: colors.yellow[4],
+          5: colors.yellow[5],
+          6: colors.yellow[6],
+          7: colors.yellow[7],
+          8: colors.yellow[8],
+          9: colors.yellow[9],
+          DEFAULT: colors.yellow[4]
+        },
+        red: {
+          0: colors.red[0],
+          1: colors.red[1],
+          2: colors.red[2],
+          3: colors.red[3],
+          4: colors.red[4],
+          5: colors.red[5],
+          6: colors.red[6],
+          7: colors.red[7],
+          8: colors.red[8],
+          9: colors.red[9],
+          DEFAULT: colors.red[4]
+        },
+        blue: {
+          0: colors.blue[0],
+          1: colors.blue[1],
+          2: colors.blue[2],
+          3: colors.blue[3],
+          4: colors.blue[4],
+          5: colors.blue[5],
+          6: colors.blue[6],
+          7: colors.blue[7],
+          8: colors.blue[8],
+          9: colors.blue[9],
+          DEFAULT: colors.blue[4]
+        },
+        orange: {
+          0: colors.orange[0],
+          1: colors.orange[1],
+          2: colors.orange[2],
+          3: colors.orange[3],
+          4: colors.orange[4],
+          5: colors.orange[5],
+          6: colors.orange[6],
+          7: colors.orange[7],
+          8: colors.orange[8],
+          9: colors.orange[9],
+          DEFAULT: colors.orange[3]
+        },
+        purple: {
+          0: colors.purple[0],
+          1: colors.purple[1],
+          2: colors.purple[2],
+          3: colors.purple[3],
+          4: colors.purple[4],
+          5: colors.purple[5],
+          6: colors.purple[6],
+          7: colors.purple[7],
+          8: colors.purple[8],
+          9: colors.purple[9],
+          DEFAULT: colors.purple[4]
+        },
+        pink: {
+          0: colors.pink[0],
+          1: colors.pink[1],
+          2: colors.pink[2],
+          3: colors.pink[3],
+          4: colors.pink[4],
+          5: colors.pink[5],
+          6: colors.pink[6],
+          7: colors.pink[7],
+          8: colors.pink[8],
+          9: colors.pink[9],
+          DEFAULT: colors.pink[4]
+        },
+        // Semantic tokens
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        text: {
+          primary: colors.text.primary,
+          secondary: colors.text.secondary,
+          tertiary: colors.text.tertiary,
+          DEFAULT: colors.text.primary
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        background: {
+          primary: colors.background.primary,
+          secondary: colors.background.secondary,
+          DEFAULT: colors.background.primary
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        border: {
+          primary: colors.border.primary,
+          secondary: colors.border.secondary,
+          DEFAULT: colors.border.primary
+        },
+        // Component tokens - Button
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "btn-primary": {
+          DEFAULT: colors.button.primary.backgroundDefault,
+          hover: colors.button.primary.backgroundHover,
+          text: colors.button.primary.text,
+          border: colors.button.primary.border
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "btn-neutral": {
+          DEFAULT: colors.button.neutral.background,
+          text: colors.button.neutral.text,
+          "text-hover": colors.button.neutral.textHover,
+          border: colors.button.neutral.border
+        },
+        "btn-link": {
+          text: colors.button.link.text,
+          hover: colors.button.link.hover
+        },
+        "btn-error": {
+          text: colors.button.error.text,
+          hover: colors.button.error.hover
+        },
+        "btn-success": {
+          text: colors.button.success.text,
+          hover: colors.button.success.hover
+        },
+        // Component tokens - Card
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        card: {
+          bg: colors.card.background,
+          content: colors.card.content,
+          border: colors.card.border
+        },
+        // Component tokens - Modal
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        modal: {
+          bg: colors.modal.background,
+          content: colors.modal.content,
+          border: colors.modal.border
+        },
+        // Component tokens - Sidebar
+        sidebar: {
+          DEFAULT: colors.sidebar.backgroundDefault,
+          hover: colors.sidebar.backgroundHover,
+          active: colors.sidebar.backgroundActive,
+          border: colors.sidebar.border,
+          "content-primary": colors.sidebar.contentPrimary,
+          "content-secondary": colors.sidebar.contentSecondary,
+          "content-tertiary": colors.sidebar.contentTertiary
+        },
+        // Component tokens - Tab
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        tab: {
+          "active-bg": colors.tab.activeBackground,
+          "active-content": colors.tab.activeContent,
+          "inactive-content": colors.tab.inactiveContent,
+          border: colors.tab.border
+        },
+        // Component tokens - Table
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "table-header": {
+          text: colors.table.header.textDefault,
+          "text-hover": colors.table.header.textHover,
+          bg: colors.table.header.backgroundDefault
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "table-cell": {
+          // biome-ignore lint: Tailwind preset defines semantic token names, not usage of shadcn color classes
+          "text-primary": colors.table.cell.textPrimary,
+          // biome-ignore lint: Tailwind preset defines semantic token names, not usage of shadcn color classes
+          "text-secondary": colors.table.cell.textSecondary,
+          bg: colors.table.cell.backgroundDefault,
+          "bg-hover": colors.table.cell.backgroundHover
+        },
+        "table-border": colors.table.border,
+        // Component tokens - Input
+        "input-field": {
+          bg: colors.inputField.backgroundDefault,
+          "bg-disabled": colors.inputField.backgroundDisabled,
+          "text-label": colors.inputField.textLabel,
+          "text-placeholder": colors.inputField.textPlaceholder,
+          "text-hint": colors.inputField.textHint,
+          "text-error": colors.inputField.textError,
+          border: colors.inputField.borderDefault,
+          "border-selected": colors.inputField.borderSelected,
+          "border-error": colors.inputField.borderError
+        },
+        // Component tokens - Badge (9 variants)
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "badge-slate": {
+          content: colors.badge.slateGrey.content,
+          outline: colors.badge.slateGrey.pillOutline,
+          border: colors.badge.slateGrey.borderPrimary,
+          bg: colors.badge.slateGrey.background
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "badge-brand": {
+          content: colors.badge.brand.content,
+          outline: colors.badge.brand.pillOutline,
+          border: colors.badge.brand.borderPrimary,
+          bg: colors.badge.brand.background
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "badge-green": {
+          content: colors.badge.green.content,
+          outline: colors.badge.green.pillOutline,
+          border: colors.badge.green.borderPrimary,
+          bg: colors.badge.green.background
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "badge-yellow": {
+          content: colors.badge.yellow.content,
+          outline: colors.badge.yellow.pillOutline,
+          border: colors.badge.yellow.borderPrimary,
+          bg: colors.badge.yellow.background
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "badge-red": {
+          content: colors.badge.red.content,
+          outline: colors.badge.red.pillOutline,
+          border: colors.badge.red.borderPrimary,
+          bg: colors.badge.red.background
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "badge-blue": {
+          content: colors.badge.blue.content,
+          outline: colors.badge.blue.pillOutline,
+          border: colors.badge.blue.borderPrimary,
+          bg: colors.badge.blue.background
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "badge-purple": {
+          content: colors.badge.purple.content,
+          outline: colors.badge.purple.pillOutline,
+          border: colors.badge.purple.borderPrimary,
+          bg: colors.badge.purple.background
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "badge-orange": {
+          content: colors.badge.orange.content,
+          outline: colors.badge.orange.pillOutline,
+          border: colors.badge.orange.borderPrimary,
+          bg: colors.badge.orange.background
+        },
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        "badge-pink": {
+          content: colors.badge.pink.content,
+          outline: colors.badge.pink.pillOutline,
+          border: colors.badge.pink.borderPrimary,
+          bg: colors.badge.pink.background
+        },
+        // Component tokens - Toggle
+        toggle: {
+          handle: colors.toggle.handleDefault,
+          "handle-disabled": colors.toggle.handleDisabled,
+          "off-bg": colors.toggle.off.backgroundDefault,
+          "off-bg-hover": colors.toggle.off.backgroundHover,
+          "on-bg": colors.toggle.on.backgroundDefault,
+          "on-bg-hover": colors.toggle.on.backgroundHover
+        },
+        // Component tokens - Menu
+        // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+        menu: {
+          DEFAULT: colors.menu.backgroundDefault,
+          hover: colors.menu.backgroundHover,
+          selected: colors.menu.selected
+        },
+        // Component tokens - Alert
+        "alert-green": {
+          content: colors.alert.green.content,
+          bg: colors.alert.green.background
+        },
+        "alert-yellow": {
+          content: colors.alert.yellow.content,
+          bg: colors.alert.yellow.background
+        },
+        "alert-red": {
+          content: colors.alert.red.content,
+          bg: colors.alert.red.background
+        }
+      },
+      // Typography
+      fontSize: {
+        xs: ["0.75rem", { lineHeight: "1rem" }],
+        sm: ["0.875rem", { lineHeight: "1.25rem" }],
+        base: ["1rem", { lineHeight: "1.5rem" }],
+        lg: ["1.125rem", { lineHeight: "1.75rem" }],
+        xl: ["1.25rem", { lineHeight: "1.75rem" }],
+        "2xl": ["1.5rem", { lineHeight: "2rem" }],
+        "3xl": ["1.875rem", { lineHeight: "2.25rem" }],
+        "4xl": ["2.25rem", { lineHeight: "2.5rem" }],
+        "5xl": ["3rem", { lineHeight: "1" }],
+        "6xl": ["3.75rem", { lineHeight: "1" }]
+      },
+      // Spacing
+      spacing: {
+        0: "0",
+        1: "0.25rem",
+        2: "0.5rem",
+        3: "0.75rem",
+        4: "1rem",
+        5: "1.25rem",
+        6: "1.5rem",
+        8: "2rem",
+        10: "2.5rem",
+        12: "3rem",
+        16: "4rem",
+        20: "5rem",
+        24: "6rem",
+        32: "8rem"
+      },
+      // Border radius
+      borderRadius: {
+        none: "0",
+        sm: "0.125rem",
+        DEFAULT: "0.25rem",
+        md: "0.375rem",
+        lg: "0.5rem",
+        xl: "0.75rem",
+        "2xl": "1rem",
+        "3xl": "1.5rem",
+        full: "9999px"
+      },
+      // Box shadow — Figma shadow scale + product glows + elevation
+      boxShadow: {
+        ...shadows,
+        ...glowShadows,
+        ...elevationShadows,
+        DEFAULT: shadows.sm,
+        // Focus rings (4px spread + xs shadow)
+        "focus-primary": focusRings.primary,
+        "focus-neutral": focusRings.neutral,
+        "focus-error": focusRings.error
+      },
+      // Backdrop blur — Figma scale
+      // biome-ignore lint: Tailwind preset intentionally maps design tokens from source
+      backdropBlur: {
+        sm: backdropBlur.sm,
+        md: backdropBlur.md,
+        lg: backdropBlur.lg,
+        xl: backdropBlur.xl
+      },
+      // Overlay background colors
+      backgroundColor: {
+        "overlay-solid": overlay.solid,
+        "overlay-blur": overlay.blur
+      },
+      // Animation
+      keyframes: {
+        "fade-in": {
+          "0%": { opacity: "0" },
+          "100%": { opacity: "1" }
+        },
+        "fade-out": {
+          "0%": { opacity: "1" },
+          "100%": { opacity: "0" }
+        },
+        "slide-in-from-top": {
+          "0%": { transform: "translateY(-100%)" },
+          "100%": { transform: "translateY(0)" }
+        },
+        "slide-in-from-bottom": {
+          "0%": { transform: "translateY(100%)" },
+          "100%": { transform: "translateY(0)" }
+        },
+        "slide-in-from-left": {
+          "0%": { transform: "translateX(-100%)" },
+          "100%": { transform: "translateX(0)" }
+        },
+        "slide-in-from-right": {
+          "0%": { transform: "translateX(100%)" },
+          "100%": { transform: "translateX(0)" }
+        }
+      },
+      animation: {
+        "fade-in": "fade-in 0.2s ease-out",
+        "fade-out": "fade-out 0.2s ease-out",
+        "slide-in-from-top": "slide-in-from-top 0.3s ease-out",
+        "slide-in-from-bottom": "slide-in-from-bottom 0.3s ease-out",
+        "slide-in-from-left": "slide-in-from-left 0.3s ease-out",
+        "slide-in-from-right": "slide-in-from-right 0.3s ease-out"
+      }
+    }
+  }
+};
+
+// ../../shared-editor-ui/dist/components/EditorPanelShell.js
+var import_react5 = __toESM(require_react(), 1);
+var MIN_WIDTH = panel_shell_default.behavior.minWidth;
+var MIN_HEIGHT = panel_shell_default.behavior.minHeight;
+var FAB_SIZE = panel_shell_default.fab.size;
+var FAB_INSET = panel_shell_default.fab.inset;
+var SNAP_THRESHOLD = panel_shell_default.behavior.snapThreshold;
+var DRAG_THRESHOLD = panel_shell_default.behavior.dragThreshold;
+var HANDLE_SIZE = panel_shell_default.behavior.handleSize;
+var RESIZE_HANDLES = [
+  {
+    dir: "n",
+    style: { top: 0, left: HANDLE_SIZE, right: HANDLE_SIZE, height: HANDLE_SIZE },
+    cursor: "ns-resize"
+  },
+  {
+    dir: "s",
+    style: { bottom: 0, left: HANDLE_SIZE, right: HANDLE_SIZE, height: HANDLE_SIZE },
+    cursor: "ns-resize"
+  },
+  {
+    dir: "e",
+    style: { right: 0, top: HANDLE_SIZE, bottom: HANDLE_SIZE, width: HANDLE_SIZE },
+    cursor: "ew-resize"
+  },
+  {
+    dir: "w",
+    style: { left: 0, top: HANDLE_SIZE, bottom: HANDLE_SIZE, width: HANDLE_SIZE },
+    cursor: "ew-resize"
+  },
+  {
+    dir: "ne",
+    style: { top: 0, right: 0, width: HANDLE_SIZE * 2, height: HANDLE_SIZE * 2 },
+    cursor: "nesw-resize"
+  },
+  {
+    dir: "nw",
+    style: { top: 0, left: 0, width: HANDLE_SIZE * 2, height: HANDLE_SIZE * 2 },
+    cursor: "nwse-resize"
+  },
+  {
+    dir: "se",
+    style: { bottom: 0, right: 0, width: HANDLE_SIZE * 2, height: HANDLE_SIZE * 2 },
+    cursor: "nwse-resize"
+  },
+  {
+    dir: "sw",
+    style: { bottom: 0, left: 0, width: HANDLE_SIZE * 2, height: HANDLE_SIZE * 2 },
+    cursor: "nesw-resize"
+  }
+];
+
+// ../../shared-editor-ui/dist/components/EditorSelect.js
+var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
+var import_react6 = __toESM(require_react(), 1);
+
+// ../../shared-editor-ui/dist/components/EditorTextarea.js
+var import_jsx_runtime15 = __toESM(require_jsx_runtime(), 1);
+var import_react7 = __toESM(require_react(), 1);
+
+// ../../shared-editor-ui/dist/components/ElementHighlight.js
+var import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
+var import_react_dom2 = __toESM(require_react_dom(), 1);
+
+// ../../shared-editor-ui/dist/hooks/useElementRect.js
+var import_react8 = __toESM(require_react(), 1);
+
+// ../../shared-editor-ui/dist/components/EmptyState.js
+var import_jsx_runtime17 = __toESM(require_jsx_runtime(), 1);
+
+// ../../shared-editor-ui/dist/components/GroupHeader.js
+var import_jsx_runtime18 = __toESM(require_jsx_runtime(), 1);
+
+// ../../shared-editor-ui/dist/components/itemCardHeader.js
+import { html, nothing } from "lit";
+function itemCardHeader(opts) {
+  const { label, labelClickable = false, onLabelClick, kindShort, statusPill = nothing, onDelete, deleteTestid, deleteLabel = "Delete" } = opts;
+  return html`
+    <div class="se-flex se-items-center se-gap-2">
+      <span
+        role=${labelClickable ? "button" : nothing}
+        tabindex=${labelClickable ? "0" : nothing}
+        @click=${labelClickable && onLabelClick ? onLabelClick : nothing}
+        @keydown=${labelClickable && onLabelClick ? (e) => {
+    if (e.key === "Enter" || e.key === " ") {
+      e.preventDefault();
+      onLabelClick();
+    }
+  } : nothing}
+        class="se-flex-1 se-overflow-hidden se-text-ellipsis se-whitespace-nowrap se-text-sm se-text-text-primary ${labelClickable ? "se-cursor-pointer" : ""}"
+      >
+        ${label}
+      </span>
+      ${kindShort ? html`<span class="se-text-[10px] se-text-text-tertiary se-uppercase">${kindShort}</span>` : nothing}
+      ${statusPill}
+      ${onDelete ? html`<button
+              type="button"
+              data-testid=${deleteTestid ?? "delete-item"}
+              aria-label=${deleteLabel}
+              @click=${(e) => {
+    e.stopPropagation();
+    onDelete(e);
+  }}
+              class="se-shrink-0 se-px-1.5 se-py-0.5 se-text-xs se-text-text-tertiary hover:se-text-red-4 se-bg-transparent se-border-none se-cursor-pointer"
+            >✕</button>` : nothing}
+    </div>
+  `;
+}
+
+// ../../shared-editor-ui/dist/components/TriggerJourney.js
+var import_jsx_runtime19 = __toESM(require_jsx_runtime(), 1);
+
+// ../../shared-editor-ui/dist/controllers/PanelShellController.js
+var DEFAULTS = {
+  minWidth: panel_shell_default.behavior.minWidth,
+  minHeight: panel_shell_default.behavior.minHeight,
+  dragThreshold: panel_shell_default.behavior.dragThreshold,
+  snapThreshold: panel_shell_default.behavior.snapThreshold,
+  fabSize: panel_shell_default.fab.size,
+  fabInset: panel_shell_default.fab.inset,
+  storageKey: "syntro:editor-panel"
+};
+var HANDLE_SIZE2 = panel_shell_default.behavior.handleSize;
+
+// ../../shared-editor-ui/dist/hooks/useTriggerWhenStatus.js
+var import_react9 = __toESM(require_react(), 1);
+
+// ../../../tests/fixtures/action-step-field-mapping.json
+var action_step_field_mapping_default = {
+  field_mapping: {
+    event: {
+      action_step_key: "event",
+      hogql: "event",
+      athena: "event_category",
+      athena_transform: "category_map",
+      runtime_event_field: "name",
+      runtime_transform: "event_name_map"
+    },
+    text: {
+      action_step_key: "text",
+      hogql: "properties.$el_text",
+      athena: "el_text",
+      runtime_element_field: "$el_text"
+    },
+    tag_name: {
+      action_step_key: "tag_name",
+      hogql: "properties.$el_tag_name",
+      athena: "tag_name",
+      runtime_element_field: "tag_name"
+    },
+    url: {
+      action_step_key: "url",
+      hogql: "properties.$current_url",
+      hogql_match: "like",
+      athena: "pathname",
+      athena_match: "like",
+      athena_transform: "url_to_path",
+      runtime_prop: "url"
+    },
+    selector: {
+      action_step_key: "selector",
+      hogql: "properties.$el_selector",
+      athena: "el_selector",
+      runtime_element_field: null
+    }
+  },
+  event_category_map: {
+    $autocapture: "click",
+    $pageview: "pageview",
+    $pageleave: "pageleave",
+    $feature_flag_called: "feature_flag"
+  },
+  event_name_map: {
+    $autocapture: "ui.click",
+    $pageview: "nav.page_view",
+    $pageleave: "nav.page_leave"
+  },
+  interactive_tags: ["a", "button", "input", "select", "textarea", "form", "summary"],
+  interactive_roles: [
+    "button",
+    "link",
+    "menuitem",
+    "tab",
+    "switch",
+    "checkbox",
+    "radio",
+    "option"
+  ],
+  test_cases: [
+    {
+      name: "CTA button click \u2014 span inside anchor",
+      action_step: {
+        event: "$autocapture",
+        tag_name: "a",
+        text: "Start Free Filing"
+      },
+      posthog_event: {
+        event: "$autocapture",
+        properties: {
+          $current_url: "https://taxinator.com/",
+          $el_text: "Start Free Filing",
+          $elements: [
+            { tag_name: "span", $el_text: "Start Free Filing" },
+            {
+              tag_name: "a",
+              $el_text: "Start Free Filing \u2192",
+              attr__href: "/dashboard",
+              "attr__data-cta": "hero-primary"
+            },
+            { tag_name: "div", $el_text: "" },
+            { tag_name: "section", $el_text: "" }
+          ]
+        }
+      },
+      should_match_hogql: true,
+      should_match_athena: true,
+      recommended_index: 1,
+      expected_action_step_from_recommended: {
+        event: "$autocapture",
+        tag_name: "a",
+        text: "Start Free Filing \u2192",
+        url: "https://taxinator.com/"
+      }
+    },
+    {
+      name: "Pageview from link href",
+      action_step: {
+        event: "$pageview",
+        url: "/pricing"
+      },
+      posthog_event: {
+        event: "$pageview",
+        properties: {
+          $current_url: "https://taxinator.com/pricing",
+          $elements: [
+            { tag_name: "a", $el_text: "See Plans & Pricing", attr__href: "/pricing" }
+          ]
+        }
+      },
+      should_match_hogql: true,
+      should_match_athena: true,
+      recommended_index: 0,
+      expected_action_step_from_recommended: {
+        event: "$pageview",
+        tag_name: "a",
+        text: "See Plans & Pricing",
+        url: "https://taxinator.com/pricing"
+      }
+    },
+    {
+      name: "Non-matching \u2014 wrong tag and text",
+      action_step: {
+        event: "$autocapture",
+        tag_name: "button",
+        text: "Submit"
+      },
+      posthog_event: {
+        event: "$autocapture",
+        properties: {
+          $current_url: "https://taxinator.com/",
+          $el_text: "Cancel",
+          $elements: [
+            { tag_name: "span", $el_text: "Cancel" },
+            { tag_name: "a", $el_text: "Cancel", attr__href: "/home" }
+          ]
+        }
+      },
+      should_match_hogql: false,
+      should_match_athena: false,
+      recommended_index: 1,
+      expected_action_step_from_recommended: {
+        event: "$autocapture",
+        tag_name: "a",
+        text: "Cancel",
+        url: "https://taxinator.com/"
+      }
+    },
+    {
+      name: "Selector only \u2014 matches HogQL and Athena",
+      action_step: {
+        event: "$autocapture",
+        selector: "#signup-btn"
+      },
+      posthog_event: {
+        event: "$autocapture",
+        properties: {
+          $current_url: "https://taxinator.com/",
+          $el_selector: "#signup-btn",
+          $elements: [
+            { tag_name: "button", $el_text: "Sign Up", $el_selector: "#signup-btn" }
+          ]
+        }
+      },
+      should_match_hogql: true,
+      should_match_athena: true,
+      recommended_index: 0,
+      expected_action_step_from_recommended: {
+        event: "$autocapture",
+        tag_name: "button",
+        text: "Sign Up",
+        url: "https://taxinator.com/",
+        selector: "#signup-btn"
+      }
+    },
+    {
+      name: "No interactive ancestor \u2014 falls back to elements[0]",
+      action_step: {
+        event: "$autocapture",
+        tag_name: "div",
+        text: "Hero Banner"
+      },
+      posthog_event: {
+        event: "$autocapture",
+        properties: {
+          $current_url: "https://taxinator.com/",
+          $el_text: "Hero Banner",
+          $elements: [
+            { tag_name: "div", $el_text: "Hero Banner" },
+            { tag_name: "section", $el_text: "" },
+            { tag_name: "main", $el_text: "" }
+          ]
+        }
+      },
+      should_match_hogql: true,
+      should_match_athena: true,
+      recommended_index: 0,
+      expected_action_step_from_recommended: {
+        event: "$autocapture",
+        tag_name: "div",
+        text: "Hero Banner",
+        url: "https://taxinator.com/"
+      }
+    }
+  ]
+};
+
+// ../../shared-editor-ui/dist/utils/elementChainRecommender.js
+var INTERACTIVE_TAGS = new Set(action_step_field_mapping_default.interactive_tags);
+var INTERACTIVE_ROLES = new Set(action_step_field_mapping_default.interactive_roles);
+
 // src/editor.ts
-import { html, LitElement, nothing } from "lit";
+import { html as html10, LitElement as LitElement9, nothing as nothing5 } from "lit";
+
+// ../../shared-editor-ui/src/components/AnchorPickerLit.ts
+import { html as html2, LitElement, render as litRender, nothing as nothing2 } from "lit";
+import { styleMap } from "lit/directives/style-map.js";
+
+// ../../shared-editor-ui/src/utils/selectorGenerator.ts
+var DEFAULT_OPTIONS2 = {
+  includeTag: true,
+  preferTestIds: true,
+  maxCombinations: 100
+};
+function generateSelector2(element, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  const selectors = [];
+  selectors.push("id");
+  if (opts.preferTestIds) {
+    selectors.push("attribute");
+  }
+  selectors.push("class");
+  selectors.push("tag");
+  selectors.push("nthchild");
+  selectors.push("nthoftype");
+  try {
+    const selector = getCssSelector(element, {
+      selectors,
+      includeTag: opts.includeTag,
+      maxCombinations: opts.maxCombinations,
+      // Blacklist common dynamic class patterns
+      blacklist: [
+        // Dynamic class patterns
+        /^[a-z]+-[a-f0-9]{5,}$/i,
+        // hash-based classes like "css-1abc23"
+        /^_[a-zA-Z0-9]+$/,
+        // CSS module classes like "_1abc23"
+        /^svelte-[a-z0-9]+$/i,
+        // Svelte scoped classes
+        /^vue-[a-z0-9]+$/i,
+        // Vue scoped classes
+        /^emotion-[0-9]+$/,
+        // Emotion CSS-in-JS
+        /^sc-[a-zA-Z]+$/,
+        // styled-components
+        // State classes that may change
+        /^(is-|has-|js-)/,
+        /^(active|selected|focused|disabled|hidden|visible)$/,
+        // Animation/transition classes
+        /^(fade|slide|animate)/,
+        /-(enter|leave|active)(-active|-done)?$/
+      ],
+      // Whitelist stable attribute selectors
+      whitelist: [
+        /^data-testid$/,
+        /^data-cy$/,
+        /^data-test$/,
+        /^data-qa$/,
+        /^aria-label$/,
+        /^role$/,
+        /^name$/,
+        /^type$/,
+        /^href$/
+      ]
+    });
+    return selector;
+  } catch (error) {
+    console.warn("[SelectorGenerator] Failed to generate selector:", error);
+    return generateFallbackSelector(element);
+  }
+}
+function generateFallbackSelector(element) {
+  const path = [];
+  let current = element;
+  while (current && current !== document.body && current !== document.documentElement) {
+    let selector = current.tagName.toLowerCase();
+    if (current.id) {
+      selector = `#${CSS.escape(current.id)}`;
+      path.unshift(selector);
+      break;
+    }
+    const parent = current.parentElement;
+    if (parent) {
+      const siblings = Array.from(parent.children);
+      const index = siblings.indexOf(current) + 1;
+      selector += `:nth-child(${index})`;
+    }
+    path.unshift(selector);
+    current = parent;
+  }
+  return path.join(" > ");
+}
+function validateSelector2(selector, expectedElement) {
+  try {
+    const matched = document.querySelector(selector);
+    return matched === expectedElement;
+  } catch {
+    return false;
+  }
+}
+function getElementDescription2(element) {
+  const tag = element.tagName.toLowerCase();
+  const id = element.id ? `#${element.id}` : "";
+  const classes = element.className && typeof element.className === "string" ? `.${element.className.split(" ").filter((c) => c && !isDynamicClass(c)).slice(0, 2).join(".")}` : "";
+  const text = element.textContent?.trim().slice(0, 30) || "";
+  const textPreview = text ? ` "${text}${text.length >= 30 ? "..." : ""}"` : "";
+  return `${tag}${id}${classes}${textPreview}`.trim();
+}
+function isDynamicClass(className) {
+  const dynamicPatterns = [
+    /^[a-z]+-[a-f0-9]{5,}$/i,
+    /^_[a-zA-Z0-9]+$/,
+    /^svelte-[a-z0-9]+$/i,
+    /^vue-[a-z0-9]+$/i,
+    /^emotion-[0-9]+$/,
+    /^sc-[a-zA-Z]+$/
+  ];
+  return dynamicPatterns.some((pattern) => pattern.test(className));
+}
+
+// ../../shared-editor-ui/src/components/AnchorPickerLit.ts
+var HIGHLIGHT_COLOR = colors_default.blue[4];
+var HIGHLIGHT_BG = "rgba(25, 105, 254, 0.1)";
+var DEFAULT_EXCLUDE_SELECTOR = "[data-syntro-editor-panel], [data-shadow-canvas-id], .syntro-tooltip, .syntro-modal, .syntro-highlight, [data-syntro-anchor-picker]";
+var AnchorPickerLit = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.isActive = false;
+    this.passthroughClicks = false;
+    this.excludeSelector = DEFAULT_EXCLUDE_SELECTOR;
+    // Internal state
+    this._hoveredElement = null;
+    this._hoveredSelector = "";
+    // DOM ref for the overlay (lives in _portalDiv, not in this element)
+    this._overlayEl = null;
+    // Portal div appended to document.body to escape backdrop-filter containing block
+    this._portalDiv = null;
+    this._handleMouseMove = (e) => {
+      const overlay2 = this._overlayEl;
+      const shadowHost = this._getShadowHost();
+      if (overlay2 && !this.passthroughClicks) {
+        overlay2.style.pointerEvents = "none";
+      }
+      const prevHostVis = shadowHost?.style.visibility;
+      if (shadowHost) shadowHost.style.visibility = "hidden";
+      const elementAtPoint = document.elementFromPoint(e.clientX, e.clientY);
+      if (shadowHost) shadowHost.style.visibility = prevHostVis ?? "";
+      if (overlay2 && !this.passthroughClicks) {
+        overlay2.style.pointerEvents = "auto";
+      }
+      if (!elementAtPoint) {
+        this._hoveredElement = null;
+        this._hoveredSelector = "";
+        return;
+      }
+      if (this.excludeSelector && elementAtPoint.closest(this.excludeSelector)) {
+        this._hoveredElement = null;
+        this._hoveredSelector = "";
+        return;
+      }
+      if (["HTML", "BODY", "HEAD"].includes(elementAtPoint.tagName)) {
+        this._hoveredElement = null;
+        this._hoveredSelector = "";
+        return;
+      }
+      this._hoveredElement = elementAtPoint;
+      this._hoveredSelector = generateSelector2(elementAtPoint);
+    };
+    this._handleClick = (e) => {
+      if (this.passthroughClicks) return;
+      e.preventDefault();
+      e.stopPropagation();
+      if (this._hoveredElement && this._hoveredSelector) {
+        let selector = this._hoveredSelector;
+        if (!validateSelector2(selector, this._hoveredElement)) {
+          selector = generateSelector2(this._hoveredElement);
+        }
+        this.dispatchEvent(
+          new CustomEvent("pick", {
+            detail: {
+              element: this._hoveredElement,
+              selector,
+              description: getElementDescription2(this._hoveredElement)
+            },
+            bubbles: true,
+            composed: true
+          })
+        );
+      }
+    };
+    this._handleKeyDown = (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        this.dispatchEvent(
+          new CustomEvent("cancel", {
+            bubbles: true,
+            composed: true
+          })
+        );
+      }
+    };
+  }
+  // No _bound* wrappers needed — methods are arrow class fields
+  createRenderRoot() {
+    return this;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (this.isActive) {
+      this._attachDocumentListeners();
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._detachDocumentListeners();
+    this._destroyPortal();
+  }
+  updated(changed) {
+    if (changed.has("isActive")) {
+      if (this.isActive) {
+        this._attachDocumentListeners();
+      } else {
+        this._detachDocumentListeners();
+        this._hoveredElement = null;
+        this._hoveredSelector = "";
+      }
+    }
+    this._syncPortal();
+  }
+  // ---- PORTAL MANAGEMENT ----
+  /**
+   * Create or update the body-level portal div.
+   * Rendering into document.body ensures position:fixed coordinates are
+   * relative to the viewport, not an ancestor with backdrop-filter.
+   */
+  _syncPortal() {
+    if (!this.isActive) {
+      this._destroyPortal();
+      return;
+    }
+    if (!this._portalDiv) {
+      this._portalDiv = document.createElement("div");
+      this._portalDiv.setAttribute("data-syntro-anchor-picker-container", "");
+      document.body.appendChild(this._portalDiv);
+    }
+    litRender(this._overlayTemplate(), this._portalDiv);
+    this._overlayEl = this._portalDiv.querySelector("[data-syntro-anchor-picker]");
+  }
+  _destroyPortal() {
+    if (this._portalDiv) {
+      litRender(nothing2, this._portalDiv);
+      this._portalDiv.remove();
+      this._portalDiv = null;
+      this._overlayEl = null;
+    }
+  }
+  // ---- DOCUMENT LISTENERS ----
+  _attachDocumentListeners() {
+    document.addEventListener("mousemove", this._handleMouseMove, true);
+    if (!this.passthroughClicks) {
+      document.addEventListener("click", this._handleClick, true);
+    }
+    document.addEventListener("keydown", this._handleKeyDown, true);
+  }
+  _detachDocumentListeners() {
+    document.removeEventListener("mousemove", this._handleMouseMove, true);
+    document.removeEventListener("click", this._handleClick, true);
+    document.removeEventListener("keydown", this._handleKeyDown, true);
+  }
+  // ---- EVENT HANDLERS ----
+  /**
+   * Resolve the shadow host this picker lives inside, if any. When the picker
+   * is mounted inside a shadow root (e.g. the editor SDK mounts inside
+   * `<smart-canvas>`'s shadow), `document.elementFromPoint` returns the shadow
+   * *host*, not the host page element beneath. Temporarily disabling pointer
+   * events on the host lets hit-testing fall through to the host page.
+   */
+  _getShadowHost() {
+    const root = this.getRootNode();
+    if (root instanceof ShadowRoot) return root.host;
+    return null;
+  }
+  // ---- RENDER ----
+  // The component itself renders nothing — all overlay HTML lives in _portalDiv
+  // (a div appended to document.body), managed by _syncPortal().
+  render() {
+    return nothing2;
+  }
+  _overlayTemplate() {
+    if (!this.isActive) return nothing2;
+    const hovered = this._hoveredElement;
+    const rect = hovered?.getBoundingClientRect() ?? null;
+    return html2`
+      <div
+        data-syntro-anchor-picker
+        style=${styleMap({
+      position: "fixed",
+      inset: "0",
+      cursor: "crosshair",
+      zIndex: "2147483644",
+      pointerEvents: this.passthroughClicks ? "none" : "auto"
+    })}
+      >
+        <!-- Semi-transparent overlay -->
+        <div
+          style=${styleMap({
+      position: "absolute",
+      inset: "0",
+      background: "rgba(0, 0, 0, 0.08)",
+      pointerEvents: "none"
+    })}
+        ></div>
+
+        <!-- Element highlight -->
+        ${hovered && rect ? html2`<div
+              style=${styleMap({
+      position: "fixed",
+      left: `${rect.left - 2}px`,
+      top: `${rect.top - 2}px`,
+      width: `${rect.width + 4}px`,
+      height: `${rect.height + 4}px`,
+      border: `2px solid ${HIGHLIGHT_COLOR}`,
+      backgroundColor: HIGHLIGHT_BG,
+      borderRadius: "4px",
+      boxShadow: "0 0 0 9999px rgba(0, 0, 0, 0.2)",
+      pointerEvents: "none",
+      transition: "all 0.1s ease-out"
+    })}
+            ></div>` : nothing2}
+
+        <!-- Element info tooltip near hovered element -->
+        ${hovered && rect ? html2`<div
+              class="se-text-xs"
+              style=${styleMap({
+      position: "fixed",
+      left: `${Math.max(8, Math.min(rect.left, window.innerWidth - 320))}px`,
+      top: `${Math.max(8, rect.top - 68)}px`,
+      backgroundColor: colors_default.slateGrey[3],
+      color: colors_default.slateGrey[11],
+      padding: "8px 12px",
+      borderRadius: "6px",
+      boxShadow: "0 4px 12px rgba(0, 0, 0, 0.3)",
+      zIndex: "1",
+      fontFamily: "monospace",
+      maxWidth: "300px",
+      pointerEvents: "none"
+    })}
+            >
+              <div
+                class="se-text-xs"
+                style=${styleMap({
+      textTransform: "uppercase",
+      letterSpacing: "0.05em",
+      marginBottom: "4px",
+      color: colors_default.slateGrey[9]
+    })}
+              >
+                Click to select
+              </div>
+              <div
+                style=${styleMap({
+      color: colors_default.blue[5],
+      overflow: "hidden",
+      textOverflow: "ellipsis",
+      whiteSpace: "nowrap"
+    })}
+              >
+                ${this._hoveredSelector}
+              </div>
+              <div
+                style=${styleMap({
+      marginTop: "4px",
+      color: colors_default.slateGrey[10],
+      overflow: "hidden",
+      textOverflow: "ellipsis",
+      whiteSpace: "nowrap"
+    })}
+              >
+                ${getElementDescription2(hovered)}
+              </div>
+            </div>` : nothing2}
+      </div>
+    `;
+  }
+};
+AnchorPickerLit.properties = {
+  isActive: { type: Boolean, attribute: "is-active" },
+  passthroughClicks: { type: Boolean, attribute: "passthrough-clicks" },
+  excludeSelector: { type: String, attribute: "exclude-selector" },
+  // Internal reactive state (not attributes)
+  _hoveredElement: { state: true },
+  _hoveredSelector: { state: true }
+};
+if (!customElements.get("se-anchor-picker")) {
+  customElements.define("se-anchor-picker", AnchorPickerLit);
+}
+
+// ../../shared-editor-ui/src/components/AnchorPillLit.ts
+import { html as html3, LitElement as LitElement2 } from "lit";
+var AnchorPillLit = class extends LitElement2 {
+  constructor() {
+    super(...arguments);
+    this.state = "missing";
+    this.route = void 0;
+    this.selector = void 0;
+    this.testidKey = "no-anchor";
+    this.testidPrefix = "anchor-pill";
+    this._onLocate = (e) => {
+      e.stopPropagation();
+      this.dispatchEvent(
+        new CustomEvent("se-anchor-locate", {
+          detail: { selector: this.selector },
+          bubbles: true,
+          composed: true
+        })
+      );
+    };
+    this._onNavigate = (e) => {
+      e.stopPropagation();
+      if (!this.route) return;
+      this.dispatchEvent(
+        new CustomEvent("se-anchor-navigate", {
+          detail: { route: this.route },
+          bubbles: true,
+          composed: true
+        })
+      );
+    };
+  }
+  createRenderRoot() {
+    return this;
+  }
+  render() {
+    const baseCls = "se-shrink-0 se-inline-flex se-items-center se-justify-center se-gap-1 se-px-3 se-py-1 se-rounded-md se-border se-text-xs se-font-semibold se-leading-5 se-cursor-pointer se-whitespace-nowrap";
+    const greenCls = "se-border-green-4/60 se-bg-green-4/10 se-text-green-5 hover:se-bg-green-4/20";
+    const redCls = "se-border-red-4/60 se-bg-red-4/10 se-text-red-5 se-cursor-not-allowed";
+    const testid = `${this.testidPrefix}-${this.testidKey}`;
+    if (this.state === "locate") {
+      return html3`<button
+        type="button"
+        data-testid=${testid}
+        data-state="locate"
+        title="Scroll to element"
+        @click=${this._onLocate}
+        class="${baseCls} ${greenCls}"
+      >
+        Locate
+      </button>`;
+    }
+    if (this.state === "navigate" && this.route) {
+      return html3`<button
+        type="button"
+        data-testid=${testid}
+        data-state="navigate"
+        title=${`Navigate to ${this.route}`}
+        @click=${this._onNavigate}
+        class="${baseCls} ${greenCls}"
+      >
+        Go to ${this.route}
+      </button>`;
+    }
+    return html3`<span
+      data-testid=${testid}
+      data-state="missing"
+      title="Anchor not available on this page"
+      class="${baseCls} ${redCls}"
+    >
+      Not found
+    </span>`;
+  }
+};
+AnchorPillLit.properties = {
+  state: { type: String },
+  route: { type: String },
+  selector: { type: String },
+  /** Stable id used to build a deterministic data-testid. */
+  testidKey: { type: String, attribute: "testid-key" },
+  /** Prefix for the data-testid: e.g. "locate-content", "locate-overlay". */
+  testidPrefix: { type: String, attribute: "testid-prefix" }
+};
+if (!customElements.get("se-anchor-pill")) {
+  customElements.define("se-anchor-pill", AnchorPillLit);
+}
+
+// ../../shared-editor-ui/src/components/EditorCardLit.ts
+import { html as html4, LitElement as LitElement3 } from "lit";
+var EditorCardLit = class extends LitElement3 {
+  constructor() {
+    super(...arguments);
+    this.itemKey = "";
+    this.validated = false;
+    this.clickable = false;
+    this._handleClick = () => {
+      if (!this.clickable) return;
+      this.dispatchEvent(
+        new CustomEvent("card-click", {
+          detail: { itemKey: this.itemKey },
+          bubbles: true,
+          composed: true
+        })
+      );
+    };
+    this._handleKeyDown = (e) => {
+      if (!this.clickable) return;
+      if (e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        this._handleClick();
+      }
+    };
+    this._handleMouseEnter = () => {
+      this.dispatchEvent(
+        new CustomEvent("card-mouseenter", {
+          detail: { itemKey: this.itemKey },
+          bubbles: true,
+          composed: true
+        })
+      );
+    };
+    this._handleMouseLeave = () => {
+      this.dispatchEvent(
+        new CustomEvent("card-mouseleave", {
+          detail: { itemKey: this.itemKey },
+          bubbles: true,
+          composed: true
+        })
+      );
+    };
+  }
+  render() {
+    const base = "py-2 px-2.5 rounded-lg border shadow-sm mb-1 text-sm";
+    const borderCls = this.validated ? "border-green-500/50" : "border-white/10";
+    const bgCls = "bg-white/[0.02]";
+    const colorCls = "text-slate-200";
+    const interactiveCls = this.clickable ? "cursor-pointer hover:border-white/20 hover:bg-white/[0.04] transition-colors" : "";
+    return html4`
+      <style>
+        :host { display: block; }
+        .card {
+          padding: 8px 10px;
+          border-radius: 8px;
+          border: 1px solid rgba(255,255,255,0.1);
+          background: rgba(255,255,255,0.02);
+          box-shadow: 0 1px 2px rgba(0,0,0,0.1);
+          margin-bottom: 4px;
+          font-size: 14px;
+          color: #e2e8f0;
+        }
+        .card.validated {
+          border-color: rgba(34,197,94,0.5);
+          box-shadow: 0 0 8px rgba(34,197,94,0.15);
+        }
+        .card.clickable {
+          cursor: pointer;
+          transition: border-color 0.15s, background 0.15s;
+        }
+        .card.clickable:hover {
+          border-color: rgba(255,255,255,0.2);
+          background: rgba(255,255,255,0.04);
+        }
+      </style>
+      <div
+        class="card ${this.validated ? "validated" : ""} ${this.clickable ? "clickable" : ""}"
+        data-item-key=${this.itemKey}
+        role=${this.clickable ? "button" : ""}
+        tabindex=${this.clickable ? "0" : ""}
+        @click=${this._handleClick}
+        @keydown=${this._handleKeyDown}
+        @mouseenter=${this._handleMouseEnter}
+        @mouseleave=${this._handleMouseLeave}
+      >
+        <slot></slot>
+      </div>
+    `;
+  }
+};
+EditorCardLit.properties = {
+  itemKey: { type: String, attribute: "item-key" },
+  cardClass: { type: String, attribute: "card-class" },
+  validated: { type: Boolean },
+  clickable: { type: Boolean }
+};
+if (!customElements.get("se-editor-card")) {
+  customElements.define("se-editor-card", EditorCardLit);
+}
+
+// ../../shared-editor-ui/src/components/EditorPanelShellLit.ts
+import { html as html5, LitElement as LitElement4, nothing as nothing3 } from "lit";
+import { styleMap as styleMap2 } from "lit/directives/style-map.js";
+var STORAGE_KEY = "syntro:editor-panel";
+var MIN_WIDTH2 = panel_shell_default.behavior.minWidth;
+var MIN_HEIGHT2 = panel_shell_default.behavior.minHeight;
+var FAB_SIZE2 = panel_shell_default.fab.size;
+var FAB_INSET2 = panel_shell_default.fab.inset;
+var SNAP_THRESHOLD2 = panel_shell_default.behavior.snapThreshold;
+var DRAG_THRESHOLD2 = panel_shell_default.behavior.dragThreshold;
+var HANDLE_SIZE3 = panel_shell_default.behavior.handleSize;
+function getDefaultGeometry() {
+  return {
+    x: 0,
+    y: 0,
+    width: MIN_WIDTH2,
+    height: typeof window !== "undefined" ? window.innerHeight : 800,
+    docked: "left"
+  };
+}
+function loadGeometry(storageKey) {
+  if (typeof window === "undefined") return getDefaultGeometry();
+  try {
+    const raw = localStorage.getItem(storageKey);
+    if (raw) {
+      const parsed = JSON.parse(raw);
+      return {
+        x: typeof parsed.x === "number" ? parsed.x : 0,
+        y: typeof parsed.y === "number" ? parsed.y : 0,
+        width: Math.max(MIN_WIDTH2, typeof parsed.width === "number" ? parsed.width : MIN_WIDTH2),
+        height: Math.max(
+          MIN_HEIGHT2,
+          typeof parsed.height === "number" ? parsed.height : window.innerHeight
+        ),
+        docked: parsed.docked === "left" || parsed.docked === "right" ? parsed.docked : null
+      };
+    }
+  } catch {
+  }
+  return getDefaultGeometry();
+}
+function saveGeometry(storageKey, geo) {
+  try {
+    localStorage.setItem(storageKey, JSON.stringify(geo));
+  } catch {
+  }
+}
+function getPanelRect(geo) {
+  if (geo.docked === "left") {
+    return { top: 0, left: 0, width: geo.width, height: window.innerHeight };
+  }
+  if (geo.docked === "right") {
+    return {
+      top: 0,
+      left: window.innerWidth - geo.width,
+      width: geo.width,
+      height: window.innerHeight
+    };
+  }
+  const { x: left, y: top, width, height } = geo;
+  return { top, left, width, height };
+}
+function getFabPosition(geo) {
+  const rect = getPanelRect(geo);
+  return {
+    left: rect.left + FAB_INSET2,
+    top: rect.top + FAB_INSET2
+  };
+}
+function clampToViewport(geo) {
+  if (geo.docked) return geo;
+  const vw = window.innerWidth;
+  const vh = window.innerHeight;
+  return {
+    ...geo,
+    x: Math.max(-(geo.width - FAB_SIZE2), Math.min(geo.x, vw - FAB_SIZE2)),
+    y: Math.max(-FAB_INSET2, Math.min(geo.y, vh - FAB_SIZE2 - FAB_INSET2))
+  };
+}
+function undockGeometry(geo) {
+  const rect = getPanelRect(geo);
+  return {
+    x: rect.left,
+    y: rect.top,
+    width: geo.width,
+    height: rect.height,
+    docked: null
+  };
+}
+var RESIZE_HANDLES2 = [
+  {
+    dir: "n",
+    style: {
+      top: "0",
+      left: `${HANDLE_SIZE3}px`,
+      right: `${HANDLE_SIZE3}px`,
+      height: `${HANDLE_SIZE3}px`
+    },
+    cursor: "ns-resize"
+  },
+  {
+    dir: "s",
+    style: {
+      bottom: "0",
+      left: `${HANDLE_SIZE3}px`,
+      right: `${HANDLE_SIZE3}px`,
+      height: `${HANDLE_SIZE3}px`
+    },
+    cursor: "ns-resize"
+  },
+  {
+    dir: "e",
+    style: {
+      right: "0",
+      top: `${HANDLE_SIZE3}px`,
+      bottom: `${HANDLE_SIZE3}px`,
+      width: `${HANDLE_SIZE3}px`
+    },
+    cursor: "ew-resize"
+  },
+  {
+    dir: "w",
+    style: {
+      left: "0",
+      top: `${HANDLE_SIZE3}px`,
+      bottom: `${HANDLE_SIZE3}px`,
+      width: `${HANDLE_SIZE3}px`
+    },
+    cursor: "ew-resize"
+  },
+  {
+    dir: "ne",
+    style: { top: "0", right: "0", width: `${HANDLE_SIZE3 * 2}px`, height: `${HANDLE_SIZE3 * 2}px` },
+    cursor: "nesw-resize"
+  },
+  {
+    dir: "nw",
+    style: { top: "0", left: "0", width: `${HANDLE_SIZE3 * 2}px`, height: `${HANDLE_SIZE3 * 2}px` },
+    cursor: "nwse-resize"
+  },
+  {
+    dir: "se",
+    style: {
+      bottom: "0",
+      right: "0",
+      width: `${HANDLE_SIZE3 * 2}px`,
+      height: `${HANDLE_SIZE3 * 2}px`
+    },
+    cursor: "nwse-resize"
+  },
+  {
+    dir: "sw",
+    style: {
+      bottom: "0",
+      left: "0",
+      width: `${HANDLE_SIZE3 * 2}px`,
+      height: `${HANDLE_SIZE3 * 2}px`
+    },
+    cursor: "nesw-resize"
+  }
+];
+var syntroLogoSvg = html5`<svg
+  aria-hidden="true"
+  width="28"
+  height="18"
+  viewBox="0 0 101 63"
+  fill="none"
+  xmlns="http://www.w3.org/2000/svg"
+>
+  <g clip-path="url(#syntro-fab-clip)">
+    <path
+      d="M51.989 0.284C52.386 0.29 52.808 0.341 53.192 0.443C53.769 0.596 54.362 0.983 54.745 1.442C55.895 2.822 56.767 4.782 57.669 6.357C59.947 10.334 62.152 14.372 64.498 18.307C64.671 18.597 65.127 19.343 65.475 19.411C66.654 19.641 79.278 11.523 81.123 10.317C80.704 8.6 80.624 7.21 81.334 5.525C82.014 3.916 83.317 2.651 84.946 2.019C86.593 1.366 88.286 1.42 89.902 2.123C91.486 2.795 92.733 4.076 93.363 5.677C95.111 10.218 91.347 15.013 86.561 14.442C85.392 14.302 84.649 13.927 83.6 13.441C76.542 18.247 69.094 22.597 61.207 25.907C60.153 26.349 59.42 26.6 58.519 27.328C60.583 27.43 87.034 24.236 87.878 23.781C87.926 23.755 88.048 23.697 88.08 23.652C88.244 23.421 88.277 23.007 88.376 22.735C88.819 21.511 89.563 20.379 90.604 19.586C91.887 18.608 93.6 18.093 95.208 18.324C96.992 18.581 98.67 19.55 99.74 21.005C100.733 22.364 101.141 24.064 100.875 25.726C100.607 27.394 99.692 28.888 98.329 29.887C96.02 31.573 92.641 31.613 90.392 29.789C89.579 29.13 89.177 28.535 88.566 27.692C86.692 28.103 83.447 28.463 81.472 28.73C76.577 29.399 71.671 29.99 66.756 30.504C65.752 30.608 59.279 31.013 58.779 31.24L58.781 31.387C59.106 31.577 66.974 33.025 68.328 33.358C72.475 34.405 76.572 35.64 80.606 37.06C82.709 37.818 84.721 38.686 86.814 39.457C88.505 38.051 89.243 36.875 91.925 36.841C93.665 36.833 95.339 37.506 96.589 38.717C97.986 40.087 98.415 41.541 98.429 43.422C98.417 44.842 98.099 45.978 97.229 47.137C96.168 48.531 94.597 49.447 92.86 49.682C91.161 49.922 89.437 49.472 88.073 48.431C86.201 47.02 85.795 45.462 85.488 43.323C85.255 43.193 85.018 43.071 84.776 42.958C83.907 42.553 78.511 40.359 77.911 40.577C77.837 41.147 78.926 42.592 79.243 43.155L84.336 52.073C85.165 53.529 86.027 54.991 86.789 56.483C87.253 57.391 87.414 58.355 87.056 59.343C86.557 60.722 85.014 61.408 83.626 61.438C81.429 61.427 79.228 61.427 77.029 61.427L62.967 61.427L35.549 61.435C33.337 61.436 20.693 61.626 19.579 61.199C18.758 60.889 18.093 60.265 17.732 59.465C17.455 58.844 17.335 57.994 17.577 57.361C18.242 55.623 19.5 53.659 20.438 52.043L28.119 39.028C28.9 37.701 31.213 33.891 31.7 32.634C25.671 32.936 18.736 32.547 12.6 32.721C11.75 34.138 10.992 35.281 9.368 35.935C7.744 36.588 5.704 36.604 4.097 35.922C2.546 35.272 1.319 34.028 0.69 32.468C0.053 30.839 0.086 29.025 0.781 27.42C2.812 22.739 9.259 22.202 12.05 26.464C12.555 27.235 12.774 27.84 13.104 28.703L26.462 28.711C28.926 28.713 31.729 28.779 34.17 28.668C35.279 26.892 36.442 24.733 37.515 22.901L45.376 9.375C46.797 6.902 48.214 4.368 49.685 1.924C50.222 1.032 50.962 0.493 51.989 0.284ZM22.119 57.31C23.512 57.503 26.045 57.431 27.526 57.429L36.661 57.42L68.412 57.422C73.113 57.421 77.994 57.351 82.68 57.438L75.664 45.098C74.562 43.171 73.093 40.773 72.104 38.827C71.245 38.351 70.291 38.109 69.335 37.848C59.189 35.076 48.669 33.421 38.172 32.796C37.642 32.764 36.994 32.766 36.469 32.794L25.855 50.865C24.634 52.935 23.364 55.302 22.119 57.31ZM52.216 5.513C49.384 10.611 46.473 15.665 43.484 20.673C42.193 22.878 40.862 25.071 39.63 27.31C39.46 27.618 39.36 27.782 39.453 28.133C40.522 28.342 45.866 26.973 47.112 26.644C49.169 26.137 60.135 22.684 61.174 21.436C61.248 21.163 61.287 21.069 61.125 20.762C60.279 19.163 59.326 17.527 58.435 15.958L53.592 7.329C53.355 6.915 52.677 5.599 52.216 5.513ZM96.18 26.494C96.963 25.713 97.12 24.502 96.563 23.547C96.005 22.592 94.872 22.133 93.807 22.432C92.972 22.666 92.324 23.327 92.108 24.167C91.892 25.007 92.14 25.899 92.758 26.507C93.396 27.134 94.327 27.361 95.182 27.096C95.558 26.98 95.901 26.773 96.18 26.494ZM87.871 10.399C89.147 10.087 89.941 8.813 89.659 7.529C89.377 6.246 88.122 5.422 86.832 5.673C85.97 5.841 85.266 6.463 84.994 7.298C84.722 8.133 84.923 9.05 85.52 9.694C86.118 10.339 87.017 10.608 87.871 10.399ZM91.505 40.879C90.185 41.122 89.31 42.388 89.55 43.709C89.791 45.03 91.055 45.907 92.377 45.669C93.22 45.517 93.921 44.933 94.223 44.131C94.525 43.329 94.383 42.428 93.85 41.758C93.29 41.055 92.389 40.717 91.505 40.879ZM9.138 29.557C9.005 28.88 8.592 28.292 8.001 27.937C7.409 27.583 6.696 27.495 6.036 27.697C5.665 27.81 5.326 28.011 5.048 28.282C4.24 29.07 4.079 30.31 4.66 31.278C5.241 32.247 6.411 32.688 7.487 32.346C8.666 31.97 9.376 30.771 9.138 29.557Z"
+      fill="currentColor"
+    />
+  </g>
+  <defs>
+    <clipPath id="syntro-fab-clip">
+      <rect width="101" height="63" fill="white" />
+    </clipPath>
+  </defs>
+</svg>`;
+var EditorPanelShellLit = class extends LitElement4 {
+  constructor() {
+    super(...arguments);
+    this.isOpen = false;
+    this.zIndex = 2147483647;
+    // Internal geometry state
+    this._geometry = getDefaultGeometry();
+    // DOM refs (set in render via query after update)
+    this._panelEl = null;
+    this._fabEl = null;
+    // Drag state (imperative refs for performance -- no re-renders during drag)
+    this._isDragging = false;
+    this._hasMoved = false;
+    this._dragOffset = { x: 0, y: 0 };
+    this._startPanelPos = { x: 0, y: 0 };
+    this._pendingGeo = null;
+    // Resize state
+    this._activeResize = null;
+    this._resizeStartMouse = { x: 0, y: 0 };
+    this._resizeStartGeo = getDefaultGeometry();
+    this._handleWindowResize = () => {
+      this._updateGeometry(clampToViewport(this._geometry));
+    };
+  }
+  // No _bound* wrapper needed — method is an arrow class field
+  get _storageKey() {
+    return this.panelId ? `syntro:editor-panel:${this.panelId}` : STORAGE_KEY;
+  }
+  createRenderRoot() {
+    return this;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this._geometry = loadGeometry(this._storageKey);
+    window.addEventListener("resize", this._handleWindowResize);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    window.removeEventListener("resize", this._handleWindowResize);
+  }
+  updated() {
+    this._panelEl = this.querySelector("[data-syntro-editor-panel]");
+    this._fabEl = this.querySelector("[data-syntro-fab]");
+  }
+  // ---- HELPERS ----
+  _updateGeometry(geo) {
+    this._geometry = geo;
+    saveGeometry(this._storageKey, geo);
+    this.requestUpdate();
+  }
+  _emitToggle() {
+    this.dispatchEvent(
+      new CustomEvent("toggle", {
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  // ---- FAB DRAG HANDLERS ----
+  _handleFabPointerDown(e) {
+    this._isDragging = true;
+    this._hasMoved = false;
+    const rect = getPanelRect(this._geometry);
+    this._startPanelPos = { x: rect.left, y: rect.top };
+    this._dragOffset = {
+      x: e.clientX - rect.left,
+      y: e.clientY - rect.top
+    };
+    e.target.setPointerCapture(e.pointerId);
+    e.preventDefault();
+  }
+  _handleFabPointerMove(e) {
+    if (!this._isDragging) return;
+    const newX = e.clientX - this._dragOffset.x;
+    const newY = e.clientY - this._dragOffset.y;
+    if (!this._hasMoved) {
+      const dx = Math.abs(newX - this._startPanelPos.x);
+      const dy = Math.abs(newY - this._startPanelPos.y);
+      if (dx < DRAG_THRESHOLD2 && dy < DRAG_THRESHOLD2) return;
+      this._hasMoved = true;
+    }
+    const geo = this._geometry;
+    const height = geo.docked ? window.innerHeight : geo.height;
+    if (this._panelEl) {
+      this._panelEl.style.left = `${newX}px`;
+      this._panelEl.style.top = `${newY}px`;
+      this._panelEl.style.right = "auto";
+      this._panelEl.style.height = `${height}px`;
+    }
+    if (this._fabEl) {
+      this._fabEl.style.left = `${newX + FAB_INSET2}px`;
+      this._fabEl.style.top = `${newY + FAB_INSET2}px`;
+    }
+    this._pendingGeo = { x: newX, y: newY, width: geo.width, height, docked: null };
+  }
+  _handleFabPointerUp(e) {
+    e.target.releasePointerCapture(e.pointerId);
+    const wasDragging = this._hasMoved;
+    this._isDragging = false;
+    this._hasMoved = false;
+    if (!wasDragging) {
+      this._emitToggle();
+      return;
+    }
+    if (this._pendingGeo) {
+      const geo = this._pendingGeo;
+      if (geo.x <= SNAP_THRESHOLD2) {
+        this._updateGeometry({ ...geo, docked: "left", x: 0, y: 0 });
+      } else if (geo.x + geo.width >= window.innerWidth - SNAP_THRESHOLD2) {
+        this._updateGeometry({ ...geo, docked: "right", x: 0, y: 0 });
+      } else {
+        this._updateGeometry(geo);
+      }
+      this._pendingGeo = null;
+    }
+  }
+  // ---- RESIZE HANDLERS ----
+  _handleResizePointerDown(e) {
+    const dir = e.currentTarget.dataset.resizeDir;
+    if (!dir) return;
+    let geo = this._geometry;
+    if (geo.docked) {
+      geo = undockGeometry(geo);
+      this._updateGeometry(geo);
+    }
+    this._activeResize = dir;
+    this._resizeStartMouse = { x: e.clientX, y: e.clientY };
+    this._resizeStartGeo = { ...geo };
+    e.target.setPointerCapture(e.pointerId);
+    e.preventDefault();
+  }
+  _handleResizePointerMove(e) {
+    if (!this._activeResize) return;
+    const dx = e.clientX - this._resizeStartMouse.x;
+    const dy = e.clientY - this._resizeStartMouse.y;
+    const dir = this._activeResize;
+    const start = this._resizeStartGeo;
+    let { x, y, width, height } = start;
+    if (dir.includes("e")) width = Math.max(MIN_WIDTH2, start.width + dx);
+    if (dir.includes("w")) {
+      const newW = Math.max(MIN_WIDTH2, start.width - dx);
+      x = start.x + start.width - newW;
+      width = newW;
+    }
+    if (dir.includes("s")) height = Math.max(MIN_HEIGHT2, start.height + dy);
+    if (dir.includes("n")) {
+      const newH = Math.max(MIN_HEIGHT2, start.height - dy);
+      y = start.y + start.height - newH;
+      height = newH;
+    }
+    if (this._panelEl) {
+      this._panelEl.style.left = `${x}px`;
+      this._panelEl.style.top = `${y}px`;
+      this._panelEl.style.width = `${width}px`;
+      this._panelEl.style.height = `${height}px`;
+    }
+    if (this._fabEl) {
+      this._fabEl.style.left = `${x + FAB_INSET2}px`;
+      this._fabEl.style.top = `${y + FAB_INSET2}px`;
+    }
+    this._pendingGeo = { x, y, width, height, docked: null };
+  }
+  _handleResizePointerUp(e) {
+    e.target.releasePointerCapture(e.pointerId);
+    this._activeResize = null;
+    if (this._pendingGeo) {
+      this._updateGeometry(this._pendingGeo);
+      this._pendingGeo = null;
+    }
+  }
+  // ---- COMPUTED STYLES ----
+  _getPanelClasses() {
+    const geo = this._geometry;
+    const isDocked = geo.docked !== null;
+    const base = "syntro-editor-scope se-fixed se-flex se-flex-col se-text-text-primary se-backdrop-blur-xl se-font-sans se-antialiased se-overflow-hidden";
+    if (isDocked) {
+      return geo.docked === "right" ? `${base} se-border-l se-border-border-primary` : `${base} se-border-r se-border-border-primary`;
+    }
+    return `${base} se-rounded-lg se-border se-border-border-primary`;
+  }
+  _getPanelStyles() {
+    const geo = this._geometry;
+    const isDocked = geo.docked !== null;
+    const styles = {
+      position: "fixed",
+      zIndex: String(this.zIndex),
+      // Re-enable pointer events — parent editor container uses pointer-events:none
+      // so clicks pass through to elements beneath (e.g., the launcher FAB).
+      pointerEvents: "auto",
+      background: panel_shell_default.background,
+      backdropFilter: `blur(${panel_shell_default.backdropBlur})`,
+      webkitBackdropFilter: `blur(${panel_shell_default.backdropBlur})`,
+      boxShadow: isDocked ? geo.docked === "right" ? panel_shell_default.shadows.dockedRight : panel_shell_default.shadows.dockedLeft : panel_shell_default.shadows.floating,
+      overflowY: "auto",
+      overscrollBehavior: "contain"
+    };
+    if (geo.docked === "left") {
+      styles.top = "0";
+      styles.left = "0";
+      styles.width = `${geo.width}px`;
+      styles.height = "100vh";
+    } else if (geo.docked === "right") {
+      styles.top = "0";
+      styles.right = "0";
+      styles.width = `${geo.width}px`;
+      styles.height = "100vh";
+    } else {
+      styles.top = `${geo.y}px`;
+      styles.left = `${geo.x}px`;
+      styles.width = `${geo.width}px`;
+      styles.height = `${geo.height}px`;
+    }
+    return styles;
+  }
+  _getFabStyles() {
+    const fabPos = getFabPosition(this._geometry);
+    return {
+      position: "fixed",
+      left: `${fabPos.left}px`,
+      top: `${fabPos.top}px`,
+      zIndex: String(this.zIndex),
+      // Re-enable pointer events — parent editor container uses pointer-events:none
+      pointerEvents: "auto",
+      width: `${FAB_SIZE2}px`,
+      height: `${FAB_SIZE2}px`,
+      borderRadius: "50%",
+      border: panel_shell_default.fab.border,
+      cursor: "grab",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      background: panel_shell_default.fab.background,
+      color: panel_shell_default.fab.color,
+      boxShadow: this.isOpen ? panel_shell_default.fab.shadowOpen : panel_shell_default.fab.shadowClosed,
+      transition: "box-shadow 150ms ease",
+      touchAction: "none",
+      userSelect: "none",
+      webkitUserSelect: "none"
+    };
+  }
+  // ---- RENDER ----
+  render() {
+    return html5`
+      ${this.isOpen ? html5`<div
+            data-syntro-editor-panel
+            data-syntro-editor-ui="panel"
+            class=${this._getPanelClasses()}
+            style=${styleMap2(this._getPanelStyles())}
+            ${this.panelId ? html5`` : nothing3}
+            id=${this.panelId ?? nothing3}
+          >
+            ${RESIZE_HANDLES2.map(
+      (h) => html5`<div
+                  data-syntro-editor-ui="resize-${h.dir}"
+                  data-resize-dir=${h.dir}
+                  @pointerdown=${this._handleResizePointerDown}
+                  @pointermove=${this._handleResizePointerMove}
+                  @pointerup=${this._handleResizePointerUp}
+                  style=${styleMap2({
+        position: "absolute",
+        ...h.style,
+        cursor: h.cursor,
+        zIndex: "1",
+        touchAction: "none"
+      })}
+                ></div>`
+    )}
+            <slot></slot>
+          </div>` : nothing3}
+
+      <div
+        class="syntro-editor-scope"
+        data-syntro-editor-ui="fab-wrapper"
+        style="display: contents"
+      >
+        <button
+          type="button"
+          data-syntro-fab
+          data-syntro-editor-ui="fab"
+          @pointerdown=${this._handleFabPointerDown}
+          @pointermove=${this._handleFabPointerMove}
+          @pointerup=${this._handleFabPointerUp}
+          style=${styleMap2(this._getFabStyles())}
+          title=${this.isOpen ? "Minimize panel" : "Open panel"}
+        >
+          ${syntroLogoSvg}
+        </button>
+      </div>
+    `;
+  }
+};
+EditorPanelShellLit.properties = {
+  isOpen: { type: Boolean, attribute: "is-open" },
+  panelId: { type: String, attribute: "panel-id" },
+  zIndex: { type: Number, attribute: "z-index" }
+};
+if (!customElements.get("se-editor-panel-shell")) {
+  customElements.define("se-editor-panel-shell", EditorPanelShellLit);
+}
+
+// ../../shared-editor-ui/src/components/EditorTextareaLit.ts
+import { html as html6, LitElement as LitElement5 } from "lit";
+var _textareaIdCounter = 0;
+var EditorTextareaLit = class extends LitElement5 {
+  constructor() {
+    super();
+    this.disabled = false;
+    this.required = false;
+    this.readonly = false;
+    this._generatedId = `se-textarea-${++_textareaIdCounter}`;
+  }
+  createRenderRoot() {
+    return this;
+  }
+  updated() {
+    const el = this.querySelector("textarea");
+    if (el) {
+      el.style.height = "auto";
+      el.style.height = `${el.scrollHeight}px`;
+    }
+  }
+  _handleChange(e) {
+    const target = e.target;
+    this.value = target.value;
+    target.style.height = "auto";
+    target.style.height = `${target.scrollHeight}px`;
+    this.dispatchEvent(
+      new CustomEvent("change", {
+        detail: { value: target.value },
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  _handleInput(e) {
+    const target = e.target;
+    this.value = target.value;
+    target.style.height = "auto";
+    target.style.height = `${target.scrollHeight}px`;
+    this.dispatchEvent(
+      new CustomEvent("input", {
+        detail: { value: target.value },
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  render() {
+    const id = this.textareaId || this._generatedId;
+    const classes = [
+      "se-w-full se-py-2 se-px-3 se-rounded-lg se-border se-border-input-field-border se-bg-slate-grey-3 se-text-text-primary se-text-sm se-font-[inherit] se-mb-2 se-resize-y se-min-h-[60px] se-max-h-[50vh] se-overflow-y-auto se-box-border",
+      "placeholder:se-text-input-field-text-placeholder",
+      "focus:se-border-input-field-border-selected focus:se-outline-none focus:se-shadow-focus-primary",
+      "disabled:se-bg-input-field-bg-disabled disabled:se-cursor-not-allowed disabled:se-opacity-50",
+      this.textareaClass || ""
+    ].filter(Boolean).join(" ");
+    return html6`
+      <div>
+        ${this.label ? html6`<label
+              for=${id}
+              class="se-text-sm se-font-medium se-text-input-field-text-label se-mb-1 se-block"
+            >${this.label}</label>` : ""}
+        <textarea
+          id=${id}
+          class=${classes}
+          name=${this.name ?? ""}
+          placeholder=${this.placeholder ?? ""}
+          ?disabled=${this.disabled}
+          ?required=${this.required}
+          ?readonly=${this.readonly}
+          rows=${this.rows ?? ""}
+          @change=${this._handleChange}
+          @input=${this._handleInput}
+        >${this.value ?? ""}</textarea>
+      </div>
+    `;
+  }
+};
+EditorTextareaLit.properties = {
+  label: { type: String },
+  textareaClass: { type: String, attribute: "textarea-class" },
+  textareaId: { type: String, attribute: "textarea-id" },
+  name: { type: String },
+  value: { type: String },
+  placeholder: { type: String },
+  disabled: { type: Boolean },
+  required: { type: Boolean },
+  readonly: { type: Boolean },
+  rows: { type: Number }
+};
+if (!customElements.get("se-editor-textarea")) {
+  customElements.define("se-editor-textarea", EditorTextareaLit);
+}
+
+// ../../shared-editor-ui/src/components/ElementHighlightLit.ts
+import { html as html7, LitElement as LitElement6, nothing as nothing4 } from "lit";
+import { styleMap as styleMap3 } from "lit/directives/style-map.js";
+var ElementHighlightLit = class extends LitElement6 {
+  constructor() {
+    super(...arguments);
+    this.element = null;
+    this.color = colors_default.blue[4];
+    this.bgColor = "transparent";
+    this.borderStyle = "solid";
+    this.borderWidth = 2;
+    this.showRemove = false;
+    this.showDimensions = false;
+    this.zIndex = 2147483644;
+    this.padding = 2;
+    /** When true, the highlight is clickable and emits 'highlight-click' events. */
+    this.interactive = false;
+    // Internal tracked rect
+    this._rect = null;
+    // Observer/listener cleanup
+    this._resizeObserver = null;
+    this._rafId = null;
+    this._scheduleUpdate = () => {
+      if (this._rafId != null) return;
+      this._rafId = requestAnimationFrame(() => {
+        this._rafId = null;
+        if (this.element) {
+          this._rect = this.element.getBoundingClientRect();
+        }
+      });
+    };
+  }
+  // No _bound* wrapper needed — method is an arrow class field
+  createRenderRoot() {
+    return this;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this._attachTracking();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._detachTracking();
+  }
+  updated(changed) {
+    if (changed.has("element")) {
+      this._detachTracking();
+      this._attachTracking();
+    }
+  }
+  // ---- RECT TRACKING (mirrors useElementRect) ----
+  _attachTracking() {
+    if (!this.element) {
+      this._rect = null;
+      return;
+    }
+    this._rect = this.element.getBoundingClientRect();
+    window.addEventListener("scroll", this._scheduleUpdate, true);
+    window.addEventListener("resize", this._scheduleUpdate);
+    this._resizeObserver = new ResizeObserver(this._scheduleUpdate);
+    this._resizeObserver.observe(this.element);
+  }
+  _detachTracking() {
+    window.removeEventListener("scroll", this._scheduleUpdate, true);
+    window.removeEventListener("resize", this._scheduleUpdate);
+    if (this._resizeObserver) {
+      this._resizeObserver.disconnect();
+      this._resizeObserver = null;
+    }
+    if (this._rafId != null) {
+      cancelAnimationFrame(this._rafId);
+      this._rafId = null;
+    }
+  }
+  // ---- EVENT HANDLERS ----
+  _handleClick(e) {
+    e.stopPropagation();
+    e.preventDefault();
+    this.dispatchEvent(
+      new CustomEvent("highlight-click", {
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  _handleKeyDown(e) {
+    if (e.key === "Enter" || e.key === " ") {
+      e.stopPropagation();
+      e.preventDefault();
+      this.dispatchEvent(
+        new CustomEvent("highlight-click", {
+          bubbles: true,
+          composed: true
+        })
+      );
+    }
+  }
+  _handleRemove(e) {
+    e.stopPropagation();
+    e.preventDefault();
+    this.dispatchEvent(
+      new CustomEvent("highlight-remove", {
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  // ---- RENDER ----
+  render() {
+    const rect = this._rect;
+    if (!rect) return nothing4;
+    const el = this.element;
+    const hasInteraction = this.interactive || this.showRemove;
+    let dimensionsLabel = null;
+    if (this.showDimensions && el) {
+      const tag = el.tagName.toLowerCase();
+      const id = el.id ? `#${el.id}` : "";
+      const cls = el.className && typeof el.className === "string" ? `.${el.className.split(" ").filter(Boolean).slice(0, 2).join(".")}` : "";
+      dimensionsLabel = `${tag}${id}${cls} \u2014 ${Math.round(rect.width)}\xD7${Math.round(rect.height)}`;
+    }
+    const displayLabel = this.label || dimensionsLabel;
+    const labelBg = this.showDimensions ? `${this.color.replace(")", ",0.85)").replace("rgb(", "rgba(")}` : this.color;
+    return html7`
+      <div
+        data-syntro-highlight
+        data-syntro-editor-ui="highlight"
+        role=${this.interactive ? "button" : nothing4}
+        tabindex=${this.interactive ? "0" : nothing4}
+        @click=${this.interactive ? this._handleClick : nothing4}
+        @keydown=${this.interactive ? this._handleKeyDown : nothing4}
+        style=${styleMap3({
+      position: "fixed",
+      top: `${rect.top - this.padding}px`,
+      left: `${rect.left - this.padding}px`,
+      width: `${rect.width + this.padding * 2}px`,
+      height: `${rect.height + this.padding * 2}px`,
+      border: `${this.borderWidth}px ${this.borderStyle} ${this.color}`,
+      backgroundColor: this.bgColor,
+      borderRadius: "4px",
+      zIndex: String(this.zIndex),
+      pointerEvents: hasInteraction ? "auto" : "none",
+      cursor: this.interactive ? "pointer" : "default",
+      transition: "all 0.05s ease-out",
+      boxSizing: "border-box"
+    })}
+      >
+        ${displayLabel ? html7`<div
+              data-syntro-highlight-label
+              data-syntro-editor-ui="highlight-label"
+              class="se-text-xs"
+              style=${styleMap3({
+      position: "absolute",
+      top: "-22px",
+      left: "0",
+      background: labelBg,
+      color: "#fff",
+      fontWeight: "600",
+      fontFamily: this.showDimensions ? "monospace" : "inherit",
+      padding: "1px 6px",
+      borderRadius: "4px",
+      whiteSpace: "nowrap",
+      display: "flex",
+      alignItems: "center",
+      gap: "6px",
+      pointerEvents: "auto"
+    })}
+            >
+              <slot name="label-icon"></slot>
+              ${displayLabel}
+              ${this.showRemove ? html7`<button
+                    type="button"
+                    class="se-text-xs"
+                    data-syntro-highlight-remove
+                    data-syntro-editor-ui="highlight-remove"
+                    @click=${this._handleRemove}
+                    style=${styleMap3({
+      background: "rgba(0,0,0,0.4)",
+      border: "none",
+      color: "#fff",
+      borderRadius: "50%",
+      width: "16px",
+      height: "16px",
+      cursor: "pointer",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      padding: "0",
+      lineHeight: "1"
+    })}
+                  >
+                    \u00d7
+                  </button>` : nothing4}
+            </div>` : nothing4}
+      </div>
+    `;
+  }
+};
+ElementHighlightLit.properties = {
+  element: { attribute: false },
+  color: { type: String },
+  bgColor: { type: String, attribute: "bg-color" },
+  borderStyle: { type: String, attribute: "border-style" },
+  borderWidth: { type: Number, attribute: "border-width" },
+  label: { type: String },
+  showRemove: { type: Boolean, attribute: "show-remove" },
+  showDimensions: { type: Boolean, attribute: "show-dimensions" },
+  zIndex: { type: Number, attribute: "z-index" },
+  padding: { type: Number },
+  interactive: { type: Boolean },
+  // Internal state
+  _rect: { state: true }
+};
+if (!customElements.get("se-element-highlight")) {
+  customElements.define("se-element-highlight", ElementHighlightLit);
+}
+
+// ../../shared-editor-ui/src/components/EmptyStateLit.ts
+import { html as html8, LitElement as LitElement7 } from "lit";
+var EmptyStateLit = class extends LitElement7 {
+  constructor() {
+    super(...arguments);
+    this.message = "";
+  }
+  createRenderRoot() {
+    return this;
+  }
+  render() {
+    return html8`
+      <div class="se-text-center se-py-8 se-px-4 se-text-text-secondary se-text-sm">
+        ${this.message}
+      </div>
+    `;
+  }
+};
+EmptyStateLit.properties = {
+  message: { type: String }
+};
+if (!customElements.get("se-empty-state")) {
+  customElements.define("se-empty-state", EmptyStateLit);
+}
+
+// ../../shared-editor-ui/src/components/GroupHeaderLit.ts
+import { html as html9, LitElement as LitElement8 } from "lit";
+var GroupHeaderLit = class extends LitElement8 {
+  constructor() {
+    super(...arguments);
+    this.label = "";
+    this.count = 0;
+  }
+  createRenderRoot() {
+    return this;
+  }
+  render() {
+    const classes = [
+      "se-text-xs se-font-bold se-text-text-primary se-uppercase se-tracking-wide se-py-1 se-pb-2 se-flex se-items-center se-justify-between",
+      this.headerClass || ""
+    ].filter(Boolean).join(" ");
+    return html9`
+      <div class=${classes}>
+        <span>${this.label}</span>
+        <span class="se-text-xs se-text-text-secondary se-bg-badge-slate-bg se-px-1.5 se-py-0.5 se-rounded-lg">
+          ${this.count}
+        </span>
+      </div>
+    `;
+  }
+};
+GroupHeaderLit.properties = {
+  label: { type: String },
+  count: { type: Number },
+  headerClass: { type: String, attribute: "header-class" }
+};
+if (!customElements.get("se-group-header")) {
+  customElements.define("se-group-header", GroupHeaderLit);
+}
 
 // src/summarize.ts
 var MAX_Q_LEN = 50;
@@ -8,8 +4452,8 @@ function truncate(text, max) {
   if (text.length <= max) return text;
   return `${text.slice(0, max).trimEnd()}...`;
 }
-function stripHtml(html2) {
-  return html2.replace(/<[^>]*>/g, "").trim();
+function stripHtml(html11) {
+  return html11.replace(/<[^>]*>/g, "").trim();
 }
 function getAnswerPreview(answer) {
   if (typeof answer === "string") return answer;
@@ -23,6 +4467,9 @@ function summarizeFAQItem(item) {
 }
 
 // src/types.ts
+function isGroupedFAQConfig(c) {
+  return !!c && Array.isArray(c.groups);
+}
 var ACTION_NAMESPACE = "faq";
 function isOwnAction(action) {
   return action.kind.startsWith(`${ACTION_NAMESPACE}:`);
@@ -34,22 +4481,64 @@ var getAnswerText = (answer) => {
   if (answer.type === "rich") return answer.html;
   return answer.content;
 };
-var flattenItems = (config) => {
-  const actions = (config.actions || []).filter(isOwnAction);
-  return actions.map((q, i) => ({
-    key: String(i),
-    index: i,
-    summary: summarizeFAQItem(q),
-    question: q
-  }));
+var summarizeTriggerWhen = (triggerWhen) => {
+  if (!triggerWhen || typeof triggerWhen !== "object") return "";
+  const t = triggerWhen;
+  if (t.type !== "rules" || !Array.isArray(t.rules)) return "Conditional";
+  const types = /* @__PURE__ */ new Set();
+  for (const rule of t.rules) {
+    for (const cond of rule.conditions || []) {
+      if (cond?.type) types.add(cond.type);
+    }
+  }
+  return types.size > 0 ? [...types].join(", ") : "Conditional";
 };
-var FAQEditorLit = class extends LitElement {
+function flattenConfig(config) {
+  if (isGroupedFAQConfig(config)) {
+    const sections = [];
+    const items = [];
+    config.groups.forEach((group, gIdx) => {
+      sections.push({
+        groupIdx: gIdx,
+        title: group.title,
+        routes: group.routes,
+        tileId: group.tileId
+      });
+      group.actions.filter(isOwnAction).forEach((q, iIdx) => {
+        items.push(buildFlatItem(`${gIdx}:${iIdx}`, gIdx, iIdx, q));
+      });
+    });
+    return { sections, items };
+  }
+  const flat = config;
+  const own = (flat.actions || []).filter(isOwnAction);
+  return {
+    sections: [{ groupIdx: -1, title: "", routes: [] }],
+    items: own.map((q, i) => buildFlatItem(String(i), -1, i, q))
+  };
+}
+function buildFlatItem(key, groupIdx, itemIdx, q) {
+  const raw = q;
+  const topTitle = typeof raw.title === "string" ? raw.title : void 0;
+  const description = typeof raw.description === "string" ? raw.description : void 0;
+  const validation = Array.isArray(raw.validation) ? raw.validation.filter((v) => typeof v === "string") : void 0;
+  return {
+    key,
+    groupIdx,
+    itemIdx,
+    summary: topTitle || summarizeFAQItem(q),
+    triggerSummary: summarizeTriggerWhen(q.triggerWhen),
+    description,
+    validation: validation && validation.length > 0 ? validation : void 0,
+    question: q
+  };
+}
+var FAQEditorLit = class extends LitElement9 {
   constructor() {
     super(...arguments);
     this.config = null;
     this.onChange = null;
     this._editingKey = null;
-    // No auto-dirty on load — only dirty when user makes changes (matching React behavior).
     // ---- Actions ----
     this._handleBack = () => {
       if (this._editingKey !== null) {
@@ -61,21 +4550,39 @@ var FAQEditorLit = class extends LitElement {
     this._handleItemClick = (key) => {
       this._editingKey = key;
     };
-    this._handleFieldChange = (index, field, value) => {
+    this._handleFieldChange = (item, field, value) => {
+      this._emitFieldChange(item, field, value);
+    };
+    this._handleDelete = (item, e) => {
+      e.stopPropagation();
       if (!this.config || !this.onChange) return;
-      const ownActions = (this.config.actions || []).filter(isOwnAction).slice();
-      const q = { ...ownActions[index], config: { ...ownActions[index].config } };
-      q.config[field] = value;
-      ownActions[index] = q;
-      const otherActions = (this.config.actions || []).filter((a) => !isOwnAction(a));
-      const updated = { ...this.config, actions: [...otherActions, ...ownActions] };
-      this.onChange(updated);
+      if (isGroupedFAQConfig(this.config)) {
+        const groups = this.config.groups.map((group, gIdx) => {
+          if (gIdx !== item.groupIdx) return group;
+          const own = group.actions.filter(isOwnAction);
+          const target = own[item.itemIdx];
+          if (!target) return group;
+          const remaining = group.actions.filter((a) => a !== target);
+          return { ...group, actions: remaining };
+        });
+        const updated = { ...this.config, groups };
+        this.onChange(updated);
+      } else {
+        const flat = this.config;
+        const own = (flat.actions || []).filter(isOwnAction);
+        const target = own[item.itemIdx];
+        if (!target) return;
+        const remaining = (flat.actions || []).filter((a) => a !== target);
+        const updated = { ...flat, actions: remaining };
+        this.onChange(updated);
+      }
+      if (this._editingKey === item.key) this._editingKey = null;
       this.dispatchEvent(new CustomEvent("dirty-change", { detail: { dirty: true }, bubbles: true }));
     };
     // ---- Render ----
     this._renderEditMode = (item) => {
       const q = item.question;
-      return html`
+      return html10`
       <div class="se-py-1">
         <div class="se-flex se-items-center se-gap-2 se-mb-3 se-text-[13px] se-font-semibold se-text-text-primary">
           <span>❓</span>
@@ -87,7 +4594,7 @@ var FAQEditorLit = class extends LitElement {
           <input
             type="text"
             .value=${q.config.question}
-            @input=${(e) => this._handleFieldChange(item.index, "question", e.target.value)}
+            @input=${(e) => this._handleFieldChange(item, "question", e.target.value)}
             class="se-w-full se-p-2 se-rounded se-border se-border-border-primary se-bg-input-field-bg se-text-text-primary se-text-sm"
           />
         </div>
@@ -96,7 +4603,7 @@ var FAQEditorLit = class extends LitElement {
           <label class="se-text-[11px] se-font-semibold se-text-text-secondary se-mb-1 se-block">Answer</label>
           <textarea
             .value=${getAnswerText(q.config.answer)}
-            @input=${(e) => this._handleFieldChange(item.index, "answer", e.target.value)}
+            @input=${(e) => this._handleFieldChange(item, "answer", e.target.value)}
             rows="4"
             class="se-w-full se-p-2 se-rounded se-border se-border-border-primary se-bg-input-field-bg se-text-text-primary se-text-sm se-resize-none"
           ></textarea>
@@ -108,66 +4615,160 @@ var FAQEditorLit = class extends LitElement {
             type="text"
             .value=${q.config.category || ""}
             placeholder="e.g., Billing, Account"
-            @input=${(e) => this._handleFieldChange(item.index, "category", e.target.value)}
+            @input=${(e) => this._handleFieldChange(item, "category", e.target.value)}
             class="se-w-full se-p-2 se-rounded se-border se-border-border-primary se-bg-input-field-bg se-text-text-primary se-text-sm"
           />
         </div>
 
-        ${q.rationale ? html`
+        ${q.rationale ? html10`
           <div>
             <span class="se-text-[11px] se-font-semibold se-text-text-secondary se-mb-1 se-block">AI Rationale</span>
             <div class="se-p-2 se-rounded se-border se-border-dashed se-border-border-primary se-bg-card-bg se-text-text-secondary se-text-xs se-mb-2">
               ${q.rationale.why}
             </div>
           </div>
-        ` : nothing}
+        ` : nothing5}
+      </div>
+    `;
+    };
+    this._renderItemCard = (item) => html10`
+    <div
+      data-item-key=${item.key}
+      data-card-body
+      @click=${() => this._handleItemClick(item.key)}
+      class="se-p-3 se-rounded-lg se-border se-border-border-primary se-bg-card-bg se-cursor-pointer se-mb-2 se-transition-all hover:se-border-pink-4/40 hover:se-bg-pink-4/5"
+    >
+      ${itemCardHeader({
+      label: item.summary,
+      onDelete: (e) => this._handleDelete(item, e),
+      deleteTestid: `delete-faq-${item.key}`,
+      deleteLabel: "Delete question"
+    })}
+      ${item.description ? html10`<div
+              data-testid=${`faq-description-${item.key}`}
+              class="se-text-[11px] se-text-text-secondary se-mt-1.5 se-line-clamp-2"
+            >${item.description}</div>` : nothing5}
+      ${item.triggerSummary ? html10`<div
+              data-testid=${`faq-trigger-${item.key}`}
+              class="se-mt-1 se-inline-flex se-items-center se-gap-1 se-px-1.5 se-py-0.5 se-rounded se-bg-pink-4/10 se-text-pink-5 se-text-[10px] se-font-medium"
+            >
+              <span>📍</span>
+              <span>When: ${item.triggerSummary}</span>
+            </div>` : nothing5}
+      ${item.validation && item.validation.length > 0 ? html10`<div
+              data-testid=${`faq-validation-${item.key}`}
+              class="se-mt-1.5 se-flex se-flex-col se-gap-0.5"
+            >
+              ${item.validation.map(
+      (line) => html10`<div
+                  class="se-text-[10px] se-text-text-tertiary se-flex se-items-start se-gap-1"
+                ><span class="se-text-text-tertiary">✓</span><span>${line}</span></div>`
+    )}
+            </div>` : nothing5}
+      ${item.question.rationale ? html10`
+        <div class="se-text-[10px] se-text-text-tertiary se-mt-1">
+          WHY: ${item.question.rationale.why}
+        </div>
+      ` : nothing5}
+    </div>
+  `;
+    this._handleNavigateFromPill = (e) => {
+      if (!e.detail?.route) return;
+      this.dispatchEvent(
+        new CustomEvent("se-navigate-to-page", {
+          detail: { route: e.detail.route },
+          bubbles: true,
+          composed: true
+        })
+      );
+    };
+    this._renderGroupHeader = (section, count) => {
+      const navRoute = section.routes[0];
+      const testidSuffix = section.tileId ?? String(section.groupIdx);
+      return html10`
+      <div
+        data-faq-group-header
+        data-faq-group-tile-id=${section.tileId ?? ""}
+        class="se-mt-3 se-mb-2 se-px-1 se-flex se-items-center se-justify-between se-gap-2"
+      >
+        <div class="se-flex se-items-center se-gap-2 se-min-w-0">
+          <span
+            class="se-text-[11px] se-font-semibold se-uppercase se-tracking-wider se-text-text-primary se-truncate"
+          >
+            ${section.title}
+          </span>
+          ${navRoute ? html10`<se-anchor-pill
+                  .state=${"navigate"}
+                  .route=${navRoute}
+                  testid-prefix="goto-faq-group"
+                  testid-key=${testidSuffix}
+                  @se-anchor-navigate=${this._handleNavigateFromPill}
+                ></se-anchor-pill>` : nothing5}
+        </div>
+        <span class="se-text-text-tertiary se-text-[11px] se-font-normal">${count}</span>
       </div>
     `;
     };
-    this._renderListMode = (items) => {
+    this._renderListMode = (sections, items) => {
       if (items.length === 0) {
-        return html`<div class="se-text-center se-py-8 se-px-4 se-text-text-secondary se-text-sm">
+        return html10`<div class="se-text-center se-py-8 se-px-4 se-text-text-secondary se-text-sm">
         No FAQ questions configured.
       </div>`;
       }
-      return html`
-      <div class="se-text-[11px] se-font-semibold se-uppercase se-tracking-wider se-text-text-secondary se-mb-2 se-px-1">
-        FAQ <span class="se-text-text-tertiary se-font-normal">${items.length}</span>
-      </div>
-      ${items.map(
-        (item) => html`
-        <div
-          data-item-key=${item.key}
-          data-card-body
-          @click=${() => this._handleItemClick(item.key)}
-          class="se-p-3 se-rounded-lg se-border se-border-border-primary se-bg-card-bg se-cursor-pointer se-mb-2 se-transition-all hover:se-border-pink-4/40 hover:se-bg-pink-4/5"
-        >
-          <div class="se-flex se-items-center se-gap-2">
-            <span class="se-flex-1 se-overflow-hidden se-text-ellipsis se-whitespace-nowrap se-text-sm se-text-text-primary">
-              ${item.summary}
-            </span>
-          </div>
-          ${item.question.rationale ? html`
-            <div class="se-text-[10px] se-text-text-tertiary se-mt-1">
-              WHY: ${item.question.rationale.why}
-            </div>
-          ` : nothing}
+      if (sections.length === 1 && sections[0].groupIdx === -1) {
+        return html10`
+        <div class="se-text-[11px] se-font-semibold se-uppercase se-tracking-wider se-text-text-secondary se-mb-2 se-px-1">
+          FAQ <span class="se-text-text-tertiary se-font-normal">${items.length}</span>
         </div>
-      `
-      )}
-    `;
+        ${items.map(this._renderItemCard)}
+      `;
+      }
+      return html10`${sections.map((section) => {
+        const sectionItems = items.filter((it) => it.groupIdx === section.groupIdx);
+        return html10`
+        ${this._renderGroupHeader(section, sectionItems.length)}
+        ${sectionItems.map(this._renderItemCard)}
+      `;
+      })}`;
     };
   }
   createRenderRoot() {
     return this;
   }
+  _emitFieldChange(item, field, value) {
+    if (!this.config || !this.onChange) return;
+    const mutateQuestion = (q) => {
+      const next = { ...q, config: { ...q.config } };
+      next.config[field] = value;
+      return next;
+    };
+    if (isGroupedFAQConfig(this.config)) {
+      const groups = this.config.groups.map((group, gIdx) => {
+        if (gIdx !== item.groupIdx) return group;
+        const own = group.actions.filter(isOwnAction).slice();
+        const others = group.actions.filter((a) => !isOwnAction(a));
+        own[item.itemIdx] = mutateQuestion(own[item.itemIdx]);
+        return { ...group, actions: [...others, ...own] };
+      });
+      const updated = { ...this.config, groups };
+      this.onChange(updated);
+    } else {
+      const flat = this.config;
+      const ownActions = (flat.actions || []).filter(isOwnAction).slice();
+      ownActions[item.itemIdx] = mutateQuestion(ownActions[item.itemIdx]);
+      const otherActions = (flat.actions || []).filter((a) => !isOwnAction(a));
+      const updated = { ...flat, actions: [...otherActions, ...ownActions] };
+      this.onChange(updated);
+    }
+    this.dispatchEvent(new CustomEvent("dirty-change", { detail: { dirty: true }, bubbles: true }));
+  }
   render() {
     if (!this.config) {
-      return html`<div class="se-p-8 se-text-center se-text-text-secondary se-text-sm">Loading...</div>`;
+      return html10`<div class="se-p-8 se-text-center se-text-text-secondary se-text-sm">Loading...</div>`;
     }
-    const items = flattenItems(this.config);
+    const { sections, items } = flattenConfig(this.config);
     const editItem = this._editingKey !== null ? items.find((it) => it.key === this._editingKey) : null;
-    return html`
+    return html10`
       <div class="se-flex se-flex-col se-h-full">
         <!-- Header (no Back button — panel provides that) -->
         <div class="se-px-4 se-pt-3 se-pb-1">
@@ -178,14 +4779,14 @@ var FAQEditorLit = class extends LitElement {
         </div>
 
         <div class="se-flex-1 se-overflow-auto se-p-4">
-          ${editItem ? html`
+          ${editItem ? html10`
             <button type="button" @click=${() => {
       this._editingKey = null;
     }}
               class="se-mb-3 se-py-1 se-px-2 se-rounded se-border-none se-bg-card-bg se-text-text-secondary se-text-xs se-cursor-pointer"
             >← Back to list</button>
             ${this._renderEditMode(editItem)}
-          ` : this._renderListMode(items)}
+          ` : this._renderListMode(sections, items)}
         </div>
       </div>
     `;
@@ -200,4 +4801,39 @@ customElements.define("se-faq-editor", FAQEditorLit);
 export {
   FAQEditorLit
 };
+/*! Bundled license information:
+
+react/cjs/react.development.js:
+  (**
+   * @license React
+   * react.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.
+   *)
+
+react/cjs/react-jsx-runtime.development.js:
+  (**
+   * @license React
+   * react-jsx-runtime.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.
+   *)
+
+react-dom/cjs/react-dom.development.js:
+  (**
+   * @license React
+   * react-dom.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.
+   *)
+*/
 //# sourceMappingURL=editor.js.map