@cognite/reveal-components 1.0.0

package/dist/foundation/utilities/extensions/arrayUtils.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Clears an array and keeps the array reference (i.e. does not create a new array).
+ *
+ * @param array
+ */
+export declare function clear<T>(array: T[]): void;
+/**
+ * Copy array from another array.
+ *
+ * @param array
+ * @param from
+ */
+export declare function copy<T>(array: T[], from: T[]): void;
+/**
+ * Inserts an element at a specific index in an array.
+ *
+ * @param array
+ * @param index
+ * @param element
+ */
+export declare function insertAt<T>(array: T[], index: number, element: T): void;
+/**
+ * Replace the last element in an array.
+ *
+ * @param array
+ * @param element
+ */
+export declare function replaceLast<T>(array: T[], element: T): void;
+/**
+ * Removes an element from an array. Return true if removed, otherwise false
+ *
+ * @param array
+ * @param element
+ */
+export declare function remove<T>(array: T[], element: T): boolean;
+/**
+ * Removes an element by the index from an array.
+ *
+ * @param array
+ * @param index
+ */
+export declare function removeAt<T>(array: T[], index: number): void;
+/**
+ * Swaps two elements in an array in index `i` and `j`.
+ *
+ * @param array
+ * @param i
+ * @param j
+ */
+export declare function swap(array: unknown[], i: number, j: number): void;
+/**
+ * Returns the first element of an array or undefined if empty array.
+ *
+ * @param array
+ * @returns
+ */
+export declare function firstElement<T>(array: readonly T[]): T | undefined;
+/**
+ * Returns the last element of an array or undefined if empty array.
+ *
+ * @param array
+ * @returns
+ */
+export declare function lastElement<T>(array: readonly T[]): T | undefined;
+/**
+ * Returns true if the two arrays contain the same elements (ignoring order).
+ *
+ * @param array1
+ * @param array2
+ * @returns
+ */
+export declare function containsTheSameSet<T>(array1: readonly T[], array2: readonly T[]): boolean;
+/**
+ * Counts the number of elements in the given array that satisfy the specified predicate.
+ *
+ * @param array - The array to search through.
+ * @param predicate - A function that tests each element for a condition.
+ * @returns The number of elements in the array that satisfy the predicate.
+ */
+export declare function count<T>(array: readonly T[], predicate: (t: T) => boolean): number;

package/dist/foundation/utilities/extensions/arrayUtils.js

@@ -0,0 +1,28 @@
+import "lodash-es";
+//#region libs/shared/reveal-components/src/foundation/utilities/extensions/arrayUtils.ts
+function e(e) {
+	e.splice(0, e.length);
+}
+function t(t, n) {
+	e(t), t.push(...n);
+}
+function n(e, t, n) {
+	e.splice(t, 0, n);
+}
+function r(e, t) {
+	e.length >= 1 && (e[e.length - 1] = t);
+}
+function i(e, t) {
+	let n = e.indexOf(t);
+	return n < 0 ? !1 : (a(e, n), !0);
+}
+function a(e, t) {
+	e.splice(t, 1);
+}
+function o(e, t) {
+	let n = 0;
+	for (let r of e) t(r) && n++;
+	return n;
+}
+//#endregion
+export { e as clear, t as copy, o as count, n as insertAt, i as remove, a as removeAt, r as replaceLast };

package/dist/foundation/utilities/extensions/generatorUtils.d.ts

@@ -0,0 +1,5 @@
+export declare function count<T>(iterable: Generator<T>, predicate?: (t: T) => boolean): number;
+export declare function last<T>(iterable: Generator<T>): T | undefined;
+export declare function first<T>(iterable: Generator<T>): T | undefined;
+export declare function filter<T>(iterable: Generator<T>, predicate: (t: T) => boolean): Generator<T>;
+export declare function map<T, U>(iterable: Generator<T>, func: (t: T) => U): Generator<U>;

package/dist/foundation/utilities/extensions/generatorUtils.js

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/extensions/generatorUtils.ts
+function* e(e, t) {
+	for (let n of e) t(n) && (yield n);
+}
+//#endregion
+export { e as filter };

package/dist/foundation/utilities/extensions/isMacOs.d.ts

@@ -0,0 +1 @@
+export declare function isMacOs(): boolean;

