@wirekyt/dom 0.0.1 → 0.0.2

package/dist/tabbable-Bz1-1GAY.cjs

@@ -0,0 +1,206 @@
+const require_dom_query = require("./dom-query-CQzY93XU.cjs");
+//#region src/common/dom-query/tabbable.ts
+const isFrame = (el) => require_dom_query.isHTMLElement(el) && el.tagName === "IFRAME";
+const NATURALLY_TABBABLE_REGEX = /^(audio|video|details)$/;
+function parseTabIndex(el) {
+	const attr = el.getAttribute("tabindex");
+	if (!attr) return NaN;
+	return parseInt(attr, 10);
+}
+const hasTabIndex = (el) => !Number.isNaN(parseTabIndex(el));
+const hasNegativeTabIndex = (el) => parseTabIndex(el) < 0;
+function isRadioInput(element) {
+	return require_dom_query.isInputElement(element) && element.type === "radio";
+}
+function isTabbableRadio(element) {
+	if (!isRadioInput(element) || !element.name) return true;
+	if (element.checked) return true;
+	const selector = `input[type="radio"][name="${CSS.escape(element.name)}"]`;
+	const scope = element.form ?? element.ownerDocument;
+	const group = Array.from(scope.querySelectorAll(selector)).filter((radio) => radio.form === element.form && isFocusable(radio));
+	const checked = group.find((radio) => radio.checked);
+	if (checked) return checked === element;
+	return group[0] === element;
+}
+function getShadowRootForNode(element, getShadowRoot) {
+	if (!getShadowRoot) return null;
+	if (getShadowRoot === true) return element.shadowRoot || null;
+	const result = getShadowRoot(element);
+	return (result === true ? element.shadowRoot : result) || null;
+}
+function collectElementsWithShadowDOM(elements, getShadowRoot, filterFn) {
+	const allElements = [...elements];
+	const toProcess = [...elements];
+	const processed = /* @__PURE__ */ new Set();
+	const positionMap = /* @__PURE__ */ new Map();
+	elements.forEach((el, i) => positionMap.set(el, i));
+	let processIndex = 0;
+	while (processIndex < toProcess.length) {
+		const element = toProcess[processIndex++];
+		if (!element || processed.has(element)) continue;
+		processed.add(element);
+		const shadowRoot = getShadowRootForNode(element, getShadowRoot);
+		if (shadowRoot) {
+			const shadowElements = Array.from(shadowRoot.querySelectorAll(focusableSelector)).filter(filterFn);
+			const hostIndex = positionMap.get(element);
+			if (hostIndex !== void 0) {
+				const insertPosition = hostIndex + 1;
+				allElements.splice(insertPosition, 0, ...shadowElements);
+				shadowElements.forEach((el, i) => {
+					positionMap.set(el, insertPosition + i);
+				});
+				for (let i = insertPosition + shadowElements.length; i < allElements.length; i++) positionMap.set(allElements[i], i);
+			} else {
+				const insertPosition = allElements.length;
+				allElements.push(...shadowElements);
+				shadowElements.forEach((el, i) => {
+					positionMap.set(el, insertPosition + i);
+				});
+			}
+			toProcess.push(...shadowElements);
+		}
+	}
+	return allElements;
+}
+const focusableSelector = "input:not([type='hidden']):not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], button:not([disabled]), [tabindex], iframe, object, embed, area[href], audio[controls], video[controls], [contenteditable]:not([contenteditable='false']), details > summary:first-of-type";
+const getFocusables = (container, options = {}) => {
+	if (!container) return [];
+	const { includeContainer = false, getShadowRoot } = options;
+	const elements = Array.from(container.querySelectorAll(focusableSelector));
+	if ((includeContainer == true || includeContainer == "if-empty" && elements.length === 0) && require_dom_query.isHTMLElement(container) && isFocusable(container)) elements.unshift(container);
+	const focusableElements = [];
+	for (const element of elements) {
+		if (!isFocusable(element)) continue;
+		if (isFrame(element) && element.contentDocument) {
+			const frameBody = element.contentDocument.body;
+			focusableElements.push(...getFocusables(frameBody, { getShadowRoot }));
+			continue;
+		}
+		focusableElements.push(element);
+	}
+	if (getShadowRoot) return collectElementsWithShadowDOM(focusableElements, getShadowRoot, isFocusable);
+	return focusableElements;
+};
+function isFocusable(element) {
+	if (!require_dom_query.isHTMLElement(element) || element.closest("[inert]")) return false;
+	return element.matches(focusableSelector) && require_dom_query.isElementVisible(element);
+}
+function getFirstFocusable(container, options = {}) {
+	const [first] = getFocusables(container, options);
+	return first || null;
+}
+function getTabbables(container, options = {}) {
+	if (!container) return [];
+	const { includeContainer, getShadowRoot } = options;
+	const elements = Array.from(container.querySelectorAll(focusableSelector));
+	if (includeContainer && isTabbable(container)) elements.unshift(container);
+	const tabbableElements = [];
+	for (const element of elements) {
+		if (!isTabbable(element)) continue;
+		if (isFrame(element) && element.contentDocument) {
+			const frameBody = element.contentDocument.body;
+			tabbableElements.push(...getTabbables(frameBody, { getShadowRoot }));
+			continue;
+		}
+		tabbableElements.push(element);
+	}
+	if (getShadowRoot) {
+		const allElements = collectElementsWithShadowDOM(tabbableElements, getShadowRoot, isTabbable);
+		if (!allElements.length && includeContainer) return elements;
+		return allElements;
+	}
+	if (!tabbableElements.length && includeContainer) return elements;
+	return tabbableElements;
+}
+function isTabbable(el) {
+	if (require_dom_query.isHTMLElement(el) && el.tabIndex > 0) return true;
+	if (!isFocusable(el) || hasNegativeTabIndex(el)) return false;
+	return isTabbableRadio(el);
+}
+function getFirstTabbable(container, options = {}) {
+	const [first] = getTabbables(container, options);
+	return first || null;
+}
+function getLastTabbable(container, options = {}) {
+	const elements = getTabbables(container, options);
+	return elements[elements.length - 1] || null;
+}
+function getTabbableEdges(container, options = {}) {
+	const elements = getTabbables(container, options);
+	return [elements[0] || null, elements[elements.length - 1] || null];
+}
+function getNextTabbable(container, options = {}) {
+	const { current, getShadowRoot } = options;
+	const tabbables = getTabbables(container, { getShadowRoot });
+	const doc = container?.ownerDocument || document;
+	const currentElement = current ?? require_dom_query.getActiveElement(doc);
+	if (!currentElement) return null;
+	return tabbables[tabbables.indexOf(currentElement) + 1] || null;
+}
+function getTabIndex(node) {
+	if (node.tabIndex < 0) {
+		if ((NATURALLY_TABBABLE_REGEX.test(node.localName) || require_dom_query.isEditableElement(node)) && !hasTabIndex(node)) return 0;
+	}
+	return node.tabIndex;
+}
+//#endregion
+Object.defineProperty(exports, "getFirstFocusable", {
+	enumerable: true,
+	get: function() {
+		return getFirstFocusable;
+	}
+});
+Object.defineProperty(exports, "getFirstTabbable", {
+	enumerable: true,
+	get: function() {
+		return getFirstTabbable;
+	}
+});
+Object.defineProperty(exports, "getFocusables", {
+	enumerable: true,
+	get: function() {
+		return getFocusables;
+	}
+});
+Object.defineProperty(exports, "getLastTabbable", {
+	enumerable: true,
+	get: function() {
+		return getLastTabbable;
+	}
+});
+Object.defineProperty(exports, "getNextTabbable", {
+	enumerable: true,
+	get: function() {
+		return getNextTabbable;
+	}
+});
+Object.defineProperty(exports, "getTabIndex", {
+	enumerable: true,
+	get: function() {
+		return getTabIndex;
+	}
+});
+Object.defineProperty(exports, "getTabbableEdges", {
+	enumerable: true,
+	get: function() {
+		return getTabbableEdges;
+	}
+});
+Object.defineProperty(exports, "getTabbables", {
+	enumerable: true,
+	get: function() {
+		return getTabbables;
+	}
+});
+Object.defineProperty(exports, "isFocusable", {
+	enumerable: true,
+	get: function() {
+		return isFocusable;
+	}
+});
+Object.defineProperty(exports, "isTabbable", {
+	enumerable: true,
+	get: function() {
+		return isTabbable;
+	}
+});

