@zag-js/rect-utils 1.34.0 → 1.35.0

package/dist/clamp.mjs

@@ -0,0 +1,27 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/clamp.ts
+var clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+var clampPoint = (position, size, boundaryRect) => {
+  const x = clamp(position.x, boundaryRect.x, boundaryRect.x + boundaryRect.width - size.width);
+  const y = clamp(position.y, boundaryRect.y, boundaryRect.y + boundaryRect.height - size.height);
+  return { x, y };
+};
+var defaultMinSize = {
+  width: 0,
+  height: 0
+};
+var defaultMaxSize = {
+  width: Infinity,
+  height: Infinity
+};
+var clampSize = (size, minSize = defaultMinSize, maxSize = defaultMaxSize) => {
+  return {
+    width: Math.min(Math.max(size.width, minSize.width), maxSize.width),
+    height: Math.min(Math.max(size.height, minSize.height), maxSize.height)
+  };
+};
+export {
+  clampPoint,
+  clampSize
+};

package/dist/closest.d.mts

@@ -0,0 +1,7 @@
+import { Point, Rect, RectSide } from './types.mjs';
+
+declare function closest(...pts: Point[]): (a: Point) => Point;
+declare function closestSideToRect(ref: Rect, r: Rect): RectSide;
+declare function closestSideToPoint(ref: Rect, p: Point): RectSide;
+
+export { closest, closestSideToPoint, closestSideToRect };

package/dist/closest.d.ts

@@ -0,0 +1,7 @@
+import { Point, Rect, RectSide } from './types.js';
+
+declare function closest(...pts: Point[]): (a: Point) => Point;
+declare function closestSideToRect(ref: Rect, r: Rect): RectSide;
+declare function closestSideToPoint(ref: Rect, p: Point): RectSide;
+
+export { closest, closestSideToPoint, closestSideToRect };

package/dist/closest.js

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/closest.ts
+var closest_exports = {};
+__export(closest_exports, {
+  closest: () => closest,
+  closestSideToPoint: () => closestSideToPoint,
+  closestSideToRect: () => closestSideToRect
+});
+module.exports = __toCommonJS(closest_exports);
+var import_distance = require("./distance.cjs");
+function closest(...pts) {
+  return (a) => {
+    const ds = pts.map((b) => (0, import_distance.distance)(b, a));
+    const c = Math.min.apply(Math, ds);
+    return pts[ds.indexOf(c)];
+  };
+}
+function closestSideToRect(ref, r) {
+  if (r.maxX <= ref.minX) return "left";
+  if (r.minX >= ref.maxX) return "right";
+  if (r.maxY <= ref.minY) return "top";
+  if (r.minY >= ref.maxY) return "bottom";
+  return "left";
+}
+function closestSideToPoint(ref, p) {
+  const { x, y } = p;
+  const dl = x - ref.minX;
+  const dr = ref.maxX - x;
+  const dt = y - ref.minY;
+  const db = ref.maxY - y;
+  let closest2 = dl;
+  let side = "left";
+  if (dr < closest2) {
+    closest2 = dr;
+    side = "right";
+  }
+  if (dt < closest2) {
+    closest2 = dt;
+    side = "top";
+  }
+  if (db < closest2) {
+    side = "bottom";
+  }
+  return side;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  closest,
+  closestSideToPoint,
+  closestSideToRect
+});

package/dist/closest.mjs

@@ -0,0 +1,44 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/closest.ts
+import { distance } from "./distance.mjs";
+function closest(...pts) {
+  return (a) => {
+    const ds = pts.map((b) => distance(b, a));
+    const c = Math.min.apply(Math, ds);
+    return pts[ds.indexOf(c)];
+  };
+}
+function closestSideToRect(ref, r) {
+  if (r.maxX <= ref.minX) return "left";
+  if (r.minX >= ref.maxX) return "right";
+  if (r.maxY <= ref.minY) return "top";
+  if (r.minY >= ref.maxY) return "bottom";
+  return "left";
+}
+function closestSideToPoint(ref, p) {
+  const { x, y } = p;
+  const dl = x - ref.minX;
+  const dr = ref.maxX - x;
+  const dt = y - ref.minY;
+  const db = ref.maxY - y;
+  let closest2 = dl;
+  let side = "left";
+  if (dr < closest2) {
+    closest2 = dr;
+    side = "right";
+  }
+  if (dt < closest2) {
+    closest2 = dt;
+    side = "top";
+  }
+  if (db < closest2) {
+    side = "bottom";
+  }
+  return side;
+}
+export {
+  closest,
+  closestSideToPoint,
+  closestSideToRect
+};

package/dist/compass.d.mts