package/dist/foundation/utilities/extensions/isMacOs.js

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/extensions/isMacOs.ts
+function e() {
+	return window.navigator.platform.toLowerCase().startsWith("mac");
+}
+//#endregion
+export { e as isMacOs };

package/dist/foundation/utilities/extensions/mathUtils.d.ts

@@ -0,0 +1,26 @@
+export declare function isZero(x: number): boolean;
+export declare function isEqual(x: number, y: number): boolean;
+export declare function isAbsEqual(x: number, y: number, tolerance: number): boolean;
+export declare function isRelativeEqual(x: number, y: number, tolerance: number): boolean;
+export declare function isInteger(value: number): boolean;
+export declare function isIncrement(value: number, increment: number): boolean;
+export declare function isOdd(value: number): boolean;
+export declare function isEven(value: number): boolean;
+export declare function isBetween(min: number, value: number, max: number): boolean;
+export declare function square(value: number): number;
+/**
+ * Round a number closest to one of these values:  2*10^N, 2.5*10^N, 5*10^N or 10*10^N.
+ * This is used to give axes a natural increment between the ticks or
+ * contour intervals on a terrain surface
+ * @param increment - The value to be rounded
+ * @returns The rounded value
+ */
+export declare function roundIncrement(increment: number): number;
+export declare function round(value: number, delta: number): number;
+export declare function ceil(value: number, delta: number): number;
+export declare function floor(value: number, delta: number): number;
+export declare function forceBetween0AndTwoPi(value: number): number;
+export declare function forceBetween0AndPi(value: number): number;
+export declare function forceAngleAround0(value: number): number;
+export declare function compare(a: number, b: number): number;
+export declare function getRandomInt(): number;

package/dist/foundation/utilities/extensions/mathUtils.js

@@ -0,0 +1,78 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/extensions/mathUtils.ts
+var e = 1e-10;
+function t(t) {
+	return t < 0 ? t > -1e-10 : t < e;
+}
+function n(t, n) {
+	return i(t, n, e);
+}
+function r(e, t, n) {
+	return Math.abs(e - t) < n;
+}
+function i(e, t, n) {
+	let r = e - t, i = e < 0 ? -e : e, a = t < 0 ? -t : t;
+	return r < 0 && (r = -r), r / (1 + (i + a) / 2) < n;
+}
+function a(e) {
+	return t(Math.round(e) - e);
+}
+function o(e, t) {
+	return t !== 0 && a(e / t);
+}
+function s(e) {
+	return e % 2 == 0;
+}
+function c(e, t, n) {
+	return e < n ? e < t && t < n : n < t && t < e;
+}
+function l(e) {
+	return e * e;
+}
+function u(e) {
+	let t = 0, n = e, r = !1;
+	for (let e = 0; e < 100; e++) if (n < 1) --t, n *= 10;
+	else if (n > 10) t += 1, n /= 10;
+	else {
+		r = !0;
+		break;
+	}
+	if (!r) return NaN;
+	if (n = n < 2 ? 2 : n < 2.5 ? 2.5 : n < 5 ? 5 : 10, t < 0) for (; t !== 0; t++) n /= 10;
+	else for (; t !== 0; t--) n *= 10;
+	return n;
+}
+function d(e, t) {
+	let n = e / t;
+	return n = Math.round(n), n *= t, n;
+}
+function f(e, t) {
+	let n = e / t;
+	return n = Math.ceil(n), n *= t, n;
+}
+function p(e, t) {
+	let n = e / t;
+	return n = Math.floor(n), n *= t, n;
+}
+function m(e) {
+	for (; e < 0;) e += 2 * Math.PI;
+	for (; e >= 2 * Math.PI;) e -= 2 * Math.PI;
+	return e;
+}
+function h(e) {
+	for (; e < 0;) e += Math.PI;
+	for (; e >= Math.PI;) e -= Math.PI;
+	return e;
+}
+function g(e) {
+	for (; e < -Math.PI;) e += 2 * Math.PI;
+	for (; e >= Math.PI;) e -= 2 * Math.PI;
+	return e;
+}
+function _(e, t) {
+	return e > t ? 1 : e < t ? -1 : 0;
+}
+function v() {
+	return Math.floor(Math.random() * (2 ** 53 - 1));
+}
+//#endregion
+export { f as ceil, _ as compare, p as floor, g as forceAngleAround0, h as forceBetween0AndPi, m as forceBetween0AndTwoPi, v as getRandomInt, r as isAbsEqual, c as isBetween, n as isEqual, s as isEven, o as isIncrement, a as isInteger, i as isRelativeEqual, t as isZero, d as round, u as roundIncrement, l as square };