package/dist/tabbable-CDA1YMjZ.js

@@ -0,0 +1,147 @@
+import { A as isInputElement, E as isEditableElement, O as isElementVisible, k as isHTMLElement, m as getActiveElement } from "./dom-query-e7fh0TEH.js";
+//#region src/common/dom-query/tabbable.ts
+const isFrame = (el) => isHTMLElement(el) && el.tagName === "IFRAME";
+const NATURALLY_TABBABLE_REGEX = /^(audio|video|details)$/;
+function parseTabIndex(el) {
+	const attr = el.getAttribute("tabindex");
+	if (!attr) return NaN;
+	return parseInt(attr, 10);
+}
+const hasTabIndex = (el) => !Number.isNaN(parseTabIndex(el));
+const hasNegativeTabIndex = (el) => parseTabIndex(el) < 0;
+function isRadioInput(element) {
+	return isInputElement(element) && element.type === "radio";
+}
+function isTabbableRadio(element) {
+	if (!isRadioInput(element) || !element.name) return true;
+	if (element.checked) return true;
+	const selector = `input[type="radio"][name="${CSS.escape(element.name)}"]`;
+	const scope = element.form ?? element.ownerDocument;
+	const group = Array.from(scope.querySelectorAll(selector)).filter((radio) => radio.form === element.form && isFocusable(radio));
+	const checked = group.find((radio) => radio.checked);
+	if (checked) return checked === element;
+	return group[0] === element;
+}
+function getShadowRootForNode(element, getShadowRoot) {
+	if (!getShadowRoot) return null;
+	if (getShadowRoot === true) return element.shadowRoot || null;
+	const result = getShadowRoot(element);
+	return (result === true ? element.shadowRoot : result) || null;
+}
+function collectElementsWithShadowDOM(elements, getShadowRoot, filterFn) {
+	const allElements = [...elements];
+	const toProcess = [...elements];
+	const processed = /* @__PURE__ */ new Set();
+	const positionMap = /* @__PURE__ */ new Map();
+	elements.forEach((el, i) => positionMap.set(el, i));
+	let processIndex = 0;
+	while (processIndex < toProcess.length) {
+		const element = toProcess[processIndex++];
+		if (!element || processed.has(element)) continue;
+		processed.add(element);
+		const shadowRoot = getShadowRootForNode(element, getShadowRoot);
+		if (shadowRoot) {
+			const shadowElements = Array.from(shadowRoot.querySelectorAll(focusableSelector)).filter(filterFn);
+			const hostIndex = positionMap.get(element);
+			if (hostIndex !== void 0) {
+				const insertPosition = hostIndex + 1;
+				allElements.splice(insertPosition, 0, ...shadowElements);
+				shadowElements.forEach((el, i) => {
+					positionMap.set(el, insertPosition + i);
+				});
+				for (let i = insertPosition + shadowElements.length; i < allElements.length; i++) positionMap.set(allElements[i], i);
+			} else {
+				const insertPosition = allElements.length;
+				allElements.push(...shadowElements);
+				shadowElements.forEach((el, i) => {
+					positionMap.set(el, insertPosition + i);
+				});
+			}
+			toProcess.push(...shadowElements);
+		}
+	}
+	return allElements;
+}
+const focusableSelector = "input:not([type='hidden']):not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], button:not([disabled]), [tabindex], iframe, object, embed, area[href], audio[controls], video[controls], [contenteditable]:not([contenteditable='false']), details > summary:first-of-type";
+const getFocusables = (container, options = {}) => {
+	if (!container) return [];
+	const { includeContainer = false, getShadowRoot } = options;
+	const elements = Array.from(container.querySelectorAll(focusableSelector));
+	if ((includeContainer == true || includeContainer == "if-empty" && elements.length === 0) && isHTMLElement(container) && isFocusable(container)) elements.unshift(container);
+	const focusableElements = [];
+	for (const element of elements) {
+		if (!isFocusable(element)) continue;
+		if (isFrame(element) && element.contentDocument) {
+			const frameBody = element.contentDocument.body;
+			focusableElements.push(...getFocusables(frameBody, { getShadowRoot }));
+			continue;
+		}
+		focusableElements.push(element);
+	}
+	if (getShadowRoot) return collectElementsWithShadowDOM(focusableElements, getShadowRoot, isFocusable);
+	return focusableElements;
+};
+function isFocusable(element) {
+	if (!isHTMLElement(element) || element.closest("[inert]")) return false;
+	return element.matches(focusableSelector) && isElementVisible(element);
+}
+function getFirstFocusable(container, options = {}) {
+	const [first] = getFocusables(container, options);
+	return first || null;
+}
+function getTabbables(container, options = {}) {
+	if (!container) return [];
+	const { includeContainer, getShadowRoot } = options;
+	const elements = Array.from(container.querySelectorAll(focusableSelector));
+	if (includeContainer && isTabbable(container)) elements.unshift(container);
+	const tabbableElements = [];
+	for (const element of elements) {
+		if (!isTabbable(element)) continue;
+		if (isFrame(element) && element.contentDocument) {
+			const frameBody = element.contentDocument.body;
+			tabbableElements.push(...getTabbables(frameBody, { getShadowRoot }));
+			continue;
+		}
+		tabbableElements.push(element);
+	}
+	if (getShadowRoot) {
+		const allElements = collectElementsWithShadowDOM(tabbableElements, getShadowRoot, isTabbable);
+		if (!allElements.length && includeContainer) return elements;
+		return allElements;
+	}
+	if (!tabbableElements.length && includeContainer) return elements;
+	return tabbableElements;
+}
+function isTabbable(el) {
+	if (isHTMLElement(el) && el.tabIndex > 0) return true;
+	if (!isFocusable(el) || hasNegativeTabIndex(el)) return false;
+	return isTabbableRadio(el);
+}
+function getFirstTabbable(container, options = {}) {
+	const [first] = getTabbables(container, options);
+	return first || null;
+}
+function getLastTabbable(container, options = {}) {
+	const elements = getTabbables(container, options);
+	return elements[elements.length - 1] || null;
+}
+function getTabbableEdges(container, options = {}) {
+	const elements = getTabbables(container, options);
+	return [elements[0] || null, elements[elements.length - 1] || null];
+}
+function getNextTabbable(container, options = {}) {
+	const { current, getShadowRoot } = options;
+	const tabbables = getTabbables(container, { getShadowRoot });
+	const doc = container?.ownerDocument || document;
+	const currentElement = current ?? getActiveElement(doc);
+	if (!currentElement) return null;
+	return tabbables[tabbables.indexOf(currentElement) + 1] || null;
+}
+function getTabIndex(node) {
+	if (node.tabIndex < 0) {
+		if ((NATURALLY_TABBABLE_REGEX.test(node.localName) || isEditableElement(node)) && !hasTabIndex(node)) return 0;
+	}
+	return node.tabIndex;
+}
+//#endregion
+export { getNextTabbable as a, getTabbables as c, getLastTabbable as i, isFocusable as l, getFirstTabbable as n, getTabIndex as o, getFocusables as r, getTabbableEdges as s, getFirstFocusable as t, isTabbable as u };