@@ -0,0 +1,7 @@
+import { Point } from './types.mjs';
+
+type CompassDirection = "n" | "ne" | "e" | "se" | "s" | "sw" | "w" | "nw";
+declare const compassDirectionMap: Record<CompassDirection, Point>;
+declare const oppositeDirectionMap: Record<CompassDirection, CompassDirection>;
+
+export { type CompassDirection, compassDirectionMap, oppositeDirectionMap };

package/dist/compass.d.ts

@@ -0,0 +1,7 @@
+import { Point } from './types.js';
+
+type CompassDirection = "n" | "ne" | "e" | "se" | "s" | "sw" | "w" | "nw";
+declare const compassDirectionMap: Record<CompassDirection, Point>;
+declare const oppositeDirectionMap: Record<CompassDirection, CompassDirection>;
+
+export { type CompassDirection, compassDirectionMap, oppositeDirectionMap };

package/dist/compass.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/compass.ts
+var compass_exports = {};
+__export(compass_exports, {
+  compassDirectionMap: () => compassDirectionMap,
+  oppositeDirectionMap: () => oppositeDirectionMap
+});
+module.exports = __toCommonJS(compass_exports);
+var compassDirectionMap = {
+  n: { x: 0.5, y: 0 },
+  ne: { x: 1, y: 0 },
+  e: { x: 1, y: 0.5 },
+  se: { x: 1, y: 1 },
+  s: { x: 0.5, y: 1 },
+  sw: { x: 0, y: 1 },
+  w: { x: 0, y: 0.5 },
+  nw: { x: 0, y: 0 }
+};
+var oppositeDirectionMap = {
+  n: "s",
+  ne: "sw",
+  e: "w",
+  se: "nw",
+  s: "n",
+  sw: "ne",
+  w: "e",
+  nw: "se"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compassDirectionMap,
+  oppositeDirectionMap
+});

package/dist/compass.mjs

@@ -0,0 +1,27 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/compass.ts
+var compassDirectionMap = {
+  n: { x: 0.5, y: 0 },
+  ne: { x: 1, y: 0 },
+  e: { x: 1, y: 0.5 },
+  se: { x: 1, y: 1 },
+  s: { x: 0.5, y: 1 },
+  sw: { x: 0, y: 1 },
+  w: { x: 0, y: 0.5 },
+  nw: { x: 0, y: 0 }
+};
+var oppositeDirectionMap = {
+  n: "s",
+  ne: "sw",
+  e: "w",
+  se: "nw",
+  s: "n",
+  sw: "ne",
+  w: "e",
+  nw: "se"
+};
+export {
+  compassDirectionMap,
+  oppositeDirectionMap
+};

package/dist/constrain.d.mts

@@ -0,0 +1,5 @@
+import { RectInit } from './types.mjs';
+
+declare const constrainRect: (rect: RectInit, boundary: RectInit) => RectInit;
+
+export { constrainRect };

package/dist/constrain.d.ts

@@ -0,0 +1,5 @@
+import { RectInit } from './types.js';
+
+declare const constrainRect: (rect: RectInit, boundary: RectInit) => RectInit;
+
+export { constrainRect };

package/dist/constrain.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/constrain.ts
+var constrain_exports = {};
+__export(constrain_exports, {
+  constrainRect: () => constrainRect
+});
+module.exports = __toCommonJS(constrain_exports);
+var constrainRect = (rect, boundary) => {
+  const left = Math.max(boundary.x, Math.min(rect.x, boundary.x + boundary.width - rect.width));
+  const top = Math.max(boundary.y, Math.min(rect.y, boundary.y + boundary.height - rect.height));
+  return {
+    x: left,
+    y: top,
+    width: Math.min(rect.width, boundary.width),
+    height: Math.min(rect.height, boundary.height)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  constrainRect
+});

package/dist/constrain.mjs

@@ -0,0 +1,16 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/constrain.ts
+var constrainRect = (rect, boundary) => {
+  const left = Math.max(boundary.x, Math.min(rect.x, boundary.x + boundary.width - rect.width));
+  const top = Math.max(boundary.y, Math.min(rect.y, boundary.y + boundary.height - rect.height));
+  return {
+    x: left,
+    y: top,
+    width: Math.min(rect.width, boundary.width),
+    height: Math.min(rect.height, boundary.height)
+  };
+};
+export {
+  constrainRect
+};

package/dist/contains.d.mts

@@ -0,0 +1,7 @@
+import { Rect, Point } from './types.mjs';
+
+declare function containsPoint(r: Rect, p: Point): boolean;
+declare function containsRect(a: Rect, b: Rect): boolean;
+declare function contains(r: Rect, v: Rect | Point): boolean;
+
+export { contains, containsPoint, containsRect };

package/dist/contains.d.ts