package/dist/foundation/utilities/extensions/rayUtils.d.ts

@@ -0,0 +1,10 @@
+import { Vector3, Ray } from 'three';
+/**
+ * Calculates the closest point on a line to a given ray.
+ * @param ray - The ray to calculate the closest point from.
+ * @param lineDirection - The direction of the line.
+ * @param pointOnLine - A point on the line.
+ * @param target - An optional Vector3 to store the closest point on the line.
+ * @returns The closest point on the line to the ray.
+ */
+export declare function getClosestPointOnLine(ray: Ray, lineDirection: Vector3, pointOnLine: Vector3, target?: Vector3): Vector3;

package/dist/foundation/utilities/extensions/rayUtils.js

@@ -0,0 +1,9 @@
+import { Vector3 as e } from "three";
+//#region libs/shared/reveal-components/src/foundation/utilities/extensions/rayUtils.ts
+function t(t, n, r, i) {
+	i === void 0 && (i = new e());
+	let a = t.distanceToPoint(r) * 100, o = r.clone().addScaledVector(n, -a), s = r.clone().addScaledVector(n, +a);
+	return t.distanceSqToSegment(o, s, void 0, i), i;
+}
+//#endregion
+export { t as getClosestPointOnLine };

package/dist/foundation/utilities/extensions/stringUtils.d.ts

@@ -0,0 +1,20 @@
+export declare function isEmpty(value: string | null | undefined): boolean;
+export declare function equalsIgnoreCase(value1: string, value2: string): boolean;
+export declare function equalsIgnoreCaseAndSpace(value1: string, value2: string): boolean;
+/**
+ * Converts a number to a string representation with improved rounding precision.
+ *
+ * This function addresses numeric precision issues where numbers like `1.20000005` or `1.19999992`
+ * may appear due to floating-point arithmetic. It rounds the number to a fixed precision and formats
+ * it as a string, ensuring a clean and accurate representation.
+ *
+ * - For very small numbers (absolute value less than 0.001), the default string conversion is used.
+ * - For other numbers, the value is multiplied by `1e5`, rounded, and formatted with a decimal point
+ *   inserted at the appropriate position.
+ * - Trailing zeros and unnecessary decimal points are removed for a cleaner output.
+ * - Negative numbers are handled by preserving the negative sign.
+ *
+ * @param value - The numeric value to convert to a string.
+ * @returns A string representation of the number with improved precision and formatting.
+ */
+export declare function numberToString(value: number): string;

package/dist/foundation/utilities/extensions/stringUtils.js

@@ -0,0 +1,21 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/extensions/stringUtils.ts
+function e(e, t) {
+	return e.toLowerCase() === t.toLowerCase();
+}
+function t(t, n) {
+	return e(t.replace(" ", ""), n.replace(" ", ""));
+}
+function n(e) {
+	let t = Math.sign(e), n = `${Math.abs(Math.round(e * 1e5))}`;
+	if (n.length === 3) n = `0.00${n}`;
+	else if (n.length === 4) n = `0.0${n}`;
+	else if (n.length === 5) n = `0.${n}`;
+	else if (n.length >= 6) {
+		let e = n.length - 5;
+		n = `${n.slice(0, e)}.${n.slice(e)}`;
+	} else return `${e}`;
+	for (; n[n.length - 1] === "0";) n = n.slice(0, -1);
+	return n[n.length - 1] === "." && (n = n.slice(0, -1)), t < 0 && (n = `-${n}`), n;
+}
+//#endregion
+export { e as equalsIgnoreCase, t as equalsIgnoreCaseAndSpace, n as numberToString };

package/dist/foundation/utilities/extensions/vectorUtils.d.ts

