@blotch/angular-lynx 22.2.5 → 22.2.7

package/fesm2022/blotch-angular-lynx-arena-Cycr_O6y.mjs

@@ -0,0 +1,755 @@
+import { r as GestureType } from "./blotch-angular-lynx-const-MkK6UdZ7.mjs";
+import { t as drawnScale } from "./blotch-angular-lynx-drawn-scale-ExB6Yx-p.mjs";
+const ORIGIN = {
+	x: 0,
+	y: 0
+};
+const pageOf = (element) => {
+	return element.getRootNode().host ?? element.ownerDocument.documentElement;
+};
+const touchPointOf = (event, type, target) => {
+	const page = pageOf(target);
+	const scale = drawnScale(page);
+	const pageBox = page.getBoundingClientRect();
+	const box = target.getBoundingClientRect();
+	return {
+		type,
+		timestamp: event.timeStamp,
+		x: (event.clientX - box.left) / scale,
+		y: (event.clientY - box.top) / scale,
+		pageX: (event.clientX - pageBox.left) / scale,
+		pageY: (event.clientY - pageBox.top) / scale,
+		clientX: event.clientX,
+		clientY: event.clientY
+	};
+};
+const VELOCITY_WINDOW = 100;
+var VelocityTracker = class {
+	#samples = [];
+	reset() {
+		this.#samples = [];
+	}
+	add(touch) {
+		const t = touch.timestamp;
+		this.#samples.push({
+			t,
+			x: touch.pageX,
+			y: touch.pageY
+		});
+		this.#samples = this.#samples.filter((sample) => t - sample.t <= VELOCITY_WINDOW);
+	}
+	velocity() {
+		const first = this.#samples[0];
+		const last = this.#samples[this.#samples.length - 1];
+		const seconds = first ? (last.t - first.t) / 1e3 : 0;
+		if (seconds <= 0) return ORIGIN;
+		return {
+			x: (last.x - first.x) / seconds,
+			y: (last.y - first.y) / seconds
+		};
+	}
+};
+const MIN_VELOCITY = 50;
+const MAX_VELOCITY = 1e4;
+const DECELERATION_RATE = .998;
+const COEFFICIENT = 1e3 * Math.log(DECELERATION_RATE);
+const distanceAt = (seconds, duration, velocity) => {
+	const progress = Math.min(1, seconds / duration);
+	return (DECELERATION_RATE ** (1e3 * progress * duration) - 1) / COEFFICIENT * velocity;
+};
+var FlingTrigger = class {
+	state = "end";
+	distance = ORIGIN;
+	lastDistance = ORIGIN;
+	#onFrame;
+	#frames = null;
+	#frame;
+	#running = false;
+	#begin = 0;
+	#velocity = ORIGIN;
+	#flingX = false;
+	#flingY = false;
+	#durationX = 0;
+	#durationY = 0;
+	constructor(onFrame) {
+		this.#onFrame = onFrame;
+	}
+	start(velocity, frames) {
+		const clamp = (v) => Math.max(Math.min(MAX_VELOCITY, v), -1e4);
+		const v = {
+			x: clamp(velocity.x),
+			y: clamp(velocity.y)
+		};
+		const flingX = Math.abs(v.x) >= MIN_VELOCITY;
+		const flingY = Math.abs(v.y) >= MIN_VELOCITY;
+		if (!flingX && !flingY) return false;
+		this.stop();
+		const threshold = .5 / (frames.devicePixelRatio || 1);
+		const duration = (speed) => Math.log(-COEFFICIENT * threshold / Math.abs(speed)) / COEFFICIENT;
+		this.#frames = frames;
+		this.#velocity = v;
+		this.#flingX = flingX;
+		this.#flingY = flingY;
+		this.#durationX = duration(v.x);
+		this.#durationY = duration(v.y);
+		this.#begin = frames.performance.now();
+		this.distance = ORIGIN;
+		this.lastDistance = ORIGIN;
+		this.state = "start";
+		this.#running = true;
+		this.#frame = frames.requestAnimationFrame(this.#tick);
+		return true;
+	}
+	stop() {
+		this.#running = false;
+		if (this.#frame !== void 0) this.#frames?.cancelAnimationFrame(this.#frame);
+		this.#frame = void 0;
+	}
+	reset() {
+		this.stop();
+		this.distance = ORIGIN;
+		this.lastDistance = ORIGIN;
+		this.state = "end";
+	}
+	isFinished() {
+		return !this.#running;
+	}
+	#tick = (now) => {
+		this.#frame = void 0;
+		if (this.state === "start") {
+			this.#onFrame(this);
+			if (!this.#running) return;
+			this.state = "update";
+		}
+		const seconds = Math.max(0, now - this.#begin) / 1e3;
+		const done = (fling, duration) => !fling || seconds >= duration;
+		const willEnd = done(this.#flingX, this.#durationX) && done(this.#flingY, this.#durationY);
+		this.distance = {
+			x: this.#flingX ? distanceAt(seconds, this.#durationX, this.#velocity.x) : this.lastDistance.x,
+			y: this.#flingY ? distanceAt(seconds, this.#durationY, this.#velocity.y) : this.lastDistance.y
+		};
+		this.#onFrame(this);
+		if (!this.#running) return;
+		this.lastDistance = this.distance;
+		if (willEnd) {
+			this.state = "end";
+			this.#onFrame(this);
+			this.stop();
+			return;
+		}
+		this.#frame = this.#frames.requestAnimationFrame(this.#tick);
+	};
+};
+const HandlerState = {
+	Init: 0,
+	Begin: 1,
+	Active: 2,
+	Fail: 3,
+	Cancel: 4,
+	End: 5,
+	Undetermined: 6
+};
+const FLING_END = {
+	x: Number.EPSILON,
+	y: Number.EPSILON
+};
+const option = (config, key, fallback) => config ? Number(config[key]) || 0 : fallback;
+const touchParams = (touch) => touch ? {
+	timestamp: touch.timestamp,
+	type: touch.type,
+	x: touch.x,
+	y: touch.y,
+	pageX: touch.pageX,
+	pageY: touch.pageY,
+	clientX: touch.clientX,
+	clientY: touch.clientY
+} : {};
+const SCROLL_PARAMS = {
+	scrollX: 0,
+	scrollY: 0,
+	isAtStart: false,
+	isAtEnd: false
+};
+const pagePoint = (touch) => ({
+	x: touch.pageX,
+	y: touch.pageY
+});
+const beyond = (from, to, distance) => Math.abs(to.x - from.x) > distance || Math.abs(to.y - from.y) > distance;
+var WebGestureHandler = class {
+	detector;
+	status = HandlerState.Init;
+	#emit;
+	constructor(detector, emit) {
+		this.detector = detector;
+		this.#emit = emit;
+	}
+	dispose() {}
+	reset() {
+		this.status = HandlerState.Init;
+	}
+	begin() {
+		this.status = HandlerState.Begin;
+	}
+	activate() {
+		this.status = HandlerState.Active;
+	}
+	fail() {
+		if (this.status !== HandlerState.End) this.status = HandlerState.Cancel;
+	}
+	end() {
+		this.status = HandlerState.End;
+	}
+	ignore() {
+		this.status = HandlerState.Undetermined;
+	}
+	touches(type, touch) {
+		this.send({
+			touchstart: "onTouchesDown",
+			touchmove: "onTouchesMove",
+			touchend: "onTouchesUp",
+			touchcancel: "onTouchesCancel"
+		}[type], touchParams(touch));
+	}
+	send(name, params) {
+		if (this.detector.callbacks.has(name)) this.#emit(this.detector, name, params);
+	}
+};
+var PanHandler = class extends WebGestureHandler {
+	#minDistance = option(this.detector.config, "minDistance", 0);
+	#start = ORIGIN;
+	#last = ORIGIN;
+	#lastTouch = null;
+	#begun = false;
+	#started = false;
+	#ended = false;
+	handle(type, touch) {
+		this.#lastTouch = touch;
+		if (!touch) {
+			this.ignore();
+			return;
+		}
+		if (this.status >= HandlerState.Fail) return;
+		if (type === "touchstart") {
+			this.#start = pagePoint(touch);
+			this.#ended = false;
+			this.begin();
+			this.#onBegin(touch);
+		} else if (type === "touchmove") {
+			this.#last = pagePoint(touch);
+			if (this.status === HandlerState.Init) {
+				this.begin();
+				this.#onBegin(touch);
+			}
+			if (beyond(this.#start, this.#last, this.#minDistance)) {
+				this.activate();
+				this.#onStart(touch);
+			}
+			if (this.status === HandlerState.Active) this.send("onUpdate", {
+				...SCROLL_PARAMS,
+				...touchParams(touch)
+			});
+		} else this.fail();
+	}
+	fail() {
+		super.fail();
+		this.#onEnd();
+	}
+	end() {
+		super.end();
+		this.#onEnd();
+	}
+	reset() {
+		super.reset();
+		this.#begun = false;
+		this.#started = false;
+		this.#ended = false;
+	}
+	#onBegin(touch) {
+		if (this.#begun) return;
+		this.#begun = true;
+		this.send("onBegin", {
+			...SCROLL_PARAMS,
+			...touchParams(touch)
+		});
+	}
+	#onStart(touch) {
+		if (this.#started || !this.#begun) return;
+		this.#started = true;
+		this.send("onStart", {
+			...SCROLL_PARAMS,
+			...touchParams(touch)
+		});
+	}
+	#onEnd() {
+		if (this.#ended || !this.#begun) return;
+		this.#ended = true;
+		this.send("onEnd", {
+			...SCROLL_PARAMS,
+			...touchParams(this.#lastTouch)
+		});
+	}
+};
+var TapHandler = class extends WebGestureHandler {
+	#maxDuration = option(this.detector.config, "maxDuration", 500);
+	#maxDistance = option(this.detector.config, "maxDistance", 10);
+	#start = ORIGIN;
+	#lastTouch = null;
+	#timer;
+	handle(type, touch) {
+		this.#lastTouch = touch;
+		if (!touch) {
+			this.ignore();
+			return;
+		}
+		if (this.status >= HandlerState.Fail) {
+			this.dispose();
+			return;
+		}
+		if (type === "touchstart") {
+			this.#start = pagePoint(touch);
+			this.begin();
+			this.send("onBegin", touchParams(touch));
+			this.#startTimer();
+			return;
+		}
+		if (type === "touchmove") {
+			if (beyond(this.#start, pagePoint(touch), this.#maxDistance)) this.fail();
+			return;
+		}
+		if (type === "touchcancel") this.fail();
+		else {
+			this.activate();
+			this.send("onStart", touchParams(touch));
+			this.send("onEnd", touchParams(touch));
+		}
+		this.dispose();
+	}
+	dispose() {
+		if (this.#timer !== void 0) clearTimeout(this.#timer);
+		this.#timer = void 0;
+	}
+	fail() {
+		super.fail();
+		this.send("onEnd", touchParams(this.#lastTouch));
+	}
+	end() {
+		super.end();
+		this.send("onEnd", touchParams(this.#lastTouch));
+	}
+	#startTimer() {
+		this.dispose();
+		this.#timer = setTimeout(() => {
+			this.#timer = void 0;
+			this.fail();
+		}, this.#maxDuration);
+	}
+};
+var LongPressHandler = class extends WebGestureHandler {
+	#minDuration = option(this.detector.config, "minDuration", 500);
+	#maxDistance = option(this.detector.config, "maxDistance", 10);
+	#start = ORIGIN;
+	#lastTouch = null;
+	#timer;
+	handle(type, touch) {
+		this.#lastTouch = touch;
+		if (!touch) {
+			this.ignore();
+			return;
+		}
+		if (this.status >= HandlerState.Fail) {
+			this.dispose();
+			return;
+		}
+		if (type === "touchstart") {
+			this.#start = pagePoint(touch);
+			this.begin();
+			this.send("onBegin", touchParams(touch));
+			this.#startTimer();
+		} else if (type === "touchmove") {
+			if (this.status === HandlerState.Begin && beyond(this.#start, pagePoint(touch), this.#maxDistance)) {
+				this.fail();
+				this.dispose();
+			}
+		} else {
+			this.dispose();
+			this.fail();
+		}
+	}
+	dispose() {
+		if (this.#timer !== void 0) clearTimeout(this.#timer);
+		this.#timer = void 0;
+	}
+	fail() {
+		super.fail();
+		this.send("onEnd", touchParams(this.#lastTouch));
+	}
+	end() {
+		super.end();
+		this.send("onEnd", touchParams(this.#lastTouch));
+	}
+	#startTimer() {
+		this.dispose();
+		this.#timer = setTimeout(() => {
+			this.#timer = void 0;
+			if (this.status !== HandlerState.Begin) return;
+			this.activate();
+			this.send("onStart", touchParams(this.#lastTouch));
+		}, this.#minDuration);
+	}
+};
+var FlingHandler = class extends WebGestureHandler {
+	#begun = false;
+	#started = false;
+	#ended = false;
+	handle(type, touch, step) {
+		if (touch) {
+			if (type === "touchend") {
+				this.begin();
+				this.#onBegin(ORIGIN);
+			} else this.ignore();
+			return;
+		}
+		if (this.status >= HandlerState.Fail && this.status <= HandlerState.End) {
+			this.#onEnd(ORIGIN);
+			return;
+		}
+		if (step === FLING_END) {
+			this.fail();
+			return;
+		}
+		if (this.status === HandlerState.Init || this.status === HandlerState.Undetermined) {
+			this.begin();
+			this.activate();
+			this.#onBegin(ORIGIN);
+			this.#onStart(ORIGIN);
+			return;
+		}
+		this.send("onUpdate", this.#params(step));
+	}
+	fail() {
+		super.fail();
+		this.#onEnd(ORIGIN);
+	}
+	end() {
+		super.end();
+		this.#onEnd(ORIGIN);
+	}
+	reset() {
+		super.reset();
+		this.#begun = false;
+		this.#started = false;
+		this.#ended = false;
+	}
+	#onBegin(step) {
+		if (this.#begun || !this.detector.callbacks.has("onBegin")) return;
+		this.#begun = true;
+		this.send("onBegin", this.#params(step));
+	}
+	#onStart(step) {
+		if (this.#started || !this.#begun) return;
+		this.#started = true;
+		this.send("onStart", this.#params(step));
+	}
+	#onEnd(step) {
+		if (this.#ended || !this.#begun) return;
+		this.#ended = true;
+		this.send("onEnd", this.#params(step));
+	}
+	#params(step) {
+		return {
+			...SCROLL_PARAMS,
+			deltaX: step.x,
+			deltaY: step.y
+		};
+	}
+};
+const createHandlers = (detectors, emit) => {
+	const handlers = [
+		[GestureType.PAN, PanHandler],
+		[GestureType.FLING, FlingHandler],
+		[GestureType.TAP, TapHandler],
+		[GestureType.LONGPRESS, LongPressHandler],
+		[GestureType.NATIVE, PanHandler]
+	];
+	const all = [...detectors];
+	return handlers.flatMap(([type, Handler]) => all.filter((detector) => detector.type === type).map((detector) => new Handler(detector, emit)));
+};
+const FAIL_STATE = 2;
+const END_STATE = 3;
+const POINTER_EVENTS = [
+	"pointermove",
+	"pointerup",
+	"pointercancel"
+];
+const DRAG_EVENTS = ["selectstart", "dragstart"];
+var WebGestureArena = class {
+	#afterDispatch;
+	#members = /* @__PURE__ */ new Map();
+	#gestureMembers = /* @__PURE__ */ new Map();
+	#velocity = new VelocityTracker();
+	#flinger = new FlingTrigger(() => this.#onFling());
+	#pointer = null;
+	#bubble = [];
+	#chain = [];
+	#winner = null;
+	#lastWinner = null;
+	#lastFlingWinner = null;
+	#simultaneousMembers = /* @__PURE__ */ new Set();
+	#simultaneousIds = /* @__PURE__ */ new Set();
+	constructor(afterDispatch) {
+		this.#afterDispatch = afterDispatch;
+	}
+	setDetector(node, id, type, config, relations) {
+		let member = this.#members.get(node);
+		if (!member) {
+			const element = node;
+			member = {
+				element,
+				detectors: /* @__PURE__ */ new Map(),
+				handlers: null
+			};
+			this.#members.set(node, member);
+			element.addEventListener("pointerdown", this.#onPointerDown);
+			element.addEventListener("touchmove", this.#onTouchMove, { passive: false });
+		}
+		member.detectors.set(id, {
+			id,
+			type,
+			config: config.config,
+			callbacks: new Map(config.callbacks.map(({ name, callback }) => [name, callback])),
+			waitFor: relations["waitFor"] ?? [],
+			simultaneous: relations["simultaneous"] ?? [],
+			continueWith: relations["continueWith"] ?? []
+		});
+		this.#invalidate(member);
+		let members = this.#gestureMembers.get(id);
+		if (!members) {
+			members = /* @__PURE__ */ new Set();
+			this.#gestureMembers.set(id, members);
+		}
+		members.add(member);
+	}
+	removeDetector(node, id) {
+		const member = this.#members.get(node);
+		if (!member?.detectors.delete(id)) return;
+		this.#invalidate(member);
+		const members = this.#gestureMembers.get(id);
+		members.delete(member);
+		if (!members.size) this.#gestureMembers.delete(id);
+		if (member.detectors.size) return;
+		this.#members.delete(node);
+		member.element.removeEventListener("pointerdown", this.#onPointerDown);
+		member.element.removeEventListener("touchmove", this.#onTouchMove);
+	}
+	setState(node, id, state) {
+		const handler = this.#members.get(node)?.handlers?.find((other) => other.detector.id === id);
+		if (state === FAIL_STATE) handler?.fail();
+		else if (state === END_STATE) handler?.end();
+	}
+	#invalidate(member) {
+		for (const handler of member.handlers ?? []) handler.dispose();
+		member.handlers = null;
+	}
+	#handlersOf(member) {
+		member.handlers ??= createHandlers(member.detectors.values(), this.#emit);
+		return member.handlers;
+	}
+	#emit = (detector, name, params) => {
+		const callback = detector.callbacks.get(name);
+		try {
+			callback._fn?.({
+				type: name,
+				timestamp: Date.now(),
+				params
+			});
+		} catch (error) {
+			queueMicrotask(() => {
+				throw error;
+			});
+		}
+		this.#afterDispatch();
+	};
+	#onPointerDown = (event) => {
+		if (this.#pointer || event.button > 0) return;
+		const bubble = [...new Set(event.composedPath().map((node) => this.#members.get(node)).filter((member) => member !== void 0))];
+		const target = event.target;
+		const { ownerDocument } = target;
+		this.#pointer = {
+			id: event.pointerId,
+			target,
+			document: ownerDocument
+		};
+		for (const type of POINTER_EVENTS) ownerDocument.addEventListener(type, this.#onPointer, true);
+		for (const type of DRAG_EVENTS) ownerDocument.addEventListener(type, this.#onDrag, true);
+		this.#flinger.stop();
+		this.#bubble = bubble;
+		this.#chain = this.#competeChain(bubble);
+		const [winner] = this.#chain;
+		this.#winner = winner;
+		this.#lastWinner = winner;
+		this.#updateSimultaneous(winner);
+		this.#velocity.reset();
+		this.#touch(event, "touchstart");
+	};
+	#onPointer = (domEvent) => {
+		const event = domEvent;
+		if (event.pointerId !== this.#pointer?.id) return;
+		if (event.type === "pointermove") {
+			this.#touch(event, "touchmove");
+			return;
+		}
+		const { document } = this.#pointer;
+		for (const type of POINTER_EVENTS) document.removeEventListener(type, this.#onPointer, true);
+		for (const type of DRAG_EVENTS) document.removeEventListener(type, this.#onDrag, true);
+		try {
+			this.#touch(event, event.type === "pointerup" ? "touchend" : "touchcancel");
+		} finally {
+			this.#pointer = null;
+		}
+	};
+	#onTouchMove = (event) => {
+		if (this.#pointer && event.cancelable && this.#panning()) event.preventDefault();
+	};
+	#onDrag = (event) => {
+		if (this.#panning()) event.preventDefault();
+	};
+	#panning() {
+		return [...this.#chain, ...this.#simultaneousMembers].some((member) => this.#handlersOf(member).some((handler) => handler.detector.type === GestureType.PAN && handler.status < HandlerState.Fail));
+	}
+	#touch(event, type) {
+		const touch = touchPointOf(event, type, this.#pointer.target);
+		this.#velocity.add(touch);
+		if (this.#winner) for (const member of this.#bubble) for (const handler of this.#handlersOf(member)) handler.touches(type, touch);
+		this.#resolve(type, touch);
+	}
+	#resolve(type, touch) {
+		if (type === "touchstart") {
+			for (const member of this.#chain) this.#reset(member);
+			this.#dispatch(type, touch, this.#winner, ORIGIN, true);
+			this.#findNextWinner(type, touch);
+			return;
+		}
+		if (type === "touchmove") {
+			this.#winner = this.#reCompete(this.#winner);
+			if (this.#winner === this.#lastWinner) this.#dispatch(type, touch, this.#winner, ORIGIN, false);
+			this.#findNextWinner(type, touch);
+			return;
+		}
+		this.#dispatch(type, touch, this.#winner, ORIGIN, true);
+		const velocity = type === "touchend" ? this.#velocity.velocity() : ORIGIN;
+		const view = this.#pointer.document.defaultView;
+		if (this.#winner && this.#flinger.start(velocity, view)) {
+			this.#lastFlingWinner = this.#lastWinner;
+			return;
+		}
+		this.#flinger.reset();
+		this.#dispatch(null, null, this.#winner, FLING_END, true);
+		if (this.#winner) this.#onFling();
+	}
+	#onFling() {
+		const { distance, lastDistance, state } = this.#flinger;
+		const step = {
+			x: lastDistance.x - distance.x,
+			y: lastDistance.y - distance.y
+		};
+		this.#lastFlingWinner = this.#reCompete(this.#lastFlingWinner);
+		this.#findNextWinner(null, null);
+		if (!this.#winner || !this.#lastFlingWinner) {
+			this.#lastFlingWinner = null;
+			this.#flinger.stop();
+			return;
+		}
+		if (state === "end") this.#dispatch(null, null, this.#lastFlingWinner, FLING_END, true);
+		else this.#dispatch(null, null, this.#lastFlingWinner, step, false);
+	}
+	#dispatch(type, touch, member, step, reCompete) {
+		if (!member) return;
+		for (const handler of this.#handlersOf(member)) handler.handle(type, touch, step);
+		for (const other of this.#simultaneousMembers) for (const handler of this.#handlersOf(other)) handler.handle(type, touch, step);
+		if (reCompete) this.#winner = this.#reCompete(this.#winner);
+	}
+	#findNextWinner(type, touch) {
+		for (let i = 0; i < this.#chain.length; i++) {
+			if (this.#winner === this.#lastWinner || !this.#winner) return;
+			this.#lastWinner = this.#winner;
+			this.#updateSimultaneous(this.#winner);
+			this.#dispatch(type, touch, this.#winner, ORIGIN, true);
+		}
+		this.#dispatch(type, touch, this.#lastWinner, ORIGIN, true);
+	}
+	#reCompete(current) {
+		if (!current && !this.#lastWinner) return null;
+		let lost = false;
+		if (!current) {
+			current = this.#lastWinner;
+			lost = true;
+			this.#resetWithSimultaneous(current);
+		}
+		const state = this.#stateOf(current);
+		if (state <= HandlerState.Active) return current;
+		if (state === HandlerState.End || lost) return null;
+		const index = this.#chain.indexOf(current);
+		return [...this.#chain.slice(index + 1), ...this.#chain.slice(0, index)].find((member) => {
+			this.#stateOf(member);
+			this.#resetWithSimultaneous(member);
+			return this.#stateOf(member) <= HandlerState.Active;
+		}) ?? null;
+	}
+	#stateOf(member) {
+		const handlers = this.#handlersOf(member);
+		if (!handlers.length) return HandlerState.Fail;
+		let least = HandlerState.Undetermined;
+		for (const handler of handlers) {
+			if (handler.status === HandlerState.End) {
+				this.#resetWithSimultaneous(member);
+				this.#lastWinner = null;
+				return HandlerState.End;
+			}
+			if (handler.status === HandlerState.Active) {
+				for (const other of handlers) if (other !== handler && !this.#simultaneousIds.has(other.detector.id)) other.fail();
+				return HandlerState.Active;
+			}
+			least = Math.min(least, handler.status);
+		}
+		return least;
+	}
+	#reset(member) {
+		for (const handler of this.#handlersOf(member)) handler.reset();
+	}
+	#resetWithSimultaneous(member) {
+		this.#reset(member);
+		for (const other of this.#simultaneousMembers) this.#reset(other);
+	}
+	#competeChain(bubble) {
+		const chain = [];
+		for (const [index, member] of bubble.entries()) {
+			const related = [...member.detectors.values()].sort((a, b) => a.id - b.id).find((detector) => detector.waitFor.length + detector.continueWith.length);
+			const ahead = related ? this.#membersOf(related.waitFor).filter((other) => bubble.slice(index + 1).includes(other)) : [];
+			chain.push(...ahead, member);
+			if (related?.waitFor.length && !ahead.length) continue;
+			if (related?.continueWith.length) {
+				chain.push(...this.#membersOf(related.continueWith));
+				break;
+			}
+			if (ahead.length) break;
+		}
+		return [...new Set(chain)];
+	}
+	#membersOf(ids) {
+		return [...new Set(ids.flatMap((id) => [...this.#gestureMembers.get(id) ?? []]))];
+	}
+	#updateSimultaneous(winner) {
+		this.#simultaneousMembers = /* @__PURE__ */ new Set();
+		this.#simultaneousIds = /* @__PURE__ */ new Set();
+		for (const detector of winner.detectors.values()) for (const id of detector.simultaneous) {
+			if (winner.detectors.has(id)) {
+				this.#simultaneousIds.add(id);
+				continue;
+			}
+			for (const member of this.#gestureMembers.get(id) ?? []) this.#simultaneousMembers.add(member);
+		}
+	}
+};
+export { WebGestureArena };
+
+//# sourceMappingURL=blotch-angular-lynx-arena-Cycr_O6y.mjs.map