@@ -0,0 +1,7 @@
+import { Rect, Point } from './types.js';
+
+declare function containsPoint(r: Rect, p: Point): boolean;
+declare function containsRect(a: Rect, b: Rect): boolean;
+declare function contains(r: Rect, v: Rect | Point): boolean;
+
+export { contains, containsPoint, containsRect };

package/dist/contains.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/contains.ts
+var contains_exports = {};
+__export(contains_exports, {
+  contains: () => contains,
+  containsPoint: () => containsPoint,
+  containsRect: () => containsRect
+});
+module.exports = __toCommonJS(contains_exports);
+var import_rect = require("./rect.cjs");
+function containsPoint(r, p) {
+  return r.minX <= p.x && p.x <= r.maxX && r.minY <= p.y && p.y <= r.maxY;
+}
+function containsRect(a, b) {
+  return Object.values((0, import_rect.getRectCorners)(b)).every((c) => containsPoint(a, c));
+}
+function contains(r, v) {
+  return (0, import_rect.isRect)(v) ? containsRect(r, v) : containsPoint(r, v);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  contains,
+  containsPoint,
+  containsRect
+});

package/dist/contains.mjs

@@ -0,0 +1,18 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/contains.ts
+import { getRectCorners, isRect } from "./rect.mjs";
+function containsPoint(r, p) {
+  return r.minX <= p.x && p.x <= r.maxX && r.minY <= p.y && p.y <= r.maxY;
+}
+function containsRect(a, b) {
+  return Object.values(getRectCorners(b)).every((c) => containsPoint(a, c));
+}
+function contains(r, v) {
+  return isRect(v) ? containsRect(r, v) : containsPoint(r, v);
+}
+export {
+  contains,
+  containsPoint,
+  containsRect
+};

package/dist/distance.d.mts

@@ -0,0 +1,11 @@
+import { Point, Rect, RectSide } from './types.mjs';
+
+interface DistanceValue extends Point {
+    value: number;
+}
+declare function distance(a: Point, b?: Point): number;
+declare function distanceFromPoint(r: Rect, p: Point): DistanceValue;
+declare function distanceFromRect(a: Rect, b: Rect): DistanceValue;
+declare function distanceBtwEdges(a: Rect, b: Rect): Record<RectSide, number>;
+
+export { type DistanceValue, distance, distanceBtwEdges, distanceFromPoint, distanceFromRect };

package/dist/distance.d.ts

@@ -0,0 +1,11 @@
+import { Point, Rect, RectSide } from './types.js';
+
+interface DistanceValue extends Point {
+    value: number;
+}
+declare function distance(a: Point, b?: Point): number;
+declare function distanceFromPoint(r: Rect, p: Point): DistanceValue;
+declare function distanceFromRect(a: Rect, b: Rect): DistanceValue;
+declare function distanceBtwEdges(a: Rect, b: Rect): Record<RectSide, number>;
+
+export { type DistanceValue, distance, distanceBtwEdges, distanceFromPoint, distanceFromRect };

package/dist/distance.js

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/distance.ts
+var distance_exports = {};
+__export(distance_exports, {
+  distance: () => distance,
+  distanceBtwEdges: () => distanceBtwEdges,
+  distanceFromPoint: () => distanceFromPoint,
+  distanceFromRect: () => distanceFromRect
+});
+module.exports = __toCommonJS(distance_exports);
+var import_intersection = require("./intersection.cjs");
+function distance(a, b = { x: 0, y: 0 }) {
+  return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2));
+}
+function distanceFromPoint(r, p) {
+  let x = 0;
+  let y = 0;
+  if (p.x < r.x) x = r.x - p.x;
+  else if (p.x > r.maxX) x = p.x - r.maxX;
+  if (p.y < r.y) y = r.y - p.y;
+  else if (p.y > r.maxY) y = p.y - r.maxY;
+  return { x, y, value: distance({ x, y }) };
+}
+function distanceFromRect(a, b) {
+  if ((0, import_intersection.intersects)(a, b)) return { x: 0, y: 0, value: 0 };
+  const left = a.x < b.x ? a : b;
+  const right = b.x < a.x ? a : b;
+  const upper = a.y < b.y ? a : b;
+  const lower = b.y < a.y ? a : b;
+  let x = left.x === right.x ? 0 : right.x - left.maxX;
+  x = Math.max(0, x);
+  let y = upper.y === lower.y ? 0 : lower.y - upper.maxY;
+  y = Math.max(0, y);
+  return { x, y, value: distance({ x, y }) };
+}
+function distanceBtwEdges(a, b) {
+  return {
+    left: b.x - a.x,
+    top: b.y - a.y,
+    right: a.maxX - b.maxX,
+    bottom: a.maxY - b.maxY
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  distance,
+  distanceBtwEdges,
+  distanceFromPoint,
+  distanceFromRect
+});

package/dist/distance.mjs