@@ -0,0 +1,96 @@
+import { Vector3, Vector2 } from 'three';
+/**
+ * Checks if two 3D vectors are approximately equal within a given epsilon.
+ * @param v1 - The first vector.
+ * @param v2 - The second vector.
+ * @param epsilon - The tolerance for equality. Default is Number.EPSILON.
+ * @returns True if the vectors are approximately equal, false otherwise.
+ */
+export declare function fuzzyEquals(v1: Vector3, v2: Vector3, epsilon?: number): boolean;
+/**
+ * Computes the horizontal angle in radians with respect to the positive x-axis.
+ *
+ * @param vector - The input vector for which the angle is to be computed.
+ * @returns The angle in radians.
+ *
+ * @remarks
+ * Copied from tree.js source code (https://github.com/mrdoob/three.js/blob/master/src/math/Vector2.js)
+ */
+export declare function horizontalAngle(vector: Vector3): number;
+/**
+ * Calculates the horizontal distance between two 3D vectors, ignoring the z-axis.
+ *
+ * @param from - The starting vector.
+ * @param to - The ending vector.
+ * @returns The horizontal distance between the two vectors.
+ */
+export declare function horizontalDistanceTo(from: Vector3, to: Vector3): number;
+/**
+ * Calculates the horizontal length of a vector, ignoring the z-axis.
+ *
+ * @param vector - The vector.
+ * @returns The length.
+ */
+export declare function horizontalLength(vector: Vector3): number;
+/**
+ * Calculates the squared horizontal length of a 3D vector, ignoring the z-axis.
+ *
+ * @param vector - The vector.
+ * @returns The squared length.
+ */
+export declare function horizontalLengthSq(vector: Vector3): number;
+/**
+ * Calculates the vertical distance between two 3D vectors.
+ *
+ * @param from - The starting vector.
+ * @param to - The ending vector.
+ * @returns The absolute vertical distance between the `from` and `to` vectors.
+ */
+export declare function verticalDistanceTo(from: Vector3, to: Vector3): number;
+/**
+ * Rotates a 2D or 3D vector around the horizontal axis by a given angle.
+ *
+ * @param vector - The vector to be rotated.
+ * @param angle - The angle in radians by which to rotate the vector.
+ */
+export declare function rotateHorizontal(vector: Vector3 | Vector2, angle: number): void;
+/**
+ * Rotates a 2D or 3D vector by 90 degrees (π/2 radians) counterclockwise.
+ *
+ * @param vector - The vector to be rotated. Can be either a Vector2 or Vector3.
+ */
+export declare function rotatePiHalf(vector: Vector3 | Vector2): void;
+/**
+ * Returns the index of the component with the maximum absolute value in a given vector.
+ *
+ * @param vector - The vector from which to find the component with the maximum absolute value.
+ * @returns The index of the component with the maximum absolute value (0, 1, or 2).
+ */
+export declare function getAbsMaxComponent(vector: Vector3): number;
+/**
+ * Computes the horizontal cross product of two vectors.
+ * The horizontal cross product is defined as:
+ * `self.x * other.y - self.y * other.x`
+ *
+ * This function works for both 2D and 3D vectors. For 3D vectors, only the x and y components are considered.
+ *
+ * @param self - The first vector
+ * @param other - The second vector
+ * @returns The horizontal cross product of the two vectors.
+ */
+export declare function getHorizontalCrossProduct(self: Vector3 | Vector2, other: Vector3 | Vector2): number;
+/**
+ * Calculates the octant of a given 2D vector.
+ *
+ * The octant are defined as follows:
+ *
+ *         North (Positive Y-axis)
+ *        3  2  1
+ * West   4  *  0 East (Positive X-axis)
+ *        5  6  7
+ *         South
+ *
+ * @param vector - The 2D vector for which to calculate the octant.
+ * @returns The octant as an integer between 0 and 7.
+ */
+export declare function getOctant(vector: Vector2): number;

package/dist/foundation/utilities/extensions/vectorUtils.js

