@glowhop/core-tour 1.0.0

package/index.js

@@ -0,0 +1,3889 @@
+// packages/core/src/definition/step-props.ts
+function cloneStepProps(props) {
+  return {
+    title: props.title,
+    content: props.content,
+    data: props.data === undefined ? undefined : structuredClone(props.data),
+    overlay: props.overlay && {
+      ...props.overlay,
+      animation: props.overlay.animation && { ...props.overlay.animation }
+    },
+    popover: props.popover && {
+      ...props.popover,
+      animation: props.popover.animation && { ...props.popover.animation },
+      arrow: props.popover.arrow && { ...props.popover.arrow },
+      keyboardShortcuts: props.popover.keyboardShortcuts && {
+        previous: props.popover.keyboardShortcuts.previous && [
+          ...props.popover.keyboardShortcuts.previous
+        ],
+        advance: props.popover.keyboardShortcuts.advance && [
+          ...props.popover.keyboardShortcuts.advance
+        ],
+        cancel: props.popover.keyboardShortcuts.cancel && [
+          ...props.popover.keyboardShortcuts.cancel
+        ]
+      },
+      placementTryOrder: props.popover.placementTryOrder && [...props.popover.placementTryOrder]
+    },
+    indicator: props.indicator && {
+      ...props.indicator,
+      animation: props.indicator.animation && { ...props.indicator.animation },
+      placementTryOrder: props.indicator.placementTryOrder && [
+        ...props.indicator.placementTryOrder
+      ]
+    }
+  };
+}
+function freezeStepProps(props) {
+  const cloned = cloneStepProps(props);
+  if (cloned.data)
+    Object.freeze(cloned.data);
+  if (cloned.overlay?.animation)
+    Object.freeze(cloned.overlay.animation);
+  if (cloned.overlay)
+    Object.freeze(cloned.overlay);
+  if (cloned.popover?.animation)
+    Object.freeze(cloned.popover.animation);
+  if (cloned.popover?.arrow)
+    Object.freeze(cloned.popover.arrow);
+  if (cloned.popover?.keyboardShortcuts?.previous)
+    Object.freeze(cloned.popover.keyboardShortcuts.previous);
+  if (cloned.popover?.keyboardShortcuts?.advance)
+    Object.freeze(cloned.popover.keyboardShortcuts.advance);
+  if (cloned.popover?.keyboardShortcuts?.cancel)
+    Object.freeze(cloned.popover.keyboardShortcuts.cancel);
+  if (cloned.popover?.keyboardShortcuts)
+    Object.freeze(cloned.popover.keyboardShortcuts);
+  if (cloned.popover?.placementTryOrder)
+    Object.freeze(cloned.popover.placementTryOrder);
+  if (cloned.popover)
+    Object.freeze(cloned.popover);
+  if (cloned.indicator?.animation)
+    Object.freeze(cloned.indicator.animation);
+  if (cloned.indicator?.placementTryOrder)
+    Object.freeze(cloned.indicator.placementTryOrder);
+  if (cloned.indicator)
+    Object.freeze(cloned.indicator);
+  return Object.freeze(cloned);
+}
+// packages/core/src/definition/workflow-definition.ts
+function freezeRecord(value) {
+  return Object.freeze(value);
+}
+function freezeAnimation(options) {
+  return options && freezeRecord({ ...options });
+}
+function freezeOverlay(options) {
+  return options && freezeRecord({
+    ...options,
+    animation: freezeAnimation(options.animation)
+  });
+}
+function freezePopover(options) {
+  return options && freezeRecord({
+    ...options,
+    animation: freezeAnimation(options.animation),
+    arrow: options.arrow && freezeRecord({ ...options.arrow }),
+    keyboardShortcuts: options.keyboardShortcuts && freezeRecord({
+      previous: options.keyboardShortcuts.previous && freezeRecord([...options.keyboardShortcuts.previous]),
+      advance: options.keyboardShortcuts.advance && freezeRecord([...options.keyboardShortcuts.advance]),
+      cancel: options.keyboardShortcuts.cancel && freezeRecord([...options.keyboardShortcuts.cancel])
+    }),
+    placementTryOrder: options.placementTryOrder && freezeRecord([...options.placementTryOrder])
+  });
+}
+function freezeIndicator(options) {
+  return options && freezeRecord({
+    ...options,
+    animation: freezeAnimation(options.animation),
+    placementTryOrder: options.placementTryOrder && freezeRecord([...options.placementTryOrder])
+  });
+}
+function freezeStep(draft) {
+  return freezeRecord({
+    id: draft.id,
+    target: draft.target,
+    resetPropsOnEnter: draft.resetPropsOnEnter,
+    props: freezeStepProps(draft.props),
+    behavior: draft.behavior && freezeRecord({
+      ...draft.behavior,
+      scroll: draft.behavior.scroll && freezeRecord({ ...draft.behavior.scroll })
+    }),
+    actions: freezeRecord(draft.actions.map((action) => action)),
+    eventHandlers: freezeRecord(draft.eventHandlers.map((handler) => freezeRecord({ ...handler }))),
+    advanceAction: draft.advanceAction,
+    previousAction: draft.previousAction,
+    cancelAction: draft.cancelAction
+  });
+}
+function freezeOptions(options) {
+  return freezeRecord({
+    ...options,
+    overlay: freezeOverlay(options.overlay),
+    popover: freezePopover(options.popover),
+    indicator: freezeIndicator(options.indicator),
+    behavior: options.behavior && freezeRecord({
+      ...options.behavior,
+      scroll: options.behavior.scroll && freezeRecord({ ...options.behavior.scroll })
+    })
+  });
+}
+function cloneWorkflowStepDraft(definition) {
+  return {
+    ...definition,
+    props: cloneStepProps(definition.props),
+    actions: definition.actions.map((action) => action),
+    eventHandlers: [...definition.eventHandlers]
+  };
+}
+function assertUniqueStepIds(name, drafts) {
+  const seen = new Map;
+  for (const [index, draft] of drafts.entries()) {
+    const label = `step ${index}${draft.props.title ? ` ("${String(draft.props.title)}")` : ""}`;
+    if (typeof draft.id !== "string" || draft.id.length === 0) {
+      throw new Error(`Workflow "${name}": ${label} is missing a non-empty "id".`);
+    }
+    const duplicate = seen.get(draft.id);
+    if (duplicate !== undefined) {
+      throw new Error(`Workflow "${name}": ${label} reuses the id "${draft.id}" already used by step ${duplicate}. Step ids must be unique.`);
+    }
+    seen.set(draft.id, index);
+  }
+}
+function createWorkflowDefinition(name, options, drafts) {
+  assertUniqueStepIds(name, drafts);
+  return freezeRecord({
+    name,
+    options: freezeOptions(options),
+    steps: freezeRecord(drafts.map(freezeStep))
+  });
+}
+// packages/core/src/runtime/abort.ts
+function abortError() {
+  return new DOMException("The operation was aborted", "AbortError");
+}
+function abortableDelay(delay, signal) {
+  if (signal.aborted)
+    throw abortError();
+  return new Promise((resolve, reject) => {
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      cleanup();
+      reject(abortError());
+    };
+    const timeoutId = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, delay);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// packages/core/src/builder/index.ts
+var DEFAULT_WAIT_INTERVAL = 16;
+var DEFAULT_WAIT_TIMEOUT = 3000;
+var INACTIVE_STEP_ERROR = "WorkflowStepBuilder is no longer active";
+var STEP_BUILDER_INTERNAL = Symbol("WorkflowStepBuilder.internal");
+function assertTimingValue(name, value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(`${name} must be a finite non-negative number`);
+  }
+}
+function throwIfAborted(signal) {
+  if (signal.aborted)
+    throw abortError();
+}
+function waitTimeoutError(timeout) {
+  return new Error(`waitUntil timed out after ${timeout}ms`);
+}
+function waitForPredicate(predicate, remainingTime, timeout, signal) {
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      clearTimeout(timeoutId);
+      signal.removeEventListener("abort", onAbort);
+    };
+    const settle = (callback) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      callback();
+    };
+    const onAbort = () => settle(() => reject(abortError()));
+    const timeoutId = setTimeout(() => settle(() => reject(waitTimeoutError(timeout))), remainingTime);
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve().then(predicate).then((result) => settle(() => resolve(result)), (error) => settle(() => reject(error)));
+  });
+}
+function waitOptions(options = {}) {
+  const timeout = options.timeout ?? DEFAULT_WAIT_TIMEOUT;
+  const interval = options.interval ?? DEFAULT_WAIT_INTERVAL;
+  if (!Number.isFinite(timeout) || timeout < 0) {
+    throw new TypeError("wait timeout must be a finite non-negative number");
+  }
+  if (!Number.isFinite(interval) || interval <= 0) {
+    throw new TypeError("wait interval must be a finite positive number");
+  }
+  return { interval, timeout };
+}
+
+class WorkflowBuilder {
+  name;
+  options;
+  steps = [];
+  currentStep = null;
+  definition = null;
+  constructor(name, options = {}) {
+    this.name = name;
+    this.options = options;
+  }
+  step(options) {
+    this.assertBuilding();
+    this.commitCurrentStep();
+    this.currentStep = new WorkflowStepBuilder(this, {
+      id: options.id,
+      target: options.target,
+      resetPropsOnEnter: options.resetPropsOnEnter,
+      props: {
+        title: options.title,
+        content: options.content,
+        data: cloneStepProps(options).data,
+        overlay: options.overlay,
+        popover: options.popover,
+        indicator: options.indicator
+      },
+      behavior: options.behavior,
+      actions: [],
+      eventHandlers: [],
+      advanceAction: null,
+      previousAction: null,
+      cancelAction: null
+    });
+    return this.currentStep;
+  }
+  append(workflow) {
+    this.assertBuilding();
+    const drafts = workflow.steps.map(cloneWorkflowStepDraft);
+    const lastStep = drafts.at(-1);
+    if (!lastStep)
+      throw new Error("Cannot append a workflow without steps");
+    this.commitCurrentStep();
+    this.steps.push(...drafts.slice(0, -1));
+    this.currentStep = new WorkflowStepBuilder(this, lastStep);
+    return this.currentStep;
+  }
+  build() {
+    if (this.definition)
+      return this.definition;
+    this.commitCurrentStep();
+    this.definition = createWorkflowDefinition(this.name, this.options, this.steps);
+    return this.definition;
+  }
+  assertBuilding() {
+    if (this.definition)
+      throw new Error("WorkflowBuilder is already finished");
+  }
+  commitCurrentStep() {
+    if (!this.currentStep)
+      return;
+    this.steps.push(this.currentStep[STEP_BUILDER_INTERNAL]());
+    this.currentStep = null;
+  }
+}
+
+class WorkflowStepBuilder {
+  owner;
+  draft;
+  active = true;
+  constructor(owner, draft) {
+    this.owner = owner;
+    this.draft = draft;
+  }
+  step(options) {
+    this.assertActive();
+    return this.owner.step(options);
+  }
+  append(workflow) {
+    this.assertActive();
+    return this.owner.append(workflow);
+  }
+  build() {
+    this.assertActive();
+    return this.owner.build();
+  }
+  clickTarget() {
+    return this.do(({ target }) => {
+      target?.click();
+      return true;
+    });
+  }
+  focusTarget() {
+    return this.do(({ target }) => {
+      target?.focus();
+      return true;
+    });
+  }
+  wait(timeMs) {
+    this.assertActive();
+    assertTimingValue("timeMs", timeMs);
+    this.draft.actions.push(timeMs);
+    return this;
+  }
+  waitUntil(predicate, options = {}) {
+    this.assertActive();
+    const { interval, timeout } = waitOptions(options);
+    this.draft.actions.push(async (context) => {
+      const startedAt = Date.now();
+      let attempted = false;
+      while (true) {
+        throwIfAborted(context.signal);
+        const elapsed = Date.now() - startedAt;
+        if (attempted && elapsed >= timeout)
+          throw waitTimeoutError(timeout);
+        attempted = true;
+        if (await waitForPredicate(() => predicate(context), Math.max(0, timeout - elapsed), timeout, context.signal))
+          return true;
+        const remainingTime = timeout - (Date.now() - startedAt);
+        if (remainingTime <= 0)
+          throw waitTimeoutError(timeout);
+        await abortableDelay(Math.min(interval, remainingTime), context.signal);
+      }
+    });
+    return this;
+  }
+  waitUntilElement(selector, options) {
+    if (selector.length === 0)
+      throw new TypeError("selector must not be empty");
+    return this.waitUntil((context) => context.target.ownerDocument.querySelector(selector) !== null, options);
+  }
+  do(callback) {
+    this.assertActive();
+    this.draft.actions.push(callback);
+    return this;
+  }
+  beforeAdvance(callback) {
+    this.assertActive();
+    this.draft.advanceAction = callback;
+    return this;
+  }
+  beforePrevious(callback) {
+    this.assertActive();
+    this.draft.previousAction = callback;
+    return this;
+  }
+  beforeCancel(callback) {
+    this.assertActive();
+    this.draft.cancelAction = callback;
+    return this;
+  }
+  onTargetEvent(eventOrEvents, callback) {
+    this.assertActive();
+    const events = typeof eventOrEvents === "string" ? [eventOrEvents] : eventOrEvents;
+    if (events.length === 0)
+      throw new TypeError("events must not be empty");
+    for (const event of events) {
+      if (event.length === 0)
+        throw new TypeError("event name must not be empty");
+      this.draft.eventHandlers.push({
+        event,
+        callback
+      });
+    }
+    return this;
+  }
+  [STEP_BUILDER_INTERNAL]() {
+    this.active = false;
+    return cloneWorkflowStepDraft(this.draft);
+  }
+  assertActive() {
+    if (!this.active)
+      throw new Error(INACTIVE_STEP_ERROR);
+  }
+}
+
+// packages/core/src/utils/utils.ts
+function ownerWindow(element) {
+  return element?.ownerDocument?.defaultView ?? (typeof window === "undefined" ? null : window);
+}
+function ownerDocument(element) {
+  return element?.ownerDocument ?? (typeof document === "undefined" ? null : document);
+}
+function isHTMLElement(value, context) {
+  const HTMLElement2 = ownerWindow(context)?.HTMLElement ?? globalThis.HTMLElement;
+  return typeof HTMLElement2 === "function" && value instanceof HTMLElement2;
+}
+function isElement(value, context) {
+  const Element = ownerWindow(context)?.Element ?? globalThis.Element;
+  return typeof Element === "function" && value instanceof Element;
+}
+function isNode(value, context) {
+  const Node = ownerWindow(context)?.Node ?? globalThis.Node;
+  return typeof Node === "function" && value instanceof Node;
+}
+function viewportDimensions(context) {
+  const currentWindow = ownerWindow(context);
+  return {
+    width: currentWindow?.innerWidth ?? 1024,
+    height: currentWindow?.innerHeight ?? 768
+  };
+}
+function isInViewport(rect, context) {
+  const viewport = viewportDimensions(context);
+  return rect.left >= 0 && rect.top >= 0 && rect.right <= viewport.width && rect.bottom <= viewport.height;
+}
+function roundByDPR(value, context) {
+  const dpr = ownerWindow(context)?.devicePixelRatio || 1;
+  return Math.round(value * dpr) / dpr;
+}
+function roundedRectPath(rect, viewport, options, context) {
+  const padding = options.padding;
+  const radius = options.radius;
+  const x = roundByDPR(rect.left - padding, context);
+  const y = roundByDPR(rect.top - padding, context);
+  const width = rect.width + padding * 2;
+  const height = rect.height + padding * 2;
+  const right = roundByDPR(rect.left + rect.width + padding, context);
+  const bottom = roundByDPR(rect.top + rect.height + padding, context);
+  const corner = roundByDPR(Math.max(0, Math.min(radius, width / 2, height / 2)), context);
+  return [
+    `M0,0 H${roundByDPR(viewport.width, context)} V${roundByDPR(viewport.height, context)} H0 Z`,
+    `M${x},${y + corner}`,
+    `Q${x},${y} ${x + corner},${y}`,
+    `H${right - corner}`,
+    `Q${right},${y} ${right},${y + corner}`,
+    `V${bottom - corner}`,
+    `Q${right},${bottom} ${right - corner},${bottom}`,
+    `H${x + corner}`,
+    `Q${x},${bottom} ${x},${bottom - corner}`,
+    "Z"
+  ].join(" ");
+}
+async function resolveTargetElement(target, options, path = "target") {
+  const rootDocument = options.document;
+  if (typeof target === "string") {
+    const element = rootDocument ? rootDocument.querySelector(target) : typeof document === "undefined" ? null : document.querySelector(target);
+    return rootDocument ? validateTargetElement(element, rootDocument, path) : element;
+  } else if (typeof target === "function") {
+    const element = await target({ signal: options.signal });
+    return rootDocument ? validateTargetElement(element, rootDocument, path) : element;
+  }
+  if (rootDocument)
+    return validateTargetElement(target, rootDocument, path);
+  return typeof HTMLElement !== "undefined" && target instanceof HTMLElement ? target : null;
+}
+function validateTargetElement(candidate, rootDocument, path) {
+  if (candidate === null)
+    return null;
+  const HTMLElement2 = rootDocument.defaultView?.HTMLElement;
+  if (typeof HTMLElement2 !== "function" || !(candidate instanceof HTMLElement2) || candidate.ownerDocument !== rootDocument) {
+    throw new TypeError(`Invalid target: ${path} must resolve to an HTMLElement in the root document`);
+  }
+  return candidate.isConnected ? candidate : null;
+}
+
+// packages/core/src/elements/base.ts
+var DEFAULT_ANIMATION_DURATION = 180;
+var DEFAULT_ANIMATION_EASING = "ease-out";
+
+class GlowTourElement {
+  element;
+  options;
+  animations = new Set;
+  cancelledAnimations = new WeakSet;
+  released = false;
+  constructor(element, options) {
+    this.element = element;
+    this.options = options;
+  }
+  setAnimationOptions(options) {
+    this.options = options;
+  }
+  _getAnimationOptions() {
+    return {
+      duration: this.options?.disabled ? 0 : this.options?.duration ?? DEFAULT_ANIMATION_DURATION,
+      easing: this.options?.easing ?? DEFAULT_ANIMATION_EASING,
+      fill: "forwards"
+    };
+  }
+  _isAnimated() {
+    return this.options?.disabled !== true && this.options?.duration !== 0;
+  }
+  _startAnimation(keyframes, options, target = this.element) {
+    if (!this._isAnimated() || typeof target.animate !== "function")
+      return null;
+    try {
+      return target.animate(keyframes, options ?? this._getAnimationOptions());
+    } catch {
+      return null;
+    }
+  }
+  _getDocument() {
+    const owner = this.element.ownerDocument;
+    return owner && typeof owner.addEventListener === "function" ? owner : null;
+  }
+  _finishWhileDocumentHidden(animation) {
+    const owner = this._getDocument();
+    if (!owner)
+      return () => {};
+    const finishIfHidden = () => {
+      if (owner.visibilityState !== "hidden")
+        return;
+      try {
+        animation.finish();
+      } catch {}
+    };
+    finishIfHidden();
+    owner.addEventListener("visibilitychange", finishIfHidden);
+    return () => owner.removeEventListener("visibilitychange", finishIfHidden);
+  }
+  async _waitForAnimation(animation) {
+    if (this.released) {
+      animation.cancel();
+      return false;
+    }
+    this.animations.add(animation);
+    const stopWatchingVisibility = this._finishWhileDocumentHidden(animation);
+    try {
+      await animation.finished;
+      return !this.released && !this.cancelledAnimations.has(animation);
+    } catch (error) {
+      if (this.released || this.cancelledAnimations.has(animation))
+        return false;
+      throw error;
+    } finally {
+      stopWatchingVisibility();
+      this.animations.delete(animation);
+    }
+  }
+  getElement() {
+    return this.released ? null : this.element;
+  }
+  disappear() {
+    return this._disappear();
+  }
+  release() {
+    if (this.released)
+      return;
+    this.released = true;
+    this.cancelAnimations();
+    this._release();
+  }
+  cancelAnimations() {
+    for (const animation of this.animations) {
+      this._cancelAnimation(animation);
+    }
+    this.animations.clear();
+  }
+  _cancelAnimation(animation) {
+    this.cancelledAnimations.add(animation);
+    animation.cancel();
+  }
+}
+
+// packages/core/src/elements/idle-presentation.ts
+var OVERLAY_IDLE_STYLE = {
+  "clip-rule": "evenodd",
+  "fill-rule": "evenodd",
+  height: "100%",
+  left: "0px",
+  "pointer-events": "none",
+  position: "fixed",
+  "stroke-linejoin": "round",
+  "stroke-miterlimit": "2",
+  top: "0px",
+  width: "100%",
+  "z-index": "10000"
+};
+var OVERLAY_IDLE_ATTRIBUTES = {
+  "aria-hidden": "true",
+  "data-glow-tour-allow-interaction": "false",
+  inert: "true"
+};
+var POINTER_IDLE_STYLE = {
+  left: "0px",
+  opacity: "0",
+  "pointer-events": "none",
+  position: "fixed",
+  top: "0px",
+  "will-change": "top, left, transform, opacity",
+  "z-index": "10002"
+};
+var POINTER_IDLE_ATTRIBUTES = {
+  "aria-hidden": "true"
+};
+var POPOVER_IDLE_STYLE = {
+  left: "0px",
+  opacity: "0",
+  position: "fixed",
+  top: "0px",
+  "transform-origin": "center center",
+  "z-index": "10001"
+};
+var POPOVER_IDLE_ATTRIBUTES = {
+  "aria-hidden": "true",
+  inert: "true",
+  tabindex: "-1"
+};
+
+// packages/core/src/elements/overlay.ts
+var DEFAULT_OVERLAY_PADDING = 8;
+var DEFAULT_OVERLAY_RADIUS = 8;
+
+class OverlayElement extends GlowTourElement {
+  currentTransition = null;
+  visualState = null;
+  setInteractionAllowed(allowed) {
+    this.element.style.setProperty("pointer-events", allowed ? "none" : "auto");
+    this.element.setAttribute("data-glow-tour-allow-interaction", String(allowed));
+  }
+  async moveToTarget(nextPosition, step) {
+    const nextVisualState = this._getVisualState(step);
+    const path = this._getPathElement();
+    if (!path) {
+      this.visualState = nextVisualState;
+      return;
+    }
+    const keyframe = this.getRenderedTargetStyles(path, this._getNextStyles(nextPosition, step));
+    this.visualState = nextVisualState;
+    if (!path.style.getPropertyValue("d")) {
+      for (const [property, value] of Object.entries(keyframe)) {
+        if (property !== "opacity" && value != null) {
+          path.style.setProperty(property, String(value));
+        }
+      }
+      const opacity = keyframe.opacity == null ? "0.7" : String(keyframe.opacity);
+      path.style.setProperty("opacity", "0");
+      const animation2 = this._startAnimation([{ opacity: "0" }, { opacity }], {
+        ...this._getAnimationOptions(),
+        fill: "none"
+      }, path);
+      if (!animation2 || await this._waitForAnimation(animation2))
+        this.applyStyles(path, keyframe);
+      return;
+    }
+    const baseStyle = {
+      d: path.style.getPropertyValue("d") ?? "",
+      fill: path.style.getPropertyValue("fill") ?? "",
+      opacity: path.style.getPropertyValue("opacity") ?? "0"
+    };
+    const animation = this._startAnimation([baseStyle, keyframe], {
+      ...this._getAnimationOptions(),
+      fill: "none"
+    }, path);
+    if (!animation || await this._waitForAnimation(animation))
+      this.applyStyles(path, keyframe);
+  }
+  async animateTo(position, step) {
+    const path = this._getPathElement();
+    if (!path)
+      return;
+    this.commitAndCancelCurrentTransition(path);
+    const from = this.getCurrentRenderedStyles(path);
+    const finalStyles = this.getRenderedTargetStyles(path, this._getNextStyles(position, step));
+    const animation = this._startAnimation([from, finalStyles], {
+      ...this._getAnimationOptions(),
+      fill: "none"
+    }, path);
+    if (!animation) {
+      this.applyStyles(path, finalStyles);
+      return;
+    }
+    this.currentTransition = animation;
+    try {
+      const completed = await this._waitForAnimation(animation);
+      if (completed && this.currentTransition === animation) {
+        this.applyStyles(path, finalStyles);
+      }
+    } finally {
+      if (this.currentTransition === animation)
+        this.currentTransition = null;
+    }
+  }
+  _getNextStyles(position, step) {
+    const { padding, radius, color, opacity } = step.overlay || {};
+    const path = roundedRectPath(position, viewportDimensions(this.element), {
+      padding: padding ?? DEFAULT_OVERLAY_PADDING,
+      radius: radius ?? DEFAULT_OVERLAY_RADIUS
+    }, this.element);
+    return {
+      d: `path("${path}")`,
+      fill: color,
+      opacity: opacity != null ? String(opacity) : 0.7
+    };
+  }
+  initializeProps() {
+    const el = this.getElement();
+    if (!el) {
+      return;
+    }
+    const viewport = viewportDimensions(el);
+    for (const [property, value] of Object.entries(OVERLAY_IDLE_STYLE)) {
+      el.style.setProperty(property, value);
+    }
+    for (const [name, value] of Object.entries(OVERLAY_IDLE_ATTRIBUTES)) {
+      el.setAttribute(name, value);
+    }
+    el.setAttribute("viewBox", `0 0 ${viewport.width} ${viewport.height}`);
+  }
+  _getPathElement() {
+    return this.element.querySelector("path");
+  }
+  _release() {
+    this.currentTransition = null;
+    this.visualState = null;
+    const path = this._getPathElement();
+    path?.style.removeProperty("d");
+    path?.style.removeProperty("fill");
+    path?.style.setProperty("opacity", "0");
+    this.element.style.setProperty("pointer-events", "none");
+  }
+  updatePosition(nextPosition, step, animateChanges = false, onTransition) {
+    const path = this._getPathElement();
+    if (!path) {
+      return;
+    }
+    const nextVisualState = this._getVisualState(step);
+    const shouldAnimate = animateChanges && this.visualState !== null && !this._isSameVisualState(this.visualState, nextVisualState);
+    if (shouldAnimate) {
+      const transition = this.animateTo(nextPosition, step);
+      if (onTransition)
+        onTransition(transition);
+      else
+        transition.catch(() => {});
+    } else
+      this.applyStyles(path, this.getRenderedTargetStyles(path, this._getNextStyles(nextPosition, step)));
+    this.visualState = nextVisualState;
+    const viewport = viewportDimensions(this.element);
+    const viewBox = `0 0 ${viewport.width} ${viewport.height}`;
+    if (this.element.getAttribute("viewBox") !== viewBox) {
+      this.element.setAttribute("viewBox", viewBox);
+    }
+  }
+  cancelAnimations() {
+    this.currentTransition = null;
+    super.cancelAnimations();
+  }
+  applyStyles(path, styles) {
+    for (const [property, value] of Object.entries(styles)) {
+      if (value == null) {
+        if (path.style.getPropertyValue(property))
+          path.style.removeProperty(property);
+      } else if (path.style.getPropertyValue(property) !== String(value)) {
+        path.style.setProperty(property, String(value));
+      }
+    }
+  }
+  commitAndCancelCurrentTransition(path) {
+    const animation = this.currentTransition;
+    if (!animation)
+      return;
+    this.applyStyles(path, this.getCurrentRenderedStyles(path));
+    this.currentTransition = null;
+    this._cancelAnimation(animation);
+  }
+  getCurrentRenderedStyles(path) {
+    const computed = computedStyle(path);
+    return {
+      d: computed?.getPropertyValue("d") || path.style.getPropertyValue("d"),
+      fill: computed?.getPropertyValue("fill") || path.style.getPropertyValue("fill"),
+      opacity: computed?.getPropertyValue("opacity") || path.style.getPropertyValue("opacity")
+    };
+  }
+  getRenderedTargetStyles(path, styles) {
+    if (styles.fill != null)
+      return styles;
+    const inlineFill = path.style.getPropertyValue("fill");
+    if (inlineFill && this.visualState?.color === undefined) {
+      return { ...styles, fill: inlineFill };
+    }
+    path.style.removeProperty("fill");
+    const renderedFill = computedStyle(path)?.getPropertyValue("fill");
+    if (inlineFill)
+      path.style.setProperty("fill", inlineFill);
+    return { ...styles, fill: renderedFill ?? "" };
+  }
+  _getVisualState(step) {
+    return {
+      color: step.overlay?.color,
+      opacity: step.overlay?.opacity,
+      padding: step.overlay?.padding,
+      radius: step.overlay?.radius
+    };
+  }
+  _isSameVisualState(current, next) {
+    return current.color === next.color && current.opacity === next.opacity && current.padding === next.padding && current.radius === next.radius;
+  }
+  async _appear(position, step) {
+    const path = this._getPathElement();
+    if (!path) {
+      return Promise.resolve();
+    }
+    const finalStyles = this.getRenderedTargetStyles(path, this._getNextStyles(position, step));
+    const opacity = String(finalStyles.opacity ?? "0.7");
+    this.applyStyles(path, { ...finalStyles, opacity: "0" });
+    const animation = this._startAnimation([{ opacity: "0" }, { opacity }], {
+      ...this._getAnimationOptions(),
+      fill: "none"
+    }, path);
+    if (!animation || await this._waitForAnimation(animation))
+      this.applyStyles(path, finalStyles);
+  }
+  async _disappear() {
+    const path = this._getPathElement();
+    if (!path) {
+      return Promise.resolve();
+    }
+    const animation = this._startAnimation({
+      opacity: "0"
+    }, { ...this._getAnimationOptions(), fill: "none" }, path);
+    if (animation && !await this._waitForAnimation(animation))
+      return;
+    path.style.removeProperty("d");
+    path.style.removeProperty("fill");
+    path.style.setProperty("opacity", "0");
+    this.element.style.setProperty("pointer-events", "none");
+  }
+}
+function computedStyle(element) {
+  const document2 = element.ownerDocument;
+  const currentWindow = document2 && "defaultView" in document2 ? document2.defaultView : ownerWindow(element);
+  return typeof currentWindow?.getComputedStyle === "function" ? currentWindow.getComputedStyle(element) : null;
+}
+
+// packages/core/src/elements/pointer.ts
+var DEFAULT_INDICATOR_GAP = 16;
+var POINTER_ANIMATION_DISTANCE = 8;
+var POINTER_ANIMATION_DURATION = 800;
+var DEFAULT_TRY_ORDER = [
+  "left",
+  "right",
+  "top",
+  "bottom"
+];
+var POINTER_DIRECTION_SELECTOR = "[data-glow-tour-pointer-direction]";
+var OPPOSITE_DIRECTION = {
+  bottom: "top",
+  left: "right",
+  right: "left",
+  top: "bottom"
+};
+
+class PointerElement extends GlowTourElement {
+  animation = null;
+  popoverPlacement;
+  directionNodes = null;
+  initializeProps() {
+    for (const [property, value] of Object.entries(POINTER_IDLE_STYLE)) {
+      this.element.style.setProperty(property, value);
+    }
+    for (const [name, value] of Object.entries(POINTER_IDLE_ATTRIBUTES)) {
+      this.element.setAttribute(name, value);
+    }
+  }
+  _getNextStyles(position, step) {
+    const nextPosition = this._resolvePosition(position, step);
+    this._setPlacement(nextPosition.placement);
+    return {
+      left: `${roundByDPR(nextPosition.x, this.element)}px`,
+      top: `${roundByDPR(nextPosition.y, this.element)}px`
+    };
+  }
+  async moveToTarget(nextPosition, step, appear, popoverPlacement) {
+    this.popoverPlacement = popoverPlacement;
+    if (!appear) {
+      await this._disappear();
+    }
+    await this._appear(nextPosition, step);
+  }
+  updatePosition(nextPosition, step, popoverPlacement) {
+    this.popoverPlacement = popoverPlacement;
+    const currentPlacement = this.element.getAttribute("data-glow-tour-placement");
+    const nextPositionState = this._resolvePosition(nextPosition, step);
+    const nextPlacement = nextPositionState.placement;
+    const left = `${roundByDPR(nextPositionState.x, this.element)}px`;
+    const top = `${roundByDPR(nextPositionState.y, this.element)}px`;
+    if (this.element.style.getPropertyValue("left") !== left) {
+      this.element.style.setProperty("left", left);
+    }
+    if (this.element.style.getPropertyValue("top") !== top) {
+      this.element.style.setProperty("top", top);
+    }
+    if (currentPlacement !== nextPlacement) {
+      this._setPlacement(nextPlacement);
+    }
+    if (nextPlacement !== currentPlacement && this.element.getAttribute("aria-hidden") !== "true") {
+      this._startPointerAnimation(nextPlacement);
+    }
+  }
+  syncVisibility(visible, position, step, popoverPlacement) {
+    this.cancelAnimations();
+    this.popoverPlacement = popoverPlacement;
+    if (!visible) {
+      this.element.style.setProperty("opacity", "0");
+      this.element.setAttribute("aria-hidden", "true");
+      this._setPlacement(null);
+      return;
+    }
+    const styles = this._getNextStyles(position, step);
+    for (const [property, value] of Object.entries(styles)) {
+      if (value != null)
+        this.element.style.setProperty(property, String(value));
+    }
+    this.element.style.setProperty("opacity", "1");
+    this.element.removeAttribute("aria-hidden");
+    const placement = this.element.getAttribute("data-glow-tour-placement");
+    this._startPointerAnimation(placement);
+  }
+  cancelAnimations() {
+    super.cancelAnimations();
+    this._stopAnimation();
+  }
+  async _appear(position, step) {
+    const styles = this._getNextStyles(position, step);
+    for (const [property, value] of Object.entries(styles)) {
+      if (value != null)
+        this.element.style.setProperty(property, String(value));
+    }
+    const animation = this._startAnimation({ opacity: 1 }, {
+      ...this._getAnimationOptions(),
+      fill: "none"
+    });
+    if (animation && !await this._waitForAnimation(animation))
+      return;
+    this.element.style.setProperty("opacity", "1");
+    this.element.removeAttribute("aria-hidden");
+    const placement = this.element.getAttribute("data-glow-tour-placement");
+    this._startPointerAnimation(placement);
+  }
+  async _disappear() {
+    this._stopAnimation();
+    const animation = this._startAnimation({ opacity: 0 }, {
+      ...this._getAnimationOptions(),
+      fill: "none"
+    });
+    if (animation && !await this._waitForAnimation(animation))
+      return;
+    this.element.style.setProperty("opacity", "0");
+    this.element.setAttribute("aria-hidden", "true");
+    this._setPlacement(null);
+  }
+  _resolvePosition(targetPosition, step) {
+    const pointerPosition = this.element.getBoundingClientRect();
+    const excludedPlacement = this.popoverPlacement === "center" ? undefined : this.popoverPlacement;
+    const configuredOrder = step.indicator?.placementTryOrder ?? [];
+    const tryOrder = [...new Set([...configuredOrder, ...DEFAULT_TRY_ORDER])].filter((placement2) => placement2 !== excludedPlacement);
+    const gap = Math.max(0, step.indicator?.gap ?? DEFAULT_INDICATOR_GAP);
+    const candidates = this._getCandidates(targetPosition, pointerPosition, gap);
+    for (const placement2 of tryOrder) {
+      const candidate2 = candidates[placement2];
+      if (isInViewport({
+        left: candidate2.x,
+        top: candidate2.y,
+        right: candidate2.x + pointerPosition.width,
+        bottom: candidate2.y + pointerPosition.height
+      }, this.element)) {
+        return { ...candidate2, placement: placement2 };
+      }
+    }
+    const placement = tryOrder[0] ?? DEFAULT_TRY_ORDER[0];
+    const candidate = candidates[placement];
+    const viewport = viewportDimensions(this.element);
+    return {
+      placement,
+      x: Math.min(Math.max(candidate.x, 0), Math.max(viewport.width - pointerPosition.width, 0)),
+      y: Math.min(Math.max(candidate.y, 0), Math.max(viewport.height - pointerPosition.height, 0))
+    };
+  }
+  _getCandidates(targetPosition, pointerPosition, gap) {
+    const centeredX = targetPosition.left + (targetPosition.width - pointerPosition.width) / 2;
+    const centeredY = targetPosition.top + (targetPosition.height - pointerPosition.height) / 2;
+    return {
+      top: {
+        x: centeredX,
+        y: targetPosition.top - pointerPosition.height - gap
+      },
+      bottom: {
+        x: centeredX,
+        y: targetPosition.bottom + gap
+      },
+      left: {
+        x: targetPosition.left - pointerPosition.width - gap,
+        y: centeredY
+      },
+      right: {
+        x: targetPosition.right + gap,
+        y: centeredY
+      }
+    };
+  }
+  _startPointerAnimation(placement) {
+    this._stopAnimation();
+    this.animation = this._startAnimation([{ transform: "translate(0px, 0px)" }, { transform: this._getTargetTransform(placement) }], {
+      direction: "alternate",
+      duration: POINTER_ANIMATION_DURATION,
+      easing: "ease-in-out",
+      iterations: Number.POSITIVE_INFINITY
+    });
+  }
+  _stopAnimation() {
+    this.animation?.cancel();
+    this.animation = null;
+    this.element.style.removeProperty("transform");
+  }
+  _release() {
+    this._stopAnimation();
+    this.element.style.setProperty("opacity", "0");
+    this.element.setAttribute("aria-hidden", "true");
+    this._setPlacement(null);
+  }
+  _setPlacement(placement) {
+    if (placement)
+      this.element.setAttribute("data-glow-tour-placement", placement);
+    else
+      this.element.removeAttribute("data-glow-tour-placement");
+    this._syncDirectionVisibility(placement);
+  }
+  _syncDirectionVisibility(placement) {
+    const nodes = this._ensureDirectionNodes();
+    const pointingDirection = placement ? OPPOSITE_DIRECTION[placement] : null;
+    for (const [direction, node] of Object.entries(nodes)) {
+      node.style.setProperty("display", direction === pointingDirection ? "" : "none");
+    }
+  }
+  _ensureDirectionNodes() {
+    if (this.directionNodes)
+      return this.directionNodes;
+    const nodes = {};
+    if (typeof this.element.querySelectorAll === "function") {
+      for (const node of Array.from(this.element.querySelectorAll(POINTER_DIRECTION_SELECTOR))) {
+        const direction = node.getAttribute("data-glow-tour-pointer-direction");
+        if (direction)
+          nodes[direction] = node;
+      }
+    }
+    this.directionNodes = nodes;
+    return nodes;
+  }
+  _getTargetTransform(placement) {
+    switch (placement) {
+      case "top":
+        return `translate(0px, ${POINTER_ANIMATION_DISTANCE}px)`;
+      case "bottom":
+        return `translate(0px, -${POINTER_ANIMATION_DISTANCE}px)`;
+      case "left":
+        return `translate(${POINTER_ANIMATION_DISTANCE}px, 0px)`;
+      case "right":
+        return `translate(-${POINTER_ANIMATION_DISTANCE}px, 0px)`;
+    }
+  }
+}
+
+// packages/core/src/dom/dom-mutation-lease.ts
+class DomMutationLease {
+  element;
+  attributes = new Map;
+  styles = new Map;
+  released = false;
+  constructor(element) {
+    this.element = element;
+  }
+  setAttribute(name, value) {
+    if (this.released)
+      return;
+    const mutation = this.attributes.get(name);
+    if (mutation)
+      mutation.value = value;
+    else
+      this.attributes.set(name, { original: this.element.getAttribute(name), value });
+    if (value === null)
+      this.element.removeAttribute(name);
+    else
+      this.element.setAttribute(name, value);
+  }
+  setStyle(name, value, priority = "") {
+    if (this.released)
+      return;
+    const mutation = this.styles.get(name);
+    if (value === null) {
+      if (mutation) {
+        this.element.style.removeProperty(name);
+        mutation.value = this.element.style.getPropertyValue(name);
+        mutation.priority = this.element.style.getPropertyPriority(name);
+      } else {
+        const firstMutation2 = this.styleMutation(name);
+        this.element.style.removeProperty(name);
+        firstMutation2.value = this.element.style.getPropertyValue(name);
+        firstMutation2.priority = this.element.style.getPropertyPriority(name);
+        this.styles.set(name, firstMutation2);
+      }
+      return;
+    }
+    const accepted = isStyleDeclarationAccepted(this.element, name, value, priority);
+    if (mutation) {
+      this.element.style.setProperty(name, value, priority);
+      if (!accepted)
+        return;
+      mutation.value = this.element.style.getPropertyValue(name);
+      mutation.priority = this.element.style.getPropertyPriority(name);
+      return;
+    }
+    const firstMutation = this.styleMutation(name);
+    this.element.style.setProperty(name, value, priority);
+    if (!accepted)
+      return;
+    firstMutation.value = this.element.style.getPropertyValue(name);
+    firstMutation.priority = this.element.style.getPropertyPriority(name);
+    this.styles.set(name, firstMutation);
+  }
+  releaseStyle(name) {
+    if (this.released)
+      return;
+    const mutation = this.styles.get(name);
+    if (!mutation)
+      return;
+    try {
+      this.restoreStyle(name, mutation);
+    } finally {
+      this.styles.delete(name);
+    }
+  }
+  release() {
+    if (this.released)
+      return;
+    this.released = true;
+    let failed = false;
+    let failure;
+    for (const [name, mutation] of this.attributes) {
+      try {
+        if (this.element.getAttribute(name) !== mutation.value)
+          continue;
+        if (mutation.original === null)
+          this.element.removeAttribute(name);
+        else
+          this.element.setAttribute(name, mutation.original);
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+    }
+    for (const [name, mutation] of this.styles) {
+      try {
+        this.restoreStyle(name, mutation);
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+    }
+    if (failed)
+      throw failure;
+  }
+  styleMutation(name) {
+    const original = this.element.style.getPropertyValue(name);
+    return {
+      original: original === "" ? null : original,
+      originalPriority: this.element.style.getPropertyPriority(name),
+      priority: this.element.style.getPropertyPriority(name),
+      value: original
+    };
+  }
+  restoreStyle(name, mutation) {
+    if (this.element.style.getPropertyValue(name) !== (mutation.value ?? "") || this.element.style.getPropertyPriority(name) !== mutation.priority) {
+      return;
+    }
+    if (mutation.original === null)
+      this.element.style.removeProperty(name);
+    else
+      this.element.style.setProperty(name, mutation.original, mutation.originalPriority);
+  }
+}
+function isStyleDeclarationAccepted(element, name, value, priority) {
+  const probe = element.ownerDocument.createElement("div");
+  probe.style.setProperty(name, value, priority);
+  return value === "" || probe.style.getPropertyValue(name) !== "";
+}
+
+// packages/core/src/elements/popover-arrow-styles.ts
+var ARROW_STYLES_SELECTOR = "style[data-glow-tour-core-arrow-styles]";
+var ARROW_STYLES = `
+:where([data-glow-tour-popover])::before {
+  background-color: var(--glow-tour-arrow-color, var(--glow-tour-color-surface, #ffffff));
+  border: var(--glow-tour-arrow-border-width, 1px) solid var(--glow-tour-arrow-border-color, var(--glow-tour-color-border, #dedee3));
+  border-radius: var(--glow-tour-arrow-border-radius, 0px);
+  box-sizing: border-box;
+  content: "";
+  height: var(--glow-tour-arrow-size, 12px);
+  pointer-events: none;
+  position: absolute;
+  width: var(--glow-tour-arrow-size, 12px);
+}
+
+:where([data-glow-tour-popover][data-glow-tour-placement="top"])::before {
+  border-left: 0;
+  border-top: 0;
+  bottom: 0;
+  left: var(--glow-tour-arrow-offset);
+  transform: translate(-50%, 50%) rotate(45deg);
+}
+
+:where([data-glow-tour-popover][data-glow-tour-placement="bottom"])::before {
+  border-bottom: 0;
+  border-right: 0;
+  left: var(--glow-tour-arrow-offset);
+  top: 0;
+  transform: translate(-50%, -50%) rotate(45deg);
+}
+
+:where([data-glow-tour-popover][data-glow-tour-placement="left"])::before {
+  border-bottom: 0;
+  border-left: 0;
+  right: 0;
+  top: var(--glow-tour-arrow-offset);
+  transform: translate(50%, -50%) rotate(45deg);
+}
+
+:where([data-glow-tour-popover][data-glow-tour-placement="right"])::before {
+  border-right: 0;
+  border-top: 0;
+  left: 0;
+  top: var(--glow-tour-arrow-offset);
+  transform: translate(-50%, -50%) rotate(45deg);
+}
+
+:where([data-glow-tour-popover][data-glow-tour-arrow-hidden])::before {
+  display: none;
+}
+`;
+function ensurePopoverArrowStyles(element, options) {
+  if (options?.disabled)
+    return;
+  if (typeof element.getRootNode !== "function")
+    return;
+  const root = element.getRootNode();
+  if (root.nodeType !== 9 && root.nodeType !== 11)
+    return;
+  const styleRoot = root;
+  if (styleRoot.querySelector(ARROW_STYLES_SELECTOR))
+    return;
+  const ownerDocument2 = root.nodeType === 9 ? root : element.ownerDocument;
+  const style = ownerDocument2.createElement("style");
+  style.setAttribute("data-glow-tour-core-arrow-styles", "");
+  if (options?.nonce)
+    style.nonce = options.nonce;
+  style.textContent = ARROW_STYLES;
+  if (root.nodeType === 9) {
+    const document2 = root;
+    (document2.head ?? document2.documentElement).append(style);
+  } else {
+    root.append(style);
+  }
+}
+
+// packages/core/src/elements/popover.ts
+var DEFAULT_POPOVER_GAP = 16;
+var DEFAULT_ARROW_EDGE_PADDING = 16;
+var DEFAULT_TRY_ORDER2 = ["bottom", "top", "right", "left"];
+var REPLACEMENT_DIFF = 50;
+var ARROW_STYLE_PROPERTIES = {
+  borderRadius: "--glow-tour-arrow-border-radius",
+  borderWidth: "--glow-tour-arrow-border-width",
+  color: "--glow-tour-arrow-color",
+  size: "--glow-tour-arrow-size"
+};
+
+class PopoverElement extends GlowTourElement {
+  appliedPosition = null;
+  pendingReposition = null;
+  repositionPhase = "idle";
+  repositionGeneration = 0;
+  mutationLease = new DomMutationLease(this.element);
+  _getNextStyles(position, step) {
+    this._applyArrowStyles(step);
+    const nextPosition = this.resolvePosition(position, step);
+    this._applyPositionState(nextPosition);
+    this.appliedPosition = nextPosition;
+    return {
+      transform: `translate(${roundByDPR(nextPosition.x, this.element)}px, ${roundByDPR(nextPosition.y, this.element)}px)`
+    };
+  }
+  resolvePosition(targetPosition, step) {
+    const currentElement = this.getElement();
+    if (!currentElement) {
+      return {
+        placement: "center",
+        x: 0,
+        y: 0,
+        arrowOffset: null
+      };
+    }
+    const gap = Math.max(0, step.popover?.gap ?? DEFAULT_POPOVER_GAP);
+    const arrowDisabled = step.popover?.arrow?.disabled === true;
+    const arrowEdgePadding = step.popover?.arrow?.edgePadding ?? DEFAULT_ARROW_EDGE_PADDING;
+    const popoverPosition = currentElement.getBoundingClientRect();
+    const viewport = viewportDimensions(currentElement);
+    const minX = gap;
+    const maxX = viewport.width - gap - popoverPosition.width;
+    const minY = gap;
+    const maxY = viewport.height - gap - popoverPosition.height;
+    const targetCenterX = targetPosition.left + targetPosition.width / 2;
+    const targetCenterY = targetPosition.top + targetPosition.height / 2;
+    if (maxX < minX || maxY < minY) {
+      return this._centerPosition(popoverPosition, viewport);
+    }
+    const centeredX = targetCenterX - popoverPosition.width / 2;
+    const centeredY = targetCenterY - popoverPosition.height / 2;
+    const candidates = {
+      top: {
+        x: clamp(centeredX, minX, maxX),
+        y: targetPosition.top - popoverPosition.height - gap
+      },
+      bottom: {
+        x: clamp(centeredX, minX, maxX),
+        y: targetPosition.bottom + gap
+      },
+      left: {
+        x: targetPosition.left - popoverPosition.width - gap,
+        y: clamp(centeredY, minY, maxY)
+      },
+      right: {
+        x: targetPosition.right + gap,
+        y: clamp(centeredY, minY, maxY)
+      }
+    };
+    const tryOrder = step.popover?.placementTryOrder ?? DEFAULT_TRY_ORDER2;
+    for (const placement of tryOrder) {
+      const candidate = candidates[placement];
+      const isVisible = candidate.x >= minX && candidate.y >= minY && candidate.x + popoverPosition.width <= viewport.width - gap && candidate.y + popoverPosition.height <= viewport.height - gap;
+      if (!isVisible) {
+        continue;
+      }
+      const arrowOffset = arrowDisabled ? null : placement === "top" || placement === "bottom" ? targetCenterX - candidate.x : targetCenterY - candidate.y;
+      const arrowAxisSize = placement === "top" || placement === "bottom" ? popoverPosition.width : popoverPosition.height;
+      if (arrowOffset !== null && (arrowOffset < arrowEdgePadding || arrowOffset > arrowAxisSize - arrowEdgePadding)) {
+        continue;
+      }
+      return { ...candidate, arrowOffset, placement };
+    }
+    return this._centerPosition(popoverPosition, viewport);
+  }
+  _centerPosition(popoverPosition, viewport) {
+    return {
+      arrowOffset: null,
+      placement: "center",
+      x: (viewport.width - popoverPosition.width) / 2,
+      y: (viewport.height - popoverPosition.height) / 2
+    };
+  }
+  _applyPositionState(position) {
+    if (this.element.getAttribute("data-glow-tour-placement") !== position.placement) {
+      this.mutationLease.setAttribute("data-glow-tour-placement", position.placement);
+    }
+    const arrowHidden = position.arrowOffset === null;
+    if (this.element.hasAttribute("data-glow-tour-arrow-hidden") !== arrowHidden) {
+      this.mutationLease.setAttribute("data-glow-tour-arrow-hidden", arrowHidden ? "" : null);
+    }
+    if (position.arrowOffset === null) {
+      if (this.element.style.getPropertyValue("--glow-tour-arrow-offset")) {
+        this.mutationLease.setStyle("--glow-tour-arrow-offset", null);
+      }
+    } else {
+      const arrowOffset = `${roundByDPR(position.arrowOffset, this.element)}px`;
+      if (this.element.style.getPropertyValue("--glow-tour-arrow-offset") !== arrowOffset) {
+        this.mutationLease.setStyle("--glow-tour-arrow-offset", arrowOffset);
+      }
+    }
+  }
+  async moveToTarget(nextPosition, step, appear, onChange) {
+    if (!appear) {
+      await this._disappear();
+    }
+    if (onChange)
+      await onChange();
+    await this._appear(nextPosition, step);
+  }
+  initializeProps() {
+    const el = this.getElement();
+    if (!el) {
+      return;
+    }
+    for (const [property, value] of Object.entries(POPOVER_IDLE_STYLE)) {
+      this.mutationLease.setStyle(property, value);
+    }
+    if (!el.hasAttribute("tabindex")) {
+      this.mutationLease.setAttribute("tabindex", POPOVER_IDLE_ATTRIBUTES.tabindex);
+    }
+    this.mutationLease.setAttribute("aria-hidden", POPOVER_IDLE_ATTRIBUTES["aria-hidden"]);
+    this.mutationLease.setAttribute("inert", POPOVER_IDLE_ATTRIBUTES.inert);
+  }
+  updatePosition(nextPosition, step, onReposition) {
+    const nextCoordinates = this.resolvePosition(nextPosition, step);
+    const appliedPosition = this.appliedPosition;
+    if (!appliedPosition) {
+      this._applyPositionState(nextCoordinates);
+      this.appliedPosition = nextCoordinates;
+      this._applyTransform(nextCoordinates);
+      return nextCoordinates.placement;
+    }
+    if (this.repositionPhase === "fading-out") {
+      this.pendingReposition = { position: nextPosition, step };
+      return nextCoordinates.placement;
+    }
+    const shouldReposition = appliedPosition.placement !== nextCoordinates.placement || Math.abs(nextCoordinates.x - appliedPosition.x) > REPLACEMENT_DIFF || Math.abs(nextCoordinates.y - appliedPosition.y) > REPLACEMENT_DIFF;
+    if (shouldReposition) {
+      this.pendingReposition = { position: nextPosition, step };
+      if (this.repositionPhase === "idle") {
+        const reposition = this._flushReposition();
+        if (onReposition)
+          onReposition(reposition);
+        else
+          reposition.catch(() => {});
+      }
+    } else if (this.repositionPhase === "fading-in") {
+      this.pendingReposition = null;
+    } else {
+      const stationaryPosition = this._stationaryPosition(appliedPosition, nextCoordinates, nextPosition, step);
+      this._applyPositionState(stationaryPosition);
+      this.appliedPosition = stationaryPosition;
+    }
+    return nextCoordinates.placement;
+  }
+  cancelAnimations() {
+    this.repositionGeneration += 1;
+    this.pendingReposition = null;
+    this.repositionPhase = "idle";
+    super.cancelAnimations();
+  }
+  async _flushReposition() {
+    if (this.repositionPhase !== "idle")
+      return;
+    const generation = ++this.repositionGeneration;
+    try {
+      while (this.pendingReposition && generation === this.repositionGeneration) {
+        let pending = this.pendingReposition;
+        this.pendingReposition = null;
+        this.repositionPhase = "fading-out";
+        await this._disappear();
+        if (generation !== this.repositionGeneration || !this.getElement())
+          return;
+        pending = this.pendingReposition ?? pending;
+        this.pendingReposition = null;
+        this.repositionPhase = "fading-in";
+        await this._appear(pending.position, pending.step);
+      }
+    } finally {
+      if (generation === this.repositionGeneration)
+        this.repositionPhase = "idle";
+    }
+  }
+  _applyTransform(position) {
+    const transform = `translate(${roundByDPR(position.x, this.element)}px, ${roundByDPR(position.y, this.element)}px)`;
+    if (this.element.style.transform !== transform) {
+      this.mutationLease.setStyle("transform", transform);
+    }
+  }
+  _stationaryPosition(appliedPosition, nextPosition, targetPosition, step) {
+    if (nextPosition.arrowOffset === null) {
+      return { ...appliedPosition, arrowOffset: null };
+    }
+    const popoverRect = this.element.getBoundingClientRect();
+    const horizontal = appliedPosition.placement === "top" || appliedPosition.placement === "bottom";
+    const targetCenter = horizontal ? targetPosition.left + targetPosition.width / 2 : targetPosition.top + targetPosition.height / 2;
+    const popoverStart = horizontal ? appliedPosition.x : appliedPosition.y;
+    const popoverSize = horizontal ? popoverRect.width : popoverRect.height;
+    const arrowEdgePadding = step.popover?.arrow?.edgePadding ?? DEFAULT_ARROW_EDGE_PADDING;
+    return {
+      ...appliedPosition,
+      arrowOffset: clamp(targetCenter - popoverStart, arrowEdgePadding, Math.max(arrowEdgePadding, popoverSize - arrowEdgePadding))
+    };
+  }
+  _applyArrowStyles(step) {
+    const arrow = step.popover?.arrow;
+    ensurePopoverArrowStyles(this.element, {
+      disabled: arrow?.disableAutoStyles,
+      nonce: arrow?.styleNonce
+    });
+    this._applyArrowStyle(ARROW_STYLE_PROPERTIES.color, arrow?.color);
+    this._applyArrowStyle(ARROW_STYLE_PROPERTIES.size, toPixels(arrow?.size));
+    this._applyArrowStyle(ARROW_STYLE_PROPERTIES.borderWidth, toPixels(arrow?.borderWidth));
+    this._applyArrowStyle(ARROW_STYLE_PROPERTIES.borderRadius, toPixels(arrow?.borderRadius));
+  }
+  _applyArrowStyle(property, value) {
+    if (value === undefined) {
+      this.mutationLease.releaseStyle(property);
+      return;
+    }
+    if (this.element.style.getPropertyValue(property) !== value || this.element.style.getPropertyPriority(property)) {
+      this.mutationLease.setStyle(property, value);
+    }
+  }
+  async _appear(position, step) {
+    const defaultStyles = this._getNextStyles(position, step);
+    for (const [key, value] of Object.entries(defaultStyles)) {
+      if (value != null)
+        this.mutationLease.setStyle(key, String(value));
+    }
+    const animation = this._startAnimation([
+      {
+        opacity: 1
+      }
+    ], this._getAnimationOptions());
+    if (animation && !await this._waitForAnimation(animation))
+      return;
+    this._applyVisibleState();
+  }
+  async _disappear() {
+    const animation = this._startAnimation({
+      opacity: 0
+    }, this._getAnimationOptions());
+    if (animation && !await this._waitForAnimation(animation))
+      return;
+    this._applyHiddenState();
+  }
+  _release() {
+    this.mutationLease.release();
+  }
+  _applyVisibleState() {
+    this.mutationLease.setStyle("opacity", "1");
+    this.mutationLease.setAttribute("aria-hidden", null);
+    this.mutationLease.setAttribute("inert", null);
+  }
+  _applyHiddenState() {
+    this.mutationLease.setStyle("opacity", "0");
+    this.mutationLease.setAttribute("aria-hidden", "true");
+    this.mutationLease.setAttribute("inert", "true");
+    this.mutationLease.setStyle("transform", null);
+  }
+}
+function toPixels(value) {
+  return value === undefined ? undefined : `${Math.max(0, value)}px`;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+// packages/core/src/state/focusable.ts
+var FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "summary",
+  "audio[controls]",
+  "video[controls]",
+  "[contenteditable]:not([contenteditable='false'])",
+  "[tabindex]:not([tabindex='-1'])"
+].join(",");
+var TOUR_TRIGGER_SELECTOR = [
+  "[data-glow-tour-previous-trigger]",
+  "[data-glow-tour-cancel-trigger]",
+  "[data-glow-tour-advance-trigger]"
+].join(",");
+function focusableElements(root) {
+  return Array.from(root.querySelectorAll(FOCUSABLE_SELECTOR)).filter(isFocusable);
+}
+function focusableElementsOwnedBy(root) {
+  const ownerRoot = root.closest("[data-glow-tour-root]");
+  return focusableElements(root).filter((element) => element.closest("[data-glow-tour-root]") === ownerRoot);
+}
+function focusableTourControls(root) {
+  return focusableElementsOwnedBy(root).filter((element) => element.matches(TOUR_TRIGGER_SELECTOR));
+}
+function isFocusable(element) {
+  if (element.hasAttribute("disabled") || element.hasAttribute("hidden") || element.getAttribute("aria-disabled") === "true" || element.getAttribute("aria-hidden") === "true" || element.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+    return false;
+  for (let current = element;current; current = current.parentElement) {
+    const document2 = current.ownerDocument;
+    const currentWindow = document2 && "defaultView" in document2 ? document2.defaultView : ownerWindow(current);
+    const style = typeof currentWindow?.getComputedStyle === "function" ? currentWindow.getComputedStyle(current) : null;
+    if (!style)
+      return false;
+    if (style.display === "none" || style.visibility === "hidden")
+      return false;
+  }
+  return true;
+}
+
+// packages/core/src/state/focus-guard.ts
+class FocusGuard {
+  initialFocus = null;
+  document = null;
+  popover = null;
+  allowedTarget = null;
+  allowTargetInteraction = false;
+  fallback = null;
+  fallbackLease = null;
+  direction = "advance";
+  active = false;
+  redirecting = false;
+  handleFocusIn = (event) => {
+    if (!this.active || this.redirecting) {
+      return;
+    }
+    const target = event.target;
+    if (!isNode(target, this.popover) || this.isAllowed(target)) {
+      return;
+    }
+    this.focusFallback();
+  };
+  activate(scope) {
+    const document2 = ownerDocument(scope.popover);
+    if (!document2)
+      return;
+    if (this.active && this.document !== document2)
+      this.deactivate();
+    if (!this.active) {
+      this.document = document2;
+      this.initialFocus = isHTMLElement(this.document.activeElement, scope.popover) ? this.document.activeElement : null;
+      this.document.addEventListener("focusin", this.handleFocusIn, true);
+      this.active = true;
+    }
+    this.update(scope);
+    const currentFocus = this.document?.activeElement;
+    if (scope.autoFocus !== false || !isNode(currentFocus, scope.popover) || !this.isAllowed(currentFocus)) {
+      this.focusFallback();
+    }
+  }
+  update(scope) {
+    this.popover = scope.popover;
+    this.allowedTarget = scope.allowedTarget ?? null;
+    this.allowTargetInteraction = scope.allowTargetInteraction ?? false;
+    this.direction = scope.direction;
+    this.setFallback(scope.fallback ?? null);
+  }
+  focus() {
+    if (this.active)
+      this.focusFallback();
+  }
+  deactivate() {
+    if (!this.active) {
+      return;
+    }
+    this.document?.removeEventListener("focusin", this.handleFocusIn, true);
+    this.document = null;
+    this.active = false;
+    this.popover = null;
+    this.allowedTarget = null;
+    this.allowTargetInteraction = false;
+    this.restoreFallback();
+    const focusToRestore = this.initialFocus;
+    this.initialFocus = null;
+    if (focusToRestore?.isConnected) {
+      focusToRestore.focus();
+    }
+  }
+  isAllowed(target) {
+    if (target === this.fallback)
+      return true;
+    const popover = this.popover;
+    if (popover && belongsToScope(target, popover))
+      return true;
+    return this.allowTargetInteraction && !!this.allowedTarget && belongsToScope(target, this.allowedTarget);
+  }
+  focusFallback() {
+    const popover = this.popover;
+    if (!popover?.isConnected) {
+      return;
+    }
+    const nextFocus = this.findFocusable(popover, this.direction) ?? (isFocusable(popover) ? popover : this.fallback?.isConnected && isFocusable(this.fallback) ? this.fallback : null);
+    if (!nextFocus)
+      return;
+    this.redirecting = true;
+    nextFocus.focus();
+    this.redirecting = false;
+  }
+  setFallback(fallback) {
+    if (this.fallback === fallback)
+      return;
+    this.restoreFallback();
+    this.fallback = fallback;
+    if (!fallback)
+      return;
+    this.fallbackLease = new DomMutationLease(fallback);
+    this.fallbackLease.setAttribute("tabindex", "-1");
+  }
+  restoreFallback() {
+    this.fallbackLease?.release();
+    this.fallbackLease = null;
+    this.fallback = null;
+  }
+  findFocusable(root, direction) {
+    const candidates = focusableTourControls(root);
+    const selector = direction === "advance" ? "[data-glow-tour-advance-trigger]" : "[data-glow-tour-previous-trigger]";
+    return candidates.find((candidate) => candidate.matches(selector)) ?? null;
+  }
+}
+function belongsToScope(target, scope) {
+  if (!scope.contains(target))
+    return false;
+  const element = isHTMLElement(target, scope) ? target : target.parentElement;
+  if (!element)
+    return target === scope;
+  return element.closest("[data-glow-tour-root]") === scope.closest("[data-glow-tour-root]");
+}
+
+// packages/core/src/state/scroll-lock.ts
+class ScrollLock {
+  document = null;
+  previousOverflow = "";
+  previousPaddingRight = "";
+  active = false;
+  activate(document2) {
+    if (this.active || !document2)
+      return;
+    const body = document2.body;
+    if (!body?.style)
+      return;
+    this.document = document2;
+    this.previousOverflow = body.style.overflow;
+    this.previousPaddingRight = body.style.paddingRight;
+    this.active = true;
+    body.style.overflow = "hidden";
+    const scrollbarWidth = this.scrollbarWidth(document2);
+    if (scrollbarWidth > 0) {
+      const currentPaddingRight = this.computedPaddingRight(document2, body);
+      body.style.paddingRight = `${currentPaddingRight + scrollbarWidth}px`;
+    }
+  }
+  deactivate() {
+    if (!this.active)
+      return;
+    const body = this.document?.body;
+    this.active = false;
+    this.document = null;
+    if (!body?.style)
+      return;
+    body.style.overflow = this.previousOverflow;
+    body.style.paddingRight = this.previousPaddingRight;
+    this.previousOverflow = "";
+    this.previousPaddingRight = "";
+  }
+  scrollbarWidth(document2) {
+    const view = document2.defaultView;
+    const documentElement = document2.documentElement;
+    if (!view || !documentElement)
+      return 0;
+    const width = view.innerWidth - documentElement.clientWidth;
+    return Number.isFinite(width) && width > 0 ? width : 0;
+  }
+  computedPaddingRight(document2, body) {
+    const view = document2.defaultView;
+    if (typeof view?.getComputedStyle !== "function")
+      return 0;
+    const value = Number.parseFloat(view.getComputedStyle(body).paddingRight || "0");
+    return Number.isFinite(value) ? value : 0;
+  }
+}
+
+// packages/core/src/dom/tour-view-driver.ts
+var DEFAULT_SCROLL_END_TIMEOUT = 1000;
+var ACTIVE_MODAL_BY_DOCUMENT = new WeakMap;
+var DEFAULT_SHORTCUTS = {
+  previous: ["ArrowLeft", "Backspace"],
+  cancel: ["Escape"],
+  advance: ["Enter", "ArrowRight"]
+};
+class DomTourViewDriver {
+  focusGuard = new FocusGuard;
+  scrollLock = new ScrollLock;
+  modalToken = {};
+  stepCleanups = [];
+  commands;
+  direction = "advance";
+  currentStep = null;
+  currentSignal = null;
+  disposed = false;
+  generation = 0;
+  active = false;
+  lastTargetRect = null;
+  lastViewport = null;
+  inertBranches = [];
+  modalDocument = null;
+  modalRoot = null;
+  overlay = null;
+  pendingKeyboardCommand = null;
+  pointer = null;
+  pendingFocusGeneration = null;
+  popover = null;
+  presentationDirty = false;
+  rafId = null;
+  rafCancel = null;
+  root = null;
+  scrollAbort = null;
+  constructor(commands) {
+    this.commands = commands ?? null;
+  }
+  setCommands(commands) {
+    if (!this.disposed)
+      this.commands = commands;
+  }
+  registerRoot(element) {
+    if (this.disposed || this.root === element)
+      return;
+    if (this.active)
+      this.releaseModality();
+    this.root = element;
+    this.refreshRegisteredElements();
+  }
+  registerOverlay(element) {
+    if (this.disposed)
+      return;
+    if (this.overlay?.getElement() === element)
+      return;
+    this.overlay?.release();
+    this.overlay = element ? new OverlayElement(element) : null;
+    this.overlay?.initializeProps();
+    this.refreshRegisteredElements();
+  }
+  registerPopover(element) {
+    if (this.disposed)
+      return;
+    if (this.popover?.getElement() === element)
+      return;
+    if (!element && this.active) {
+      this.releaseModality();
+      this.focusGuard.deactivate();
+      this.scrollLock.deactivate();
+    }
+    this.popover?.release();
+    this.popover = element ? new PopoverElement(element) : null;
+    this.popover?.initializeProps();
+    if (element)
+      this.refreshRegisteredElements();
+  }
+  registerPointer(element) {
+    if (this.disposed)
+      return;
+    if (this.pointer?.getElement() === element)
+      return;
+    this.pointer?.release();
+    this.pointer = element ? new PointerElement(element) : null;
+    this.pointer?.initializeProps();
+    this.refreshRegisteredElements();
+  }
+  async show(step, direction, signal, onBeforePopoverAppear) {
+    this.throwIfAborted(signal);
+    const generation = this.beginGeneration();
+    const removeAbort = this.cancelAnimationsOnAbort(signal);
+    const replaceVisiblePopover = this.active && onBeforePopoverAppear !== undefined;
+    let removeTransitionKeydown = () => {};
+    try {
+      this.cleanupStepResources();
+      this.throwIfStale(generation, signal);
+      this.active = false;
+      this.currentStep = step;
+      this.currentSignal = signal;
+      this.direction = direction;
+      this.lastTargetRect = null;
+      this.lastViewport = null;
+      this.presentationDirty = false;
+      if (replaceVisiblePopover) {
+        const listener = (event) => this.queueTransitionKeydown(event, step, generation);
+        const currentWindow = this.getWindow();
+        if (typeof currentWindow?.addEventListener === "function") {
+          currentWindow.addEventListener("keydown", listener);
+          removeTransitionKeydown = () => currentWindow.removeEventListener("keydown", listener);
+        }
+      }
+      const target = step.target;
+      if (!target)
+        return;
+      this.syncModality(step.behavior?.allowInteraction === true);
+      await this.scrollTargetIntoView(step, target, signal);
+      this.throwIfStale(generation, signal);
+      this.initializeElements(step);
+      const targetRect = target.getBoundingClientRect();
+      await this.appear(targetRect, step, !replaceVisiblePopover, onBeforePopoverAppear);
+      this.throwIfStale(generation, signal);
+      this.lastTargetRect = snapshotRect(targetRect);
+      this.lastViewport = snapshotViewport(target);
+      this.active = true;
+      this.activateFocus(step, target, direction, generation);
+      this.syncScrollLock(step);
+      this.throwIfStale(generation, signal);
+      removeTransitionKeydown();
+      removeTransitionKeydown = () => {};
+      this.attachStepResources(step, target, generation, signal);
+    } catch (error) {
+      if (this.isCurrentGeneration(generation))
+        this.releaseModality();
+      throw error;
+    } finally {
+      removeTransitionKeydown();
+      removeAbort();
+    }
+  }
+  async clear(signal) {
+    if (signal.aborted || this.disposed)
+      this.releaseModality();
+    this.throwIfAborted(signal);
+    const generation = this.beginGeneration();
+    const removeAbort = this.cancelAnimationsOnAbort(signal);
+    try {
+      this.cleanupStepResources();
+      this.releaseModality();
+      this.focusGuard.deactivate();
+      this.scrollLock.deactivate();
+      this.throwIfStale(generation, signal);
+      this.active = false;
+      this.currentStep = null;
+      this.currentSignal = null;
+      this.lastTargetRect = null;
+      this.lastViewport = null;
+      this.popover?.getElement()?.removeAttribute("aria-modal");
+      await Promise.allSettled([
+        this.overlay?.disappear() ?? Promise.resolve(),
+        this.popover?.disappear() ?? Promise.resolve(),
+        this.pointer?.disappear() ?? Promise.resolve()
+      ]);
+      this.throwIfStale(generation, signal);
+    } finally {
+      removeAbort();
+    }
+  }
+  releaseMount() {
+    if (this.disposed)
+      return;
+    this.beginGeneration();
+    this.cleanupStepResources();
+    this.releaseModality();
+    this.focusGuard.deactivate();
+    this.scrollLock.deactivate();
+    this.active = false;
+    this.currentStep = null;
+    this.currentSignal = null;
+    this.overlay?.release();
+    this.popover?.release();
+    this.pointer?.release();
+    this.overlay = null;
+    this.popover = null;
+    this.pointer = null;
+    this.root = null;
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.releaseMount();
+    this.disposed = true;
+    this.commands = null;
+  }
+  refreshRegisteredElements() {
+    if (!this.active || !this.currentStep || !this.lastTargetRect)
+      return;
+    const generation = this.beginGeneration();
+    this.cleanupStepResources();
+    this.activateRegisteredElements(generation).catch((error) => {
+      if (!this.isCurrentGeneration(generation))
+        return;
+      return this.commands?.reportError(error);
+    });
+  }
+  async activateRegisteredElements(generation) {
+    const step = this.currentStep;
+    const targetRect = this.lastTargetRect;
+    const target = step?.target;
+    const signal = this.currentSignal;
+    if (this.disposed || !step || !target || !targetRect || !signal)
+      return;
+    this.initializeElements(step);
+    await this.appear(targetRect, step);
+    this.throwIfStale(generation);
+    this.activateFocus(step, target, this.direction, generation);
+    this.syncScrollLock(step);
+    this.throwIfStale(generation);
+    this.attachStepResources(step, target, generation, signal);
+  }
+  initializeElements(step) {
+    const interactionAllowed = step.behavior?.allowInteraction === true;
+    this.overlay?.initializeProps();
+    this.overlay?.setAnimationOptions(animationOptions(step, step.overlay, this.overlay.getElement()));
+    this.overlay?.setInteractionAllowed(interactionAllowed);
+    this.popover?.initializeProps();
+    this.popover?.setAnimationOptions(animationOptions(step, step.popover, this.popover.getElement()));
+    const popover = this.popover?.getElement();
+    if (isHTMLElement(popover, this.root ?? popover) && !interactionAllowed)
+      popover.setAttribute("aria-modal", "true");
+    this.pointer?.initializeProps();
+    this.pointer?.setAnimationOptions(animationOptions(step, step.indicator, this.pointer.getElement()));
+  }
+  syncModality(interactionAllowed) {
+    if (interactionAllowed) {
+      this.releaseModality();
+      return;
+    }
+    const root = this.root;
+    if (!root)
+      return;
+    const document2 = root.ownerDocument;
+    const owner = ACTIVE_MODAL_BY_DOCUMENT.get(document2);
+    if (owner && owner !== this.modalToken) {
+      throw new Error("GlowTour.js only supports one active modal tour per document");
+    }
+    ACTIVE_MODAL_BY_DOCUMENT.set(document2, this.modalToken);
+    this.modalDocument = document2;
+    if (this.modalRoot === root)
+      return;
+    this.restoreInertBranches();
+    this.modalRoot = root;
+    let branch = root;
+    while (branch !== document2.body) {
+      const parent = branch.parentElement;
+      if (!parent)
+        break;
+      for (const sibling of Array.from(parent.children)) {
+        if (!isHTMLElement(sibling, root) || sibling === branch)
+          continue;
+        this.inertBranches.push({ element: sibling, previous: sibling.getAttribute("inert") });
+        sibling.setAttribute("inert", "");
+      }
+      branch = parent;
+    }
+  }
+  releaseModality() {
+    this.popover?.getElement()?.removeAttribute("aria-modal");
+    this.restoreInertBranches();
+    const document2 = this.modalDocument;
+    if (document2 && ACTIVE_MODAL_BY_DOCUMENT.get(document2) === this.modalToken) {
+      ACTIVE_MODAL_BY_DOCUMENT.delete(document2);
+    }
+    this.modalDocument = null;
+    this.modalRoot = null;
+  }
+  restoreInertBranches() {
+    for (const { element, previous } of this.inertBranches.splice(0)) {
+      if (element.getAttribute("inert") !== "")
+        continue;
+      if (previous === null)
+        element.removeAttribute("inert");
+      else
+        element.setAttribute("inert", previous);
+    }
+  }
+  async appear(targetRect, step, appearPopover = true, onBeforePopoverAppear) {
+    const pointerEnabled = this.isPointerEnabled(step);
+    const popoverPlacement = this.popover?.resolvePosition(targetRect, step).placement;
+    const commitStep = onBeforePopoverAppear ? async () => {
+      await onBeforePopoverAppear();
+      this.syncControlState(step);
+      this.syncShortcutLabels(step);
+    } : undefined;
+    const popoverTransition = this.popover ? this.popover.moveToTarget(targetRect, step, appearPopover, commitStep) : Promise.resolve(commitStep?.());
+    await Promise.all([
+      this.overlay?.moveToTarget(targetRect, step) ?? Promise.resolve(),
+      popoverTransition,
+      pointerEnabled ? this.pointer?.moveToTarget(targetRect, step, true, popoverPlacement) ?? Promise.resolve() : this.pointer?.disappear() ?? Promise.resolve()
+    ]);
+  }
+  attachStepResources(step, target, generation, signal) {
+    let initialPropsNotification = true;
+    this.stepCleanups.push(step.props.subscribe(() => {
+      if (!this.isCurrentGeneration(generation))
+        return;
+      if (initialPropsNotification) {
+        initialPropsNotification = false;
+        return;
+      }
+      this.presentationDirty = true;
+    }));
+    this.stepCleanups.push(this.commands?.subscribeCapabilities?.((active) => {
+      if (!this.isCurrentGeneration(generation))
+        return;
+      this.syncControlState(step);
+      if (active && this.pendingFocusGeneration === generation) {
+        this.pendingFocusGeneration = null;
+        this.focusGuard.focus();
+      }
+      if (active)
+        this.flushPendingKeyboardCommand(step, generation);
+    }) ?? (() => {}));
+    for (const handler of step.definition.eventHandlers) {
+      const listener = (event) => {
+        if (!this.isCurrentGeneration(generation))
+          return;
+        const context = Object.freeze({
+          advance: () => this.commandForStep("advance", step, signal),
+          cancel: () => this.commandForStep("cancel", step, signal),
+          previous: () => this.commandForStep("previous", step, signal),
+          props: step.props,
+          signal,
+          target
+        });
+        Promise.resolve().then(() => handler.callback(event, context)).catch((error) => {
+          if (signal.aborted || this.currentStep !== step)
+            return;
+          return this.commands?.reportError(error);
+        });
+      };
+      this.listen(target, handler.event, listener);
+    }
+    const currentWindow = this.getWindow(target);
+    if (typeof currentWindow?.addEventListener === "function") {
+      this.listen(currentWindow, "keydown", (event) => {
+        if (this.isCurrentGeneration(generation))
+          this.handleKeydown(event);
+      });
+      this.listen(currentWindow, "click", (event) => {
+        if (this.isCurrentGeneration(generation)) {
+          this.handleOverlayClick(event, step, target);
+        }
+      });
+    }
+    this.attachButtonHandlers(step);
+    this.observeControls(step, generation);
+    this.syncControlState(step);
+    this.syncShortcutLabels(step);
+    this.schedulePosition(generation);
+  }
+  listen(target, type, listener, options) {
+    target.addEventListener(type, listener, options);
+    this.stepCleanups.push(() => target.removeEventListener(type, listener, options));
+  }
+  schedulePosition(generation = this.generation) {
+    if (!this.isCurrentGeneration(generation) || !this.currentStep || this.rafId !== null)
+      return;
+    const owner = this.currentStep.target?.ownerDocument?.defaultView;
+    const ownerRequest = owner?.requestAnimationFrame;
+    const ownerCancel = owner?.cancelAnimationFrame;
+    const ownerHasFrameCapability = typeof ownerRequest === "function" || typeof ownerCancel === "function";
+    const request = ownerHasFrameCapability ? ownerRequest : globalThis.requestAnimationFrame;
+    const cancel = ownerHasFrameCapability ? ownerCancel : globalThis.cancelAnimationFrame;
+    if (typeof request !== "function" || typeof cancel !== "function")
+      return;
+    const frameWindow = ownerHasFrameCapability && owner ? owner : globalThis;
+    this.rafCancel = (id) => cancel.call(frameWindow, id);
+    this.rafId = request.call(frameWindow, () => {
+      this.rafId = null;
+      this.rafCancel = null;
+      if (!this.isCurrentGeneration(generation))
+        return;
+      this.updatePosition(generation);
+      this.schedulePosition(generation);
+    });
+  }
+  updatePosition(generation) {
+    const step = this.currentStep;
+    const target = step?.target;
+    if (!this.isCurrentGeneration(generation) || !step || !target)
+      return;
+    if (!this.isCurrentTargetAvailable(target)) {
+      this.stopForDisconnectedTarget(target, generation);
+      return;
+    }
+    const targetRect = target.getBoundingClientRect();
+    const targetSnapshot = snapshotRect(targetRect);
+    const viewportSnapshot = snapshotViewport(target);
+    const presentationChanged = this.presentationDirty;
+    if (!presentationChanged && sameRect(targetSnapshot, this.lastTargetRect) && sameViewport(viewportSnapshot, this.lastViewport))
+      return;
+    if (presentationChanged) {
+      this.overlay?.setAnimationOptions(animationOptions(step, step.overlay, this.overlay.getElement()));
+      this.popover?.setAnimationOptions(animationOptions(step, step.popover, this.popover.getElement()));
+      this.pointer?.setAnimationOptions(animationOptions(step, step.indicator, this.pointer.getElement()));
+      this.syncControlState(step);
+      this.syncShortcutLabels(step);
+    }
+    this.overlay?.updatePosition(targetRect, step, presentationChanged, (transition) => this.observeDynamicOperation(transition, generation));
+    const popoverPlacement = this.popover?.updatePosition(targetRect, step, (reposition) => this.observeDynamicOperation(reposition, generation));
+    if (presentationChanged) {
+      this.pointer?.syncVisibility(this.isPointerEnabled(step), targetRect, step, popoverPlacement);
+    } else if (this.isPointerEnabled(step)) {
+      const pointer = this.pointer?.getElement();
+      if (pointer?.getAttribute("aria-hidden") === "true") {
+        this.observeDynamicOperation(this.pointer?.moveToTarget(targetRect, step, true, popoverPlacement), generation);
+      } else {
+        this.pointer?.updatePosition(targetRect, step, popoverPlacement);
+      }
+    } else if (this.pointer?.getElement()?.getAttribute("aria-hidden") !== "true") {
+      this.observeDynamicOperation(this.pointer?.disappear(), generation);
+    }
+    this.lastTargetRect = targetSnapshot;
+    this.lastViewport = viewportSnapshot;
+    if (presentationChanged)
+      this.presentationDirty = false;
+  }
+  observeDynamicOperation(operation, generation) {
+    if (!operation)
+      return;
+    operation.catch((error) => {
+      if (!this.isCurrentGeneration(generation))
+        return;
+      try {
+        const reported = this.commands?.reportError(error);
+        reported?.catch(() => {});
+      } catch {}
+    });
+  }
+  handleKeydown(event) {
+    const step = this.currentStep;
+    if (!step || event.defaultPrevented || event.isComposing || event.ctrlKey || event.metaKey || event.altKey)
+      return;
+    if (event.key === "Tab" && step.behavior?.allowInteraction !== true) {
+      this.loopFocus(event);
+      return;
+    }
+    const shortcuts = step.popover?.keyboardShortcuts;
+    if ((shortcuts?.cancel ?? DEFAULT_SHORTCUTS.cancel).includes(event.key) && this.canCommand("cancel", step)) {
+      event.preventDefault();
+      this.command("cancel", "keyboard");
+      return;
+    }
+    if (isEditable(event.target, this.root))
+      return;
+    if ((shortcuts?.advance ?? DEFAULT_SHORTCUTS.advance).includes(event.key) && this.canCommand("advance", step)) {
+      event.preventDefault();
+      this.command("advance", "keyboard");
+    } else if ((shortcuts?.previous ?? DEFAULT_SHORTCUTS.previous).includes(event.key) && this.canCommand("previous", step)) {
+      event.preventDefault();
+      this.command("previous", "keyboard");
+    }
+  }
+  handleOverlayClick(event, step, target) {
+    if (this.currentStep !== step || event.defaultPrevented)
+      return;
+    if (step.behavior?.allowInteraction === true)
+      return;
+    const path = event.composedPath();
+    const popover = this.popover?.getElement();
+    const pointer = this.pointer?.getElement();
+    if (path.includes(target) || popover && path.includes(popover) || pointer && path.includes(pointer))
+      return;
+    const overlayClick = step.behavior?.overlayClick ?? "none";
+    if (overlayClick === "advance" && this.canCommand("advance", step)) {
+      this.command("advance", "overlay");
+    } else if (overlayClick === "cancel" && this.canCommand("cancel", step)) {
+      this.command("cancel", "overlay");
+    }
+  }
+  queueTransitionKeydown(event, step, generation) {
+    if (!this.isCurrentGeneration(generation) || event.defaultPrevented || event.isComposing || event.ctrlKey || event.metaKey || event.altKey)
+      return;
+    const shortcuts = step.popover?.keyboardShortcuts;
+    let command = null;
+    if ((shortcuts?.cancel ?? DEFAULT_SHORTCUTS.cancel).includes(event.key))
+      command = "cancel";
+    else if (!isEditable(event.target, this.root)) {
+      if ((shortcuts?.advance ?? DEFAULT_SHORTCUTS.advance).includes(event.key) && step.props.get().popover?.disableAdvanceButton !== true)
+        command = "advance";
+      else if ((shortcuts?.previous ?? DEFAULT_SHORTCUTS.previous).includes(event.key) && step.props.get().popover?.disablePreviousButton !== true)
+        command = "previous";
+    }
+    if (!command)
+      return;
+    event.preventDefault();
+    this.pendingKeyboardCommand ??= { command, generation };
+  }
+  flushPendingKeyboardCommand(step, generation) {
+    const pending = this.pendingKeyboardCommand;
+    if (!pending || pending.generation !== generation)
+      return;
+    this.pendingKeyboardCommand = null;
+    queueMicrotask(() => {
+      if (!this.isCurrentGeneration(generation) || this.currentStep !== step || !this.canCommand(pending.command, step))
+        return;
+      this.commandForGeneration(pending.command, generation, "keyboard");
+    });
+  }
+  loopFocus(event) {
+    const popover = this.popover?.getElement();
+    if (!isHTMLElement(popover, this.root ?? popover))
+      return;
+    const focusable = focusableElementsOwnedBy(popover);
+    if (focusable.length === 0) {
+      event.preventDefault();
+      popover.focus();
+      return;
+    }
+    const current = popover.ownerDocument.activeElement;
+    const index = isHTMLElement(current, popover) ? focusable.indexOf(current) : -1;
+    if (event.shiftKey && (index <= 0 || !popover.contains(current))) {
+      event.preventDefault();
+      focusable.at(-1)?.focus();
+    } else if (!event.shiftKey && (index === focusable.length - 1 || !popover.contains(current))) {
+      event.preventDefault();
+      focusable[0]?.focus();
+    }
+  }
+  activateFocus(step, target, direction, generation) {
+    const popover = this.popover?.getElement();
+    if (!isHTMLElement(popover, this.root ?? popover))
+      return;
+    const autoFocus = step.behavior?.disableAutoFocus !== true;
+    const deferFocus = autoFocus && this.commands?.subscribeCapabilities !== undefined;
+    if (deferFocus)
+      this.pendingFocusGeneration = generation;
+    this.focusGuard.activate({
+      allowedTarget: target,
+      allowTargetInteraction: step.behavior?.allowInteraction === true,
+      autoFocus: autoFocus && !deferFocus,
+      direction,
+      fallback: this.root ?? popover.parentElement,
+      popover
+    });
+  }
+  syncScrollLock(step) {
+    if (step.allowScroll) {
+      this.scrollLock.deactivate();
+      return;
+    }
+    this.scrollLock.activate(this.root?.ownerDocument ?? this.popover?.getElement()?.ownerDocument);
+  }
+  syncShortcutLabels(step) {
+    for (const advance of this.findTriggers("advance")) {
+      syncKeyShortcuts(advance, step.popover?.keyboardShortcuts?.advance ?? DEFAULT_SHORTCUTS.advance);
+    }
+    for (const previous of this.findTriggers("previous")) {
+      syncKeyShortcuts(previous, step.popover?.keyboardShortcuts?.previous ?? DEFAULT_SHORTCUTS.previous);
+    }
+  }
+  attachButtonHandlers(step) {
+    const generation = this.generation;
+    const scope = this.root ?? this.popover?.getElement();
+    if (!isHTMLElement(scope, scope) || typeof scope.addEventListener !== "function")
+      return;
+    this.listen(scope, "click", (event) => {
+      if (!isElement(event.target, scope))
+        return;
+      const match = this.findClickedTrigger(event.target, scope);
+      if (!match)
+        return;
+      this.deferTriggerCommand(match.command, event, step, generation, match.trigger);
+    });
+  }
+  findClickedTrigger(target, scope) {
+    for (const [command, direction] of [
+      ["advance", "advance"],
+      ["previous", "previous"],
+      ["cancel", "cancel"]
+    ]) {
+      const trigger = target.closest(`[data-glow-tour-${direction}-trigger]`);
+      if (trigger && this.ownsTrigger(trigger, scope)) {
+        return { command, trigger };
+      }
+    }
+    return null;
+  }
+  observeControls(step, generation) {
+    const scope = this.root ?? this.popover?.getElement();
+    if (!isHTMLElement(scope, scope))
+      return;
+    const MutationObserver = this.getWindow(scope)?.MutationObserver ?? globalThis.MutationObserver;
+    if (typeof MutationObserver !== "function")
+      return;
+    let queued = false;
+    const observer = new MutationObserver(() => {
+      if (queued)
+        return;
+      queued = true;
+      queueMicrotask(() => {
+        queued = false;
+        if (!this.isCurrentGeneration(generation) || this.currentStep !== step)
+          return;
+        this.syncControlState(step);
+        this.syncShortcutLabels(step);
+      });
+    });
+    observer.observe(scope, { childList: true, subtree: true });
+    this.stepCleanups.push(() => observer.disconnect());
+  }
+  deferTriggerCommand(command, event, step, generation, trigger) {
+    if (event.defaultPrevented || this.isLiveDisabled(trigger) || !this.canCommand(command, step, trigger))
+      return;
+    queueMicrotask(() => {
+      if (event.defaultPrevented || this.isLiveDisabled(trigger) || !this.isCurrentGeneration(generation) || this.currentStep !== step || !this.canCommand(command, step, trigger))
+        return;
+      this.commandForGeneration(command, generation, "trigger");
+    });
+  }
+  syncControlState(step) {
+    for (const advance of this.findTriggers("advance")) {
+      this.syncControl(advance, this.commands?.isAdvanceDisabled() === true || step.props.get().popover?.disableAdvanceButton === true);
+    }
+    for (const previous of this.findTriggers("previous")) {
+      this.syncControl(previous, this.commands?.isPreviousDisabled() === true || step.props.get().popover?.disablePreviousButton === true);
+    }
+    for (const cancel of this.findTriggers("cancel")) {
+      this.syncControl(cancel, this.commands?.isCancelDisabled() === true);
+    }
+  }
+  findTriggers(direction) {
+    const scope = this.root ?? this.popover?.getElement();
+    if (!isHTMLElement(scope, scope) || typeof scope.querySelectorAll !== "function")
+      return [];
+    return Array.from(scope.querySelectorAll(`[data-glow-tour-${direction}-trigger]`)).filter((trigger) => this.ownsTrigger(trigger, scope));
+  }
+  ownsTrigger(trigger, scope) {
+    if (!scope.contains(trigger))
+      return false;
+    const owner = this.root ?? scope.closest("[data-glow-tour-root]");
+    return trigger.closest("[data-glow-tour-root]") === owner;
+  }
+  async command(command, source) {
+    if (this.disposed)
+      return;
+    if (command === "advance")
+      await this.commands?.advance(source);
+    else if (command === "previous")
+      await this.commands?.previous(source);
+    else
+      await this.commands?.cancel(source);
+  }
+  commandForGeneration(command, generation, source) {
+    return this.isCurrentGeneration(generation) ? this.command(command, source) : Promise.resolve();
+  }
+  commandForStep(command, step, signal) {
+    return !signal.aborted && this.currentStep === step ? this.command(command, "api") : Promise.resolve();
+  }
+  canCommand(command, step, trigger) {
+    if (this.isConsumerDisabled(trigger ?? null))
+      return false;
+    if (command === "advance") {
+      return (this.commands?.canAdvance?.() ?? true) && step.props.get().popover?.disableAdvanceButton !== true;
+    }
+    if (command === "previous") {
+      return (this.commands?.canPrevious?.() ?? true) && step.props.get().popover?.disablePreviousButton !== true;
+    }
+    return this.commands?.canCancel?.() ?? true;
+  }
+  syncControl(element, disabled) {
+    if (!element)
+      return;
+    if (element.hasAttribute("data-glow-tour-control-managed"))
+      return;
+    const isDisabled = disabled || this.isConsumerDisabled(element);
+    if (element.disabled !== isDisabled)
+      element.disabled = isDisabled;
+    if (element.getAttribute("aria-disabled") !== String(isDisabled)) {
+      element.setAttribute("aria-disabled", String(isDisabled));
+    }
+  }
+  isConsumerDisabled(element) {
+    return element?.getAttribute("data-glow-tour-consumer-disabled") === "true";
+  }
+  isLiveDisabled(element) {
+    return element.disabled || element.getAttribute("aria-disabled") === "true" || this.isConsumerDisabled(element);
+  }
+  isPointerEnabled(step) {
+    return step.behavior?.allowInteraction === true && step.indicator?.disabled !== true;
+  }
+  cleanupStepResources() {
+    this.scrollAbort?.abort();
+    this.scrollAbort = null;
+    this.presentationDirty = false;
+    if (this.rafId !== null)
+      this.rafCancel?.(this.rafId);
+    this.rafId = null;
+    this.rafCancel = null;
+    for (const cleanup of this.stepCleanups.splice(0))
+      cleanup();
+  }
+  isCurrentTargetAvailable(target) {
+    const rootDocument = this.root?.ownerDocument;
+    return target.isConnected && (!rootDocument || target.ownerDocument === rootDocument);
+  }
+  stopForDisconnectedTarget(target, generation) {
+    if (!this.isCurrentGeneration(generation))
+      return;
+    this.beginGeneration();
+    this.cleanupStepResources();
+    this.releaseModality();
+    this.focusGuard.deactivate();
+    this.scrollLock.deactivate();
+    this.active = false;
+    this.currentSignal = null;
+    this.currentStep = null;
+    this.lastTargetRect = null;
+    this.lastViewport = null;
+    Promise.resolve(this.commands?.targetDisconnected(target)).catch((error) => {
+      this.commands?.reportError(error).catch(() => {});
+    });
+  }
+  beginGeneration() {
+    this.generation += 1;
+    this.pendingKeyboardCommand = null;
+    this.pendingFocusGeneration = null;
+    this.cancelElementAnimations();
+    return this.generation;
+  }
+  cancelAnimationsOnAbort(signal) {
+    const onAbort = () => this.cancelElementAnimations();
+    signal.addEventListener("abort", onAbort, { once: true });
+    return () => signal.removeEventListener("abort", onAbort);
+  }
+  cancelElementAnimations() {
+    this.overlay?.cancelAnimations();
+    this.popover?.cancelAnimations();
+    this.pointer?.cancelAnimations();
+  }
+  isCurrentGeneration(generation) {
+    return !this.disposed && generation === this.generation;
+  }
+  async scrollTargetIntoView(step, target, signal) {
+    this.throwIfAborted(signal);
+    if (step.behavior?.disableAutoScroll || isInViewport(target.getBoundingClientRect(), target))
+      return;
+    const currentWindow = this.getWindow(target);
+    if (!currentWindow)
+      return;
+    const controller = new AbortController;
+    this.scrollAbort = controller;
+    await new Promise((resolve, reject) => {
+      let timeout = null;
+      const abort = () => finish(abortError2());
+      const finish = (error) => {
+        currentWindow.removeEventListener("scrollend", complete);
+        signal.removeEventListener("abort", abort);
+        controller.signal.removeEventListener("abort", abort);
+        if (timeout !== null)
+          clearTimeout(timeout);
+        if (this.scrollAbort === controller)
+          this.scrollAbort = null;
+        if (error)
+          reject(error);
+        else
+          resolve();
+      };
+      const complete = () => finish();
+      currentWindow.addEventListener("scrollend", complete, { once: true });
+      signal.addEventListener("abort", abort, { once: true });
+      controller.signal.addEventListener("abort", abort, { once: true });
+      timeout = setTimeout(complete, DEFAULT_SCROLL_END_TIMEOUT);
+      try {
+        target.scrollIntoView({
+          behavior: prefersReducedMotion(target) ? "instant" : step.behavior?.scroll?.behavior ?? "smooth",
+          block: step.behavior?.scroll?.block ?? "center",
+          inline: step.behavior?.scroll?.inline ?? "nearest"
+        });
+      } catch (error) {
+        finish(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  throwIfAborted(signal) {
+    if (signal.aborted || this.disposed)
+      throw abortError2();
+  }
+  throwIfStale(generation, signal) {
+    if (!this.isCurrentGeneration(generation) || signal?.aborted)
+      throw abortError2();
+  }
+  getWindow(element) {
+    return ownerWindow(element ?? this.root ?? this.popover?.getElement() ?? this.pointer?.getElement() ?? this.overlay?.getElement());
+  }
+}
+function animationOptions(step, options, element) {
+  return {
+    disabled: step.animated === false || options?.animated === false || prefersReducedMotion(element),
+    duration: options?.animation?.duration,
+    easing: options?.animation?.easing
+  };
+}
+function abortError2() {
+  return new DOMException("The operation was aborted", "AbortError");
+}
+function snapshotRect(rect) {
+  const left = finite(rect.left);
+  const top = finite(rect.top);
+  const width = finite(rect.width);
+  const height = finite(rect.height);
+  return {
+    bottom: finite(rect.bottom, top + height),
+    height,
+    left,
+    right: finite(rect.right, left + width),
+    top,
+    width,
+    x: finite(rect.x, left),
+    y: finite(rect.y, top)
+  };
+}
+function snapshotViewport(context) {
+  const viewport = viewportDimensions(context);
+  return {
+    height: finite(viewport.height),
+    width: finite(viewport.width)
+  };
+}
+function sameRect(left, right) {
+  return right !== null && left.bottom === right.bottom && left.height === right.height && left.left === right.left && left.right === right.right && left.top === right.top && left.width === right.width && left.x === right.x && left.y === right.y;
+}
+function sameViewport(left, right) {
+  return right !== null && left.height === right.height && left.width === right.width;
+}
+function finite(value, fallback = 0) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function isEditable(target, context) {
+  if (!isHTMLElement(target, context))
+    return false;
+  if (target.matches("input, textarea, select"))
+    return true;
+  let current = target;
+  while (current) {
+    const contentEditable = current.getAttribute("contenteditable");
+    if (contentEditable !== null)
+      return contentEditable.toLowerCase() !== "false";
+    current = current.parentElement;
+  }
+  return false;
+}
+function prefersReducedMotion(context) {
+  const currentWindow = ownerWindow(context);
+  return typeof currentWindow?.matchMedia === "function" && currentWindow.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function syncKeyShortcuts(element, shortcuts) {
+  if (!element)
+    return;
+  if (shortcuts.length === 0)
+    element.removeAttribute("aria-keyshortcuts");
+  else
+    element.setAttribute("aria-keyshortcuts", shortcuts.join(" "));
+}
+
+// packages/core/src/options/validation.ts
+function invalidOption(path) {
+  return new TypeError(`Invalid option: ${path}`);
+}
+function validateFiniteNonNegative(path, value) {
+  if (value !== undefined && (!Number.isFinite(value) || value < 0))
+    throw invalidOption(path);
+}
+function validateAnimation(path, animation) {
+  if (animation?.duration === undefined && animation !== undefined)
+    throw invalidOption(`${path}.duration`);
+  validateFiniteNonNegative(`${path}.duration`, animation?.duration);
+}
+function validateOverlay(path, overlay) {
+  if (!overlay)
+    return;
+  validateAnimation(`${path}.animation`, overlay.animation);
+  validateFiniteNonNegative(`${path}.padding`, overlay.padding);
+  validateFiniteNonNegative(`${path}.radius`, overlay.radius);
+  const opacity = overlay.opacity;
+  if (opacity !== undefined && (!Number.isFinite(opacity) || opacity < 0 || opacity > 1)) {
+    throw invalidOption(`${path}.opacity`);
+  }
+}
+function validatePopover(path, popover) {
+  if (!popover)
+    return;
+  validateAnimation(`${path}.animation`, popover.animation);
+  validateFiniteNonNegative(`${path}.gap`, popover.gap);
+  if (!popover.arrow)
+    return;
+  validateFiniteNonNegative(`${path}.arrow.size`, popover.arrow.size);
+  validateFiniteNonNegative(`${path}.arrow.borderWidth`, popover.arrow.borderWidth);
+  validateFiniteNonNegative(`${path}.arrow.borderRadius`, popover.arrow.borderRadius);
+  validateFiniteNonNegative(`${path}.arrow.edgePadding`, popover.arrow.edgePadding);
+}
+function validateIndicator(path, indicator) {
+  if (!indicator)
+    return;
+  validateAnimation(`${path}.animation`, indicator.animation);
+  validateFiniteNonNegative(`${path}.gap`, indicator.gap);
+}
+function validateBehavior(path, behavior) {
+  validateFiniteNonNegative(`${path}.targetTimeout`, behavior?.targetTimeout);
+}
+function validateStepProps(path, props) {
+  validateOverlay(`${path}.overlay`, props.overlay);
+  validatePopover(`${path}.popover`, props.popover);
+  validateIndicator(`${path}.indicator`, props.indicator);
+}
+function validateWorkflowOptions(workflow) {
+  validateOverlay("options.overlay", workflow.options.overlay);
+  validatePopover("options.popover", workflow.options.popover);
+  validateIndicator("options.indicator", workflow.options.indicator);
+  validateBehavior("options.behavior", workflow.options.behavior);
+  for (const [index, step] of workflow.steps.entries()) {
+    const path = `steps[${index}]`;
+    validateBehavior(`${path}.behavior`, step.behavior);
+    validateStepProps(path, step.props);
+  }
+}
+
+// packages/core/src/utils/options.ts
+function mergeOverlayOptions(defaults, overrides) {
+  if (!defaults && !overrides) {
+    return;
+  }
+  return {
+    ...mergeBaseOptions(defaults, overrides),
+    color: overrides?.color ?? defaults?.color,
+    opacity: overrides?.opacity ?? defaults?.opacity,
+    padding: overrides?.padding ?? defaults?.padding,
+    radius: overrides?.radius ?? defaults?.radius
+  };
+}
+function mergeIndicatorOptions(defaults, overrides) {
+  if (!defaults && !overrides) {
+    return;
+  }
+  return {
+    ...mergeBaseOptions(defaults, overrides),
+    disabled: overrides?.disabled ?? defaults?.disabled,
+    gap: overrides?.gap ?? defaults?.gap,
+    placementTryOrder: cloneArray(overrides?.placementTryOrder ?? defaults?.placementTryOrder)
+  };
+}
+function mergePopoverOptions(defaults, overrides) {
+  if (!defaults && !overrides) {
+    return;
+  }
+  const placementTryOrder = overrides?.placementTryOrder ?? defaults?.placementTryOrder;
+  const hasArrow = !!defaults?.arrow || !!overrides?.arrow;
+  const hasKeyboardShortcuts = !!defaults?.keyboardShortcuts || !!overrides?.keyboardShortcuts;
+  return {
+    ...mergeBaseOptions(defaults, overrides),
+    arrow: hasArrow ? {
+      disabled: overrides?.arrow?.disabled ?? defaults?.arrow?.disabled,
+      color: overrides?.arrow?.color ?? defaults?.arrow?.color,
+      size: overrides?.arrow?.size ?? defaults?.arrow?.size,
+      borderWidth: overrides?.arrow?.borderWidth ?? defaults?.arrow?.borderWidth,
+      borderRadius: overrides?.arrow?.borderRadius ?? defaults?.arrow?.borderRadius,
+      edgePadding: overrides?.arrow?.edgePadding ?? defaults?.arrow?.edgePadding,
+      styleNonce: overrides?.arrow?.styleNonce ?? defaults?.arrow?.styleNonce,
+      disableAutoStyles: overrides?.arrow?.disableAutoStyles ?? defaults?.arrow?.disableAutoStyles
+    } : undefined,
+    disableAdvanceButton: overrides?.disableAdvanceButton ?? defaults?.disableAdvanceButton,
+    disablePreviousButton: overrides?.disablePreviousButton ?? defaults?.disablePreviousButton,
+    gap: overrides?.gap ?? defaults?.gap,
+    hideAdvanceButton: overrides?.hideAdvanceButton ?? defaults?.hideAdvanceButton,
+    hideFooter: overrides?.hideFooter ?? defaults?.hideFooter,
+    hidePreviousButton: overrides?.hidePreviousButton ?? defaults?.hidePreviousButton,
+    placementTryOrder: cloneArray(placementTryOrder),
+    keyboardShortcuts: hasKeyboardShortcuts ? {
+      previous: cloneArray(overrides?.keyboardShortcuts?.previous ?? defaults?.keyboardShortcuts?.previous),
+      advance: cloneArray(overrides?.keyboardShortcuts?.advance ?? defaults?.keyboardShortcuts?.advance),
+      cancel: cloneArray(overrides?.keyboardShortcuts?.cancel ?? defaults?.keyboardShortcuts?.cancel)
+    } : undefined
+  };
+}
+function mergeScrollOptions(defaults, overrides) {
+  if (!defaults && !overrides) {
+    return;
+  }
+  return {
+    behavior: overrides?.behavior ?? defaults?.behavior,
+    block: overrides?.block ?? defaults?.block,
+    inline: overrides?.inline ?? defaults?.inline
+  };
+}
+function mergeAnimationOptions(defaults, overrides) {
+  if (!defaults) {
+    return overrides ? { ...overrides } : undefined;
+  }
+  if (!overrides) {
+    return { ...defaults };
+  }
+  return {
+    duration: overrides.duration ?? defaults.duration,
+    easing: overrides.easing ?? defaults.easing
+  };
+}
+function mergeBaseOptions(defaults, overrides) {
+  return {
+    animated: overrides?.animated ?? defaults?.animated,
+    animation: mergeAnimationOptions(defaults?.animation, overrides?.animation)
+  };
+}
+function mergeStepBehavior(defaults, overrides) {
+  if (!defaults && !overrides) {
+    return;
+  }
+  return {
+    allowInteraction: overrides?.allowInteraction ?? defaults?.allowInteraction,
+    disableAutoFocus: overrides?.disableAutoFocus ?? defaults?.disableAutoFocus,
+    disableAutoScroll: overrides?.disableAutoScroll ?? defaults?.disableAutoScroll,
+    missingTargetStrategy: overrides?.missingTargetStrategy ?? defaults?.missingTargetStrategy,
+    scroll: mergeScrollOptions(defaults?.scroll, overrides?.scroll),
+    targetTimeout: overrides?.targetTimeout ?? defaults?.targetTimeout,
+    overlayClick: overrides?.overlayClick ?? defaults?.overlayClick
+  };
+}
+function cloneArray(value) {
+  return value ? [...value] : undefined;
+}
+
+// packages/core/src/runtime/step-props-store.ts
+function createStepPropsStore(initialProps, reportListenerError, path = "steps[0]") {
+  let current = freezeStepProps(initialProps);
+  const listeners = new Set;
+  const notify = (listener, props) => {
+    try {
+      listener(props);
+    } catch (error) {
+      try {
+        reportListenerError(error);
+      } catch {}
+    }
+  };
+  return Object.freeze({
+    get: () => current,
+    set: (update) => {
+      const next = typeof update === "function" ? update(current) : update;
+      validateStepProps(path, next);
+      current = freezeStepProps(next);
+      const published = current;
+      for (const listener of Array.from(listeners))
+        notify(listener, published);
+    },
+    subscribe: (listener) => {
+      notify(listener, current);
+      listeners.add(listener);
+      let subscribed = true;
+      return () => {
+        if (!subscribed)
+          return;
+        subscribed = false;
+        listeners.delete(listener);
+      };
+    }
+  });
+}
+
+// packages/core/src/runtime/active-step.ts
+class ActiveStep {
+  definition;
+  path;
+  rootDocument;
+  initialProps;
+  props;
+  behavior;
+  animated;
+  allowScroll;
+  target = null;
+  constructor(definition, defaults, reportSubscriberError = () => {}, path = "steps[0]", rootDocument) {
+    this.definition = definition;
+    this.path = path;
+    this.rootDocument = rootDocument;
+    this.initialProps = freezeStepProps({
+      title: definition.props.title,
+      content: definition.props.content,
+      data: definition.props.data,
+      overlay: mergeOverlayOptions(defaults.overlay, definition.props.overlay),
+      popover: mergePopoverOptions(defaults.popover, definition.props.popover),
+      indicator: mergeIndicatorOptions(defaults.indicator, definition.props.indicator)
+    });
+    this.props = createStepPropsStore(this.initialProps, reportSubscriberError, path);
+    this.behavior = mergeStepBehavior(defaults.behavior, definition.behavior);
+    this.animated = defaults.animated;
+    this.allowScroll = defaults.allowScroll === true;
+  }
+  reset() {
+    this.props.set(this.initialProps);
+  }
+  get overlay() {
+    return this.props.get().overlay;
+  }
+  get popover() {
+    return this.props.get().popover;
+  }
+  get indicator() {
+    return this.props.get().indicator;
+  }
+  async resolveTarget(signal) {
+    return await resolveTargetElement(this.definition.target, { document: this.rootDocument, signal }, this.path);
+  }
+  snapshot() {
+    return Object.freeze({
+      id: this.definition.id,
+      initialProps: freezeStepProps(this.initialProps),
+      currentProps: freezeStepProps(this.props.get()),
+      target: this.target
+    });
+  }
+}
+
+// packages/core/src/runtime/adapter-contract.ts
+var ADAPTER_BRIDGE_SYMBOL = Symbol.for("@glowhop/core-tour/adapter-bridge/v1");
+var ADAPTER_BRIDGE_VERSION = 1;
+
+// packages/core/src/runtime/root-bridge.ts
+var ROOT_OWNER_SYMBOL = Symbol.for("@glowhop/core-tour/root-owner/v1");
+var DOCUMENT_PREFIX_RESERVATIONS_SYMBOL = Symbol.for("@glowhop/core-tour/id-prefix-reservations/v1");
+var DEFAULT_ID_PREFIX = "glow-tour";
+var ID_PREFIX_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
+
+class TourRootBinding {
+  driver;
+  root;
+  ids;
+  reservation;
+  mutations;
+  onMountReleaseStart;
+  onMountReleaseComplete;
+  onRelease;
+  released = false;
+  overlay = null;
+  pointer = null;
+  popover = null;
+  constructor(driver, root, ids, reservation, mutations, onMountReleaseStart, onMountReleaseComplete, onRelease) {
+    this.driver = driver;
+    this.root = root;
+    this.ids = ids;
+    this.reservation = reservation;
+    this.mutations = mutations;
+    this.onMountReleaseStart = onMountReleaseStart;
+    this.onMountReleaseComplete = onMountReleaseComplete;
+    this.onRelease = onRelease;
+  }
+  bindOverlay(element) {
+    this.assertLiveElement(element);
+    this.overlay = element;
+    this.driver.registerOverlay(element);
+    return () => {
+      if (this.released || this.overlay !== element)
+        return;
+      this.overlay = null;
+      this.driver.registerOverlay(null);
+    };
+  }
+  bindPointer(element) {
+    this.assertLiveElement(element);
+    this.pointer = element;
+    this.driver.registerPointer(element);
+    return () => {
+      if (this.released || this.pointer !== element)
+        return;
+      this.pointer = null;
+      this.driver.registerPointer(null);
+    };
+  }
+  bindPopover(element) {
+    this.assertLiveElement(element);
+    this.popover = element;
+    this.driver.registerPopover(element);
+    return () => {
+      if (this.released || this.popover !== element)
+        return;
+      this.popover = null;
+      this.driver.registerPopover(null);
+    };
+  }
+  hasPopover() {
+    return this.popover !== null;
+  }
+  get document() {
+    return this.root.ownerDocument;
+  }
+  release() {
+    if (this.released)
+      return;
+    this.released = true;
+    this.overlay = null;
+    this.pointer = null;
+    this.popover = null;
+    try {
+      runCleanup([
+        this.onMountReleaseStart,
+        () => this.driver.releaseMount(),
+        () => this.mutations.release(),
+        () => releaseRootOwner(this.root, this.reservation),
+        () => releasePrefix(this.root.ownerDocument, this.ids.root.slice(0, -"-root".length), this.reservation)
+      ]);
+    } finally {
+      this.onRelease(this);
+      this.onMountReleaseComplete();
+    }
+  }
+  assertLiveElement(element) {
+    if (this.released)
+      throw new Error("Glow tour root binding has been released");
+    if (element === this.root || !this.root.contains(element)) {
+      throw new Error("Glow tour elements must be descendants of the claimed root");
+    }
+  }
+}
+function attachRootBridge(tour, driver, isDisposed, onMountReleaseStart, onMountReleaseComplete) {
+  let binding = null;
+  let pending = null;
+  const bridge = Object.freeze({
+    version: ADAPTER_BRIDGE_VERSION,
+    connectRoot(options) {
+      if (isDisposed())
+        throw new Error("Cannot connect a root to a disposed glow tour");
+      if (binding || pending)
+        throw new Error("Glow tour already has a live root lease");
+      const root = options.root;
+      if (!root?.ownerDocument)
+        throw new Error("Glow tour root must belong to a document");
+      if (Reflect.has(root, ROOT_OWNER_SYMBOL)) {
+        throw new Error("Glow tour root is already owned by another tour");
+      }
+      const reservation = {};
+      const mutations = new DomMutationLease(root);
+      let prefix = null;
+      let ids = null;
+      let ownsPrefix = false;
+      let ownsRoot = false;
+      let registeredRoot = false;
+      let releasing = false;
+      const rollback = () => {
+        runCleanup([
+          () => {
+            if (!registeredRoot)
+              return;
+            registeredRoot = false;
+            driver.releaseMount();
+          },
+          () => mutations.release(),
+          () => {
+            if (!ownsRoot)
+              return;
+            ownsRoot = false;
+            releaseRootOwner(root, reservation);
+          },
+          () => {
+            if (!ownsPrefix || !prefix)
+              return;
+            ownsPrefix = false;
+            releasePrefix(root.ownerDocument, prefix, reservation);
+          }
+        ]);
+      };
+      const pendingLease = {
+        release: () => {
+          if (pending !== pendingLease || releasing)
+            return;
+          releasing = true;
+          try {
+            rollback();
+          } finally {
+            if (pending === pendingLease)
+              pending = null;
+          }
+        }
+      };
+      pending = pendingLease;
+      try {
+        prefix = reservePrefix(root.ownerDocument, options.idPrefix, root);
+        claimRootOwner(root, reservation);
+        ownsRoot = true;
+        reservePrefixOwnership(root.ownerDocument, prefix, reservation);
+        ownsPrefix = true;
+        ids = idsFor(prefix);
+        mutations.setAttribute("id", ids.root);
+        mutations.setAttribute("data-glow-tour-id-prefix", prefix);
+        registeredRoot = true;
+        driver.registerRoot(root);
+        if (isDisposed())
+          throw new Error("Cannot connect a root to a disposed glow tour");
+        if (pending !== pendingLease)
+          throw new Error("Glow tour root lease was released while connecting");
+        const live = new TourRootBinding(driver, root, ids, reservation, mutations, onMountReleaseStart, onMountReleaseComplete, (released) => {
+          if (binding === released)
+            binding = null;
+        });
+        binding = live;
+        pending = null;
+        return live;
+      } catch (error) {
+        try {
+          if (pending === pendingLease)
+            pendingLease.release();
+          else
+            rollback();
+        } catch {}
+        throw error;
+      }
+    }
+  });
+  Object.defineProperty(tour, ADAPTER_BRIDGE_SYMBOL, {
+    configurable: false,
+    enumerable: false,
+    value: bridge,
+    writable: false
+  });
+  return {
+    assertCanRun(workflow) {
+      if (!binding)
+        throw new Error("Glow tour requires a connected root before run()");
+      if (workflow.steps.length > 0 && !binding.hasPopover()) {
+        throw new Error("Glow tour requires a connected popover before run()");
+      }
+      return binding.document;
+    },
+    release() {
+      binding?.release();
+      pending?.release();
+    }
+  };
+}
+function runCleanup(cleanups) {
+  let failed = false;
+  let failure;
+  for (const cleanup of cleanups) {
+    try {
+      cleanup();
+    } catch (error) {
+      if (!failed) {
+        failed = true;
+        failure = error;
+      }
+    }
+  }
+  if (failed)
+    throw failure;
+}
+function claimRootOwner(root, reservation) {
+  Object.defineProperty(root, ROOT_OWNER_SYMBOL, {
+    configurable: true,
+    enumerable: false,
+    value: reservation
+  });
+}
+function releaseRootOwner(root, reservation) {
+  if (Reflect.get(root, ROOT_OWNER_SYMBOL) === reservation) {
+    Reflect.deleteProperty(root, ROOT_OWNER_SYMBOL);
+  }
+}
+function idsFor(prefix) {
+  return Object.freeze({
+    description: `${prefix}-description`,
+    popover: `${prefix}-popover`,
+    root: `${prefix}-root`,
+    title: `${prefix}-title`
+  });
+}
+function reservePrefix(document2, requestedPrefix, root) {
+  if (requestedPrefix !== undefined && !ID_PREFIX_PATTERN.test(requestedPrefix)) {
+    throw new Error("Glow tour idPrefix must match [A-Za-z][A-Za-z0-9_-]*");
+  }
+  if (requestedPrefix !== undefined) {
+    if (prefixIsAvailable(document2, requestedPrefix, root))
+      return requestedPrefix;
+    throw new Error(`Glow tour idPrefix is already in use: ${requestedPrefix}`);
+  }
+  for (let suffix = 1;; suffix += 1) {
+    const prefix = suffix === 1 ? DEFAULT_ID_PREFIX : `${DEFAULT_ID_PREFIX}-${suffix}`;
+    if (prefixIsAvailable(document2, prefix, root))
+      return prefix;
+  }
+}
+function prefixIsAvailable(document2, prefix, root) {
+  const reservations = prefixReservations(document2);
+  if (reservations.has(prefix))
+    return false;
+  return Object.values(idsFor(prefix)).every((id) => Array.from(document2.querySelectorAll("[id]")).filter((element) => element.id === id).every((element) => root?.contains(element) === true));
+}
+function reservePrefixOwnership(document2, prefix, reservation) {
+  prefixReservations(document2).set(prefix, reservation);
+}
+function releasePrefix(document2, prefix, reservation) {
+  const reservations = prefixReservations(document2);
+  if (reservations.get(prefix) === reservation)
+    reservations.delete(prefix);
+}
+function prefixReservations(document2) {
+  const current = Reflect.get(document2, DOCUMENT_PREFIX_RESERVATIONS_SYMBOL);
+  if (current instanceof Map)
+    return current;
+  const reservations = new Map;
+  Object.defineProperty(document2, DOCUMENT_PREFIX_RESERVATIONS_SYMBOL, {
+    configurable: true,
+    enumerable: false,
+    value: reservations
+  });
+  return reservations;
+}
+
+// packages/core/src/runtime/tour-controller.ts
+var DEFAULT_TARGET_TIMEOUT = 3000;
+var DISPOSED_ERROR_MESSAGE = "Tour controller is disposed";
+function resolveStartIndex(workflow, startAt) {
+  if (startAt === undefined)
+    return 0;
+  const index = workflow.steps.findIndex((step) => step.id === startAt);
+  if (index === -1) {
+    throw new Error(`Workflow "${workflow.name}" has no step with id "${startAt}" to start at.`);
+  }
+  return index;
+}
+function normalizedError(error) {
+  if (error instanceof Error)
+    return error;
+  try {
+    return new Error(String(error));
+  } catch {
+    return new Error("Unknown error");
+  }
+}
+
+class TourController {
+  driver;
+  options;
+  snapshot;
+  workflow = null;
+  steps = [];
+  index = -1;
+  direction = "advance";
+  status = "idle";
+  error = null;
+  operationToken = 0;
+  publicationRevision = 0;
+  operation = null;
+  disposed = false;
+  retainedPresentation = null;
+  stateListeners = new Set;
+  stepPropsSubscriptions = [];
+  tourStartedAt = 0;
+  stepEnteredAt = 0;
+  commandSource = "api";
+  state = Object.freeze({
+    get: () => this.snapshot,
+    subscribe: (listener) => {
+      if (this.disposed)
+        return () => {};
+      this.notifyStateListener(listener, this.snapshot);
+      if (this.disposed)
+        return () => {};
+      this.stateListeners.add(listener);
+      return () => {
+        this.stateListeners.delete(listener);
+      };
+    }
+  });
+  constructor(driver, options = {}) {
+    this.driver = driver;
+    this.options = options;
+    this.snapshot = this.createSnapshot();
+    this.driver.setCommands?.({
+      advance: (source) => this.advance(source),
+      canAdvance: () => this.canNavigate("advance"),
+      canCancel: () => this.status === "active" && this.isCancelAvailable(),
+      canPrevious: () => this.canNavigate("previous"),
+      cancel: (source) => this.cancel(source),
+      isAdvanceDisabled: () => !this.isPresentedAdvanceAvailable(),
+      isCancelDisabled: () => !this.isPresentedCancelAvailable(),
+      isPreviousDisabled: () => !this.isPresentedPreviousAvailable(),
+      previous: (source) => this.previous(source),
+      reportError: async (error) => {
+        if (this.disposed || this.status === "idle")
+          return;
+        const operation = this.beginOperation();
+        try {
+          await this.handleFailure(error, operation);
+        } catch {}
+      },
+      targetDisconnected: async (target) => {
+        await this.recoverDisconnectedTarget(target);
+      },
+      subscribeCapabilities: (listener) => this.state.subscribe((state) => listener(state.status === "active"))
+    });
+  }
+  create(name, options = {}) {
+    return new WorkflowBuilder(name, options);
+  }
+  async run(workflow, runOptions = {}) {
+    this.assertNotDisposed();
+    validateWorkflowOptions(workflow);
+    const startIndex = resolveStartIndex(workflow, runOptions.startAt);
+    const rootDocument = this.options.assertCanRun?.(workflow) ?? undefined;
+    const retainedPresentation = this.capturePresentation();
+    const operation = this.beginOperation();
+    this.workflow = workflow;
+    this.releaseStepPropsSubscriptions();
+    this.steps = workflow.steps.map((step, index) => new ActiveStep(step, workflow.options, (error) => this.reportSubscriberError(error), `steps[${index}]`, rootDocument));
+    for (const step of this.steps) {
+      this.stepPropsSubscriptions.push(step.props.subscribe(() => {
+        if (!this.disposed && this.currentStep() === step)
+          this.publish();
+      }));
+    }
+    this.index = -1;
+    this.error = null;
+    this.commandSource = "api";
+    this.retainedPresentation = retainedPresentation;
+    try {
+      this.setStatus("starting");
+      this.assertCurrent(operation);
+      const { context: startContext, isAborted: isStartAborted } = this.createLifecycleHookContext(this.steps[startIndex] ?? null);
+      await workflow.options.onStart?.(startContext);
+      this.assertCurrent(operation);
+      if (isStartAborted()) {
+        this.resetToIdle();
+        return;
+      }
+      this.tourStartedAt = Date.now();
+      this.emit("tour:start", this.steps[startIndex] ?? null, 0);
+      if (this.steps.length === 0) {
+        await this.finish(operation);
+        return;
+      }
+      await this.enter(startIndex, "advance", operation);
+    } catch (error) {
+      await this.handleFailure(error, operation);
+    }
+  }
+  async advance(source = "api") {
+    this.assertNotDisposed();
+    await this.transitionFromPublic("advance", undefined, source);
+  }
+  async previous(source = "api") {
+    this.assertNotDisposed();
+    await this.transitionFromPublic("previous", undefined, source);
+  }
+  async goToStep(index) {
+    this.assertNotDisposed();
+    if (this.status === "starting" || this.status === "transitioning")
+      return;
+    if (index < 0 || index >= this.steps.length) {
+      throw new Error(`Step index ${index} is out of bounds`);
+    }
+    const direction = index > this.index ? "advance" : "previous";
+    await this.transitionFromPublic(direction, index, "api");
+  }
+  async cancel(source = "api") {
+    this.assertNotDisposed();
+    if (!this.workflow || !this.canCancel())
+      return;
+    this.commandSource = source;
+    const operation = this.beginOperation();
+    try {
+      await this.cancelCurrent(operation);
+    } catch (error) {
+      await this.handleFailure(error, operation);
+    }
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    this.invalidateOperation();
+    this.releaseStepPropsSubscriptions();
+    this.steps = [];
+    this.workflow = null;
+    this.index = -1;
+    this.direction = "advance";
+    this.error = null;
+    this.retainedPresentation = null;
+    this.status = "disposed";
+    this.publish(true);
+    this.stateListeners.clear();
+    this.options.onDispose?.();
+    this.driver.dispose();
+  }
+  isDisposed() {
+    return this.disposed;
+  }
+  beginMountRelease() {
+    if (this.disposed)
+      return;
+    this.invalidateOperation();
+    this.workflow = null;
+    this.releaseStepPropsSubscriptions();
+    this.steps = [];
+    this.index = -1;
+    this.direction = "advance";
+    this.error = null;
+    this.retainedPresentation = null;
+    this.status = "idle";
+  }
+  completeMountRelease() {
+    if (!this.disposed)
+      this.publish();
+  }
+  async enter(index, direction, operation) {
+    this.direction = direction;
+    this.emitStepLeave(this.currentStep());
+    this.setStatus("transitioning");
+    this.assertCurrent(operation);
+    const step = this.steps[index];
+    if (!step)
+      throw new Error(`Step index ${index} is out of bounds`);
+    if (step.definition.resetPropsOnEnter !== false)
+      step.reset();
+    const target = await this.resolveTarget(step, operation);
+    this.assertCurrent(operation);
+    if (!target) {
+      await this.advancePastMissingTarget(index, direction, operation);
+      return;
+    }
+    step.target = target;
+    let committed = false;
+    const commitStep = () => {
+      this.assertCurrent(operation);
+      if (committed)
+        return;
+      committed = true;
+      this.index = index;
+      this.retainedPresentation = null;
+      this.publish();
+    };
+    await this.driver.show(step, direction, this.signalFor(operation), commitStep);
+    this.assertCurrent(operation);
+    commitStep();
+    this.setStatus("active");
+    this.assertCurrent(operation);
+    this.stepEnteredAt = Date.now();
+    this.emit("step:enter", step, 0);
+    await this.runActions(operation);
+  }
+  async transitionFromPublic(direction, destination, source = "api") {
+    if (!this.canNavigate(direction, destination))
+      return;
+    this.commandSource = source;
+    const operation = this.beginOperation();
+    try {
+      await this.transition(direction, operation, destination);
+    } catch (error) {
+      await this.handleFailure(error, operation);
+    }
+  }
+  async transition(direction, operation, destination) {
+    if (!this.canNavigate(direction, destination))
+      return;
+    const step = this.currentStep();
+    if (!step)
+      return;
+    this.setStatus("transitioning");
+    this.assertCurrent(operation);
+    const hook = direction === "advance" ? step.definition.advanceAction : step.definition.previousAction;
+    await hook?.(this.createBeforeActionStepContext(step));
+    this.assertCurrent(operation);
+    if (destination !== undefined) {
+      await this.enter(destination, direction, operation);
+      return;
+    }
+    if (direction === "advance") {
+      const nextIndex = this.index + 1;
+      if (nextIndex >= this.steps.length)
+        await this.finish(operation);
+      else
+        await this.enter(nextIndex, direction, operation);
+      return;
+    }
+    if (this.index === 0) {
+      if (this.canCancel())
+        await this.cancelCurrent(operation);
+      else
+        this.setStatus("active");
+      return;
+    }
+    await this.enter(this.index - 1, direction, operation);
+  }
+  async runActions(operation) {
+    const step = this.currentStep();
+    if (!step)
+      return;
+    for (const action of step.definition.actions) {
+      this.assertCurrent(operation);
+      if (typeof action === "number") {
+        await abortableDelay(action, this.signalFor(operation));
+        this.assertCurrent(operation);
+        continue;
+      }
+      let controlInvoked = false;
+      const shouldContinue = await action(this.createStepContext(step, operation, () => {
+        controlInvoked = true;
+      }));
+      this.assertCurrent(operation);
+      if (controlInvoked || shouldContinue === false)
+        return;
+    }
+  }
+  async resolveTarget(step, operation) {
+    const signal = this.signalFor(operation);
+    const strategy = step.behavior?.missingTargetStrategy ?? "error";
+    const timeout = step.behavior?.targetTimeout ?? DEFAULT_TARGET_TIMEOUT;
+    const startedAt = Date.now();
+    while (true) {
+      const target = await step.resolveTarget(signal);
+      this.assertCurrent(operation);
+      if (target)
+        return target;
+      if (strategy === "skip")
+        return null;
+      if (strategy !== "wait" || Date.now() - startedAt >= timeout) {
+        throw this.missingTargetError(step);
+      }
+      await abortableDelay(16, signal);
+      this.assertCurrent(operation);
+    }
+  }
+  async recoverDisconnectedTarget(target) {
+    if (this.disposed || this.status !== "active")
+      return;
+    const step = this.currentStep();
+    if (!step || step.target !== target)
+      return;
+    const index = this.index;
+    const direction = this.direction;
+    const operation = this.beginOperation();
+    try {
+      this.setStatus("transitioning");
+      this.assertCurrent(operation);
+      await this.driver.clear(this.signalFor(operation));
+      this.assertCurrent(operation);
+      const recoveredTarget = await this.resolveTarget(step, operation);
+      this.assertCurrent(operation);
+      if (!recoveredTarget) {
+        await this.advancePastRecoveryMissingTarget(step, index, direction, operation);
+        return;
+      }
+      step.target = recoveredTarget;
+      await this.driver.show(step, direction, this.signalFor(operation));
+      this.assertCurrent(operation);
+      this.setStatus("active");
+    } catch (error) {
+      try {
+        await this.handleFailure(error, operation);
+      } catch {}
+    }
+  }
+  async advancePastMissingTarget(index, direction, operation) {
+    const nextIndex = direction === "advance" ? index + 1 : index - 1;
+    if (nextIndex >= this.steps.length)
+      await this.finish(operation);
+    else if (nextIndex < 0) {
+      if (this.canCancel())
+        await this.cancelCurrent(operation);
+      else
+        this.setStatus("active");
+    } else
+      await this.enter(nextIndex, direction, operation);
+  }
+  async advancePastRecoveryMissingTarget(step, index, direction, operation) {
+    const nextIndex = direction === "advance" ? index + 1 : index - 1;
+    if (nextIndex >= this.steps.length)
+      await this.finish(operation);
+    else if (nextIndex < 0) {
+      if (this.canCancel())
+        await this.cancelCurrent(operation);
+      else
+        throw this.missingTargetError(step);
+    } else
+      await this.enter(nextIndex, direction, operation);
+  }
+  missingTargetError(step) {
+    return new Error(`Missing target at ${step.path}: ${String(step.definition.target)}`);
+  }
+  async finish(operation) {
+    this.assertCurrent(operation);
+    const step = this.currentStep();
+    const { context, isAborted } = this.createLifecycleHookContext(step);
+    await this.workflow?.options.onFinish?.(context);
+    this.assertCurrent(operation);
+    if (isAborted()) {
+      if (step)
+        this.setStatus("active");
+      else
+        this.resetToIdle();
+      return;
+    }
+    this.emitStepLeave(step);
+    await this.driver.clear(this.signalFor(operation));
+    this.assertCurrent(operation);
+    this.retainedPresentation = null;
+    this.setStatus("finished");
+    this.emit("tour:complete", step, Date.now() - this.tourStartedAt);
+    this.assertCurrent(operation);
+  }
+  async cancelCurrent(operation) {
+    const step = this.currentStep();
+    if (step?.definition.cancelAction) {
+      await step.definition.cancelAction(this.createBeforeActionStepContext(step));
+    }
+    this.assertCurrent(operation);
+    const { context, isAborted } = this.createLifecycleHookContext(step);
+    await this.workflow?.options.onCancel?.(context);
+    this.assertCurrent(operation);
+    if (isAborted()) {
+      this.setStatus("active");
+      return;
+    }
+    this.emitStepLeave(step);
+    await this.driver.clear(this.signalFor(operation));
+    this.assertCurrent(operation);
+    this.retainedPresentation = null;
+    this.setStatus("cancelled");
+    this.emit("tour:cancel", step, Date.now() - this.tourStartedAt);
+    this.assertCurrent(operation);
+  }
+  createLifecycleHookContext(step) {
+    let aborted = false;
+    const context = Object.freeze({
+      step: step?.snapshot() ?? null,
+      abort: () => {
+        aborted = true;
+      }
+    });
+    return { context, isAborted: () => aborted };
+  }
+  resetToIdle() {
+    this.workflow = null;
+    this.releaseStepPropsSubscriptions();
+    this.steps = [];
+    this.index = -1;
+    this.retainedPresentation = null;
+    this.setStatus("idle");
+  }
+  async handleFailure(reason, operation) {
+    if (!this.isCurrent(operation))
+      return;
+    const error = normalizedError(reason);
+    this.error = error;
+    this.retainedPresentation = null;
+    this.setStatus("error");
+    this.emit("tour:error", this.currentStep(), Date.now() - this.tourStartedAt, error);
+    if (!this.isCurrent(operation))
+      throw error;
+    try {
+      await this.driver.clear(this.signalFor(operation));
+    } catch {}
+    throw error;
+  }
+  beginOperation() {
+    this.invalidateOperation();
+    this.operation = new AbortController;
+    return this.operationToken;
+  }
+  createStepContext(step, operation, onControl) {
+    if (!step.target)
+      throw new Error("Cannot create a step context without a target");
+    return Object.freeze({
+      advance: async () => {
+        onControl?.();
+        this.assertCurrent(operation);
+        await this.transition("advance", operation);
+      },
+      cancel: async () => {
+        onControl?.();
+        this.assertCurrent(operation);
+        if (this.canCancel())
+          await this.cancelCurrent(operation);
+      },
+      previous: async () => {
+        onControl?.();
+        this.assertCurrent(operation);
+        await this.transition("previous", operation);
+      },
+      props: step.props,
+      signal: this.signalFor(operation),
+      target: step.target
+    });
+  }
+  createBeforeActionStepContext(step) {
+    if (!step.target)
+      throw new Error("Cannot create a step context without a target");
+    return Object.freeze({
+      ...step.props.get(),
+      target: step.target
+    });
+  }
+  invalidateOperation() {
+    this.operationToken += 1;
+    this.operation?.abort();
+    this.operation = null;
+  }
+  signalFor(operation) {
+    this.assertCurrent(operation);
+    const signal = this.operation?.signal;
+    if (!signal)
+      throw abortError();
+    return signal;
+  }
+  assertCurrent(operation) {
+    if (!this.isCurrent(operation))
+      throw abortError();
+  }
+  isCurrent(operation) {
+    return !this.disposed && operation === this.operationToken && this.operation?.signal.aborted === false;
+  }
+  assertNotDisposed() {
+    if (this.disposed)
+      throw new Error(DISPOSED_ERROR_MESSAGE);
+  }
+  currentStep() {
+    return this.index >= 0 ? this.steps[this.index] ?? null : null;
+  }
+  releaseStepPropsSubscriptions() {
+    for (const unsubscribe of this.stepPropsSubscriptions.splice(0))
+      unsubscribe();
+  }
+  canNavigate(direction, destination) {
+    if (this.status !== "active" || !this.currentStep())
+      return false;
+    if (destination !== undefined) {
+      return destination >= 0 && destination < this.steps.length && destination !== this.index;
+    }
+    return direction === "advance" || this.index > 0;
+  }
+  isAdvanceButtonAvailable() {
+    const props = this.currentStep()?.props.get();
+    return props !== undefined && props.popover?.disableAdvanceButton !== true;
+  }
+  isPreviousButtonAvailable() {
+    const props = this.currentStep()?.props.get();
+    return props !== undefined && props.popover?.disablePreviousButton !== true && this.index > 0;
+  }
+  isCancelAvailable() {
+    return this.currentStep() !== null && this.canCancel();
+  }
+  isPresentedAdvanceAvailable() {
+    return this.currentStep() ? this.isAdvanceButtonAvailable() : this.retainedPresentation?.advanceButtonAvailable ?? false;
+  }
+  isPresentedPreviousAvailable() {
+    return this.currentStep() ? this.isPreviousButtonAvailable() : this.retainedPresentation?.previousButtonAvailable ?? false;
+  }
+  isPresentedCancelAvailable() {
+    return this.currentStep() ? this.isCancelAvailable() : this.retainedPresentation?.canCancel ?? false;
+  }
+  canCancel() {
+    return (this.workflow?.options.cancellable ?? true) && this.status !== "finished" && this.status !== "cancelled" && this.status !== "error";
+  }
+  setStatus(status) {
+    this.status = status;
+    this.publish();
+  }
+  publish(allowDisposed = false) {
+    const revision = ++this.publicationRevision;
+    const state = this.createSnapshot();
+    this.snapshot = state;
+    for (const listener of Array.from(this.stateListeners)) {
+      if (!allowDisposed && this.disposed || revision !== this.publicationRevision)
+        break;
+      this.notifyStateListener(listener, state);
+      if (!allowDisposed && this.disposed || revision !== this.publicationRevision)
+        break;
+    }
+  }
+  notifyStateListener(listener, state) {
+    try {
+      listener(state);
+    } catch (error) {
+      this.reportSubscriberError(error);
+    }
+  }
+  hasEventListeners() {
+    return Boolean(this.options.onEvent ?? this.workflow?.options.onEvent);
+  }
+  emit(type, step, durationMs, error = null) {
+    const instanceListener = this.options.onEvent;
+    const workflowListener = this.workflow?.options.onEvent;
+    if (!instanceListener && !workflowListener)
+      return;
+    const index = step ? this.steps.indexOf(step) : -1;
+    const event = Object.freeze({
+      direction: this.direction,
+      durationMs,
+      error,
+      source: this.commandSource,
+      stepCount: this.steps.length,
+      stepId: step?.definition.id ?? null,
+      stepIndex: index,
+      timestamp: Date.now(),
+      type,
+      workflowName: this.workflow?.name ?? ""
+    });
+    this.notifyEventListener(instanceListener, event);
+    this.notifyEventListener(workflowListener, event);
+  }
+  notifyEventListener(listener, event) {
+    if (!listener)
+      return;
+    try {
+      listener(event);
+    } catch (error) {
+      this.reportSubscriberError(error);
+    }
+  }
+  emitStepLeave(step) {
+    if (!step || !this.hasEventListeners())
+      return;
+    this.emit("step:leave", step, Date.now() - this.stepEnteredAt);
+  }
+  reportSubscriberError(reason) {
+    const error = normalizedError(reason);
+    const onSubscriberError = this.options.onSubscriberError;
+    if (!onSubscriberError) {
+      this.reportUnhandledError(error);
+      return;
+    }
+    try {
+      Promise.resolve(onSubscriberError(error)).catch((hookError) => {
+        this.reportUnhandledError(normalizedError(hookError));
+      });
+    } catch (hookError) {
+      this.reportUnhandledError(normalizedError(hookError));
+    }
+  }
+  reportUnhandledError(error) {
+    const reporter = this.options.reportUnhandledError ?? ((reason) => {
+      throw reason;
+    });
+    queueMicrotask(() => reporter(error));
+  }
+  createSnapshot() {
+    const currentStep = this.currentStep();
+    const retained = currentStep ? null : this.retainedPresentation;
+    const currentStepIndex = retained?.currentStepIndex ?? this.index;
+    const totalSteps = retained?.totalSteps ?? this.steps.length;
+    const isFirstStep = retained?.isFirstStep ?? currentStepIndex === 0;
+    const isLastStep = retained?.isLastStep ?? (currentStepIndex === totalSteps - 1 && currentStepIndex >= 0);
+    return Object.freeze({
+      name: this.workflow?.name ?? "",
+      totalSteps,
+      currentStepIndex,
+      currentStep: currentStep?.snapshot() ?? retained?.currentStep ?? null,
+      direction: this.direction,
+      canAdvance: this.canNavigate("advance"),
+      canPrevious: this.canNavigate("previous"),
+      canCancel: this.isPresentedCancelAvailable(),
+      isFirstStep,
+      isLastStep,
+      status: this.status,
+      error: this.error
+    });
+  }
+  capturePresentation() {
+    if (this.retainedPresentation)
+      return this.retainedPresentation;
+    if (this.status !== "active" && this.status !== "transitioning")
+      return null;
+    const state = this.createSnapshot();
+    if (!state.currentStep)
+      return null;
+    return {
+      advanceButtonAvailable: this.isAdvanceButtonAvailable(),
+      canCancel: state.canCancel,
+      currentStep: state.currentStep,
+      currentStepIndex: state.currentStepIndex,
+      isFirstStep: state.isFirstStep,
+      isLastStep: state.isLastStep,
+      previousButtonAvailable: this.isPreviousButtonAvailable(),
+      totalSteps: state.totalSteps
+    };
+  }
+}
+function createGlowTour(options = {}) {
+  const driver = new DomTourViewDriver;
+  let bridge;
+  const controller = new TourController(driver, {
+    assertCanRun: (workflow) => bridge.assertCanRun(workflow),
+    onDispose: () => bridge.release(),
+    onEvent: options.onEvent,
+    onSubscriberError: options.onSubscriberError
+  });
+  const tour = {
+    advance: () => controller.advance(),
+    cancel: () => controller.cancel(),
+    create: (name, options2) => controller.create(name, options2),
+    dispose: () => controller.dispose(),
+    goToStep: (index) => controller.goToStep(index),
+    previous: () => controller.previous(),
+    run: (workflow, runOptions) => controller.run(workflow, runOptions),
+    state: controller.state
+  };
+  bridge = attachRootBridge(tour, driver, () => controller.isDisposed(), () => controller.beginMountRelease(), () => controller.completeMountRelease());
+  return Object.freeze(tour);
+}
+export {
+  createGlowTour
+};