@sprawlify/primitives 0.0.1

package/dist/rect-utils-0ellN0a_.mjs

@@ -0,0 +1,854 @@
+import { t as _defineProperty } from "./defineProperty-DrXfyjd4.mjs";
+
+//#region src/shared/rect-utils/affine-transform.ts
+var AffineTransform = class AffineTransform {
+	constructor([m00, m01, m02, m10, m11, m12] = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	]) {
+		_defineProperty(this, "m00", void 0);
+		_defineProperty(this, "m01", void 0);
+		_defineProperty(this, "m02", void 0);
+		_defineProperty(this, "m10", void 0);
+		_defineProperty(this, "m11", void 0);
+		_defineProperty(this, "m12", void 0);
+		_defineProperty(this, "rotate", (...args) => {
+			return this.prepend(AffineTransform.rotate(...args));
+		});
+		_defineProperty(this, "scale", (...args) => {
+			return this.prepend(AffineTransform.scale(...args));
+		});
+		_defineProperty(this, "translate", (...args) => {
+			return this.prepend(AffineTransform.translate(...args));
+		});
+		this.m00 = m00;
+		this.m01 = m01;
+		this.m02 = m02;
+		this.m10 = m10;
+		this.m11 = m11;
+		this.m12 = m12;
+	}
+	applyTo(point) {
+		const { x, y } = point;
+		const { m00, m01, m02, m10, m11, m12 } = this;
+		return {
+			x: m00 * x + m01 * y + m02,
+			y: m10 * x + m11 * y + m12
+		};
+	}
+	prepend(other) {
+		return new AffineTransform([
+			this.m00 * other.m00 + this.m01 * other.m10,
+			this.m00 * other.m01 + this.m01 * other.m11,
+			this.m00 * other.m02 + this.m01 * other.m12 + this.m02,
+			this.m10 * other.m00 + this.m11 * other.m10,
+			this.m10 * other.m01 + this.m11 * other.m11,
+			this.m10 * other.m02 + this.m11 * other.m12 + this.m12
+		]);
+	}
+	append(other) {
+		return new AffineTransform([
+			other.m00 * this.m00 + other.m01 * this.m10,
+			other.m00 * this.m01 + other.m01 * this.m11,
+			other.m00 * this.m02 + other.m01 * this.m12 + other.m02,
+			other.m10 * this.m00 + other.m11 * this.m10,
+			other.m10 * this.m01 + other.m11 * this.m11,
+			other.m10 * this.m02 + other.m11 * this.m12 + other.m12
+		]);
+	}
+	get determinant() {
+		return this.m00 * this.m11 - this.m01 * this.m10;
+	}
+	get isInvertible() {
+		const det = this.determinant;
+		return isFinite(det) && isFinite(this.m02) && isFinite(this.m12) && det !== 0;
+	}
+	invert() {
+		const det = this.determinant;
+		return new AffineTransform([
+			this.m11 / det,
+			-this.m01 / det,
+			(this.m01 * this.m12 - this.m11 * this.m02) / det,
+			-this.m10 / det,
+			this.m00 / det,
+			(this.m10 * this.m02 - this.m00 * this.m12) / det
+		]);
+	}
+	get array() {
+		return [
+			this.m00,
+			this.m01,
+			this.m02,
+			this.m10,
+			this.m11,
+			this.m12,
+			0,
+			0,
+			1
+		];
+	}
+	get float32Array() {
+		return new Float32Array(this.array);
+	}
+	static get identity() {
+		return new AffineTransform([
+			1,
+			0,
+			0,
+			0,
+			1,
+			0
+		]);
+	}
+	static rotate(theta, origin) {
+		const rotation = new AffineTransform([
+			Math.cos(theta),
+			-Math.sin(theta),
+			0,
+			Math.sin(theta),
+			Math.cos(theta),
+			0
+		]);
+		if (origin && (origin.x !== 0 || origin.y !== 0)) return AffineTransform.multiply(AffineTransform.translate(origin.x, origin.y), rotation, AffineTransform.translate(-origin.x, -origin.y));
+		return rotation;
+	}
+	static scale(sx, sy = sx, origin = {
+		x: 0,
+		y: 0
+	}) {
+		const scale = new AffineTransform([
+			sx,
+			0,
+			0,
+			0,
+			sy,
+			0
+		]);
+		if (origin.x !== 0 || origin.y !== 0) return AffineTransform.multiply(AffineTransform.translate(origin.x, origin.y), scale, AffineTransform.translate(-origin.x, -origin.y));
+		return scale;
+	}
+	static translate(tx, ty) {
+		return new AffineTransform([
+			1,
+			0,
+			tx,
+			0,
+			1,
+			ty
+		]);
+	}
+	static multiply(...[first, ...rest]) {
+		if (!first) return AffineTransform.identity;
+		return rest.reduce((result, item) => result.prepend(item), first);
+	}
+	get a() {
+		return this.m00;
+	}
+	get b() {
+		return this.m10;
+	}
+	get c() {
+		return this.m01;
+	}
+	get d() {
+		return this.m11;
+	}
+	get tx() {
+		return this.m02;
+	}
+	get ty() {
+		return this.m12;
+	}
+	get scaleComponents() {
+		return {
+			x: this.a,
+			y: this.d
+		};
+	}
+	get translationComponents() {
+		return {
+			x: this.tx,
+			y: this.ty
+		};
+	}
+	get skewComponents() {
+		return {
+			x: this.c,
+			y: this.b
+		};
+	}
+	toString() {
+		return `matrix(${this.a}, ${this.b}, ${this.c}, ${this.d}, ${this.tx}, ${this.ty})`;
+	}
+};
+
+//#endregion
+//#region src/shared/rect-utils/align.ts
+function hAlign(a, ref, h) {
+	let x = ref.minX;
+	if (h === "left-inside") x = ref.minX;
+	if (h === "left-outside") x = ref.minX - ref.width;
+	if (h === "right-inside") x = ref.maxX - ref.width;
+	if (h === "right-outside") x = ref.maxX;
+	if (h === "center") x = ref.midX - ref.width / 2;
+	return {
+		...a,
+		x
+	};
+}
+function vAlign(a, ref, v) {
+	let y = ref.minY;
+	if (v === "top-inside") y = ref.minY;
+	if (v === "top-outside") y = ref.minY - a.height;
+	if (v === "bottom-inside") y = ref.maxY - a.height;
+	if (v === "bottom-outside") y = ref.maxY;
+	if (v === "center") y = ref.midY - a.height / 2;
+	return {
+		...a,
+		y
+	};
+}
+function alignRect(a, ref, options) {
+	const { h, v } = options;
+	return vAlign(hAlign(a, ref, h), ref, v);
+}
+
+//#endregion
+//#region src/shared/rect-utils/angle.ts
+function getPointAngle(rect, point, reference = rect.center) {
+	const x = point.x - reference.x;
+	const y = point.y - reference.y;
+	return 360 - (Math.atan2(x, y) * (180 / Math.PI) + 180);
+}
+
+//#endregion
+//#region src/shared/rect-utils/clamp.ts
+const clamp = (value, min$2, max$1) => Math.min(Math.max(value, min$2), max$1);
+const clampPoint = (position, size, boundaryRect) => {
+	return {
+		x: clamp(position.x, boundaryRect.x, boundaryRect.x + boundaryRect.width - size.width),
+		y: clamp(position.y, boundaryRect.y, boundaryRect.y + boundaryRect.height - size.height)
+	};
+};
+const defaultMinSize = {
+	width: 0,
+	height: 0
+};
+const defaultMaxSize = {
+	width: Infinity,
+	height: Infinity
+};
+const 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)
+	};
+};
+
+//#endregion
+//#region src/shared/rect-utils/rect.ts
+const createPoint = (x, y) => ({
+	x,
+	y
+});
+const subtractPoints = (a, b) => {
+	if (!b) return a;
+	return createPoint(a.x - b.x, a.y - b.y);
+};
+const addPoints = (a, b) => createPoint(a.x + b.x, a.y + b.y);
+function isPoint(v) {
+	return Reflect.has(v, "x") && Reflect.has(v, "y");
+}
+function createRect(r) {
+	const { x, y, width, height } = r;
+	const midX = x + width / 2;
+	const midY = y + height / 2;
+	return {
+		x,
+		y,
+		width,
+		height,
+		minX: x,
+		minY: y,
+		maxX: x + width,
+		maxY: y + height,
+		midX,
+		midY,
+		center: createPoint(midX, midY)
+	};
+}
+function isRect(v) {
+	return Reflect.has(v, "x") && Reflect.has(v, "y") && Reflect.has(v, "width") && Reflect.has(v, "height");
+}
+function getRectCenters(v) {
+	return {
+		top: createPoint(v.midX, v.minY),
+		right: createPoint(v.maxX, v.midY),
+		bottom: createPoint(v.midX, v.maxY),
+		left: createPoint(v.minX, v.midY)
+	};
+}
+function getRectCorners(v) {
+	return {
+		top: createPoint(v.minX, v.minY),
+		right: createPoint(v.maxX, v.minY),
+		bottom: createPoint(v.maxX, v.maxY),
+		left: createPoint(v.minX, v.maxY)
+	};
+}
+function getRectEdges(v) {
+	const c = getRectCorners(v);
+	return {
+		top: [c.top, c.right],
+		right: [c.right, c.bottom],
+		bottom: [c.left, c.bottom],
+		left: [c.top, c.left]
+	};
+}
+
+//#endregion
+//#region src/shared/rect-utils/intersection.ts
+function intersects(a, b) {
+	return a.x < b.maxX && a.y < b.maxY && a.maxX > b.x && a.maxY > b.y;
+}
+function intersection(a, b) {
+	const x = Math.max(a.x, b.x);
+	const y = Math.max(a.y, b.y);
+	const x2 = Math.min(a.x + a.width, b.x + b.width);
+	const y2 = Math.min(a.y + a.height, b.y + b.height);
+	return createRect({
+		x,
+		y,
+		width: x2 - x,
+		height: y2 - y
+	});
+}
+function collisions(a, b) {
+	return {
+		top: a.minY <= b.minY,
+		right: a.maxX >= b.maxX,
+		bottom: a.maxY >= b.maxY,
+		left: a.minX <= b.minX
+	};
+}
+
+//#endregion
+//#region src/shared/rect-utils/distance.ts
+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
+	};
+}
+
+//#endregion
+//#region src/shared/rect-utils/closest.ts
+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 closest$1 = dl;
+	let side = "left";
+	if (dr < closest$1) {
+		closest$1 = dr;
+		side = "right";
+	}
+	if (dt < closest$1) {
+		closest$1 = dt;
+		side = "top";
+	}
+	if (db < closest$1) side = "bottom";
+	return side;
+}
+
+//#endregion
+//#region src/shared/rect-utils/constrain.ts
+const constrainRect = (rect, boundary) => {
+	return {
+		x: Math.max(boundary.x, Math.min(rect.x, boundary.x + boundary.width - rect.width)),
+		y: Math.max(boundary.y, Math.min(rect.y, boundary.y + boundary.height - rect.height)),
+		width: Math.min(rect.width, boundary.width),
+		height: Math.min(rect.height, boundary.height)
+	};
+};
+
+//#endregion
+//#region src/shared/rect-utils/contains.ts
+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);
+}
+
+//#endregion
+//#region src/shared/rect-utils/equality.ts
+const isSizeEqual = (a, b) => {
+	return a.width === b?.width && a.height === b?.height;
+};
+const isPointEqual = (a, b) => {
+	return a.x === b?.x && a.y === b?.y;
+};
+const isRectEqual = (a, b) => {
+	return isPointEqual(a, b) && isSizeEqual(a, b);
+};
+
+//#endregion
+//#region src/shared/rect-utils/from-element.ts
+const styleCache = /* @__PURE__ */ new WeakMap();
+function getCacheComputedStyle(el) {
+	if (!styleCache.has(el)) {
+		const win = el.ownerDocument.defaultView || window;
+		styleCache.set(el, win.getComputedStyle(el));
+	}
+	return styleCache.get(el);
+}
+function getElementRect(el, opts = {}) {
+	return createRect(getClientRect(el, opts));
+}
+function getClientRect(el, opts = {}) {
+	const { excludeScrollbar = false, excludeBorders = false } = opts;
+	const { x, y, width, height } = el.getBoundingClientRect();
+	const r = {
+		x,
+		y,
+		width,
+		height
+	};
+	const { borderLeftWidth, borderTopWidth, borderRightWidth, borderBottomWidth } = getCacheComputedStyle(el);
+	const borderXWidth = sum(borderLeftWidth, borderRightWidth);
+	const borderYWidth = sum(borderTopWidth, borderBottomWidth);
+	if (excludeBorders) {
+		r.width -= borderXWidth;
+		r.height -= borderYWidth;
+		r.x += px(borderLeftWidth);
+		r.y += px(borderTopWidth);
+	}
+	if (excludeScrollbar) {
+		const scrollbarWidth = el.offsetWidth - el.clientWidth - borderXWidth;
+		const scrollbarHeight = el.offsetHeight - el.clientHeight - borderYWidth;
+		r.width -= scrollbarWidth;
+		r.height -= scrollbarHeight;
+	}
+	return r;
+}
+const px = (v) => parseFloat(v.replace("px", ""));
+const sum = (...vals) => vals.reduce((sum$1, v) => sum$1 + (v ? px(v) : 0), 0);
+
+//#endregion
+//#region src/shared/rect-utils/from-points.ts
+function getRectFromPoints(...pts) {
+	const xs = pts.map((p) => p.x);
+	const ys = pts.map((p) => p.y);
+	const x = Math.min(...xs);
+	const y = Math.min(...ys);
+	return createRect({
+		x,
+		y,
+		width: Math.max(...xs) - x,
+		height: Math.max(...ys) - y
+	});
+}
+
+//#endregion
+//#region src/shared/rect-utils/union.ts
+const { min: min$1, max } = Math;
+function union(...rs) {
+	return getRectFromPoints({
+		x: min$1(...rs.map((r) => r.minX)),
+		y: min$1(...rs.map((r) => r.minY))
+	}, {
+		x: max(...rs.map((r) => r.maxX)),
+		y: max(...rs.map((r) => r.maxY))
+	});
+}
+
+//#endregion
+//#region src/shared/rect-utils/from-range.ts
+function fromRange(range) {
+	let rs = [];
+	const rects = Array.from(range.getClientRects());
+	if (rects.length) {
+		rs = rs.concat(rects.map(createRect));
+		return union.apply(void 0, rs);
+	}
+	let start = range.startContainer;
+	if (start.nodeType === Node.TEXT_NODE) start = start.parentNode;
+	if (start instanceof HTMLElement) {
+		const r = getElementRect(start);
+		rs.push({
+			...r,
+			x: r.maxX,
+			width: 0
+		});
+	}
+	return union.apply(void 0, rs);
+}
+
+//#endregion
+//#region src/shared/rect-utils/from-rotation.ts
+function toRad(d) {
+	return d % 360 * Math.PI / 180;
+}
+function rotate(a, d, c) {
+	const r = toRad(d);
+	const sin = Math.sin(r);
+	const cos = Math.cos(r);
+	const x = a.x - c.x;
+	const y = a.y - c.y;
+	return {
+		x: c.x + x * cos - y * sin,
+		y: c.y + x * sin + y * cos
+	};
+}
+function getRotationRect(r, deg) {
+	const rr = Object.values(getRectCorners(r)).map((p) => rotate(p, deg, r.center));
+	const xs = rr.map((p) => p.x);
+	const ys = rr.map((p) => p.y);
+	const minX = Math.min(...xs);
+	const minY = Math.min(...ys);
+	const maxX = Math.max(...xs);
+	const maxY = Math.max(...ys);
+	return createRect({
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	});
+}
+
+//#endregion
+//#region src/shared/rect-utils/from-window.ts
+function getWindowRect(win, opts = {}) {
+	return createRect(getViewportRect(win, opts));
+}
+function getViewportRect(win, opts) {
+	const { excludeScrollbar = false } = opts;
+	const { innerWidth, innerHeight, document: doc, visualViewport } = win;
+	const rect = {
+		x: 0,
+		y: 0,
+		width: visualViewport?.width || innerWidth,
+		height: visualViewport?.height || innerHeight
+	};
+	if (excludeScrollbar) {
+		const scrollbarWidth = innerWidth - doc.documentElement.clientWidth;
+		const scrollbarHeight = innerHeight - doc.documentElement.clientHeight;
+		rect.width -= scrollbarWidth;
+		rect.height -= scrollbarHeight;
+	}
+	return rect;
+}
+
+//#endregion
+//#region src/shared/rect-utils/operations.ts
+const isSymmetric = (v) => "dx" in v || "dy" in v;
+function inset(r, i) {
+	const { top = 0, right = 0, bottom = 0, left = 0 } = isSymmetric(i) ? {
+		left: i.dx,
+		right: i.dx,
+		top: i.dy,
+		bottom: i.dy
+	} : i;
+	return createRect({
+		x: r.x + left,
+		y: r.y + top,
+		width: r.width - left - right,
+		height: r.height - top - bottom
+	});
+}
+function expand(r, v) {
+	return inset(r, typeof v === "number" ? {
+		dx: -v,
+		dy: -v
+	} : v);
+}
+function shrink(r, v) {
+	return inset(r, typeof v === "number" ? {
+		dx: -v,
+		dy: -v
+	} : v);
+}
+function shift(r, o) {
+	const { x = 0, y = 0 } = o;
+	return createRect({
+		x: r.x + x,
+		y: r.y + y,
+		width: r.width,
+		height: r.height
+	});
+}
+
+//#endregion
+//#region src/shared/rect-utils/polygon.ts
+function getElementPolygon(rectValue, placement) {
+	const { top, right, left, bottom } = getRectCorners(createRect(rectValue));
+	const [base] = placement.split("-");
+	return {
+		top: [
+			left,
+			top,
+			right,
+			bottom
+		],
+		right: [
+			top,
+			right,
+			bottom,
+			left
+		],
+		bottom: [
+			top,
+			left,
+			bottom,
+			right
+		],
+		left: [
+			right,
+			top,
+			left,
+			bottom
+		]
+	}[base];
+}
+function isPointInPolygon(polygon, point) {
+	const { x, y } = point;
+	let c = false;
+	for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+		const xi = polygon[i].x;
+		const yi = polygon[i].y;
+		const xj = polygon[j].x;
+		const yj = polygon[j].y;
+		if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) c = !c;
+	}
+	return c;
+}
+function createPolygonElement() {
+	const id = "debug-polygon";
+	const existingPolygon = document.getElementById(id);
+	if (existingPolygon) return existingPolygon;
+	const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+	Object.assign(svg.style, {
+		top: "0",
+		left: "0",
+		width: "100%",
+		height: "100%",
+		opacity: "0.15",
+		position: "fixed",
+		pointerEvents: "none",
+		fill: "red"
+	});
+	const polygon = document.createElementNS("http://www.w3.org/2000/svg", "polygon");
+	polygon.setAttribute("id", id);
+	polygon.setAttribute("points", "0,0 0,0");
+	svg.appendChild(polygon);
+	document.body.appendChild(svg);
+	return polygon;
+}
+function debugPolygon(polygon) {
+	const el = createPolygonElement();
+	const points = polygon.map((point) => `${point.x},${point.y}`).join(" ");
+	el.setAttribute("points", points);
+	return () => {
+		el.remove();
+	};
+}
+
+//#endregion
+//#region src/shared/rect-utils/compass.ts
+const compassDirectionMap = {
+	n: {
+		x: .5,
+		y: 0
+	},
+	ne: {
+		x: 1,
+		y: 0
+	},
+	e: {
+		x: 1,
+		y: .5
+	},
+	se: {
+		x: 1,
+		y: 1
+	},
+	s: {
+		x: .5,
+		y: 1
+	},
+	sw: {
+		x: 0,
+		y: 1
+	},
+	w: {
+		x: 0,
+		y: .5
+	},
+	nw: {
+		x: 0,
+		y: 0
+	}
+};
+const oppositeDirectionMap = {
+	n: "s",
+	ne: "sw",
+	e: "w",
+	se: "nw",
+	s: "n",
+	sw: "ne",
+	w: "e",
+	nw: "se"
+};
+
+//#endregion
+//#region src/shared/rect-utils/resize.ts
+const { sign, abs, min } = Math;
+function getRectExtentPoint(rect, direction) {
+	const { minX, minY, maxX, maxY, midX, midY } = rect;
+	return {
+		x: direction.includes("w") ? minX : direction.includes("e") ? maxX : midX,
+		y: direction.includes("n") ? minY : direction.includes("s") ? maxY : midY
+	};
+}
+function getOppositeDirection(direction) {
+	return oppositeDirectionMap[direction];
+}
+function resizeRect(rect, offset, direction, opts) {
+	const { scalingOriginMode, lockAspectRatio } = opts;
+	const extent = getRectExtentPoint(rect, direction);
+	const oppositeExtent = getRectExtentPoint(rect, getOppositeDirection(direction));
+	if (scalingOriginMode === "center") offset = {
+		x: offset.x * 2,
+		y: offset.y * 2
+	};
+	const newExtent = {
+		x: extent.x + offset.x,
+		y: extent.y + offset.y
+	};
+	const multiplier = {
+		x: compassDirectionMap[direction].x * 2 - 1,
+		y: compassDirectionMap[direction].y * 2 - 1
+	};
+	const newSize = {
+		width: newExtent.x - oppositeExtent.x,
+		height: newExtent.y - oppositeExtent.y
+	};
+	const scaleX = multiplier.x * newSize.width / rect.width;
+	const scaleY = multiplier.y * newSize.height / rect.height;
+	const largestMagnitude = abs(scaleX) > abs(scaleY) ? scaleX : scaleY;
+	const scale = lockAspectRatio ? {
+		x: largestMagnitude,
+		y: largestMagnitude
+	} : {
+		x: extent.x === oppositeExtent.x ? 1 : scaleX,
+		y: extent.y === oppositeExtent.y ? 1 : scaleY
+	};
+	if (extent.y === oppositeExtent.y) scale.y = abs(scale.y);
+	else if (sign(scale.y) !== sign(scaleY)) scale.y *= -1;
+	if (extent.x === oppositeExtent.x) scale.x = abs(scale.x);
+	else if (sign(scale.x) !== sign(scaleX)) scale.x *= -1;
+	switch (scalingOriginMode) {
+		case "extent": return transformRect(rect, AffineTransform.scale(scale.x, scale.y, oppositeExtent), false);
+		case "center": return transformRect(rect, AffineTransform.scale(scale.x, scale.y, {
+			x: rect.midX,
+			y: rect.midY
+		}), false);
+	}
+}
+function createRectFromPoints(initialPoint, finalPoint, normalized = true) {
+	if (normalized) return {
+		x: min(finalPoint.x, initialPoint.x),
+		y: min(finalPoint.y, initialPoint.y),
+		width: abs(finalPoint.x - initialPoint.x),
+		height: abs(finalPoint.y - initialPoint.y)
+	};
+	return {
+		x: initialPoint.x,
+		y: initialPoint.y,
+		width: finalPoint.x - initialPoint.x,
+		height: finalPoint.y - initialPoint.y
+	};
+}
+function transformRect(rect, transform, normalized = true) {
+	return createRectFromPoints(transform.applyTo({
+		x: rect.minX,
+		y: rect.minY
+	}), transform.applyTo({
+		x: rect.maxX,
+		y: rect.maxY
+	}), normalized);
+}
+
+//#endregion
+export { distanceBtwEdges as A, getRectCorners as B, containsPoint as C, closestSideToPoint as D, closest as E, intersects as F, clampPoint as G, isPoint as H, addPoints as I, alignRect as J, clampSize as K, createPoint as L, distanceFromRect as M, collisions as N, closestSideToRect as O, intersection as P, createRect as R, contains as S, constrainRect as T, isRect as U, getRectEdges as V, subtractPoints as W, AffineTransform as Y, getRectFromPoints as _, expand as a, isRectEqual as b, shift as c, getWindowRect as d, getRotationRect as f, union as g, fromRange as h, isPointInPolygon as i, distanceFromPoint as j, distance as k, shrink as l, toRad as m, debugPolygon as n, inset as o, rotate as p, getPointAngle as q, getElementPolygon as r, isSymmetric as s, resizeRect as t, getViewportRect as u, getElementRect as v, containsRect as w, isSizeEqual as x, isPointEqual as y, getRectCenters as z };