foldkit-primitives 0.15.3 → 0.16.0

package/dist/dom/keyboard-inset.d.ts

@@ -0,0 +1,29 @@
+import * as Mount from "foldkit/mount";
+/**
+ * The custom property `KeyboardInset` writes on its element: how much of the layout
+ * viewport's bottom the on-screen keyboard (or anything else the visual viewport leaves
+ * out) covers, in pixels.
+ */
+export declare const KEYBOARD_INSET = "--fk-keyboard-inset";
+/**
+ * The part of the layout viewport's height below the visual viewport: what the on-screen
+ * keyboard covers. Rounded down, since a fraction of a pixel of zoom is no keyboard.
+ */
+export declare const keyboardInset: (view: {
+  readonly innerHeight: number;
+  readonly visualViewport: {
+    readonly height: number;
+    readonly offsetTop: number;
+  } | null;
+}) => number;
+/**
+ * The on-screen keyboard's height as a Mount, with no Message and no Model: where it is
+ * is the browser's. iOS Safari, and Chrome on Android unless the page asks otherwise,
+ * leave the layout viewport as it is when the keyboard opens, so a panel fixed to the
+ * screen keeps its height and its bottom under the keys. This writes `KEYBOARD_INSET` on
+ * the element, from the visual viewport's size and scroll, for a style to pad or shrink by
+ * (`var(--fk-keyboard-inset, 0px)`), and removes it when the element goes. Where there is
+ * no visual viewport it writes nothing.
+ */
+export declare const KeyboardInset: Mount.MountDefinitionWithArgs<"KeyboardInset", {}, never>;
+//# sourceMappingURL=keyboard-inset.d.ts.map

package/dist/dom/keyboard-inset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard-inset.d.ts","names":[],"sources":["../../src/dom/keyboard-inset.ts"],"mappings":";;;;;;qBAQa;;;;;qBAMA,gBAAa;WACf;WACA;aAA2B;aAAyB;;;;;;;;;;;;qBAkBlD,eAAa,MAAA"}

package/dist/dom/keyboard-inset.js