package/dist/text-selection-B3OQpQGy.cjs

@@ -0,0 +1,75 @@
+const require_platform = require("./platform-BZS-dkZN.cjs");
+const require_raf = require("./raf-BSDcY4UD.cjs");
+//#region src/common/dom-query/text-selection.ts
+let state = "default";
+let userSelect = "";
+const elementMap = /* @__PURE__ */ new WeakMap();
+function disableTextSelectionImpl(options = {}) {
+	const { target, doc } = options;
+	const docNode = doc ?? document;
+	const rootEl = docNode.documentElement;
+	if (require_platform.isIos()) {
+		if (state === "default") {
+			userSelect = rootEl.style.webkitUserSelect;
+			rootEl.style.webkitUserSelect = "none";
+		}
+		state = "disabled";
+	} else if (target) {
+		elementMap.set(target, target.style.userSelect);
+		target.style.userSelect = "none";
+	}
+	return () => restoreTextSelection({
+		target,
+		doc: docNode
+	});
+}
+function restoreTextSelection(options = {}) {
+	const { target, doc } = options;
+	const rootEl = (doc ?? document).documentElement;
+	if (require_platform.isIos()) {
+		if (state !== "disabled") return;
+		state = "restoring";
+		setTimeout(() => {
+			require_raf.nextTick(() => {
+				if (state === "restoring") {
+					if (rootEl.style.webkitUserSelect === "none") rootEl.style.webkitUserSelect = userSelect || "";
+					userSelect = "";
+					state = "default";
+				}
+			});
+		}, 300);
+	} else if (target && elementMap.has(target)) {
+		const prevUserSelect = elementMap.get(target);
+		if (target.style.userSelect === "none") target.style.userSelect = prevUserSelect ?? "";
+		if (target.getAttribute("style") === "") target.removeAttribute("style");
+		elementMap.delete(target);
+	}
+}
+function disableTextSelection(options = {}) {
+	const { defer, target, ...restOptions } = options;
+	const func = defer ? require_raf.raf : (v) => v();
+	const cleanups = [];
+	cleanups.push(func(() => {
+		const node = typeof target === "function" ? target() : target;
+		cleanups.push(disableTextSelectionImpl({
+			...restOptions,
+			target: node
+		}));
+	}));
+	return () => {
+		cleanups.forEach((fn) => fn?.());
+	};
+}
+//#endregion
+Object.defineProperty(exports, "disableTextSelection", {
+	enumerable: true,
+	get: function() {
+		return disableTextSelection;
+	}
+});
+Object.defineProperty(exports, "restoreTextSelection", {
+	enumerable: true,
+	get: function() {
+		return restoreTextSelection;
+	}
+});