@@ -0,0 +1,48 @@
+import { square as e } from "./mathUtils.js";
+//#region libs/shared/reveal-components/src/foundation/utilities/extensions/vectorUtils.ts
+function t(e, t, n = 2 ** -52) {
+	return Math.abs(e.x - t.x) < n && Math.abs(e.y - t.y) < n && Math.abs(e.z - t.z) < n;
+}
+function n(e) {
+	return Math.atan2(-e.y, -e.x) + Math.PI;
+}
+function r(t, n) {
+	return Math.sqrt(e(t.x - n.x) + e(t.y - n.y));
+}
+function i(e) {
+	return Math.sqrt(a(e));
+}
+function a(t) {
+	return e(t.x) + e(t.y);
+}
+function o(e, t) {
+	return Math.abs(e.z - t.z);
+}
+function s(e, t) {
+	let n = e.x;
+	e.x = n * Math.cos(t) - e.y * Math.sin(t), e.y = n * Math.sin(t) + e.y * Math.cos(t);
+}
+function c(e) {
+	let t = e.x;
+	e.x = -e.y, e.y = t;
+}
+function l(e) {
+	let t = 0, n = 0;
+	for (let r = 0; r < 3; r++) {
+		let i = Math.abs(e.getComponent(r));
+		i < t || (n = r, t = i);
+	}
+	return n;
+}
+function u(e, t) {
+	return e.x * t.y - e.y * t.x;
+}
+function d(e) {
+	let t = e.angle() / (2 * Math.PI);
+	for (; t < 0;) t += 1;
+	for (; t > 1;) --t;
+	let n = Math.round(8 * t);
+	return n >= 8 ? n - 8 : n < 0 ? n + 8 : n;
+}
+//#endregion
+export { t as fuzzyEquals, l as getAbsMaxComponent, u as getHorizontalCrossProduct, d as getOctant, n as horizontalAngle, r as horizontalDistanceTo, i as horizontalLength, a as horizontalLengthSq, s as rotateHorizontal, c as rotatePiHalf, o as verticalDistanceTo };

package/dist/foundation/utilities/geometry/Index2.d.ts

@@ -0,0 +1,13 @@
+export declare class Index2 {
+    i: number;
+    j: number;
+    constructor(i?: number, j?: number);
+    clone(): Index2;
+    get size(): number;
+    get isZero(): boolean;
+    getComponent(dimension: number): number;
+    toString(): string;
+    copyFrom(value: Index2): this;
+    add(value: Index2): this;
+    subtract(value: Index2): this;
+}

package/dist/foundation/utilities/geometry/Index2.js

@@ -0,0 +1,38 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/geometry/Index2.ts
+var e = class e {
+	i;
+	j;
+	constructor(e, t) {
+		this.i = e ?? 0, this.j = t ?? this.i;
+	}
+	clone() {
+		return new e(this.i, this.j);
+	}
+	get size() {
+		return this.i * this.j;
+	}
+	get isZero() {
+		return this.i === 0 && this.j === 0;
+	}
+	getComponent(e) {
+		switch (e) {
+			case 0: return this.i;
+			case 1: return this.j;
+			default: return NaN;
+		}
+	}
+	toString() {
+		return `(${this.i}, ${this.j})`;
+	}
+	copyFrom(e) {
+		return this.i = e.i, this.j = e.j, this;
+	}
+	add(e) {
+		return this.i += e.i, this.j += e.j, this;
+	}
+	subtract(e) {
+		return this.i -= e.i, this.j -= e.j, this;
+	}
+};
+//#endregion
+export { e as Index2 };

package/dist/foundation/utilities/geometry/Range1.d.ts

@@ -0,0 +1,36 @@
+export declare class Range1 {
+    static readonly empty: Range1;
+    private _min;
+    private _max;
+    private _isEmpty;
+    get isEmpty(): boolean;
+    get isSingular(): boolean;
+    get hasSpan(): boolean;
+    get min(): number;
+    get max(): number;
+    get delta(): number;
+    get center(): number;
+    constructor(min?: number, max?: number);
+    clone(): Range1;
+    equals(other: Range1): boolean;
+    isInside(value: number): boolean;
+    toString(): string;
+    getFraction(value: number): number;
+    getTruncatedFraction(value: number): number;
+    getValue(fraction: number): number;
+    getBestIncrement(numberOfTicks?: number): number;
+    getNumTicks(increment: number): number;
+    getTicks(increment: number): Generator<number>;
+    getFastTicks(increment: number, tolerance: number): Generator<number>;
+    getBoldIncrement(increment: number, every?: number): number;
+    makeEmpty(): void;
+    set(min: number, max: number): void;
+    translate(value: number): void;
+    scale(value: number): void;
+    scaleDelta(scale: number): void;
+    add(value: number): void;
+    addRange(value: Range1): void;
+    expandByMargin(margin: number): void;
+    expandByFraction(fraction: number): void;
+    roundByInc(increment: number): boolean;
+}

package/dist/foundation/utilities/geometry/Range1.js