@@ -0,0 +1,45 @@
+import { Effect, Schema, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+// src/dom/keyboard-inset.ts
+/**
+* The custom property `KeyboardInset` writes on its element: how much of the layout
+* viewport's bottom the on-screen keyboard (or anything else the visual viewport leaves
+* out) covers, in pixels.
+*/
+const KEYBOARD_INSET = "--fk-keyboard-inset";
+/**
+* The part of the layout viewport's height below the visual viewport: what the on-screen
+* keyboard covers. Rounded down, since a fraction of a pixel of zoom is no keyboard.
+*/
+const keyboardInset = (view) => view.visualViewport === null ? 0 : Math.max(0, Math.floor(view.innerHeight - view.visualViewport.height - view.visualViewport.offsetTop));
+/**
+* The on-screen keyboard's height as a Mount, with no Message and no Model: where it is
+* is the browser's. iOS Safari, and Chrome on Android unless the page asks otherwise,
+* leave the layout viewport as it is when the keyboard opens, so a panel fixed to the
+* screen keeps its height and its bottom under the keys. This writes `KEYBOARD_INSET` on
+* the element, from the visual viewport's size and scroll, for a style to pad or shrink by
+* (`var(--fk-keyboard-inset, 0px)`), and removes it when the element goes. Where there is
+* no visual viewport it writes nothing.
+*/
+const KeyboardInset = Mount.defineStream("KeyboardInset", {
+	messages: [Schema.Never],
+	args: {},
+	execute: ({ element }) => Stream.callback(() => Effect.acquireRelease(Effect.sync(() => {
+		const view = element.ownerDocument.defaultView;
+		const viewport = view?.visualViewport;
+		if (!(element instanceof HTMLElement) || view === null || view === void 0 || viewport === null || viewport === void 0) return () => {};
+		const target = element;
+		const measure = () => target.style.setProperty(KEYBOARD_INSET, `${keyboardInset(view)}px`);
+		measure();
+		viewport.addEventListener("resize", measure);
+		viewport.addEventListener("scroll", measure);
+		return () => {
+			viewport.removeEventListener("resize", measure);
+			viewport.removeEventListener("scroll", measure);
+			target.style.removeProperty(KEYBOARD_INSET);
+		};
+	}), (release) => Effect.sync(release)))
+});
+export { KEYBOARD_INSET, KeyboardInset, keyboardInset };
+
+//# sourceMappingURL=keyboard-inset.js.map

package/dist/dom/keyboard-inset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard-inset.js","names":[],"sources":["../../src/dom/keyboard-inset.ts"],"sourcesContent":["import { Effect, Schema, Stream } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\n/**\n * The custom property `KeyboardInset` writes on its element: how much of the layout\n * viewport's bottom the on-screen keyboard (or anything else the visual viewport leaves\n * out) covers, in pixels.\n */\nexport const KEYBOARD_INSET = '--fk-keyboard-inset'\n\n/**\n * The part of the layout viewport's height below the visual viewport: what the on-screen\n * keyboard covers. Rounded down, since a fraction of a pixel of zoom is no keyboard.\n */\nexport const keyboardInset = (view: {\n  readonly innerHeight: number\n  readonly visualViewport: { readonly height: number; readonly offsetTop: number } | null\n}): number =>\n  view.visualViewport === null\n    ? 0\n    : Math.max(\n        0,\n        Math.floor(view.innerHeight - view.visualViewport.height - view.visualViewport.offsetTop),\n      )\n\n/**\n * The on-screen keyboard's height as a Mount, with no Message and no Model: where it is\n * is the browser's. iOS Safari, and Chrome on Android unless the page asks otherwise,\n * leave the layout viewport as it is when the keyboard opens, so a panel fixed to the\n * screen keeps its height and its bottom under the keys. This writes `KEYBOARD_INSET` on\n * the element, from the visual viewport's size and scroll, for a style to pad or shrink by\n * (`var(--fk-keyboard-inset, 0px)`), and removes it when the element goes. Where there is\n * no visual viewport it writes nothing.\n */\nexport const KeyboardInset = Mount.defineStream('KeyboardInset', {\n  messages: [Schema.Never],\n  args: {},\n  execute: ({ element }) =>\n    Stream.callback<never>(() =>\n      Effect.acquireRelease(\n        Effect.sync(() => {\n          const view = element.ownerDocument.defaultView\n          const viewport = view?.visualViewport\n          if (\n            !(element instanceof HTMLElement) ||\n            view === null ||\n            view === undefined ||\n            viewport === null ||\n            viewport === undefined\n          ) {\n            return () => {}\n          }\n          const target = element\n          const measure = () => target.style.setProperty(KEYBOARD_INSET, `${keyboardInset(view)}px`)\n          measure()\n          viewport.addEventListener('resize', measure)\n          viewport.addEventListener('scroll', measure)\n          return () => {\n            viewport.removeEventListener('resize', measure)\n            viewport.removeEventListener('scroll', measure)\n            target.style.removeProperty(KEYBOARD_INSET)\n          }\n        }),\n        release => Effect.sync(release),\n      ),\n    ),\n})\n"],"mappings":";;;;;;;;AAQA,MAAa,iBAAiB;;;;;AAM9B,MAAa,iBAAiB,SAI5B,KAAK,mBAAmB,OACpB,IACA,KAAK,IACH,GACA,KAAK,MAAM,KAAK,cAAc,KAAK,eAAe,SAAS,KAAK,eAAe,SAAS,CAC1F;;;;;;;;;;AAWN,MAAa,gBAAgB,MAAM,aAAa,iBAAiB;CAC/D,UAAU,CAAC,OAAO,KAAK;CACvB,MAAM,CAAC;CACP,UAAU,EAAE,cACV,OAAO,eACL,OAAO,eACL,OAAO,WAAW;EAChB,MAAM,OAAO,QAAQ,cAAc;EACnC,MAAM,WAAW,MAAM;EACvB,IACE,EAAE,mBAAmB,gBACrB,SAAS,QACT,SAAS,KAAA,KACT,aAAa,QACb,aAAa,KAAA,GAEb,aAAa,CAAC;EAEhB,MAAM,SAAS;EACf,MAAM,gBAAgB,OAAO,MAAM,YAAY,gBAAgB,GAAG,cAAc,IAAI,EAAE,GAAG;EACzF,QAAQ;EACR,SAAS,iBAAiB,UAAU,OAAO;EAC3C,SAAS,iBAAiB,UAAU,OAAO;EAC3C,aAAa;GACX,SAAS,oBAAoB,UAAU,OAAO;GAC9C,SAAS,oBAAoB,UAAU,OAAO;GAC9C,OAAO,MAAM,eAAe,cAAc;EAC5C;CACF,CAAC,IACD,YAAW,OAAO,KAAK,OAAO,CAChC,CACF;AACJ,CAAC"}

package/dist/dom/layers.d.ts

@@ -0,0 +1,6 @@
+import * as Mount from "foldkit/mount";
+/** Locks the document's scroll while the element is mounted; nested locks release with the last. */
+export declare const ScrollLock: Mount.MountDefinitionNoArgs<"ScrollLock", never>;
+/** Makes everything outside the element inert while it is mounted, and restores it after. */
+export declare const HideOutside: Mount.MountDefinitionNoArgs<"HideOutside", never>;
+//# sourceMappingURL=layers.d.ts.map

package/dist/dom/layers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layers.d.ts","names":[],"sources":["../../src/dom/layers.ts"],"mappings":";;qBAgBa,YAAU,MAAA;;qBAWV,aAAW,MAAA"}

package/dist/dom/layers.js

@@ -0,0 +1,35 @@
+import { Effect, Schema, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+import * as Dom from "foldkit/dom";
+// src/dom/layers.ts
+/**
+* Two Mounts over Foldkit's own DOM helpers, for an overlay that is not a
+* native `<dialog>` or `popover`:
+*
+* - `ScrollLock` locks the document's scroll while mounted. Foldkit's lock is
+*   refcounted, so nested overlays release it only when the last one goes.
+* - `HideOutside` marks everything outside the element inert while mounted,
+*   through `Dom.inertOthers`, keyed by an id this Mount mints.
+*
+* Both emit no Messages; they are element lifecycle.
+*/
+/** Locks the document's scroll while the element is mounted; nested locks release with the last. */
+const ScrollLock = Mount.defineStream("ScrollLock", {
+	messages: [Schema.Never],
+	execute: () => Stream.callback(() => Effect.acquireRelease(Dom.lockScroll, () => Dom.unlockScroll))
+});
+const HIDE_OUTSIDE_ATTRIBUTE = "data-foldkit-plus-hide-outside";
+let minted = 0;
+/** Makes everything outside the element inert while it is mounted, and restores it after. */
+const HideOutside = Mount.defineStream("HideOutside", {
+	messages: [Schema.Never],
+	execute: ({ element }) => Stream.callback(() => Effect.acquireRelease(Effect.gen(function* () {
+		const id = `hide-outside-${minted += 1}`;
+		element.setAttribute(HIDE_OUTSIDE_ATTRIBUTE, id);
+		yield* Dom.inertOthers(id, [`[${HIDE_OUTSIDE_ATTRIBUTE}="${id}"]`]);
+		return id;
+	}), (id) => Effect.andThen(Dom.restoreInert(id), () => Effect.sync(() => element.removeAttribute(HIDE_OUTSIDE_ATTRIBUTE)))))
+});
+export { HideOutside, ScrollLock };
+
+//# sourceMappingURL=layers.js.map

package/dist/dom/layers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layers.js","names":[],"sources":["../../src/dom/layers.ts"],"sourcesContent":["/**\n * Two Mounts over Foldkit's own DOM helpers, for an overlay that is not a\n * native `<dialog>` or `popover`:\n *\n * - `ScrollLock` locks the document's scroll while mounted. Foldkit's lock is\n *   refcounted, so nested overlays release it only when the last one goes.\n * - `HideOutside` marks everything outside the element inert while mounted,\n *   through `Dom.inertOthers`, keyed by an id this Mount mints.\n *\n * Both emit no Messages; they are element lifecycle.\n */\nimport { Effect, Schema, Stream } from 'effect'\nimport * as Dom from 'foldkit/dom'\nimport * as Mount from 'foldkit/mount'\n\n/** Locks the document's scroll while the element is mounted; nested locks release with the last. */\nexport const ScrollLock = Mount.defineStream('ScrollLock', {\n  messages: [Schema.Never],\n  execute: () =>\n    Stream.callback<never>(() => Effect.acquireRelease(Dom.lockScroll, () => Dom.unlockScroll)),\n})\n\nconst HIDE_OUTSIDE_ATTRIBUTE = 'data-foldkit-plus-hide-outside'\n\nlet minted = 0\n\n/** Makes everything outside the element inert while it is mounted, and restores it after. */\nexport const HideOutside = Mount.defineStream('HideOutside', {\n  messages: [Schema.Never],\n  execute: ({ element }) =>\n    Stream.callback<never>(() =>\n      Effect.acquireRelease(\n        Effect.gen(function* () {\n          // A per-mount id: Foldkit keys the inert set by it, so two overlays\n          // restore independently. The attribute is how the element is found.\n          const id = `hide-outside-${(minted += 1)}`\n          element.setAttribute(HIDE_OUTSIDE_ATTRIBUTE, id)\n          yield* Dom.inertOthers(id, [`[${HIDE_OUTSIDE_ATTRIBUTE}=\"${id}\"]`])\n          return id\n        }),\n        id =>\n          Effect.andThen(Dom.restoreInert(id), () =>\n            Effect.sync(() => element.removeAttribute(HIDE_OUTSIDE_ATTRIBUTE)),\n          ),\n      ),\n    ),\n})\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAa,aAAa,MAAM,aAAa,cAAc;CACzD,UAAU,CAAC,OAAO,KAAK;CACvB,eACE,OAAO,eAAsB,OAAO,eAAe,IAAI,kBAAkB,IAAI,YAAY,CAAC;AAC9F,CAAC;AAED,MAAM,yBAAyB;AAE/B,IAAI,SAAS;;AAGb,MAAa,cAAc,MAAM,aAAa,eAAe;CAC3D,UAAU,CAAC,OAAO,KAAK;CACvB,UAAU,EAAE,cACV,OAAO,eACL,OAAO,eACL,OAAO,IAAI,aAAa;EAGtB,MAAM,KAAK,gBAAiB,UAAU;EACtC,QAAQ,aAAa,wBAAwB,EAAE;EAC/C,OAAO,IAAI,YAAY,IAAI,CAAC,IAAI,uBAAuB,IAAI,GAAG,GAAG,CAAC;EAClE,OAAO;CACT,CAAC,IACD,OACE,OAAO,QAAQ,IAAI,aAAa,EAAE,SAChC,OAAO,WAAW,QAAQ,gBAAgB,sBAAsB,CAAC,CACnE,CACJ,CACF;AACJ,CAAC"}

package/dist/dom/measure.d.ts

@@ -0,0 +1,42 @@
+import { Schema } from "effect";
+import * as Mount from "foldkit/mount";
+/** The custom properties `Measure` writes for a target named `name`. */
+export declare const measured: (name: string) => {
+  readonly x: `--fk-${string}-x`;
+  readonly y: `--fk-${string}-y`;
+  readonly w: `--fk-${string}-w`;
+  readonly h: `--fk-${string}-h`;
+  readonly display: `--fk-${string}-display`;
+  /**
+   * `1` for the measure that finds the mark on another element than the
+   * last, `0` for any other (the layout moved or resized the same one, or
+   * it is the first found): an overlay that glides to a new mark scales its
+   * duration by it, so it keeps to its element as the layout settles.
+   */
+  readonly moving: `--fk-${string}-moving`;
+};
+/**
+ * Measures marked elements as a Mount, for a view to draw something over them,
+ * such as an editor's selection outline, with no Message and no Model: where
+ * an element is, is presentation, known to the DOM and to no transition.
+ *
+ * For each named target, the first element in the mounted one's subtree that
+ * matches its selector is measured relative to the mounted element's scroll
+ * box, which is what an absolutely placed child of it is laid out in. The
+ * mounted element gets `--fk-<name>-x`, `-y`, `-w` and `-h` in pixels, and
+ * `--fk-<name>-display`: `block` while a target is found, `none` while none is,
+ * and `--fk-<name>-moving` (see `measured`).
+ *
+ * It measures again when the subtree changes (a selection moves) or the
+ * mounted element or a measured one changes size, in the frame the change is
+ * drawn in; and, at most once a frame, when the mounted element scrolls, the
+ * window resizes, an image or a font inside loads, and on every frame of a
+ * transition or an animation inside. What moves a target by any other way,
+ * such as a stylesheet added that shifts it without resizing it, is seen at
+ * the next of these.
+ */
+export declare const Measure: Mount.MountDefinitionWithArgs<"Measure", {
+  /** Each target by name, as a selector within the element: `{ selected: '[aria-selected="true"]' }`. */
+  targets: Schema.$Record<Schema.String, Schema.String>;
+}, never>;
+//# sourceMappingURL=measure.d.ts.map

package/dist/dom/measure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure.d.ts","names":[],"sources":["../../src/dom/measure.ts"],"mappings":";;;qBAIa,WAAQ;WAEjB;WACA;WACA;WACA;WACA;;;;;;;WAOA;;;;;;;;;;;;;;;;;;;;;;qBAuBS,SAAO,MAAA"}

package/dist/dom/measure.js

@@ -0,0 +1,123 @@
+import { Effect, Schema, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+// src/dom/measure.ts
+/** The custom properties `Measure` writes for a target named `name`. */
+const measured = (name) => ({
+	x: `--fk-${name}-x`,
+	y: `--fk-${name}-y`,
+	w: `--fk-${name}-w`,
+	h: `--fk-${name}-h`,
+	display: `--fk-${name}-display`,
+	/**
+	* `1` for the measure that finds the mark on another element than the
+	* last, `0` for any other (the layout moved or resized the same one, or
+	* it is the first found): an overlay that glides to a new mark scales its
+	* duration by it, so it keeps to its element as the layout settles.
+	*/
+	moving: `--fk-${name}-moving`
+});
+/**
+* Measures marked elements as a Mount, for a view to draw something over them,
+* such as an editor's selection outline, with no Message and no Model: where
+* an element is, is presentation, known to the DOM and to no transition.
+*
+* For each named target, the first element in the mounted one's subtree that
+* matches its selector is measured relative to the mounted element's scroll
+* box, which is what an absolutely placed child of it is laid out in. The
+* mounted element gets `--fk-<name>-x`, `-y`, `-w` and `-h` in pixels, and
+* `--fk-<name>-display`: `block` while a target is found, `none` while none is,
+* and `--fk-<name>-moving` (see `measured`).
+*
+* It measures again when the subtree changes (a selection moves) or the
+* mounted element or a measured one changes size, in the frame the change is
+* drawn in; and, at most once a frame, when the mounted element scrolls, the
+* window resizes, an image or a font inside loads, and on every frame of a
+* transition or an animation inside. What moves a target by any other way,
+* such as a stylesheet added that shifts it without resizing it, is seen at
+* the next of these.
+*/
+const Measure = Mount.defineStream("Measure", {
+	messages: [Schema.Never],
+	args: { 
+	/** Each target by name, as a selector within the element: `{ selected: '[aria-selected="true"]' }`. */
+targets: Schema.Record(Schema.String, Schema.String) },
+	execute: ({ element, targets }) => Stream.callback(() => Effect.acquireRelease(Effect.sync(() => {
+		const container = element;
+		const names = Object.keys(targets);
+		let watched = [];
+		const last = /* @__PURE__ */ new Map();
+		let frame;
+		let animating = false;
+		const measure = () => {
+			if (frame !== void 0) cancelAnimationFrame(frame);
+			frame = void 0;
+			const box = container.getBoundingClientRect();
+			const found = [];
+			for (const name of names) {
+				const property = measured(name);
+				const target = container.querySelector(targets[name]);
+				if (target === null) {
+					container.style.setProperty(property.display, "none");
+					continue;
+				}
+				found.push(target);
+				const previous = last.get(name);
+				last.set(name, target);
+				const rect = target.getBoundingClientRect();
+				const x = rect.left - box.left - container.clientLeft + container.scrollLeft;
+				const y = rect.top - box.top - container.clientTop + container.scrollTop;
+				container.style.setProperty(property.x, `${x}px`);
+				container.style.setProperty(property.y, `${y}px`);
+				container.style.setProperty(property.w, `${rect.width}px`);
+				container.style.setProperty(property.h, `${rect.height}px`);
+				container.style.setProperty(property.display, "block");
+				container.style.setProperty(property.moving, previous === void 0 || previous === target ? "0" : "1");
+			}
+			if (found.length !== watched.length || found.some((each, at) => each !== watched[at])) {
+				for (const each of watched) sizes.unobserve(each);
+				for (const each of found) sizes.observe(each);
+				watched = found;
+			}
+			if (animating) {
+				animating = container.getAnimations({ subtree: true }).some((animation) => animation.playState === "running");
+				if (animating) soon();
+			}
+		};
+		const soon = () => {
+			if (frame === void 0) frame = requestAnimationFrame(measure);
+		};
+		const moving = () => {
+			animating = true;
+			soon();
+		};
+		const changes = new MutationObserver(measure);
+		const sizes = new ResizeObserver(measure);
+		document.fonts.addEventListener("loadingdone", soon);
+		changes.observe(container, {
+			subtree: true,
+			childList: true,
+			attributes: true
+		});
+		sizes.observe(container);
+		container.addEventListener("scroll", soon, { passive: true });
+		window.addEventListener("resize", soon);
+		container.addEventListener("load", soon, { capture: true });
+		container.addEventListener("transitionrun", moving);
+		container.addEventListener("animationstart", moving);
+		measure();
+		return () => {
+			if (frame !== void 0) cancelAnimationFrame(frame);
+			changes.disconnect();
+			sizes.disconnect();
+			container.removeEventListener("scroll", soon);
+			window.removeEventListener("resize", soon);
+			container.removeEventListener("load", soon, { capture: true });
+			document.fonts.removeEventListener("loadingdone", soon);
+			container.removeEventListener("transitionrun", moving);
+			container.removeEventListener("animationstart", moving);
+		};
+	}), (stop) => Effect.sync(stop)))
+});
+export { Measure, measured };
+
+//# sourceMappingURL=measure.js.map

package/dist/dom/measure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure.js","names":[],"sources":["../../src/dom/measure.ts"],"sourcesContent":["import { Effect, Schema, Stream } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\n/** The custom properties `Measure` writes for a target named `name`. */\nexport const measured = (name: string) =>\n  ({\n    x: `--fk-${name}-x`,\n    y: `--fk-${name}-y`,\n    w: `--fk-${name}-w`,\n    h: `--fk-${name}-h`,\n    display: `--fk-${name}-display`,\n    /**\n     * `1` for the measure that finds the mark on another element than the\n     * last, `0` for any other (the layout moved or resized the same one, or\n     * it is the first found): an overlay that glides to a new mark scales its\n     * duration by it, so it keeps to its element as the layout settles.\n     */\n    moving: `--fk-${name}-moving`,\n  }) as const\n\n/**\n * Measures marked elements as a Mount, for a view to draw something over them,\n * such as an editor's selection outline, with no Message and no Model: where\n * an element is, is presentation, known to the DOM and to no transition.\n *\n * For each named target, the first element in the mounted one's subtree that\n * matches its selector is measured relative to the mounted element's scroll\n * box, which is what an absolutely placed child of it is laid out in. The\n * mounted element gets `--fk-<name>-x`, `-y`, `-w` and `-h` in pixels, and\n * `--fk-<name>-display`: `block` while a target is found, `none` while none is,\n * and `--fk-<name>-moving` (see `measured`).\n *\n * It measures again when the subtree changes (a selection moves) or the\n * mounted element or a measured one changes size, in the frame the change is\n * drawn in; and, at most once a frame, when the mounted element scrolls, the\n * window resizes, an image or a font inside loads, and on every frame of a\n * transition or an animation inside. What moves a target by any other way,\n * such as a stylesheet added that shifts it without resizing it, is seen at\n * the next of these.\n */\nexport const Measure = Mount.defineStream('Measure', {\n  messages: [Schema.Never],\n  args: {\n    /** Each target by name, as a selector within the element: `{ selected: '[aria-selected=\"true\"]' }`. */\n    targets: Schema.Record(Schema.String, Schema.String),\n  },\n  execute: ({ element, targets }) =>\n    Stream.callback<never>(() =>\n      Effect.acquireRelease(\n        Effect.sync(() => {\n          const container = element as HTMLElement\n          const names = Object.keys(targets)\n          let watched: ReadonlyArray<Element> = []\n          // The element each target was last measured on, to tell a new mark from a moved layout.\n          const last = new Map<string, Element>()\n          let frame: number | undefined\n          // Whether a transition or an animation may be moving something, until one frame finds none.\n          let animating = false\n\n          const measure = () => {\n            if (frame !== undefined) cancelAnimationFrame(frame)\n            frame = undefined\n            const box = container.getBoundingClientRect()\n            const found: Array<Element> = []\n            for (const name of names) {\n              const property = measured(name)\n              const target = container.querySelector(targets[name]!)\n              if (target === null) {\n                container.style.setProperty(property.display, 'none')\n                continue\n              }\n              found.push(target)\n              const previous = last.get(name)\n              last.set(name, target)\n              const rect = target.getBoundingClientRect()\n              // Relative to the scroll box: where the content is, not where the viewport shows it.\n              const x = rect.left - box.left - container.clientLeft + container.scrollLeft\n              const y = rect.top - box.top - container.clientTop + container.scrollTop\n              container.style.setProperty(property.x, `${x}px`)\n              container.style.setProperty(property.y, `${y}px`)\n              container.style.setProperty(property.w, `${rect.width}px`)\n              container.style.setProperty(property.h, `${rect.height}px`)\n              container.style.setProperty(property.display, 'block')\n              container.style.setProperty(\n                property.moving,\n                previous === undefined || previous === target ? '0' : '1',\n              )\n            }\n            // A measured element that changes size, as an image loading does, is measured again.\n            if (found.length !== watched.length || found.some((each, at) => each !== watched[at])) {\n              for (const each of watched) sizes.unobserve(each)\n              for (const each of found) sizes.observe(each)\n              watched = found\n            }\n            if (animating) {\n              // Asked each frame rather than counted: an element removed mid-transition ends none.\n              animating = container\n                .getAnimations({ subtree: true })\n                .some(animation => animation.playState === 'running')\n              if (animating) soon()\n            }\n          }\n          const soon = () => {\n            if (frame === undefined) frame = requestAnimationFrame(measure)\n          }\n          const moving = () => {\n            animating = true\n            soon()\n          }\n\n          // A change is measured as its records arrive, before the frame it is drawn in is\n          // painted, so a box never shows one frame on the element it has left.\n          const changes = new MutationObserver(measure)\n          // Made, and the fonts listened to, before anything observes: where one is\n          // missing (jsdom has neither a ResizeObserver nor `document.fonts`), the Mount\n          // fails with nothing attached to call `measure`. A size is measured as it is\n          // observed, after layout and before paint: a frame later, a popup whose width\n          // settled as it opened showed its marker at the old width, past its edge.\n          const sizes = new ResizeObserver(measure)\n          document.fonts.addEventListener('loadingdone', soon)\n          // Its own properties change the container's style too, but writing the same\n          // values again records nothing, so a measure that changed nothing rests.\n          changes.observe(container, { subtree: true, childList: true, attributes: true })\n          sizes.observe(container)\n          container.addEventListener('scroll', soon, { passive: true })\n          window.addEventListener('resize', soon)\n          // `load` does not bubble, so it is caught on the way down.\n          container.addEventListener('load', soon, { capture: true })\n          container.addEventListener('transitionrun', moving)\n          container.addEventListener('animationstart', moving)\n          measure()\n          return () => {\n            if (frame !== undefined) cancelAnimationFrame(frame)\n            changes.disconnect()\n            sizes.disconnect()\n            container.removeEventListener('scroll', soon)\n            window.removeEventListener('resize', soon)\n            container.removeEventListener('load', soon, { capture: true })\n            document.fonts.removeEventListener('loadingdone', soon)\n            container.removeEventListener('transitionrun', moving)\n            container.removeEventListener('animationstart', moving)\n          }\n        }),\n        stop => Effect.sync(stop),\n      ),\n    ),\n})\n"],"mappings":"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"}

package/dist/dom/move.d.ts

@@ -0,0 +1,45 @@
+import { Schema } from "effect";
+import * as Mount from "foldkit/mount";
+export declare const MoveStarted: Schema.TaggedStruct<"MoveStarted", {
+  readonly pointerId: Schema.Number;
+  readonly pointerType: Schema.String;
+}>;
+export type MoveStarted = typeof MoveStarted.Type;
+export declare const Moved: Schema.TaggedStruct<"Moved", {
+  readonly pointerId: Schema.Number;
+  /** From where the pointer went down, in CSS pixels. */
+  readonly deltaX: Schema.Number;
+  readonly deltaY: Schema.Number;
+  readonly pointerType: Schema.String;
+}>;
+export type Moved = typeof Moved.Type;
+export declare const MoveEnded: Schema.TaggedStruct<"MoveEnded", {
+  readonly pointerId: Schema.Number;
+  /** `false` when the pointer was cancelled or capture was lost. */
+  readonly completed: Schema.Boolean;
+}>;
+export type MoveEnded = typeof MoveEnded.Type;
+export type Fact = MoveStarted | Moved | MoveEnded;
+/**
+ * Pointer movement on an element as a Mount: a primary-button pointer down
+ * captures the pointer, each move reports the delta from where it started,
+ * and up, cancel, or lost capture ends it. Nothing is decided here: a drag
+ * threshold, a snap, or a constraint is the parent's `update`. Capture is
+ * released with the Mount.
+ */
+export declare const Move: Mount.MountDefinitionNoArgs<"Move", {
+  readonly _tag: "MoveStarted";
+  readonly pointerId: number;
+  readonly pointerType: string;
+} | {
+  readonly _tag: "Moved";
+  readonly pointerId: number;
+  readonly deltaX: number;
+  readonly deltaY: number;
+  readonly pointerType: string;
+} | {
+  readonly _tag: "MoveEnded";
+  readonly pointerId: number;
+  readonly completed: boolean;
+}>;
+//# sourceMappingURL=move.d.ts.map

package/dist/dom/move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move.d.ts","names":[],"sources":["../../src/dom/move.ts"],"mappings":";;qBAGa,aAAW,OAAA;;;;YAIZ,qBAAqB,YAAY;qBAEhC,OAAK,OAAA;;;;;;;YAON,eAAe,MAAM;qBAEpB,WAAS,OAAA;;;;;YAKV,mBAAmB,UAAU;YAE7B,OAAO,cAAc,QAAQ;;;;;;;;qBAsB5B,MAAI,MAAA"}

package/dist/dom/move.js

@@ -0,0 +1,96 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+// src/dom/move.ts
+const MoveStarted = Schema.TaggedStruct("MoveStarted", {
+	pointerId: Schema.Number,
+	pointerType: Schema.String
+});
+const Moved = Schema.TaggedStruct("Moved", {
+	pointerId: Schema.Number,
+	/** From where the pointer went down, in CSS pixels. */
+	deltaX: Schema.Number,
+	deltaY: Schema.Number,
+	pointerType: Schema.String
+});
+const MoveEnded = Schema.TaggedStruct("MoveEnded", {
+	pointerId: Schema.Number,
+	/** `false` when the pointer was cancelled or capture was lost. */
+	completed: Schema.Boolean
+});
+/**
+* Pointer movement on an element as a Mount: a primary-button pointer down
+* captures the pointer, each move reports the delta from where it started,
+* and up, cancel, or lost capture ends it. Nothing is decided here: a drag
+* threshold, a snap, or a constraint is the parent's `update`. Capture is
+* released with the Mount.
+*/
+const Move = Mount.defineStream("Move", {
+	messages: [
+		MoveStarted,
+		Moved,
+		MoveEnded
+	],
+	execute: ({ element }) => Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+		const target = element;
+		let active = null;
+		const offer = (fact) => Queue.offerUnsafe(queue, fact);
+		const end = (pointerId, completed) => {
+			if (active === null || active.pointerId !== pointerId) return;
+			active = null;
+			try {
+				target.releasePointerCapture?.(pointerId);
+			} catch {}
+			offer(MoveEnded.make({
+				pointerId,
+				completed
+			}));
+		};
+		const listeners = [
+			["pointerdown", (event) => {
+				const pointer = event;
+				if ((pointer.button ?? 0) !== 0 || active !== null) return;
+				const pointerId = pointer.pointerId ?? 0;
+				active = {
+					pointerId,
+					x: pointer.clientX ?? 0,
+					y: pointer.clientY ?? 0
+				};
+				try {
+					target.setPointerCapture?.(pointerId);
+				} catch {}
+				offer(MoveStarted.make({
+					pointerId,
+					pointerType: pointer.pointerType ?? "mouse"
+				}));
+			}],
+			["pointermove", (event) => {
+				const pointer = event;
+				const pointerId = pointer.pointerId ?? 0;
+				if (active === null || active.pointerId !== pointerId) return;
+				offer(Moved.make({
+					pointerId,
+					deltaX: (pointer.clientX ?? 0) - active.x,
+					deltaY: (pointer.clientY ?? 0) - active.y,
+					pointerType: pointer.pointerType ?? "mouse"
+				}));
+			}],
+			["pointerup", (event) => end(event.pointerId ?? 0, true)],
+			["pointercancel", (event) => end(event.pointerId ?? 0, false)],
+			["lostpointercapture", (event) => end(event.pointerId ?? 0, false)]
+		];
+		for (const [type, listener] of listeners) element.addEventListener(type, listener);
+		return {
+			listeners,
+			current: () => active
+		};
+	}), ({ listeners, current }) => Effect.sync(() => {
+		for (const [type, listener] of listeners) element.removeEventListener(type, listener);
+		const pointer = current();
+		if (pointer !== null) try {
+			element.releasePointerCapture?.(pointer.pointerId);
+		} catch {}
+	})))
+});
+export { Move, MoveEnded, MoveStarted, Moved };
+
+//# sourceMappingURL=move.js.map

package/dist/dom/move.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"move.js","names":[],"sources":["../../src/dom/move.ts"],"sourcesContent":["import { Effect, Queue, Schema, Stream } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\nexport const MoveStarted = Schema.TaggedStruct('MoveStarted', {\n  pointerId: Schema.Number,\n  pointerType: Schema.String,\n})\nexport type MoveStarted = typeof MoveStarted.Type\n\nexport const Moved = Schema.TaggedStruct('Moved', {\n  pointerId: Schema.Number,\n  /** From where the pointer went down, in CSS pixels. */\n  deltaX: Schema.Number,\n  deltaY: Schema.Number,\n  pointerType: Schema.String,\n})\nexport type Moved = typeof Moved.Type\n\nexport const MoveEnded = Schema.TaggedStruct('MoveEnded', {\n  pointerId: Schema.Number,\n  /** `false` when the pointer was cancelled or capture was lost. */\n  completed: Schema.Boolean,\n})\nexport type MoveEnded = typeof MoveEnded.Type\n\nexport type Fact = MoveStarted | Moved | MoveEnded\n\ntype PointerLike = Event & {\n  readonly pointerId?: number\n  readonly button?: number\n  readonly pointerType?: string\n  readonly clientX?: number\n  readonly clientY?: number\n}\n\ntype Capturing = Element & {\n  setPointerCapture?: (pointerId: number) => void\n  releasePointerCapture?: (pointerId: number) => void\n}\n\n/**\n * Pointer movement on an element as a Mount: a primary-button pointer down\n * captures the pointer, each move reports the delta from where it started,\n * and up, cancel, or lost capture ends it. Nothing is decided here: a drag\n * threshold, a snap, or a constraint is the parent's `update`. Capture is\n * released with the Mount.\n */\nexport const Move = Mount.defineStream('Move', {\n  messages: [MoveStarted, Moved, MoveEnded],\n  execute: ({ element }) =>\n    Stream.callback<Fact>(queue =>\n      Effect.acquireRelease(\n        Effect.sync(() => {\n          const target = element as Capturing\n          let active: {\n            readonly pointerId: number\n            readonly x: number\n            readonly y: number\n          } | null = null\n          const offer = (fact: Fact) => Queue.offerUnsafe(queue, fact)\n          const end = (pointerId: number, completed: boolean) => {\n            if (active === null || active.pointerId !== pointerId) return\n            active = null\n            try {\n              target.releasePointerCapture?.(pointerId)\n            } catch {\n              // Capture may already be gone; the end is still reported.\n            }\n            offer(MoveEnded.make({ pointerId, completed }))\n          }\n          const listeners: ReadonlyArray<readonly [string, (event: Event) => void]> = [\n            [\n              'pointerdown',\n              event => {\n                const pointer = event as PointerLike\n                if ((pointer.button ?? 0) !== 0 || active !== null) return\n                const pointerId = pointer.pointerId ?? 0\n                active = { pointerId, x: pointer.clientX ?? 0, y: pointer.clientY ?? 0 }\n                try {\n                  target.setPointerCapture?.(pointerId)\n                } catch {\n                  // Without capture the move still reports while over the element.\n                }\n                offer(MoveStarted.make({ pointerId, pointerType: pointer.pointerType ?? 'mouse' }))\n              },\n            ],\n            [\n              'pointermove',\n              event => {\n                const pointer = event as PointerLike\n                const pointerId = pointer.pointerId ?? 0\n                if (active === null || active.pointerId !== pointerId) return\n                offer(\n                  Moved.make({\n                    pointerId,\n                    deltaX: (pointer.clientX ?? 0) - active.x,\n                    deltaY: (pointer.clientY ?? 0) - active.y,\n                    pointerType: pointer.pointerType ?? 'mouse',\n                  }),\n                )\n              },\n            ],\n            ['pointerup', event => end((event as PointerLike).pointerId ?? 0, true)],\n            ['pointercancel', event => end((event as PointerLike).pointerId ?? 0, false)],\n            ['lostpointercapture', event => end((event as PointerLike).pointerId ?? 0, false)],\n          ]\n          for (const [type, listener] of listeners) element.addEventListener(type, listener)\n          return { listeners, current: () => active }\n        }),\n        ({ listeners, current }) =>\n          Effect.sync(() => {\n            for (const [type, listener] of listeners) element.removeEventListener(type, listener)\n            const pointer = current()\n            if (pointer !== null) {\n              try {\n                ;(element as Capturing).releasePointerCapture?.(pointer.pointerId)\n              } catch {\n                // Already released.\n              }\n            }\n          }),\n      ),\n    ),\n})\n"],"mappings":";;;AAGA,MAAa,cAAc,OAAO,aAAa,eAAe;CAC5D,WAAW,OAAO;CAClB,aAAa,OAAO;AACtB,CAAC;AAGD,MAAa,QAAQ,OAAO,aAAa,SAAS;CAChD,WAAW,OAAO;;CAElB,QAAQ,OAAO;CACf,QAAQ,OAAO;CACf,aAAa,OAAO;AACtB,CAAC;AAGD,MAAa,YAAY,OAAO,aAAa,aAAa;CACxD,WAAW,OAAO;;CAElB,WAAW,OAAO;AACpB,CAAC;;;;;;;;AAyBD,MAAa,OAAO,MAAM,aAAa,QAAQ;CAC7C,UAAU;EAAC;EAAa;EAAO;CAAS;CACxC,UAAU,EAAE,cACV,OAAO,UAAe,UACpB,OAAO,eACL,OAAO,WAAW;EAChB,MAAM,SAAS;EACf,IAAI,SAIO;EACX,MAAM,SAAS,SAAe,MAAM,YAAY,OAAO,IAAI;EAC3D,MAAM,OAAO,WAAmB,cAAuB;GACrD,IAAI,WAAW,QAAQ,OAAO,cAAc,WAAW;GACvD,SAAS;GACT,IAAI;IACF,OAAO,wBAAwB,SAAS;GAC1C,QAAQ,CAER;GACA,MAAM,UAAU,KAAK;IAAE;IAAW;GAAU,CAAC,CAAC;EAChD;EACA,MAAM,YAAsE;GAC1E,CACE,gBACA,UAAS;IACP,MAAM,UAAU;IAChB,KAAK,QAAQ,UAAU,OAAO,KAAK,WAAW,MAAM;IACpD,MAAM,YAAY,QAAQ,aAAa;IACvC,SAAS;KAAE;KAAW,GAAG,QAAQ,WAAW;KAAG,GAAG,QAAQ,WAAW;IAAE;IACvE,IAAI;KACF,OAAO,oBAAoB,SAAS;IACtC,QAAQ,CAER;IACA,MAAM,YAAY,KAAK;KAAE;KAAW,aAAa,QAAQ,eAAe;IAAQ,CAAC,CAAC;GACpF,CACF;GACA,CACE,gBACA,UAAS;IACP,MAAM,UAAU;IAChB,MAAM,YAAY,QAAQ,aAAa;IACvC,IAAI,WAAW,QAAQ,OAAO,cAAc,WAAW;IACvD,MACE,MAAM,KAAK;KACT;KACA,SAAS,QAAQ,WAAW,KAAK,OAAO;KACxC,SAAS,QAAQ,WAAW,KAAK,OAAO;KACxC,aAAa,QAAQ,eAAe;IACtC,CAAC,CACH;GACF,CACF;GACA,CAAC,cAAa,UAAS,IAAK,MAAsB,aAAa,GAAG,IAAI,CAAC;GACvE,CAAC,kBAAiB,UAAS,IAAK,MAAsB,aAAa,GAAG,KAAK,CAAC;GAC5E,CAAC,uBAAsB,UAAS,IAAK,MAAsB,aAAa,GAAG,KAAK,CAAC;EACnF;EACA,KAAK,MAAM,CAAC,MAAM,aAAa,WAAW,QAAQ,iBAAiB,MAAM,QAAQ;EACjF,OAAO;GAAE;GAAW,eAAe;EAAO;CAC5C,CAAC,IACA,EAAE,WAAW,cACZ,OAAO,WAAW;EAChB,KAAK,MAAM,CAAC,MAAM,aAAa,WAAW,QAAQ,oBAAoB,MAAM,QAAQ;EACpF,MAAM,UAAU,QAAQ;EACxB,IAAI,YAAY,MACd,IAAI;GACD,QAAuB,wBAAwB,QAAQ,SAAS;EACnE,QAAQ,CAER;CAEJ,CAAC,CACL,CACF;AACJ,CAAC"}

package/dist/dom/pointed-links.d.ts

@@ -0,0 +1,13 @@
+import { Stream } from "effect";
+import { Url } from "foldkit/url";
+/**
+ * The address of the link a reader means to follow, on the page's own
+ * origin: for a `Data.preload` before they go (`Site.routing`'s `preload`).
+ * A pointer or focus counts once it has rested on a link for 50 ms, and
+ * leaving first cancels it, so a pointer sweeping a list reads one page, not
+ * every page it crosses. A finger counts at once: the tap that follows is the
+ * navigation. Crossing the elements inside a link is staying on it. Without
+ * a document the stream is empty.
+ */
+export declare const pointedLinks: () => Stream.Stream<Url>;
+//# sourceMappingURL=pointed-links.d.ts.map

package/dist/dom/pointed-links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointed-links.d.ts","names":[],"sources":["../../src/dom/pointed-links.ts"],"mappings":";;;;;;;;;;;qBAiBa,oBAAmB,OAAO,OAAO"}

package/dist/dom/pointed-links.js

@@ -0,0 +1,59 @@
+import { Effect, Option, Queue, Stream } from "effect";
+import { fromString } from "foldkit/url";
+// src/dom/pointed-links.ts
+/** How long, in milliseconds, a pointer or focus rests on a link before it counts as intent. */
+const REST = 50;
+const LISTENED = [
+	"pointerover",
+	"pointerout",
+	"focusin",
+	"focusout"
+];
+/**
+* The address of the link a reader means to follow, on the page's own
+* origin: for a `Data.preload` before they go (`Site.routing`'s `preload`).
+* A pointer or focus counts once it has rested on a link for 50 ms, and
+* leaving first cancels it, so a pointer sweeping a list reads one page, not
+* every page it crosses. A finger counts at once: the tap that follows is the
+* navigation. Crossing the elements inside a link is staying on it. Without
+* a document the stream is empty.
+*/
+const pointedLinks = () => {
+	if (typeof document === "undefined") return Stream.empty;
+	const linkOf = (target) => {
+		const link = target instanceof Element ? target.closest("a[href]") : null;
+		return link instanceof HTMLAnchorElement && link.origin === window.location.origin ? Option.some(link) : Option.none();
+	};
+	return Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+		let on;
+		let waiting;
+		const listener = (event) => {
+			const found = linkOf(event.target);
+			if (Option.isNone(found)) return;
+			const link = found.value;
+			if (event.type === "pointerout" || event.type === "focusout") {
+				const related = "relatedTarget" in event ? event.relatedTarget : null;
+				if (related instanceof Node && link.contains(related)) return;
+				if (link.href !== on) return;
+				on = void 0;
+				clearTimeout(waiting);
+				return;
+			}
+			if (link.href === on) return;
+			on = link.href;
+			clearTimeout(waiting);
+			const url = fromString(link.href);
+			if (Option.isNone(url)) return;
+			if ("pointerType" in event && event.pointerType === "touch") Queue.offerUnsafe(queue, url.value);
+			else waiting = setTimeout(() => Queue.offerUnsafe(queue, url.value), REST);
+		};
+		for (const type of LISTENED) document.addEventListener(type, listener);
+		return () => {
+			clearTimeout(waiting);
+			for (const type of LISTENED) document.removeEventListener(type, listener);
+		};
+	}), (release) => Effect.sync(release)));
+};
+export { pointedLinks };
+
+//# sourceMappingURL=pointed-links.js.map

package/dist/dom/pointed-links.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointed-links.js","names":[],"sources":["../../src/dom/pointed-links.ts"],"sourcesContent":["import { Effect, Option, Queue, Stream } from 'effect'\nimport { fromString, type Url } from 'foldkit/url'\n\n/** How long, in milliseconds, a pointer or focus rests on a link before it counts as intent. */\nconst REST = 50\n\nconst LISTENED = ['pointerover', 'pointerout', 'focusin', 'focusout'] as const\n\n/**\n * The address of the link a reader means to follow, on the page's own\n * origin: for a `Data.preload` before they go (`Site.routing`'s `preload`).\n * A pointer or focus counts once it has rested on a link for 50 ms, and\n * leaving first cancels it, so a pointer sweeping a list reads one page, not\n * every page it crosses. A finger counts at once: the tap that follows is the\n * navigation. Crossing the elements inside a link is staying on it. Without\n * a document the stream is empty.\n */\nexport const pointedLinks = (): Stream.Stream<Url> => {\n  if (typeof document === 'undefined') return Stream.empty\n  const linkOf = (target: EventTarget | null): Option.Option<HTMLAnchorElement> => {\n    const link = target instanceof Element ? target.closest('a[href]') : null\n    return link instanceof HTMLAnchorElement && link.origin === window.location.origin\n      ? Option.some(link)\n      : Option.none()\n  }\n  // One listener for all four events, so they are read in the order they\n  // happened: a focus moving between links sends its focusout and focusin in\n  // one task, and a merge of four streams could read them the other way round.\n  return Stream.callback<Url>(queue =>\n    Effect.acquireRelease(\n      Effect.sync(() => {\n        // The link the reader is on, by its address, and the wait for it to count.\n        let on: string | undefined\n        let waiting: ReturnType<typeof setTimeout> | undefined\n        const listener = (event: Event): void => {\n          const found = linkOf(event.target)\n          if (Option.isNone(found)) return\n          const link = found.value\n          if (event.type === 'pointerout' || event.type === 'focusout') {\n            const related = 'relatedTarget' in event ? event.relatedTarget : null\n            // Leaving for an element inside the same link is staying on it.\n            if (related instanceof Node && link.contains(related)) return\n            if (link.href !== on) return\n            on = undefined\n            clearTimeout(waiting)\n            return\n          }\n          if (link.href === on) return\n          on = link.href\n          clearTimeout(waiting)\n          const url = fromString(link.href)\n          if (Option.isNone(url)) return\n          if ('pointerType' in event && event.pointerType === 'touch')\n            Queue.offerUnsafe(queue, url.value)\n          else waiting = setTimeout(() => Queue.offerUnsafe(queue, url.value), REST)\n        }\n        for (const type of LISTENED) document.addEventListener(type, listener)\n        return () => {\n          clearTimeout(waiting)\n          for (const type of LISTENED) document.removeEventListener(type, listener)\n        }\n      }),\n      release => Effect.sync(release),\n    ),\n  )\n}\n"],"mappings":";;;;AAIA,MAAM,OAAO;AAEb,MAAM,WAAW;CAAC;CAAe;CAAc;CAAW;AAAU;;;;;;;;;;AAWpE,MAAa,qBAAyC;CACpD,IAAI,OAAO,aAAa,aAAa,OAAO,OAAO;CACnD,MAAM,UAAU,WAAiE;EAC/E,MAAM,OAAO,kBAAkB,UAAU,OAAO,QAAQ,SAAS,IAAI;EACrE,OAAO,gBAAgB,qBAAqB,KAAK,WAAW,OAAO,SAAS,SACxE,OAAO,KAAK,IAAI,IAChB,OAAO,KAAK;CAClB;CAIA,OAAO,OAAO,UAAc,UAC1B,OAAO,eACL,OAAO,WAAW;EAEhB,IAAI;EACJ,IAAI;EACJ,MAAM,YAAY,UAAuB;GACvC,MAAM,QAAQ,OAAO,MAAM,MAAM;GACjC,IAAI,OAAO,OAAO,KAAK,GAAG;GAC1B,MAAM,OAAO,MAAM;GACnB,IAAI,MAAM,SAAS,gBAAgB,MAAM,SAAS,YAAY;IAC5D,MAAM,UAAU,mBAAmB,QAAQ,MAAM,gBAAgB;IAEjE,IAAI,mBAAmB,QAAQ,KAAK,SAAS,OAAO,GAAG;IACvD,IAAI,KAAK,SAAS,IAAI;IACtB,KAAK,KAAA;IACL,aAAa,OAAO;IACpB;GACF;GACA,IAAI,KAAK,SAAS,IAAI;GACtB,KAAK,KAAK;GACV,aAAa,OAAO;GACpB,MAAM,MAAM,WAAW,KAAK,IAAI;GAChC,IAAI,OAAO,OAAO,GAAG,GAAG;GACxB,IAAI,iBAAiB,SAAS,MAAM,gBAAgB,SAClD,MAAM,YAAY,OAAO,IAAI,KAAK;QAC/B,UAAU,iBAAiB,MAAM,YAAY,OAAO,IAAI,KAAK,GAAG,IAAI;EAC3E;EACA,KAAK,MAAM,QAAQ,UAAU,SAAS,iBAAiB,MAAM,QAAQ;EACrE,aAAa;GACX,aAAa,OAAO;GACpB,KAAK,MAAM,QAAQ,UAAU,SAAS,oBAAoB,MAAM,QAAQ;EAC1E;CACF,CAAC,IACD,YAAW,OAAO,KAAK,OAAO,CAChC,CACF;AACF"}