package/dist/text-selection-DXvWvm6k.js

@@ -0,0 +1,64 @@
+import { u as isIos } from "./platform-BDB0wXUk.js";
+import { i as raf, n as nextTick } from "./raf-Dhvm7f1e.js";
+//#region src/common/dom-query/text-selection.ts
+let state = "default";
+let userSelect = "";
+const elementMap = /* @__PURE__ */ new WeakMap();
+function disableTextSelectionImpl(options = {}) {
+	const { target, doc } = options;
+	const docNode = doc ?? document;
+	const rootEl = docNode.documentElement;
+	if (isIos()) {
+		if (state === "default") {
+			userSelect = rootEl.style.webkitUserSelect;
+			rootEl.style.webkitUserSelect = "none";
+		}
+		state = "disabled";
+	} else if (target) {
+		elementMap.set(target, target.style.userSelect);
+		target.style.userSelect = "none";
+	}
+	return () => restoreTextSelection({
+		target,
+		doc: docNode
+	});
+}
+function restoreTextSelection(options = {}) {
+	const { target, doc } = options;
+	const rootEl = (doc ?? document).documentElement;
+	if (isIos()) {
+		if (state !== "disabled") return;
+		state = "restoring";
+		setTimeout(() => {
+			nextTick(() => {
+				if (state === "restoring") {
+					if (rootEl.style.webkitUserSelect === "none") rootEl.style.webkitUserSelect = userSelect || "";
+					userSelect = "";
+					state = "default";
+				}
+			});
+		}, 300);
+	} else if (target && elementMap.has(target)) {
+		const prevUserSelect = elementMap.get(target);
+		if (target.style.userSelect === "none") target.style.userSelect = prevUserSelect ?? "";
+		if (target.getAttribute("style") === "") target.removeAttribute("style");
+		elementMap.delete(target);
+	}
+}
+function disableTextSelection(options = {}) {
+	const { defer, target, ...restOptions } = options;
+	const func = defer ? raf : (v) => v();
+	const cleanups = [];
+	cleanups.push(func(() => {
+		const node = typeof target === "function" ? target() : target;
+		cleanups.push(disableTextSelectionImpl({
+			...restOptions,
+			target: node
+		}));
+	}));
+	return () => {
+		cleanups.forEach((fn) => fn?.());
+	};
+}
+//#endregion
+export { restoreTextSelection as n, disableTextSelection as t };