@@ -0,0 +1,116 @@
+import { ceil as e, floor as t, isIncrement as n, roundIncrement as r } from "../extensions/mathUtils.js";
+//#region libs/shared/reveal-components/src/foundation/utilities/geometry/Range1.ts
+var i = 1e3, a = class a {
+	static empty = new a();
+	_min = 0;
+	_max = 0;
+	_isEmpty = !0;
+	get isEmpty() {
+		return this._isEmpty;
+	}
+	get isSingular() {
+		return this.min === this.max;
+	}
+	get hasSpan() {
+		return !this.isEmpty && !this.isSingular;
+	}
+	get min() {
+		return this._min;
+	}
+	get max() {
+		return this._max;
+	}
+	get delta() {
+		return this._max - this._min;
+	}
+	get center() {
+		return (this._min + this._max) / 2;
+	}
+	constructor(e, t) {
+		e === void 0 && t !== void 0 ? this.set(t, t) : e !== void 0 && t === void 0 ? this.set(e, e) : e !== void 0 && t !== void 0 && this.set(e, t);
+	}
+	clone() {
+		let e = new a();
+		return e._min = this._min, e._max = this._max, e._isEmpty = this._isEmpty, e;
+	}
+	equals(e) {
+		return e === void 0 ? !1 : this._isEmpty && e._isEmpty ? !0 : this._isEmpty === e._isEmpty && this.min === e.min && this.max === e.max;
+	}
+	isInside(e) {
+		return this.min <= e && e <= this.max;
+	}
+	toString() {
+		return `(${this._min}, ${this._max})`;
+	}
+	getFraction(e) {
+		return (e - this.min) / this.delta;
+	}
+	getTruncatedFraction(e) {
+		let t = this.getFraction(e);
+		return t < 0 ? 0 : t > 1 ? 1 : t;
+	}
+	getValue(e) {
+		return e * this.delta + this.min;
+	}
+	getBestIncrement(e = 50) {
+		let t = this.delta / e;
+		return r(t);
+	}
+	getNumTicks(e) {
+		return Math.round(this.delta / e);
+	}
+	*getTicks(e) {
+		let t = this.clone();
+		if (!t.roundByInc(-e) || t.getNumTicks(e) > i) return;
+		let n = e / 1e4, r = t.max + n;
+		for (let i = t.min; i <= r; i += e) yield Math.abs(i) < n ? 0 : i;
+	}
+	*getFastTicks(e, t) {
+		if (!this.roundByInc(-e) || this.getNumTicks(e) > i) return;
+		let n = this.max + t;
+		for (let r = this.min; r <= n; r += e) yield Math.abs(r) < t ? 0 : r;
+	}
+	getBoldIncrement(e, t = 2) {
+		let r = 0, i = e * t;
+		for (let t of this.getTicks(e)) if (n(t, i) && (r += 1, r > 2)) return i;
+		return e;
+	}
+	makeEmpty() {
+		this._min = 0, this._max = 0, this._isEmpty = !0;
+	}
+	set(e, t) {
+		this._min = Math.min(e, t), this._max = Math.max(e, t), this._isEmpty = !1;
+	}
+	translate(e) {
+		this.isEmpty || (this._min += e, this._max += e);
+	}
+	scale(e) {
+		this.isEmpty || (this._min *= e, this._max *= e);
+	}
+	scaleDelta(e) {
+		if (this.isEmpty) return;
+		let { center: t } = this;
+		this._min = (this._min - t) * e + t, this._max = (this._max - t) * e + t;
+	}
+	add(e) {
+		Number.isNaN(e) || (this.isEmpty ? (this._isEmpty = !1, this._min = e, this._max = e) : e < this._min ? this._min = e : e > this._max && (this._max = e));
+	}
+	addRange(e) {
+		e.isEmpty || (this.isEmpty ? (this._isEmpty = !1, this._min = e.min, this._max = e.max) : (this.add(e.min), this.add(e.max)));
+	}
+	expandByMargin(e) {
+		this.isEmpty || (this._min -= e, this._max += e, this._min > this._max && ([this._max, this._min] = [this._min, this._max]));
+	}
+	expandByFraction(e) {
+		this.isEmpty || this.expandByMargin(this.delta * e);
+	}
+	roundByInc(n) {
+		if (this.isEmpty) return !1;
+		if (n < 0) {
+			if (this._min = e(this._min, -n), this._max = t(this._max, -n), this._min > this._max) return !1;
+		} else n > 0 && (this._min = t(this._min, n), this._max = e(this._max, n));
+		return !0;
+	}
+};
+//#endregion
+export { a as Range1 };