@wirekyt/dom 0.0.1 → 0.0.2

package/dist/remove-scroll.d.ts

@@ -0,0 +1,4 @@
+//#region src/common/remove-scroll/index.d.ts
+declare function preventBodyScroll(_document?: Document): VoidFunction;
+//#endregion
+export { preventBodyScroll };

package/dist/remove-scroll.js

@@ -0,0 +1,2 @@
+import { t as preventBodyScroll } from "./remove-scroll-WEheFCiq.js";
+export { preventBodyScroll };

package/dist/rolldown-runtime-D6vf50IK.cjs

@@ -0,0 +1,28 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/scale-C5BBHVgH.js

@@ -0,0 +1,17 @@
+//#region src/common/dom-query/scale.ts
+function getScale(element) {
+	const rect = element.getBoundingClientRect();
+	const offsetWidth = element.offsetWidth;
+	const offsetHeight = element.offsetHeight;
+	const hasTransform = Math.round(rect.width) !== offsetWidth || Math.round(rect.height) !== offsetHeight;
+	let x = hasTransform ? Math.round(rect.width) / offsetWidth : 1;
+	let y = hasTransform ? Math.round(rect.height) / offsetHeight : 1;
+	if (!x || !Number.isFinite(x)) x = 1;
+	if (!y || !Number.isFinite(y)) y = 1;
+	return {
+		x,
+		y
+	};
+}
+//#endregion
+export { getScale as t };

package/dist/scale-C7iiUGhS.cjs

@@ -0,0 +1,22 @@
+//#region src/common/dom-query/scale.ts
+function getScale(element) {
+	const rect = element.getBoundingClientRect();
+	const offsetWidth = element.offsetWidth;
+	const offsetHeight = element.offsetHeight;
+	const hasTransform = Math.round(rect.width) !== offsetWidth || Math.round(rect.height) !== offsetHeight;
+	let x = hasTransform ? Math.round(rect.width) / offsetWidth : 1;
+	let y = hasTransform ? Math.round(rect.height) / offsetHeight : 1;
+	if (!x || !Number.isFinite(x)) x = 1;
+	if (!y || !Number.isFinite(y)) y = 1;
+	return {
+		x,
+		y
+	};
+}
+//#endregion
+Object.defineProperty(exports, "getScale", {
+	enumerable: true,
+	get: function() {
+		return getScale;
+	}
+});

package/dist/scope-CysKlKe9.cjs

@@ -0,0 +1,28 @@
+const require_dom_query = require("./dom-query-CQzY93XU.cjs");
+const require_form = require("./form-CoupKpuP.cjs");
+//#region src/common/dom-query/scope.ts
+function createScope(methods) {
+	const dom = {
+		getRootNode: (ctx) => ctx.getRootNode?.() ?? document,
+		getDoc: (ctx) => require_dom_query.getDocument(dom.getRootNode(ctx)),
+		getWin: (ctx) => dom.getDoc(ctx).defaultView ?? window,
+		getActiveElement: (ctx) => require_dom_query.getActiveElement(dom.getRootNode(ctx)),
+		isActiveElement: require_dom_query.isActiveElement,
+		getById: (ctx, id) => dom.getRootNode(ctx).getElementById(id),
+		setValue: (elem, value) => {
+			if (elem == null || value == null) return;
+			require_form.setElementValue(elem, value.toString());
+		}
+	};
+	return {
+		...dom,
+		...methods
+	};
+}
+//#endregion
+Object.defineProperty(exports, "createScope", {
+	enumerable: true,
+	get: function() {
+		return createScope;
+	}
+});

package/dist/scope-D1873Mzi.js

@@ -0,0 +1,23 @@
+import { C as isActiveElement, g as getDocument, m as getActiveElement } from "./dom-query-e7fh0TEH.js";
+import { o as setElementValue } from "./form-B1DW_w_3.js";
+//#region src/common/dom-query/scope.ts
+function createScope(methods) {
+	const dom = {
+		getRootNode: (ctx) => ctx.getRootNode?.() ?? document,
+		getDoc: (ctx) => getDocument(dom.getRootNode(ctx)),
+		getWin: (ctx) => dom.getDoc(ctx).defaultView ?? window,
+		getActiveElement: (ctx) => getActiveElement(dom.getRootNode(ctx)),
+		isActiveElement,
+		getById: (ctx, id) => dom.getRootNode(ctx).getElementById(id),
+		setValue: (elem, value) => {
+			if (elem == null || value == null) return;
+			setElementValue(elem, value.toString());
+		}
+	};
+	return {
+		...dom,
+		...methods
+	};
+}
+//#endregion
+export { createScope as t };

