@sprawlify/primitives 0.0.1

package/dist/rect-utils-DKLRhP8G.cjs

@@ -0,0 +1,1147 @@
+const require_defineProperty = require('./defineProperty-BoUOT9Ie.cjs');
+
+//#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
+	]) {
+		require_defineProperty._defineProperty(this, "m00", void 0);
+		require_defineProperty._defineProperty(this, "m01", void 0);
+		require_defineProperty._defineProperty(this, "m02", void 0);
+		require_defineProperty._defineProperty(this, "m10", void 0);
+		require_defineProperty._defineProperty(this, "m11", void 0);
+		require_defineProperty._defineProperty(this, "m12", void 0);
+		require_defineProperty._defineProperty(this, "rotate", (...args) => {
+			return this.prepend(AffineTransform.rotate(...args));
+		});
+		require_defineProperty._defineProperty(this, "scale", (...args) => {
+			return this.prepend(AffineTransform.scale(...args));
+		});
+		require_defineProperty._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
+Object.defineProperty(exports, 'AffineTransform', {
+  enumerable: true,
+  get: function () {
+    return AffineTransform;
+  }
+});
+Object.defineProperty(exports, 'addPoints', {
+  enumerable: true,
+  get: function () {
+    return addPoints;
+  }
+});
+Object.defineProperty(exports, 'alignRect', {
+  enumerable: true,
+  get: function () {
+    return alignRect;
+  }
+});
+Object.defineProperty(exports, 'clampPoint', {
+  enumerable: true,
+  get: function () {
+    return clampPoint;
+  }
+});
+Object.defineProperty(exports, 'clampSize', {
+  enumerable: true,
+  get: function () {
+    return clampSize;
+  }
+});
+Object.defineProperty(exports, 'closest', {
+  enumerable: true,
+  get: function () {
+    return closest;
+  }
+});
+Object.defineProperty(exports, 'closestSideToPoint', {
+  enumerable: true,
+  get: function () {
+    return closestSideToPoint;
+  }
+});
+Object.defineProperty(exports, 'closestSideToRect', {
+  enumerable: true,
+  get: function () {
+    return closestSideToRect;
+  }
+});
+Object.defineProperty(exports, 'collisions', {
+  enumerable: true,
+  get: function () {
+    return collisions;
+  }
+});
+Object.defineProperty(exports, 'constrainRect', {
+  enumerable: true,
+  get: function () {
+    return constrainRect;
+  }
+});
+Object.defineProperty(exports, 'contains', {
+  enumerable: true,
+  get: function () {
+    return contains;
+  }
+});
+Object.defineProperty(exports, 'containsPoint', {
+  enumerable: true,
+  get: function () {
+    return containsPoint;
+  }
+});
+Object.defineProperty(exports, 'containsRect', {
+  enumerable: true,
+  get: function () {
+    return containsRect;
+  }
+});
+Object.defineProperty(exports, 'createPoint', {
+  enumerable: true,
+  get: function () {
+    return createPoint;
+  }
+});
+Object.defineProperty(exports, 'createRect', {
+  enumerable: true,
+  get: function () {
+    return createRect;
+  }
+});
+Object.defineProperty(exports, 'debugPolygon', {
+  enumerable: true,
+  get: function () {
+    return debugPolygon;
+  }
+});
+Object.defineProperty(exports, 'distance', {
+  enumerable: true,
+  get: function () {
+    return distance;
+  }
+});
+Object.defineProperty(exports, 'distanceBtwEdges', {
+  enumerable: true,
+  get: function () {
+    return distanceBtwEdges;
+  }
+});
+Object.defineProperty(exports, 'distanceFromPoint', {
+  enumerable: true,
+  get: function () {
+    return distanceFromPoint;
+  }
+});
+Object.defineProperty(exports, 'distanceFromRect', {
+  enumerable: true,
+  get: function () {
+    return distanceFromRect;
+  }
+});
+Object.defineProperty(exports, 'expand', {
+  enumerable: true,
+  get: function () {
+    return expand;
+  }
+});
+Object.defineProperty(exports, 'fromRange', {
+  enumerable: true,
+  get: function () {
+    return fromRange;
+  }
+});
+Object.defineProperty(exports, 'getElementPolygon', {
+  enumerable: true,
+  get: function () {
+    return getElementPolygon;
+  }
+});
+Object.defineProperty(exports, 'getElementRect', {
+  enumerable: true,
+  get: function () {
+    return getElementRect;
+  }
+});
+Object.defineProperty(exports, 'getPointAngle', {
+  enumerable: true,
+  get: function () {
+    return getPointAngle;
+  }
+});
+Object.defineProperty(exports, 'getRectCenters', {
+  enumerable: true,
+  get: function () {
+    return getRectCenters;
+  }
+});
+Object.defineProperty(exports, 'getRectCorners', {
+  enumerable: true,
+  get: function () {
+    return getRectCorners;
+  }
+});
+Object.defineProperty(exports, 'getRectEdges', {
+  enumerable: true,
+  get: function () {
+    return getRectEdges;
+  }
+});
+Object.defineProperty(exports, 'getRectFromPoints', {
+  enumerable: true,
+  get: function () {
+    return getRectFromPoints;
+  }
+});
+Object.defineProperty(exports, 'getRotationRect', {
+  enumerable: true,
+  get: function () {
+    return getRotationRect;
+  }
+});
+Object.defineProperty(exports, 'getViewportRect', {
+  enumerable: true,
+  get: function () {
+    return getViewportRect;
+  }
+});
+Object.defineProperty(exports, 'getWindowRect', {
+  enumerable: true,
+  get: function () {
+    return getWindowRect;
+  }
+});
+Object.defineProperty(exports, 'inset', {
+  enumerable: true,
+  get: function () {
+    return inset;
+  }
+});
+Object.defineProperty(exports, 'intersection', {
+  enumerable: true,
+  get: function () {
+    return intersection;
+  }
+});
+Object.defineProperty(exports, 'intersects', {
+  enumerable: true,
+  get: function () {
+    return intersects;
+  }
+});
+Object.defineProperty(exports, 'isPoint', {
+  enumerable: true,
+  get: function () {
+    return isPoint;
+  }
+});
+Object.defineProperty(exports, 'isPointEqual', {
+  enumerable: true,
+  get: function () {
+    return isPointEqual;
+  }
+});
+Object.defineProperty(exports, 'isPointInPolygon', {
+  enumerable: true,
+  get: function () {
+    return isPointInPolygon;
+  }
+});
+Object.defineProperty(exports, 'isRect', {
+  enumerable: true,
+  get: function () {
+    return isRect;
+  }
+});
+Object.defineProperty(exports, 'isRectEqual', {
+  enumerable: true,
+  get: function () {
+    return isRectEqual;
+  }
+});
+Object.defineProperty(exports, 'isSizeEqual', {
+  enumerable: true,
+  get: function () {
+    return isSizeEqual;
+  }
+});
+Object.defineProperty(exports, 'isSymmetric', {
+  enumerable: true,
+  get: function () {
+    return isSymmetric;
+  }
+});
+Object.defineProperty(exports, 'resizeRect', {
+  enumerable: true,
+  get: function () {
+    return resizeRect;
+  }
+});
+Object.defineProperty(exports, 'rotate', {
+  enumerable: true,
+  get: function () {
+    return rotate;
+  }
+});
+Object.defineProperty(exports, 'shift', {
+  enumerable: true,
+  get: function () {
+    return shift;
+  }
+});
+Object.defineProperty(exports, 'shrink', {
+  enumerable: true,
+  get: function () {
+    return shrink;
+  }
+});
+Object.defineProperty(exports, 'subtractPoints', {
+  enumerable: true,
+  get: function () {
+    return subtractPoints;
+  }
+});
+Object.defineProperty(exports, 'toRad', {
+  enumerable: true,
+  get: function () {
+    return toRad;
+  }
+});
+Object.defineProperty(exports, 'union', {
+  enumerable: true,
+  get: function () {
+    return union;
+  }
+});