@@ -0,0 +1,42 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/distance.ts
+import { intersects } from "./intersection.mjs";
+function distance(a, b = { x: 0, y: 0 }) {
+  return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2));
+}
+function distanceFromPoint(r, p) {
+  let x = 0;
+  let y = 0;
+  if (p.x < r.x) x = r.x - p.x;
+  else if (p.x > r.maxX) x = p.x - r.maxX;
+  if (p.y < r.y) y = r.y - p.y;
+  else if (p.y > r.maxY) y = p.y - r.maxY;
+  return { x, y, value: distance({ x, y }) };
+}
+function distanceFromRect(a, b) {
+  if (intersects(a, b)) return { x: 0, y: 0, value: 0 };
+  const left = a.x < b.x ? a : b;
+  const right = b.x < a.x ? a : b;
+  const upper = a.y < b.y ? a : b;
+  const lower = b.y < a.y ? a : b;
+  let x = left.x === right.x ? 0 : right.x - left.maxX;
+  x = Math.max(0, x);
+  let y = upper.y === lower.y ? 0 : lower.y - upper.maxY;
+  y = Math.max(0, y);
+  return { x, y, value: distance({ x, y }) };
+}
+function distanceBtwEdges(a, b) {
+  return {
+    left: b.x - a.x,
+    top: b.y - a.y,
+    right: a.maxX - b.maxX,
+    bottom: a.maxY - b.maxY
+  };
+}
+export {
+  distance,
+  distanceBtwEdges,
+  distanceFromPoint,
+  distanceFromRect
+};

package/dist/equality.d.mts

@@ -0,0 +1,7 @@
+import { Point, RectInit, Size } from './types.mjs';
+
+declare const isSizeEqual: (a: Size, b: Size | undefined) => boolean;
+declare const isPointEqual: (a: Point, b: Point | undefined) => boolean;
+declare const isRectEqual: (a: RectInit, b: RectInit | undefined) => boolean;
+
+export { isPointEqual, isRectEqual, isSizeEqual };

package/dist/equality.d.ts

@@ -0,0 +1,7 @@
+import { Point, RectInit, Size } from './types.js';
+
+declare const isSizeEqual: (a: Size, b: Size | undefined) => boolean;
+declare const isPointEqual: (a: Point, b: Point | undefined) => boolean;
+declare const isRectEqual: (a: RectInit, b: RectInit | undefined) => boolean;
+
+export { isPointEqual, isRectEqual, isSizeEqual };

package/dist/equality.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/equality.ts
+var equality_exports = {};
+__export(equality_exports, {
+  isPointEqual: () => isPointEqual,
+  isRectEqual: () => isRectEqual,
+  isSizeEqual: () => isSizeEqual
+});
+module.exports = __toCommonJS(equality_exports);
+var isSizeEqual = (a, b) => {
+  return a.width === b?.width && a.height === b?.height;
+};
+var isPointEqual = (a, b) => {
+  return a.x === b?.x && a.y === b?.y;
+};
+var isRectEqual = (a, b) => {
+  return isPointEqual(a, b) && isSizeEqual(a, b);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPointEqual,
+  isRectEqual,
+  isSizeEqual
+});

package/dist/equality.mjs

@@ -0,0 +1,17 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/equality.ts
+var isSizeEqual = (a, b) => {
+  return a.width === b?.width && a.height === b?.height;
+};
+var isPointEqual = (a, b) => {
+  return a.x === b?.x && a.y === b?.y;
+};
+var isRectEqual = (a, b) => {
+  return isPointEqual(a, b) && isSizeEqual(a, b);
+};
+export {
+  isPointEqual,
+  isRectEqual,
+  isSizeEqual
+};

package/dist/from-element.d.mts

@@ -0,0 +1,15 @@
+import { Rect } from './types.mjs';
+
+declare function getElementRect(el: HTMLElement, opts?: ElementRectOptions): Rect;
+type ElementRectOptions = {
+    /**
+     * Whether to exclude the element's scrollbar size from the calculation.
+     */
+    excludeScrollbar?: boolean | undefined;
+    /**
+     * Whether to exclude the element's borders from the calculation.
+     */
+    excludeBorders?: boolean | undefined;
+};
+
+export { type ElementRectOptions, getElementRect };

package/dist/from-element.d.ts

@@ -0,0 +1,15 @@
+import { Rect } from './types.js';
+
+declare function getElementRect(el: HTMLElement, opts?: ElementRectOptions): Rect;
+type ElementRectOptions = {
+    /**
+     * Whether to exclude the element's scrollbar size from the calculation.
+     */
+    excludeScrollbar?: boolean | undefined;
+    /**
+     * Whether to exclude the element's borders from the calculation.
+     */
+    excludeBorders?: boolean | undefined;
+};
+
+export { type ElementRectOptions, getElementRect };