package/dist/scroll-CVJ40w2e.js

@@ -0,0 +1,46 @@
+import { S as getWindow, k as isHTMLElement } from "./dom-query-e7fh0TEH.js";
+import { i as isOverflowElement } from "./overflow-C-zO1CWA.js";
+//#region src/common/dom-query/scroll.ts
+function isScrollable(el) {
+	return el.scrollHeight > el.clientHeight || el.scrollWidth > el.clientWidth;
+}
+function scrollIntoView(el, options) {
+	const { rootEl, ...scrollOptions } = options || {};
+	if (!el || !rootEl) return;
+	if (!isOverflowElement(rootEl) || !isScrollable(rootEl)) return;
+	el.scrollIntoView(scrollOptions);
+}
+function scrollToElement(el, options) {
+	const { rootEl, behavior } = options || {};
+	if (!el || !rootEl) return false;
+	if (!rootEl.contains(el)) return false;
+	const win = getWindow(rootEl);
+	const rootRect = rootEl.getBoundingClientRect();
+	const elRect = el.getBoundingClientRect();
+	const rootStyle = win.getComputedStyle(rootEl);
+	const elStyle = win.getComputedStyle(el);
+	const scrollPaddingTop = getNumericStyle(rootStyle.scrollPaddingBlockStart || rootStyle.scrollPaddingTop);
+	const scrollMarginTop = getNumericStyle(elStyle.scrollMarginBlockStart || elStyle.scrollMarginTop);
+	const top = elRect.top - rootRect.top + rootEl.scrollTop - scrollPaddingTop - scrollMarginTop;
+	rootEl.scrollTo({
+		top,
+		...behavior && { behavior }
+	});
+	return true;
+}
+const getNumericStyle = (value) => {
+	const numericValue = Number.parseFloat(value);
+	return Number.isNaN(numericValue) ? 0 : numericValue;
+};
+function getScrollPosition(element) {
+	if (isHTMLElement(element)) return {
+		scrollLeft: element.scrollLeft,
+		scrollTop: element.scrollTop
+	};
+	return {
+		scrollLeft: element.scrollX,
+		scrollTop: element.scrollY
+	};
+}
+//#endregion
+export { scrollIntoView as n, scrollToElement as r, getScrollPosition as t };

package/dist/scroll-Dyd1QLrc.cjs

@@ -0,0 +1,63 @@
+const require_dom_query = require("./dom-query-CQzY93XU.cjs");
+const require_overflow = require("./overflow-BBihfMxX.cjs");
+//#region src/common/dom-query/scroll.ts
+function isScrollable(el) {
+	return el.scrollHeight > el.clientHeight || el.scrollWidth > el.clientWidth;
+}
+function scrollIntoView(el, options) {
+	const { rootEl, ...scrollOptions } = options || {};
+	if (!el || !rootEl) return;
+	if (!require_overflow.isOverflowElement(rootEl) || !isScrollable(rootEl)) return;
+	el.scrollIntoView(scrollOptions);
+}
+function scrollToElement(el, options) {
+	const { rootEl, behavior } = options || {};
+	if (!el || !rootEl) return false;
+	if (!rootEl.contains(el)) return false;
+	const win = require_dom_query.getWindow(rootEl);
+	const rootRect = rootEl.getBoundingClientRect();
+	const elRect = el.getBoundingClientRect();
+	const rootStyle = win.getComputedStyle(rootEl);
+	const elStyle = win.getComputedStyle(el);
+	const scrollPaddingTop = getNumericStyle(rootStyle.scrollPaddingBlockStart || rootStyle.scrollPaddingTop);
+	const scrollMarginTop = getNumericStyle(elStyle.scrollMarginBlockStart || elStyle.scrollMarginTop);
+	const top = elRect.top - rootRect.top + rootEl.scrollTop - scrollPaddingTop - scrollMarginTop;
+	rootEl.scrollTo({
+		top,
+		...behavior && { behavior }
+	});
+	return true;
+}
+const getNumericStyle = (value) => {
+	const numericValue = Number.parseFloat(value);
+	return Number.isNaN(numericValue) ? 0 : numericValue;
+};
+function getScrollPosition(element) {
+	if (require_dom_query.isHTMLElement(element)) return {
+		scrollLeft: element.scrollLeft,
+		scrollTop: element.scrollTop
+	};
+	return {
+		scrollLeft: element.scrollX,
+		scrollTop: element.scrollY
+	};
+}
+//#endregion
+Object.defineProperty(exports, "getScrollPosition", {
+	enumerable: true,
+	get: function() {
+		return getScrollPosition;
+	}
+});
+Object.defineProperty(exports, "scrollIntoView", {
+	enumerable: true,
+	get: function() {
+		return scrollIntoView;
+	}
+});
+Object.defineProperty(exports, "scrollToElement", {
+	enumerable: true,
+	get: function() {
+		return scrollToElement;
+	}
+});

