@vobs/captcha 1.1.0 → 1.2.1

package/dist/index.cjs

@@ -0,0 +1,1240 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// packages/reactivity/src/debug.ts
+var activeDebugHooks = null;
+var signalNames = /* @__PURE__ */ new WeakMap();
+function hasDebugHooks() {
+  return activeDebugHooks !== null;
+}
+__name(hasDebugHooks, "hasDebugHooks");
+function setSignalDebugName(signal, name) {
+  signalNames.set(signal, name);
+  invokeDebug("signalNamed", signal, name);
+}
+__name(setSignalDebugName, "setSignalDebugName");
+function invokeDebug(name, ...args) {
+  return;
+}
+__name(invokeDebug, "invokeDebug");
+
+// packages/reactivity/src/owner.ts
+var currentOwner = null;
+var nextOwnerId = 1;
+var ownerNames = /* @__PURE__ */ new WeakMap();
+function createOwner() {
+  const parent = currentOwner;
+  let disposed = parent?.disposed ?? false;
+  const children = [];
+  const cleanups = [];
+  const errorHandlers = /* @__PURE__ */ new Set();
+  const owner = {
+    id: `owner-${nextOwnerId++}`,
+    parent,
+    children,
+    depth: (parent?.depth ?? -1) + 1,
+    get disposed() {
+      return disposed;
+    },
+    run(fn) {
+      if (disposed) throw new Error("Vobs: \u5DF2\u9500\u6BC1\u7684 Owner \u4E0D\u80FD\u7EE7\u7EED\u8FD0\u884C");
+      const previous = currentOwner;
+      currentOwner = owner;
+      try {
+        return fn();
+      } finally {
+        currentOwner = previous;
+      }
+    },
+    addCleanup(cleanup) {
+      if (disposed) {
+        cleanup();
+        return;
+      }
+      cleanups.push(cleanup);
+    },
+    onDispose(cleanup) {
+      owner.addCleanup(cleanup);
+    },
+    onError(handler) {
+      errorHandlers.add(handler);
+      const remove = /* @__PURE__ */ __name(() => errorHandlers.delete(handler), "remove");
+      owner.addCleanup(remove);
+      return remove;
+    },
+    handleError(error) {
+      for (const handler of [...errorHandlers].reverse()) {
+        try {
+          handler(error);
+          return true;
+        } catch (handlerError) {
+          return parent?.handleError(handlerError) ?? false;
+        }
+      }
+      return parent?.handleError(error) ?? false;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const child of [...children]) child.dispose();
+      children.length = 0;
+      let firstError;
+      for (let index = cleanups.length - 1; index >= 0; index--) {
+        try {
+          cleanups[index]();
+        } catch (error) {
+          firstError ?? (firstError = error);
+        }
+      }
+      cleanups.length = 0;
+      if (parent) {
+        const index = parent.children.indexOf(owner);
+        if (index >= 0) parent.children.splice(index, 1);
+      }
+      if (firstError) throw firstError;
+    }
+  };
+  if (parent && !parent.disposed) parent.children.push(owner);
+  return owner;
+}
+__name(createOwner, "createOwner");
+function setOwnerDebugName(owner, name) {
+  ownerNames.set(owner, name);
+}
+__name(setOwnerDebugName, "setOwnerDebugName");
+function getCurrentOwner() {
+  return currentOwner;
+}
+__name(getCurrentOwner, "getCurrentOwner");
+function onDispose(cleanup) {
+  const owner = getCurrentOwner();
+  if (!owner) throw new Error("Vobs: onDispose \u5FC5\u987B\u5728 Owner \u4F5C\u7528\u57DF\u5185\u8C03\u7528");
+  owner.onDispose(cleanup);
+}
+__name(onDispose, "onDispose");
+
+// packages/reactivity/src/signal.ts
+var currentSubscriber = null;
+function getCurrentSubscriber() {
+  return currentSubscriber;
+}
+__name(getCurrentSubscriber, "getCurrentSubscriber");
+function setCurrentSubscriber(subscriber) {
+  currentSubscriber = subscriber;
+}
+__name(setCurrentSubscriber, "setCurrentSubscriber");
+function trackDependency(dependency) {
+  if (!currentSubscriber || currentSubscriber.disposed) return;
+  !currentSubscriber.dependencies.has(dependency);
+  currentSubscriber.dependencies.add(dependency);
+}
+__name(trackDependency, "trackDependency");
+function state(initialValue, debugName) {
+  let value = initialValue;
+  let disposed = false;
+  const subscribers = /* @__PURE__ */ new Set();
+  const signalInstance = {
+    get value() {
+      const subscriber = getCurrentSubscriber();
+      if (subscriber && !subscriber.disposed) {
+        subscribers.add(subscriber);
+        trackDependency(signalInstance);
+      }
+      return value;
+    },
+    set value(nextValue) {
+      if (disposed || Object.is(value, nextValue)) return;
+      value = nextValue;
+      for (const subscriber of [...subscribers]) subscriber.notify();
+    },
+    unsubscribe(subscriber) {
+      subscribers.delete(subscriber);
+    },
+    // 与 `.value =` 赋值同一条路径：判等短路、debug hook、notify 全部一致。
+    // 以闭包实现，可安全地作为回调直接传递（无 this 绑定问题）。
+    set(next) {
+      signalInstance.value = next;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      subscribers.clear();
+    }
+  };
+  const owner = getCurrentOwner();
+  owner?.addCleanup(signalInstance.dispose);
+  if (debugName?.trim()) setSignalDebugName(signalInstance, debugName.trim());
+  return signalInstance;
+}
+__name(state, "state");
+
+// packages/reactivity/src/scheduler.ts
+var _Scheduler = class _Scheduler {
+  constructor() {
+    this.dirtyEffects = /* @__PURE__ */ new Set();
+    this.lowPriorityEffects = /* @__PURE__ */ new Set();
+    // flush 不可重入（flushing 标志保证），缓冲数组可在轮次间安全复用，避免每轮分配。
+    this.normalBuffer = [];
+    this.lowBuffer = [];
+    this.flushing = false;
+    this.scheduled = false;
+    this.batchDepth = 0;
+  }
+  schedule(effect2) {
+    if (effect2.disposed) return;
+    this.dirtyEffects.add(effect2);
+    this.lowPriorityEffects.delete(effect2);
+    this.ensureScheduled();
+  }
+  /** Queue an effect behind normal updates while preserving deterministic order. */
+  scheduleLow(effect2) {
+    if (effect2.disposed) return;
+    if (!this.dirtyEffects.has(effect2)) this.lowPriorityEffects.add(effect2);
+    this.ensureScheduled();
+  }
+  ensureScheduled() {
+    if (this.batchDepth === 0 && !this.flushing && !this.scheduled) {
+      this.scheduled = true;
+      queueMicrotask(() => {
+        this.scheduled = false;
+        this.flush();
+      });
+    }
+  }
+  remove(effect2) {
+    this.dirtyEffects.delete(effect2);
+    this.lowPriorityEffects.delete(effect2);
+  }
+  batch(fn) {
+    this.batchDepth++;
+    try {
+      return fn();
+    } finally {
+      this.batchDepth--;
+      if (this.batchDepth === 0) this.flush();
+    }
+  }
+  flush() {
+    if (this.flushing || this.batchDepth > 0) return;
+    this.flushing = true;
+    let rounds = 0;
+    let firstError;
+    let hasError = false;
+    try {
+      while (this.dirtyEffects.size > 0 || this.lowPriorityEffects.size > 0) {
+        if (++rounds > 100) {
+          this.dirtyEffects.clear();
+          this.lowPriorityEffects.clear();
+          throw new Error("Vobs: \u54CD\u5E94\u5F0F\u66F4\u65B0\u8D85\u8FC7 100 \u8F6E\uFF0C\u53EF\u80FD\u5B58\u5728\u5FAA\u73AF\u4F9D\u8D56");
+        }
+        this.collectRunnable(this.dirtyEffects, this.normalBuffer);
+        this.collectRunnable(this.lowPriorityEffects, this.lowBuffer);
+        sortEffects(this.normalBuffer);
+        sortEffects(this.lowBuffer);
+        for (const effect2 of this.normalBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        for (const effect2 of this.lowBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        this.normalBuffer.length = 0;
+        this.lowBuffer.length = 0;
+      }
+    } finally {
+      this.normalBuffer.length = 0;
+      this.lowBuffer.length = 0;
+      this.flushing = false;
+    }
+    if (hasError) throw firstError;
+  }
+  /** 收集未 disposed 的 effect 并清空源集合；run() 期间新调度的 effect 留给下一轮。 */
+  collectRunnable(source, target) {
+    for (const effect2 of source) {
+      if (!effect2.disposed) target.push(effect2);
+    }
+    source.clear();
+  }
+};
+__name(_Scheduler, "Scheduler");
+var Scheduler = _Scheduler;
+function sortEffects(effects) {
+  if (effects.length > 1) {
+    effects.sort((a, b) => b.depth - a.depth || a.order - b.order);
+  }
+}
+__name(sortEffects, "sortEffects");
+var scheduler = new Scheduler();
+
+// packages/reactivity/src/effect.ts
+var nextEffectOrder = 1;
+function cleanupDependencies(subscriber) {
+  for (const dependency of subscriber.dependencies) {
+    dependency.unsubscribe(subscriber);
+  }
+  subscriber.dependencies.clear();
+}
+__name(cleanupDependencies, "cleanupDependencies");
+function effect(callback) {
+  const owner = getCurrentOwner();
+  let cleanup;
+  let dirty = true;
+  let disposed = false;
+  const eff = {
+    order: nextEffectOrder++,
+    depth: owner?.depth ?? 0,
+    dependencies: /* @__PURE__ */ new Set(),
+    get disposed() {
+      return disposed;
+    },
+    notify() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.schedule(eff);
+    },
+    run() {
+      if (disposed || !dirty) return;
+      dirty = false;
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled2 = owner?.handleError(error) ?? false;
+          if (!handled2) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      const previous = getCurrentSubscriber();
+      setCurrentSubscriber(eff);
+      let thrown;
+      let handled = false;
+      try {
+        const result = owner ? owner.run(callback) : callback();
+        cleanup = typeof result === "function" ? result : void 0;
+      } catch (error) {
+        thrown = error;
+        handled = owner?.handleError(error) ?? false;
+        if (!handled) throw error;
+      } finally {
+        setCurrentSubscriber(previous);
+      }
+      if (cleanupError && !thrown) throw cleanupError;
+    },
+    scheduleLow() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.scheduleLow(eff);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      dirty = false;
+      scheduler.remove(eff);
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled = owner?.handleError(error) ?? false;
+          if (!handled) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      if (cleanupError) throw cleanupError;
+    }
+  };
+  owner?.addCleanup(eff.dispose);
+  eff.run();
+  return eff;
+}
+__name(effect, "effect");
+
+// packages/runtime/src/debug.ts
+var activeRuntimeDebugHooks = null;
+function getRuntimeDebugHooks() {
+  return activeRuntimeDebugHooks;
+}
+__name(getRuntimeDebugHooks, "getRuntimeDebugHooks");
+function invokeRuntimeDebug(name, ...args) {
+  return;
+}
+__name(invokeRuntimeDebug, "invokeRuntimeDebug");
+function readDebugValue(read) {
+  try {
+    return read();
+  } catch {
+    return "[Uninspectable]";
+  }
+}
+__name(readDebugValue, "readDebugValue");
+function describeDebugNode(node) {
+  if (!node || typeof node !== "object") return "node";
+  const value = node;
+  const name = typeof value.tagName === "string" ? value.tagName.toLowerCase() : typeof value.nodeName === "string" ? value.nodeName.toLowerCase() : "node";
+  const id = typeof value.id === "string" && value.id ? `#${value.id}` : "";
+  const className = typeof value.className === "string" && value.className ? `.${value.className.trim().split(/\s+/).filter(Boolean).join(".")}` : "";
+  return `${name}${id}${className}`;
+}
+__name(describeDebugNode, "describeDebugNode");
+
+// packages/runtime/src/hmr.ts
+var globalTarget = globalThis;
+var hmrGlobal = globalTarget.__VOBS_HMR__ ?? { modules: /* @__PURE__ */ new Map() };
+globalTarget.__VOBS_HMR__ = hmrGlobal;
+function markHmrInstanceMounted(node, parent) {
+  const instance = hmrInstances.get(node);
+  if (instance) instance.parent = parent;
+}
+__name(markHmrInstanceMounted, "markHmrInstanceMounted");
+var hmrInstances = /* @__PURE__ */ new WeakMap();
+var nodeOwners = /* @__PURE__ */ new WeakMap();
+var eventBindings = /* @__PURE__ */ new WeakMap();
+function getRenderer() {
+  {
+    throw new Error("\u6E32\u67D3\u5668\u672A\u521D\u59CB\u5316");
+  }
+}
+__name(getRenderer, "getRenderer");
+function createText(content) {
+  return getRenderer().createText(content);
+}
+__name(createText, "createText");
+function createElement(tag) {
+  return getRenderer().createElement(tag);
+}
+__name(createElement, "createElement");
+function createComment(content) {
+  return getRenderer().createComment(content);
+}
+__name(createComment, "createComment");
+function insertBefore(parent, child, anchor) {
+  if (isVobsFragment(child)) {
+    child.mount(parent, isVobsFragment(anchor) ? anchor.start : anchor);
+    return;
+  }
+  getRenderer().insertBefore(parent, child, isVobsFragment(anchor) ? anchor.start : anchor);
+  markHmrInstanceMounted(child, parent);
+}
+__name(insertBefore, "insertBefore");
+function removeChild(parent, child) {
+  disposeNodeOwner(child);
+  if (isVobsFragment(child)) {
+    child.unmount(parent);
+    return;
+  }
+  getRenderer().removeChild(parent, child);
+}
+__name(removeChild, "removeChild");
+function setProperty(node, key, value) {
+  getRenderer().setProperty(node, key, value);
+}
+__name(setProperty, "setProperty");
+function setAttribute(node, key, value) {
+  getRenderer().setAttribute(node, key, value);
+}
+__name(setAttribute, "setAttribute");
+function addEventListener(node, event, handler) {
+  const renderer = getRenderer();
+  const owner = getCurrentOwner();
+  let bindings = eventBindings.get(node);
+  if (!bindings) {
+    bindings = /* @__PURE__ */ new Map();
+    eventBindings.set(node, bindings);
+  }
+  const previous = bindings.get(event);
+  if (previous && previous.original === handler && previous.owner === owner) return;
+  if (previous) renderer.removeEventListener(node, event, previous.handler);
+  const listener = owner ? (reason) => {
+    try {
+      owner.run(() => handler(reason));
+    } catch (error) {
+      const handled = owner.handleError(error);
+      invokeRuntimeDebug("error", {
+        error,
+        owner,
+        phase: "event",
+        handled,
+        recovery: handled ? "handled" : "propagated"
+      });
+      if (!handled) throw error;
+    }
+  } : handler;
+  const binding = { handler: listener, owner, original: handler };
+  bindings.set(event, binding);
+  renderer.addEventListener(node, event, listener);
+  owner?.onDispose(() => {
+    if (bindings?.get(event) !== binding) return;
+    bindings.delete(event);
+    renderer.removeEventListener(node, event, listener);
+  });
+}
+__name(addEventListener, "addEventListener");
+function createBlock(factory) {
+  const owner = createOwner();
+  setOwnerDebugName(owner, "dynamic");
+  let node;
+  try {
+    node = owner.run(factory);
+  } catch (error) {
+    owner.dispose();
+    throw error;
+  }
+  if (!node) {
+    owner.dispose();
+    return null;
+  }
+  associateNodeOwner(node, owner);
+  return node;
+}
+__name(createBlock, "createBlock");
+function associateNodeOwner(node, owner) {
+  nodeOwners.set(node, owner);
+}
+__name(associateNodeOwner, "associateNodeOwner");
+function disposeNodeOwner(node) {
+  const owner = nodeOwners.get(node);
+  if (!owner) return;
+  nodeOwners.delete(node);
+  owner.dispose();
+}
+__name(disposeNodeOwner, "disposeNodeOwner");
+
+// packages/runtime/src/fragment.ts
+function createFragment(factory) {
+  const start = createComment("vobs:fragment:start");
+  const end = createComment("vobs:fragment:end");
+  let parent = null;
+  let initialized = false;
+  const owner = getCurrentOwner();
+  const fragment = {
+    kind: "vobs-fragment",
+    start,
+    end,
+    mount(nextParent, anchor) {
+      if (parent && parent !== nextParent) {
+        throw new Error("Vobs Fragment: \u4E0D\u80FD\u8DE8\u7236\u8282\u70B9\u79FB\u52A8 Fragment");
+      }
+      if (initialized) {
+        moveRange(nextParent, start, end, anchor);
+        return;
+      }
+      const renderer = getRenderer();
+      renderer.insertBefore(nextParent, start, anchor);
+      renderer.insertBefore(nextParent, end, anchor);
+      parent = nextParent;
+      initialized = true;
+      if (owner) owner.run(() => factory(nextParent, end));
+      else factory(nextParent, end);
+    },
+    unmount(nextParent) {
+      if (!initialized || parent !== nextParent) {
+        throw new Error("Vobs Fragment: Fragment \u4E0D\u5C5E\u4E8E\u6307\u5B9A\u7236\u8282\u70B9");
+      }
+      const renderer = getRenderer();
+      let current = renderer.nextSibling(start);
+      while (current && current !== end) {
+        const next = renderer.nextSibling(current);
+        renderer.removeChild(nextParent, current);
+        current = next;
+      }
+      renderer.removeChild(nextParent, start);
+      renderer.removeChild(nextParent, end);
+      parent = null;
+      initialized = false;
+    }
+  };
+  return fragment;
+}
+__name(createFragment, "createFragment");
+function isVobsFragment(value) {
+  return Boolean(value) && typeof value === "object" && value.kind === "vobs-fragment";
+}
+__name(isVobsFragment, "isVobsFragment");
+function moveRange(parent, start, end, anchor) {
+  const renderer = getRenderer();
+  const nodes = [start];
+  let current = renderer.nextSibling(start);
+  while (current) {
+    nodes.push(current);
+    if (current === end) break;
+    current = renderer.nextSibling(current);
+  }
+  if (nodes[nodes.length - 1] !== end) {
+    throw new Error("Vobs Fragment: \u627E\u4E0D\u5230\u7ED3\u675F\u951A\u70B9");
+  }
+  for (const node of nodes) renderer.insertBefore(parent, node, anchor);
+}
+__name(moveRange, "moveRange");
+
+// packages/runtime/src/dynamic.ts
+function insertDynamic(parent, anchor, factory) {
+  const marker = createComment("vobs:dynamic");
+  insertBefore(parent, marker, anchor);
+  let current = null;
+  effect(() => {
+    const next = createBlock(factory);
+    if (next === current) return;
+    if (current) removeChild(parent, current);
+    current = next;
+    if (current) insertBefore(parent, current, marker);
+  });
+}
+__name(insertDynamic, "insertDynamic");
+
+// packages/captcha/src/slider.ts
+var sessionId = createSessionId();
+function collectCaptchaDeviceSignals() {
+  if (typeof navigator === "undefined" || typeof window === "undefined") {
+    return { sessionId };
+  }
+  let timezone;
+  try {
+    timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    timezone = void 0;
+  }
+  const screen = window.screen;
+  const navigatorWithMemory = navigator;
+  return {
+    sessionId,
+    userAgent: navigator.userAgent,
+    platform: navigator.platform,
+    language: navigator.language,
+    languages: navigator.languages ? [...navigator.languages] : void 0,
+    timezone,
+    screen: {
+      width: screen.width,
+      height: screen.height,
+      pixelRatio: window.devicePixelRatio || 1
+    },
+    viewport: {
+      width: window.innerWidth,
+      height: window.innerHeight
+    },
+    touchPoints: navigator.maxTouchPoints,
+    hardwareConcurrency: navigator.hardwareConcurrency,
+    deviceMemory: navigatorWithMemory.deviceMemory,
+    webdriver: navigator.webdriver
+  };
+}
+__name(collectCaptchaDeviceSignals, "collectCaptchaDeviceSignals");
+function SliderCaptcha(props = {}) {
+  const positions = /* @__PURE__ */ new Map();
+  const successDismissed = state(false);
+  let successTimer;
+  let waitingForDismiss = false;
+  effect(() => {
+    const currentStatus = readValue(props, "status", "idle");
+    if (currentStatus !== "verified") {
+      waitingForDismiss = false;
+      successDismissed.value = false;
+      if (successTimer !== void 0) {
+        clearTimeout(successTimer);
+        successTimer = void 0;
+      }
+      return;
+    }
+    if (waitingForDismiss) return;
+    waitingForDismiss = true;
+    const duration = Math.max(0, readValue(props, "successDuration", 1e3));
+    successTimer = setTimeout(() => {
+      successTimer = void 0;
+      successDismissed.value = true;
+      props.onSuccessDismiss?.();
+    }, duration);
+  });
+  onDispose(() => {
+    if (successTimer !== void 0) clearTimeout(successTimer);
+    positions.clear();
+  });
+  return Captcha({
+    get challenge() {
+      return readValue(props, "challenge", null);
+    },
+    get status() {
+      return readValue(props, "status", "idle");
+    },
+    get error() {
+      return readValue(props, "error", void 0);
+    },
+    get disabled() {
+      return readValue(props, "disabled", false);
+    },
+    get retryLabel() {
+      return readValue(props, "status", "idle") === "loading" ? readValue(props, "refreshingLabel", "Refreshing\u2026") : readValue(props, "retryLabel", "Retry");
+    },
+    get retryIcon() {
+      return props.retryIcon;
+    },
+    get cancelLabel() {
+      return readValue(props, "cancelLabel", "Cancel");
+    },
+    get loadingLabel() {
+      return readValue(props, "loadingLabel", "Loading captcha\u2026");
+    },
+    get emptyLabel() {
+      return readValue(props, "emptyLabel", "Captcha is not ready.");
+    },
+    get expiredLabel() {
+      return readValue(props, "expiredLabel", "This captcha has expired.");
+    },
+    get errorLabel() {
+      return readValue(props, "errorLabel", "Captcha verification failed.");
+    },
+    get label() {
+      return readValue(props, "label", "");
+    },
+    get messagePlacement() {
+      return "none";
+    },
+    get keepChallengeOnError() {
+      return true;
+    },
+    get keepChallengeOnLoading() {
+      return true;
+    },
+    get keepChallengeOnVerifying() {
+      return true;
+    },
+    get showRetry() {
+      return true;
+    },
+    get showRetryWhileLoading() {
+      return true;
+    },
+    get showCancel() {
+      return true;
+    },
+    get class() {
+      return classNames(
+        "vobs-slider-captcha",
+        successDismissed.value ? "vobs-slider-captcha--dismissed" : void 0,
+        readString(props, "class"),
+        readString(props, "className")
+      );
+    },
+    get id() {
+      return readString(props, "id");
+    },
+    get title() {
+      return readString(props, "title");
+    },
+    get role() {
+      return readString(props, "role");
+    },
+    onRetry: props.onRetry,
+    onCancel: props.onCancel,
+    onSubmit(answer, challenge) {
+      if (!isSliderResult(answer)) return;
+      return props.onSubmit?.(answer, challenge);
+    },
+    renderChallenge(context) {
+      return createSliderChallenge(
+        context,
+        props,
+        positions.get(context.challenge.id) ?? 0,
+        (position) => positions.set(context.challenge.id, position)
+      );
+    },
+    ...readDataAndAriaProps(props)
+  });
+}
+__name(SliderCaptcha, "SliderCaptcha");
+function createSliderChallenge(context, props, initialPosition, onPositionChange) {
+  const challenge = context.challenge;
+  const payload = challenge.payload;
+  const interactionDisabled = context.disabled || context.status === "error" || context.status === "expired" || context.status === "verified";
+  const wrapper = createElement("div");
+  const visual = createElement("div");
+  const target = createElement("div");
+  const targetImage = createElement("div");
+  const piece = createElement("div");
+  const pieceImage = createElement("div");
+  const track = createElement("div");
+  const trackPrompt = createElement("span");
+  const handle = createElement("button");
+  const handleText = createText(context.status === "verified" ? "\u221A" : readValue(props, "dragLabel", ">"));
+  const trail = [];
+  const startX = clamp(payload.startX ?? 0, 0, Math.max(0, payload.width - payload.pieceWidth));
+  const maxPosition = Math.max(0, payload.width - payload.pieceWidth - startX);
+  const position = state(clamp(initialPosition, 0, maxPosition));
+  const dragging = state(false);
+  const handleWidth = 50;
+  let startClientX = 0;
+  let startPosition = 0;
+  let lastRecordedAt = 0;
+  let startedAt = 0;
+  setAttribute(wrapper, "class", "vobs-slider-captcha__challenge");
+  setAttribute(visual, "class", "vobs-slider-captcha__visual");
+  setAttribute(target, "class", `vobs-slider-captcha__target vobs-slider-captcha__target--${payload.shape ?? "puzzle"}`);
+  setAttribute(targetImage, "class", "vobs-slider-captcha__image");
+  setAttribute(piece, "class", `vobs-slider-captcha__piece vobs-slider-captcha__piece--${payload.shape ?? "puzzle"}`);
+  setAttribute(pieceImage, "class", "vobs-slider-captcha__image");
+  setAttribute(track, "class", "vobs-slider-captcha__track");
+  setAttribute(trackPrompt, "class", "vobs-slider-captcha__track-prompt");
+  setAttribute(handle, "class", `vobs-slider-captcha__handle${context.status === "verified" ? " vobs-slider-captcha__handle--verified" : ""}`);
+  setAttribute(handle, "type", "button");
+  setAttribute(handle, "role", "slider");
+  setAttribute(handle, "aria-label", context.status === "verified" ? "\u9A8C\u8BC1\u901A\u8FC7" : readValue(props, "dragLabel", ">"));
+  insertBefore(trackPrompt, createText("\u5411\u53F3\u62D6\u52A8\u6ED1\u5757\u5B8C\u6210\u62FC\u56FE"), null);
+  insertBefore(handle, handleText, null);
+  const visualImageStyle = payload.image ? `background-image: url(${quoteCssUrl(payload.image)}); background-size: ${payload.width}px ${payload.height}px;` : "";
+  const imageAt = /* @__PURE__ */ __name((x, y) => payload.image ? `${visualImageStyle} background-position: -${x}px -${y}px;` : "", "imageAt");
+  setAttribute(visual, "style", `width: ${payload.width}px; height: ${payload.height}px; ${visualImageStyle}`);
+  const targetRotation = rotationStyle(payload.rotation);
+  setAttribute(target, "style", `left: ${payload.targetX}px; top: ${payload.targetY}px; width: ${payload.pieceWidth}px; height: ${payload.pieceHeight}px; ${targetRotation}`);
+  setAttribute(targetImage, "style", `${counterRotationStyle(payload.rotation)} ${imageAt(payload.targetX, payload.targetY)}`);
+  setAttribute(pieceImage, "style", `${counterRotationStyle(payload.rotation)} ${imageAt(payload.targetX, payload.targetY)}`);
+  setAttribute(piece, "style", `top: ${payload.targetY}px; width: ${payload.pieceWidth}px; height: ${payload.pieceHeight}px; ${targetRotation}`);
+  setAttribute(track, "style", `width: ${payload.width}px`);
+  insertBefore(target, targetImage, null);
+  const decoys = readDecoys(payload);
+  const decoyNodes = decoys.map((decoyData) => {
+    const decoy = createElement("div");
+    const decoyImage = createElement("div");
+    setAttribute(decoy, "class", `vobs-slider-captcha__decoy vobs-slider-captcha__decoy--${payload.shape ?? "puzzle"}`);
+    setAttribute(decoyImage, "class", "vobs-slider-captcha__image");
+    setAttribute(decoy, "style", `left: ${decoyData.x}px; top: ${decoyData.y}px; width: ${payload.pieceWidth}px; height: ${payload.pieceHeight}px; ${rotationStyle(decoyData.rotation)}`);
+    setAttribute(decoyImage, "style", `${counterRotationStyle(decoyData.rotation)} ${imageAt(decoyData.x, decoyData.y)}`);
+    insertBefore(decoy, decoyImage, null);
+    return decoy;
+  });
+  insertBefore(piece, pieceImage, null);
+  insertBefore(visual, target, null);
+  for (const decoy of decoyNodes) insertBefore(visual, decoy, null);
+  insertBefore(visual, piece, null);
+  if (context.status === "error" || context.status === "loading") {
+    const notice = createElement("p");
+    const isError = context.status === "error";
+    setAttribute(notice, "class", isError ? "vobs-slider-captcha__error" : "vobs-slider-captcha__notice");
+    setAttribute(notice, "role", isError ? "alert" : "status");
+    insertBefore(notice, createText(isError ? readErrorMessage(props) : readValue(props, "loadingLabel", "Refreshing captcha\u2026")), null);
+    insertBefore(visual, notice, null);
+  }
+  insertBefore(track, trackPrompt, null);
+  insertBefore(track, handle, null);
+  insertBefore(wrapper, visual, null);
+  insertBefore(wrapper, track, null);
+  effect(() => {
+    const value = position.value;
+    const pieceX = startX + value;
+    onPositionChange(value);
+    setAttribute(track, "data-has-moved", String(value > 0));
+    setAttribute(piece, "style", `left: ${pieceX}px; top: ${payload.targetY}px; width: ${payload.pieceWidth}px; height: ${payload.pieceHeight}px; ${targetRotation}`);
+    setAttribute(handle, "style", `left: calc(${value / Math.max(1, maxPosition) * 100}% - ${value / Math.max(1, maxPosition) * handleWidth}px)`);
+    setAttribute(handle, "aria-valuemin", "0");
+    setAttribute(handle, "aria-valuemax", String(maxPosition));
+    setAttribute(handle, "aria-valuenow", String(Math.round(value)));
+    setProperty(handle, "disabled", interactionDisabled);
+    setAttribute(wrapper, "data-dragging", String(dragging.value));
+  });
+  for (const source of [piece, handle]) {
+    addEventListener(source, "pointerdown", (event) => {
+      if (interactionDisabled) return;
+      const pointer = event;
+      if (pointer.button !== void 0 && pointer.button !== 0) return;
+      dragging.value = true;
+      startClientX = pointer.clientX;
+      startPosition = position.value;
+      startedAt = Date.now();
+      lastRecordedAt = 0;
+      trail.length = 0;
+      recordPoint(pointer);
+      const capture = source;
+      capture.setPointerCapture?.(pointer.pointerId);
+    });
+    addEventListener(source, "pointermove", (event) => {
+      if (!dragging.value || interactionDisabled) return;
+      const pointer = event;
+      const scale = getVisualScale(visual, payload.width);
+      position.value = clamp(startPosition + (pointer.clientX - startClientX) / scale, 0, maxPosition);
+      recordPoint(pointer);
+    });
+    addEventListener(source, "pointerup", (event) => {
+      if (!dragging.value) return;
+      recordPoint(event, true);
+      dragging.value = false;
+      submit();
+    });
+    addEventListener(source, "pointercancel", () => {
+      dragging.value = false;
+      position.value = 0;
+      trail.length = 0;
+    });
+  }
+  addEventListener(handle, "keydown", (event) => {
+    if (interactionDisabled) return;
+    const keyboard = event;
+    if (keyboard.key === "ArrowLeft" || keyboard.key === "ArrowRight") {
+      const direction = keyboard.key === "ArrowRight" ? 1 : -1;
+      position.value = clamp(position.value + direction * Math.max(1, maxPosition / 20), 0, maxPosition);
+      recordPoint({ clientX: position.value, clientY: 0 }, true);
+      keyboard.preventDefault();
+    } else if (keyboard.key === "Enter" || keyboard.key === " ") {
+      submit();
+      keyboard.preventDefault();
+    }
+  });
+  onDispose(() => {
+    trail.length = 0;
+  });
+  function recordPoint(pointer, force = false) {
+    const now = Date.now();
+    if (!force && now - lastRecordedAt < 20) return;
+    trail.push({ x: pointer.clientX, y: pointer.clientY, t: now });
+    lastRecordedAt = now;
+  }
+  __name(recordPoint, "recordPoint");
+  function submit() {
+    if (interactionDisabled || trail.length === 0) return;
+    const now = Date.now();
+    const finalPoint = trail[trail.length - 1];
+    context.submit({
+      x: startX + position.value,
+      y: payload.targetY,
+      trail: trail.slice(),
+      duration: Math.max(0, (finalPoint?.t ?? now) - (startedAt || now)),
+      analysis: analyzeSliderTrail(trail),
+      deviceSignals: readValue(props, "collectDeviceSignals", true) ? collectCaptchaDeviceSignals() : void 0
+    });
+  }
+  __name(submit, "submit");
+  return wrapper;
+}
+__name(createSliderChallenge, "createSliderChallenge");
+function analyzeSliderTrail(trail) {
+  if (trail.length === 0) {
+    return {
+      pointCount: 0,
+      duration: 0,
+      distance: 0,
+      averageSpeed: 0,
+      maxSpeed: 0,
+      directionChanges: 0,
+      verticalTravel: 0,
+      averageInterval: 0,
+      looksHuman: false
+    };
+  }
+  let distance = 0;
+  let verticalTravel = 0;
+  let maxSpeed = 0;
+  let directionChanges = 0;
+  let previousDirection = 0;
+  let intervalTotal = 0;
+  let intervalCount = 0;
+  for (let index = 1; index < trail.length; index++) {
+    const previous = trail[index - 1];
+    const current = trail[index];
+    const dx = current.x - previous.x;
+    const dy = current.y - previous.y;
+    const dt = Math.max(1, current.t - previous.t);
+    const segmentDistance = Math.hypot(dx, dy);
+    distance += segmentDistance;
+    verticalTravel += Math.abs(dy);
+    maxSpeed = Math.max(maxSpeed, segmentDistance / dt * 1e3);
+    intervalTotal += current.t - previous.t;
+    intervalCount++;
+    if (Math.abs(dx) >= 0.5) {
+      const direction = Math.sign(dx);
+      if (previousDirection !== 0 && direction !== previousDirection) directionChanges++;
+      previousDirection = direction;
+    }
+  }
+  const duration = Math.max(0, trail[trail.length - 1].t - trail[0].t);
+  const averageSpeed = duration > 0 ? distance / duration * 1e3 : 0;
+  const averageInterval = intervalCount > 0 ? intervalTotal / intervalCount : 0;
+  const looksHuman = trail.length >= 3 && duration >= 120 && duration <= 1e4 && directionChanges > 0;
+  return {
+    pointCount: trail.length,
+    duration,
+    distance,
+    averageSpeed,
+    maxSpeed,
+    directionChanges,
+    verticalTravel,
+    averageInterval,
+    looksHuman
+  };
+}
+__name(analyzeSliderTrail, "analyzeSliderTrail");
+function readErrorMessage(props) {
+  const error = readValue(props, "error", void 0);
+  if (typeof error === "string" && error) return error;
+  if (error instanceof Error) return error.message;
+  return readValue(props, "errorLabel", "Captcha verification failed.");
+}
+__name(readErrorMessage, "readErrorMessage");
+function isSliderResult(value) {
+  if (value === null || typeof value !== "object") return false;
+  const result = value;
+  return typeof result.x === "number" && typeof result.y === "number" && typeof result.duration === "number" && Array.isArray(result.trail) && typeof result.analysis === "object" && result.analysis !== null;
+}
+__name(isSliderResult, "isSliderResult");
+function getVisualScale(visual, width) {
+  const measured = visual.getBoundingClientRect?.().width ?? width;
+  return measured > 0 ? measured / width : 1;
+}
+__name(getVisualScale, "getVisualScale");
+function quoteCssUrl(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+__name(quoteCssUrl, "quoteCssUrl");
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+__name(clamp, "clamp");
+function rotationStyle(rotation) {
+  return rotation === void 0 || rotation === 0 ? "" : `transform: rotate(${rotation}deg);`;
+}
+__name(rotationStyle, "rotationStyle");
+function readDecoys(payload) {
+  if (payload.decoys !== void 0) return payload.decoys;
+  if (payload.decoyX === void 0 || payload.decoyY === void 0) return [];
+  return [{ x: payload.decoyX, y: payload.decoyY, rotation: payload.decoyRotation }];
+}
+__name(readDecoys, "readDecoys");
+function counterRotationStyle(rotation) {
+  return rotation === void 0 || rotation === 0 ? "" : `transform: rotate(${-rotation}deg);`;
+}
+__name(counterRotationStyle, "counterRotationStyle");
+function classNames(...values) {
+  return values.filter(Boolean).join(" ");
+}
+__name(classNames, "classNames");
+function readValue(props, name, fallback) {
+  const value = Reflect.get(props, name);
+  if (value === void 0) return fallback;
+  if (typeof value === "function") return value();
+  if (isSignal(value)) return value.value;
+  return value;
+}
+__name(readValue, "readValue");
+function readString(props, name) {
+  const value = readValue(props, name, void 0);
+  return typeof value === "string" ? value : void 0;
+}
+__name(readString, "readString");
+function readDataAndAriaProps(props) {
+  const result = {};
+  for (const name of Object.keys(props)) {
+    if (name.startsWith("aria-") || name.startsWith("data-")) result[name] = readValue(props, name, void 0);
+  }
+  return result;
+}
+__name(readDataAndAriaProps, "readDataAndAriaProps");
+function isSignal(value) {
+  return value !== null && typeof value === "object" && "value" in value && typeof value.dispose === "function";
+}
+__name(isSignal, "isSignal");
+function createSessionId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  return `captcha-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+__name(createSessionId, "createSessionId");
+
+// packages/captcha/src/index.ts
+function Captcha(props = {}) {
+  const root = createElement("section");
+  const challengeHost = createElement("div");
+  const messageHost = createElement("div");
+  const actions = createElement("div");
+  const header = createElement("div");
+  const headerText = createText("");
+  setAttribute(header, "class", "vobs-captcha__header");
+  setAttribute(challengeHost, "class", "vobs-captcha__challenge");
+  setAttribute(messageHost, "class", "vobs-captcha__message-host");
+  setAttribute(actions, "class", "vobs-captcha__actions");
+  insertBefore(root, header, null);
+  insertBefore(root, challengeHost, null);
+  insertBefore(root, messageHost, null);
+  insertBefore(root, actions, null);
+  insertDynamic(header, null, () => {
+    const label = readString2(props, "label");
+    if (!label) return null;
+    setText(headerText, label);
+    return headerText;
+  });
+  effect(() => {
+    const status = readValue2(props, "status", "idle");
+    setAttribute(root, "class", classNames2("vobs-captcha", readString2(props, "class"), readString2(props, "className")));
+    setAttribute(root, "data-status", status);
+    setOptionalAttribute(root, "id", readString2(props, "id"));
+    setOptionalAttribute(root, "title", readString2(props, "title"));
+    setOptionalAttribute(root, "role", readString2(props, "role"));
+    setAttribute(root, "aria-busy", String(status === "loading" || status === "verifying"));
+    if (readValue2(props, "disabled", false) || status === "loading" || status === "verifying") setAttribute(root, "aria-disabled", "true");
+    else root.removeAttribute("aria-disabled");
+    bindDataAndAriaAttributes(root, props);
+  });
+  insertDynamic(challengeHost, null, () => renderChallenge(props));
+  insertDynamic(messageHost, null, () => renderMessage(props));
+  insertDynamic(actions, null, () => renderActions(props));
+  return root;
+  function renderChallenge(input) {
+    const status = readValue2(input, "status", "idle");
+    const challenge = readValue2(input, "challenge", null);
+    const disabled = readValue2(input, "disabled", false) || status === "loading" || status === "verifying";
+    const renderer = readCallback(input, "renderChallenge", void 0);
+    if (status === "loading" && !readValue2(input, "keepChallengeOnLoading", false)) {
+      return createMessage(readValue2(input, "loadingLabel", "Loading captcha\u2026"));
+    }
+    if (status === "verifying" && !readValue2(input, "keepChallengeOnVerifying", false)) {
+      return createMessage("Verifying captcha\u2026");
+    }
+    if (status === "expired") return createMessage(readValue2(input, "expiredLabel", "This captcha has expired."));
+    if (status === "error" && !readValue2(input, "keepChallengeOnError", false) && readValue2(input, "messagePlacement", "challenge") === "challenge") {
+      return createMessage(readError(input) || readValue2(input, "errorLabel", "Captcha verification failed."));
+    }
+    if (status === "error" && !readValue2(input, "keepChallengeOnError", false)) return null;
+    if (!challenge) return createMessage(readValue2(input, "emptyLabel", "Captcha is not ready."));
+    if (!renderer) return createMessage("Provide renderChallenge to render this captcha challenge.");
+    return renderer({
+      challenge,
+      status,
+      disabled,
+      submit(answer) {
+        const onSubmit = readCallback(input, "onSubmit", void 0);
+        if (disabled || !onSubmit) return;
+        return onSubmit(answer, challenge);
+      }
+    }) ?? createMessage(readValue2(input, "emptyLabel", "Captcha is not ready."));
+  }
+  function renderMessage(input) {
+    const status = readValue2(input, "status", "idle");
+    if (readValue2(input, "messagePlacement", "challenge") !== "footer") return null;
+    if (status !== "error") return null;
+    return createMessage(readError(input) || readValue2(input, "errorLabel", "Captcha verification failed."));
+  }
+  function renderActions(input) {
+    const status = readValue2(input, "status", "idle");
+    const disabled = readValue2(input, "disabled", false) || status === "loading" || status === "verifying";
+    const retry = readCallback(input, "onRetry", void 0);
+    const cancel = readCallback(input, "onCancel", void 0);
+    if (!retry && !cancel) return null;
+    return createFragment((parent, anchor) => {
+      const canRetry = status === "idle" || status === "expired" || status === "error" || status === "loading" && readValue2(input, "showRetryWhileLoading", false) || readValue2(input, "showRetry", false) && status !== "loading" && status !== "verifying";
+      if (retry && canRetry) {
+        insertBefore(parent, createActionButton(
+          readValue2(input, "retryLabel", "Retry"),
+          readCallback(input, "retryIcon", void 0),
+          retry,
+          disabled,
+          "vobs-captcha__action--retry"
+        ), anchor);
+      }
+      const canCancel = status === "loading" || status === "verifying" || readValue2(input, "showCancel", false);
+      if (cancel && canCancel) {
+        insertBefore(parent, createActionButton(
+          readValue2(input, "cancelLabel", "Cancel"),
+          void 0,
+          cancel,
+          disabled,
+          "vobs-captcha__action--cancel"
+        ), anchor);
+      }
+    });
+  }
+  function createActionButton(label, icon, handler, disabled, variant) {
+    const button = createElement("button");
+    setAttribute(button, "class", `vobs-captcha__action ${variant}`);
+    setAttribute(button, "type", "button");
+    setAttribute(button, "aria-label", label);
+    setProperty(button, "disabled", disabled);
+    if (icon !== void 0) {
+      const iconHost = createElement("span");
+      setAttribute(iconHost, "class", "vobs-captcha__action-icon");
+      const value = typeof icon === "function" ? icon() : icon;
+      if (value !== null && value !== void 0) insertBefore(iconHost, value, null);
+      insertBefore(button, iconHost, null);
+    }
+    insertBefore(button, createText(label), null);
+    addEventListener(button, "click", handler);
+    return button;
+  }
+  function createMessage(message) {
+    const node = createElement("p");
+    setAttribute(node, "class", "vobs-captcha__message");
+    insertBefore(node, createText(message), null);
+    return node;
+  }
+}
+__name(Captcha, "Captcha");
+function setText(node, value) {
+  node.data = value;
+}
+__name(setText, "setText");
+function classNames2(...values) {
+  return values.filter(Boolean).join(" ");
+}
+__name(classNames2, "classNames");
+function readValue2(props, name, fallback) {
+  const value = Reflect.get(props, name);
+  if (value === void 0) return fallback;
+  if (typeof value === "function") return value();
+  if (isSignal2(value)) return value.value;
+  return value;
+}
+__name(readValue2, "readValue");
+function readCallback(props, name, fallback) {
+  const value = Reflect.get(props, name);
+  return value === void 0 ? fallback : value;
+}
+__name(readCallback, "readCallback");
+function readString2(props, name) {
+  const value = readValue2(props, name, void 0);
+  return typeof value === "string" ? value : void 0;
+}
+__name(readString2, "readString");
+function readError(props) {
+  const error = readValue2(props, "error", void 0);
+  if (typeof error === "string") return error;
+  if (error instanceof Error) return error.message;
+  return error == null ? void 0 : String(error);
+}
+__name(readError, "readError");
+function setOptionalAttribute(node, name, value) {
+  if (value) setAttribute(node, name, value);
+  else node.removeAttribute(name);
+}
+__name(setOptionalAttribute, "setOptionalAttribute");
+function bindDataAndAriaAttributes(node, props) {
+  for (const name of Object.keys(props)) {
+    if (!name.startsWith("aria-") && !name.startsWith("data-")) continue;
+    const value = readValue2(props, name, void 0);
+    if (value === void 0 || value === null || value === false) node.removeAttribute(name);
+    else setAttribute(node, name, String(value));
+  }
+}
+__name(bindDataAndAriaAttributes, "bindDataAndAriaAttributes");
+function isSignal2(value) {
+  return value !== null && typeof value === "object" && "value" in value && typeof value.dispose === "function";
+}
+__name(isSignal2, "isSignal");
+
+exports.Captcha = Captcha;
+exports.SliderCaptcha = SliderCaptcha;
+exports.analyzeSliderTrail = analyzeSliderTrail;
+exports.collectCaptchaDeviceSignals = collectCaptchaDeviceSignals;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map