package/dist/timers-BRyPrXIX.js

@@ -0,0 +1,82 @@
+//#region src/common/utils/timers.ts
+const currentTime = () => performance.now();
+var Timer = class {
+	onTick;
+	frameId = null;
+	pausedAtMs = null;
+	context;
+	constructor(onTick) {
+		this.onTick = onTick;
+		this.context = {
+			now: 0,
+			startMs: currentTime(),
+			deltaMs: 0
+		};
+	}
+	cancelFrame = () => {
+		if (this.frameId === null) return;
+		cancelAnimationFrame(this.frameId);
+		this.frameId = null;
+	};
+	setStartMs = (startMs) => {
+		this.context.startMs = startMs;
+	};
+	get elapsedMs() {
+		if (this.pausedAtMs !== null) return this.pausedAtMs - this.context.startMs;
+		return currentTime() - this.context.startMs;
+	}
+	start = () => {
+		if (this.frameId !== null) return;
+		const now = currentTime();
+		if (this.pausedAtMs !== null) {
+			this.context.startMs += now - this.pausedAtMs;
+			this.pausedAtMs = null;
+		} else this.context.startMs = now;
+		this.frameId = requestAnimationFrame(this.#tick);
+	};
+	pause = () => {
+		if (this.frameId === null) return;
+		this.cancelFrame();
+		this.pausedAtMs = currentTime();
+	};
+	stop = () => {
+		if (this.frameId === null) return;
+		this.cancelFrame();
+		this.pausedAtMs = null;
+	};
+	#tick = (now) => {
+		this.context.now = now;
+		this.context.deltaMs = now - this.context.startMs;
+		if (this.onTick(this.context) === false) {
+			this.stop();
+			return;
+		}
+		this.frameId = requestAnimationFrame(this.#tick);
+	};
+};
+function setRafInterval(fn, intervalMs) {
+	const timer = new Timer(({ now, deltaMs }) => {
+		if (deltaMs >= intervalMs) {
+			const startMs = intervalMs > 0 ? now - deltaMs % intervalMs : now;
+			timer.setStartMs(startMs);
+			fn({
+				startMs,
+				deltaMs
+			});
+		}
+	});
+	timer.start();
+	return () => timer.stop();
+}
+function setRafTimeout(fn, delayMs) {
+	const timer = new Timer(({ deltaMs }) => {
+		if (deltaMs >= delayMs) {
+			fn();
+			return false;
+		}
+	});
+	timer.start();
+	return () => timer.stop();
+}
+//#endregion
+export { setRafInterval as n, setRafTimeout as r, Timer as t };

package/dist/timers-Beu4SfAj.cjs

@@ -0,0 +1,99 @@
+//#region src/common/utils/timers.ts
+const currentTime = () => performance.now();
+var Timer = class {
+	onTick;
+	frameId = null;
+	pausedAtMs = null;
+	context;
+	constructor(onTick) {
+		this.onTick = onTick;
+		this.context = {
+			now: 0,
+			startMs: currentTime(),
+			deltaMs: 0
+		};
+	}
+	cancelFrame = () => {
+		if (this.frameId === null) return;
+		cancelAnimationFrame(this.frameId);
+		this.frameId = null;
+	};
+	setStartMs = (startMs) => {
+		this.context.startMs = startMs;
+	};
+	get elapsedMs() {
+		if (this.pausedAtMs !== null) return this.pausedAtMs - this.context.startMs;
+		return currentTime() - this.context.startMs;
+	}
+	start = () => {
+		if (this.frameId !== null) return;
+		const now = currentTime();
+		if (this.pausedAtMs !== null) {
+			this.context.startMs += now - this.pausedAtMs;
+			this.pausedAtMs = null;
+		} else this.context.startMs = now;
+		this.frameId = requestAnimationFrame(this.#tick);
+	};
+	pause = () => {
+		if (this.frameId === null) return;
+		this.cancelFrame();
+		this.pausedAtMs = currentTime();
+	};
+	stop = () => {
+		if (this.frameId === null) return;
+		this.cancelFrame();
+		this.pausedAtMs = null;
+	};
+	#tick = (now) => {
+		this.context.now = now;
+		this.context.deltaMs = now - this.context.startMs;
+		if (this.onTick(this.context) === false) {
+			this.stop();
+			return;
+		}
+		this.frameId = requestAnimationFrame(this.#tick);
+	};
+};
+function setRafInterval(fn, intervalMs) {
+	const timer = new Timer(({ now, deltaMs }) => {
+		if (deltaMs >= intervalMs) {
+			const startMs = intervalMs > 0 ? now - deltaMs % intervalMs : now;
+			timer.setStartMs(startMs);
+			fn({
+				startMs,
+				deltaMs
+			});
+		}
+	});
+	timer.start();
+	return () => timer.stop();
+}
+function setRafTimeout(fn, delayMs) {
+	const timer = new Timer(({ deltaMs }) => {
+		if (deltaMs >= delayMs) {
+			fn();
+			return false;
+		}
+	});
+	timer.start();
+	return () => timer.stop();
+}
+//#endregion
+Object.defineProperty(exports, "Timer", {
+	enumerable: true,
+	get: function() {
+		return Timer;
+	}
+});
+Object.defineProperty(exports, "setRafInterval", {
+	enumerable: true,
+	get: function() {
+		return setRafInterval;
+	}
+});
+Object.defineProperty(exports, "setRafTimeout", {
+	enumerable: true,
+	get: function() {
+		return setRafTimeout;
+	}
+});