package/dist/scroll-snap-Cuaqdevf.cjs

@@ -0,0 +1,224 @@
+require("./dom-query-CQzY93XU.cjs");
+const require_computed_style = require("./computed-style-DLArEFNw.cjs");
+const require_scale = require("./scale-C7iiUGhS.cjs");
+//#region src/common/scroll-snap/index.ts
+const getDirection = (element) => require_computed_style.getComputedStyle(element).direction;
+const convert = (raw, size) => {
+	let n = parseFloat(raw);
+	if (/%/.test(raw)) {
+		n /= 100;
+		n *= size;
+	}
+	return Number.isNaN(n) ? 0 : n;
+};
+function getScrollPadding(element) {
+	const style = require_computed_style.getComputedStyle(element);
+	const layoutWidth = element.offsetWidth;
+	const layoutHeight = element.offsetHeight;
+	let xBeforeRaw = style.getPropertyValue("scroll-padding-left").replace("auto", "0px");
+	let yBeforeRaw = style.getPropertyValue("scroll-padding-top").replace("auto", "0px");
+	let xAfterRaw = style.getPropertyValue("scroll-padding-right").replace("auto", "0px");
+	let yAfterRaw = style.getPropertyValue("scroll-padding-bottom").replace("auto", "0px");
+	let xBefore = convert(xBeforeRaw, layoutWidth);
+	let yBefore = convert(yBeforeRaw, layoutHeight);
+	let xAfter = convert(xAfterRaw, layoutWidth);
+	let yAfter = convert(yAfterRaw, layoutHeight);
+	return {
+		x: {
+			before: xBefore,
+			after: xAfter
+		},
+		y: {
+			before: yBefore,
+			after: yAfter
+		}
+	};
+}
+function isRectIntersecting(a, b, axis = "both") {
+	return axis === "x" && a.right >= b.left && a.left <= b.right || axis === "y" && a.bottom >= b.top && a.top <= b.bottom || axis === "both" && a.right >= b.left && a.left <= b.right && a.bottom >= b.top && a.top <= b.bottom;
+}
+function getDescendants(parent) {
+	let children = [];
+	for (const child of parent.children) children = children.concat(child, getDescendants(child));
+	return children;
+}
+function getSnapPositions(parent, subtree = false) {
+	const parentRect = parent.getBoundingClientRect();
+	const isRtl = getDirection(parent) === "rtl";
+	const scale = require_scale.getScale(parent);
+	const positions = {
+		x: {
+			start: [],
+			center: [],
+			end: []
+		},
+		y: {
+			start: [],
+			center: [],
+			end: []
+		}
+	};
+	const children = subtree ? getDescendants(parent) : parent.children;
+	for (const axis of ["x", "y"]) {
+		const orthogonalAxis = axis === "x" ? "y" : "x";
+		const axisStart = axis === "x" ? "left" : "top";
+		const axisEnd = axis === "x" ? "right" : "bottom";
+		const axisSize = axis === "x" ? "width" : "height";
+		const axisScroll = axis === "x" ? "scrollLeft" : "scrollTop";
+		const axisScale = axis === "x" ? scale.x : scale.y;
+		const useRtlCalc = isRtl && axis === "x";
+		for (const child of children) {
+			const childRect = child.getBoundingClientRect();
+			if (!isRectIntersecting(parentRect, childRect, orthogonalAxis)) continue;
+			let [childAlignY, childAlignX] = require_computed_style.getComputedStyle(child).getPropertyValue("scroll-snap-align").split(" ");
+			if (typeof childAlignX === "undefined") childAlignX = childAlignY;
+			const childAlign = axis === "x" ? childAlignX : childAlignY;
+			let childOffsetStart;
+			let childOffsetEnd;
+			let childOffsetCenter;
+			if (useRtlCalc) {
+				const scrollOffset = Math.abs(parent[axisScroll]);
+				const rightOffset = (parentRect[axisEnd] - childRect[axisEnd]) / axisScale + scrollOffset;
+				childOffsetStart = rightOffset;
+				childOffsetEnd = rightOffset + childRect[axisSize] / axisScale;
+				childOffsetCenter = rightOffset + childRect[axisSize] / (2 * axisScale);
+			} else {
+				childOffsetStart = (childRect[axisStart] - parentRect[axisStart]) / axisScale + parent[axisScroll];
+				childOffsetEnd = childOffsetStart + childRect[axisSize] / axisScale;
+				childOffsetCenter = childOffsetStart + childRect[axisSize] / (2 * axisScale);
+			}
+			switch (childAlign) {
+				case "none": break;
+				case "start":
+					positions[axis].start.push({
+						node: child,
+						position: childOffsetStart
+					});
+					break;
+				case "center":
+					positions[axis].center.push({
+						node: child,
+						position: childOffsetCenter
+					});
+					break;
+				case "end":
+					positions[axis].end.push({
+						node: child,
+						position: childOffsetEnd
+					});
+					break;
+			}
+		}
+	}
+	return positions;
+}
+function getScrollSnapPositions(element) {
+	const dir = getDirection(element);
+	const scrollPadding = getScrollPadding(element);
+	const snapPositions = getSnapPositions(element);
+	const layoutWidth = element.offsetWidth;
+	const layoutHeight = element.offsetHeight;
+	const maxScroll = {
+		x: element.scrollWidth - element.offsetWidth,
+		y: element.scrollHeight - element.offsetHeight
+	};
+	const isRtl = dir === "rtl";
+	const usesNegativeScrollLeft = isRtl && element.scrollLeft <= 0;
+	let xPositions;
+	if (isRtl) {
+		xPositions = uniq([
+			...snapPositions.x.start.map((v) => v.position - scrollPadding.x.after),
+			...snapPositions.x.center.map((v) => v.position - layoutWidth / 2),
+			...snapPositions.x.end.map((v) => v.position - layoutWidth + scrollPadding.x.before)
+		].map(clamp(0, maxScroll.x)));
+		if (usesNegativeScrollLeft) xPositions = xPositions.map((pos) => -pos);
+	} else xPositions = uniq([
+		...snapPositions.x.start.map((v) => v.position - scrollPadding.x.before),
+		...snapPositions.x.center.map((v) => v.position - layoutWidth / 2),
+		...snapPositions.x.end.map((v) => v.position - layoutWidth + scrollPadding.x.after)
+	].map(clamp(0, maxScroll.x)));
+	return {
+		x: xPositions,
+		y: uniq([
+			...snapPositions.y.start.map((v) => v.position - scrollPadding.y.before),
+			...snapPositions.y.center.map((v) => v.position - layoutHeight / 2),
+			...snapPositions.y.end.map((v) => v.position - layoutHeight + scrollPadding.y.after)
+		].map(clamp(0, maxScroll.y)))
+	};
+}
+function findSnapPoint(parent, axis, predicate) {
+	const dir = getDirection(parent);
+	const scrollPadding = getScrollPadding(parent);
+	const snapPositions = getSnapPositions(parent);
+	const items = [
+		...snapPositions[axis].start,
+		...snapPositions[axis].center,
+		...snapPositions[axis].end
+	];
+	const isRtl = dir === "rtl";
+	const usesNegativeScrollLeft = isRtl && axis === "x" && parent.scrollLeft <= 0;
+	for (const item of items) if (predicate(item.node)) {
+		let position;
+		if (axis === "x" && isRtl) {
+			position = item.position - scrollPadding.x.after;
+			if (usesNegativeScrollLeft) position = -position;
+		} else position = item.position - (axis === "x" ? scrollPadding.x.before : scrollPadding.y.before);
+		return position;
+	}
+}
+function getSnapPointTarget(parent, snapPoint) {
+	const rect = parent.getBoundingClientRect();
+	const scale = require_scale.getScale(parent);
+	const scrollPadding = getScrollPadding(parent);
+	const children = Array.from(parent.children);
+	const layoutWidth = parent.offsetWidth;
+	const layoutHeight = parent.offsetHeight;
+	for (const child of children) {
+		const childRect = child.getBoundingClientRect();
+		const childOffsetStart = {
+			x: (childRect.left - rect.left) / scale.x + parent.scrollLeft,
+			y: (childRect.top - rect.top) / scale.y + parent.scrollTop
+		};
+		const childLayoutWidth = childRect.width / scale.x;
+		const childLayoutHeight = childRect.height / scale.y;
+		const matchesX = [
+			childOffsetStart.x - scrollPadding.x.before,
+			childOffsetStart.x + childLayoutWidth / 2 - layoutWidth / 2,
+			childOffsetStart.x + childLayoutWidth - layoutWidth + scrollPadding.x.after
+		].some((pos) => Math.abs(pos - snapPoint) < 1);
+		const matchesY = [
+			childOffsetStart.y - scrollPadding.y.before,
+			childOffsetStart.y + childLayoutHeight / 2 - layoutHeight / 2,
+			childOffsetStart.y + childLayoutHeight - layoutHeight + scrollPadding.y.after
+		].some((pos) => Math.abs(pos - snapPoint) < 1);
+		if (matchesX || matchesY) return child;
+	}
+	return children[0];
+}
+const uniq = (arr) => [...new Set(arr)];
+const clamp = (min, max) => (value) => Math.max(min, Math.min(max, value));
+//#endregion
+Object.defineProperty(exports, "findSnapPoint", {
+	enumerable: true,
+	get: function() {
+		return findSnapPoint;
+	}
+});
+Object.defineProperty(exports, "getScrollSnapPositions", {
+	enumerable: true,
+	get: function() {
+		return getScrollSnapPositions;
+	}
+});
+Object.defineProperty(exports, "getSnapPointTarget", {
+	enumerable: true,
+	get: function() {
+		return getSnapPointTarget;
+	}
+});
+Object.defineProperty(exports, "getSnapPositions", {
+	enumerable: true,
+	get: function() {
+		return getSnapPositions;
+	}
+});

package/dist/scroll-snap-DqMiFASa.js

@@ -0,0 +1,201 @@
+import "./dom-query-e7fh0TEH.js";
+import { t as getComputedStyle } from "./computed-style-B1MKlCoo.js";
+import { t as getScale } from "./scale-C5BBHVgH.js";
+//#region src/common/scroll-snap/index.ts
+const getDirection = (element) => getComputedStyle(element).direction;
+const convert = (raw, size) => {
+	let n = parseFloat(raw);
+	if (/%/.test(raw)) {
+		n /= 100;
+		n *= size;
+	}
+	return Number.isNaN(n) ? 0 : n;
+};
+function getScrollPadding(element) {
+	const style = getComputedStyle(element);
+	const layoutWidth = element.offsetWidth;
+	const layoutHeight = element.offsetHeight;
+	let xBeforeRaw = style.getPropertyValue("scroll-padding-left").replace("auto", "0px");
+	let yBeforeRaw = style.getPropertyValue("scroll-padding-top").replace("auto", "0px");
+	let xAfterRaw = style.getPropertyValue("scroll-padding-right").replace("auto", "0px");
+	let yAfterRaw = style.getPropertyValue("scroll-padding-bottom").replace("auto", "0px");
+	let xBefore = convert(xBeforeRaw, layoutWidth);
+	let yBefore = convert(yBeforeRaw, layoutHeight);
+	let xAfter = convert(xAfterRaw, layoutWidth);
+	let yAfter = convert(yAfterRaw, layoutHeight);
+	return {
+		x: {
+			before: xBefore,
+			after: xAfter
+		},
+		y: {
+			before: yBefore,
+			after: yAfter
+		}
+	};
+}
+function isRectIntersecting(a, b, axis = "both") {
+	return axis === "x" && a.right >= b.left && a.left <= b.right || axis === "y" && a.bottom >= b.top && a.top <= b.bottom || axis === "both" && a.right >= b.left && a.left <= b.right && a.bottom >= b.top && a.top <= b.bottom;
+}
+function getDescendants(parent) {
+	let children = [];
+	for (const child of parent.children) children = children.concat(child, getDescendants(child));
+	return children;
+}
+function getSnapPositions(parent, subtree = false) {
+	const parentRect = parent.getBoundingClientRect();
+	const isRtl = getDirection(parent) === "rtl";
+	const scale = getScale(parent);
+	const positions = {
+		x: {
+			start: [],
+			center: [],
+			end: []
+		},
+		y: {
+			start: [],
+			center: [],
+			end: []
+		}
+	};
+	const children = subtree ? getDescendants(parent) : parent.children;
+	for (const axis of ["x", "y"]) {
+		const orthogonalAxis = axis === "x" ? "y" : "x";
+		const axisStart = axis === "x" ? "left" : "top";
+		const axisEnd = axis === "x" ? "right" : "bottom";
+		const axisSize = axis === "x" ? "width" : "height";
+		const axisScroll = axis === "x" ? "scrollLeft" : "scrollTop";
+		const axisScale = axis === "x" ? scale.x : scale.y;
+		const useRtlCalc = isRtl && axis === "x";
+		for (const child of children) {
+			const childRect = child.getBoundingClientRect();
+			if (!isRectIntersecting(parentRect, childRect, orthogonalAxis)) continue;
+			let [childAlignY, childAlignX] = getComputedStyle(child).getPropertyValue("scroll-snap-align").split(" ");
+			if (typeof childAlignX === "undefined") childAlignX = childAlignY;
+			const childAlign = axis === "x" ? childAlignX : childAlignY;
+			let childOffsetStart;
+			let childOffsetEnd;
+			let childOffsetCenter;
+			if (useRtlCalc) {
+				const scrollOffset = Math.abs(parent[axisScroll]);
+				const rightOffset = (parentRect[axisEnd] - childRect[axisEnd]) / axisScale + scrollOffset;
+				childOffsetStart = rightOffset;
+				childOffsetEnd = rightOffset + childRect[axisSize] / axisScale;
+				childOffsetCenter = rightOffset + childRect[axisSize] / (2 * axisScale);
+			} else {
+				childOffsetStart = (childRect[axisStart] - parentRect[axisStart]) / axisScale + parent[axisScroll];
+				childOffsetEnd = childOffsetStart + childRect[axisSize] / axisScale;
+				childOffsetCenter = childOffsetStart + childRect[axisSize] / (2 * axisScale);
+			}
+			switch (childAlign) {
+				case "none": break;
+				case "start":
+					positions[axis].start.push({
+						node: child,
+						position: childOffsetStart
+					});
+					break;
+				case "center":
+					positions[axis].center.push({
+						node: child,
+						position: childOffsetCenter
+					});
+					break;
+				case "end":
+					positions[axis].end.push({
+						node: child,
+						position: childOffsetEnd
+					});
+					break;
+			}
+		}
+	}
+	return positions;
+}
+function getScrollSnapPositions(element) {
+	const dir = getDirection(element);
+	const scrollPadding = getScrollPadding(element);
+	const snapPositions = getSnapPositions(element);
+	const layoutWidth = element.offsetWidth;
+	const layoutHeight = element.offsetHeight;
+	const maxScroll = {
+		x: element.scrollWidth - element.offsetWidth,
+		y: element.scrollHeight - element.offsetHeight
+	};
+	const isRtl = dir === "rtl";
+	const usesNegativeScrollLeft = isRtl && element.scrollLeft <= 0;
+	let xPositions;
+	if (isRtl) {
+		xPositions = uniq([
+			...snapPositions.x.start.map((v) => v.position - scrollPadding.x.after),
+			...snapPositions.x.center.map((v) => v.position - layoutWidth / 2),
+			...snapPositions.x.end.map((v) => v.position - layoutWidth + scrollPadding.x.before)
+		].map(clamp(0, maxScroll.x)));
+		if (usesNegativeScrollLeft) xPositions = xPositions.map((pos) => -pos);
+	} else xPositions = uniq([
+		...snapPositions.x.start.map((v) => v.position - scrollPadding.x.before),
+		...snapPositions.x.center.map((v) => v.position - layoutWidth / 2),
+		...snapPositions.x.end.map((v) => v.position - layoutWidth + scrollPadding.x.after)
+	].map(clamp(0, maxScroll.x)));
+	return {
+		x: xPositions,
+		y: uniq([
+			...snapPositions.y.start.map((v) => v.position - scrollPadding.y.before),
+			...snapPositions.y.center.map((v) => v.position - layoutHeight / 2),
+			...snapPositions.y.end.map((v) => v.position - layoutHeight + scrollPadding.y.after)
+		].map(clamp(0, maxScroll.y)))
+	};
+}
+function findSnapPoint(parent, axis, predicate) {
+	const dir = getDirection(parent);
+	const scrollPadding = getScrollPadding(parent);
+	const snapPositions = getSnapPositions(parent);
+	const items = [
+		...snapPositions[axis].start,
+		...snapPositions[axis].center,
+		...snapPositions[axis].end
+	];
+	const isRtl = dir === "rtl";
+	const usesNegativeScrollLeft = isRtl && axis === "x" && parent.scrollLeft <= 0;
+	for (const item of items) if (predicate(item.node)) {
+		let position;
+		if (axis === "x" && isRtl) {
+			position = item.position - scrollPadding.x.after;
+			if (usesNegativeScrollLeft) position = -position;
+		} else position = item.position - (axis === "x" ? scrollPadding.x.before : scrollPadding.y.before);
+		return position;
+	}
+}
+function getSnapPointTarget(parent, snapPoint) {
+	const rect = parent.getBoundingClientRect();
+	const scale = getScale(parent);
+	const scrollPadding = getScrollPadding(parent);
+	const children = Array.from(parent.children);
+	const layoutWidth = parent.offsetWidth;
+	const layoutHeight = parent.offsetHeight;
+	for (const child of children) {
+		const childRect = child.getBoundingClientRect();
+		const childOffsetStart = {
+			x: (childRect.left - rect.left) / scale.x + parent.scrollLeft,
+			y: (childRect.top - rect.top) / scale.y + parent.scrollTop
+		};
+		const childLayoutWidth = childRect.width / scale.x;
+		const childLayoutHeight = childRect.height / scale.y;
+		const matchesX = [
+			childOffsetStart.x - scrollPadding.x.before,
+			childOffsetStart.x + childLayoutWidth / 2 - layoutWidth / 2,
+			childOffsetStart.x + childLayoutWidth - layoutWidth + scrollPadding.x.after
+		].some((pos) => Math.abs(pos - snapPoint) < 1);
+		const matchesY = [
+			childOffsetStart.y - scrollPadding.y.before,
+			childOffsetStart.y + childLayoutHeight / 2 - layoutHeight / 2,
+			childOffsetStart.y + childLayoutHeight - layoutHeight + scrollPadding.y.after
+		].some((pos) => Math.abs(pos - snapPoint) < 1);
+		if (matchesX || matchesY) return child;
+	}
+	return children[0];
+}
+const uniq = (arr) => [...new Set(arr)];
+const clamp = (min, max) => (value) => Math.max(min, Math.min(max, value));
+//#endregion
+export { getSnapPositions as i, getScrollSnapPositions as n, getSnapPointTarget as r, findSnapPoint as t };

package/dist/scroll-snap.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_scroll_snap = require("./scroll-snap-Cuaqdevf.cjs");
+exports.findSnapPoint = require_scroll_snap.findSnapPoint;
+exports.getScrollSnapPositions = require_scroll_snap.getScrollSnapPositions;
+exports.getSnapPointTarget = require_scroll_snap.getSnapPointTarget;
+exports.getSnapPositions = require_scroll_snap.getSnapPositions;