@stemy/ngx-utils 19.7.1 → 19.7.2

package/fesm2022/stemy-ngx-utils.mjs

@@ -1146,6 +1146,9 @@ function drawOval(ctx, w, h) {
     ctx.ellipse(0, 0, w / 2, h / 2, 0, 0, Math.PI * 2);
     ctx.closePath();
 }
+function drawPoint(ctx) {
+    drawOval(ctx, 4, 4);
+}
 class CanvasUtils {
     static manipulatePixels(canvas, ctx, colorTransformer) {
         const imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);
@@ -1732,28 +1735,54 @@ class FileSystemEntry {
 function dotProduct(a, b) {
     return a.x * b.x + a.y * b.y;
 }
+function tripleProduct(a, b, c) {
+    const ac = a.x * c.x + a.y * c.y;
+    const bc = b.x * c.x + b.y * c.y;
+    return { x: b.x * ac - a.x * bc, y: b.y * ac - a.y * bc };
+}
 function isPoint(v) {
-    return typeof v === "object" && !isNaN(v.x) && !isNaN(v.y);
+    return typeof v === "object" && Number.isFinite(v.x) && Number.isFinite(v.y);
+}
+function ensurePoint(p, fallback = { x: 0, y: 0 }) {
+    return isPoint(p) ? { x: +p.x, y: +p.y } : fallback;
 }
 function perpendicular(p) {
     return { x: -p.y, y: +p.x };
 }
-function ptAdd(a, b) {
+function negatePt(p) {
+    return { x: -p.x, y: -p.y };
+}
+function normalizePt(p) {
+    const length = lengthOfPt(p);
+    return dividePts(p, length);
+}
+function addPts(a, b) {
     return { x: a.x + b.x, y: a.y + b.y };
 }
-function ptDistance(a, b) {
+function distanceSq(a, b) {
     const x = b.x - a.x;
     const y = b.y - a.y;
-    return Math.sqrt(x * x + y * y);
+    return x * x + y * y;
+}
+function distance(a, b) {
+    return Math.sqrt(distanceSq(a, b));
 }
-function ptLength(p) {
+function lerpPts(a, b, t) {
+    const diff = subPts(b, a);
+    return addPts(a, multiplyPts(diff, t));
+}
+function lengthOfPt(p) {
     return Math.hypot(p.x, p.y);
 }
-function ptMultiply(a, b) {
+function multiplyPts(a, b) {
     const s = isPoint(b) ? b : { x: b, y: b };
     return { x: a.x * s.x, y: a.y * s.y };
 }
-function ptSubtract(a, b) {
+function dividePts(a, b) {
+    const s = isPoint(b) ? b : { x: b, y: b };
+    return { x: a.x / s.x, y: a.y / s.y };
+}
+function subPts(a, b) {
     return { x: a.x - b.x, y: a.y - b.y };
 }
 function rotateDeg(p, ang) {
@@ -1770,125 +1799,261 @@ function toRadians(deg) {
     return deg * Math.PI / 180;
 }
 
-function combineA(simplex, bary) {
-    let out = { x: 0, y: 0 };
-    for (let i = 0; i < simplex.length; i++)
-        out = ptAdd(out, ptMultiply(simplex[i].a, bary[i] || 0));
-    return out;
+const EPSILON = 1e-9;
+/**
+ * Normalize a range
+ * @param minOrRange
+ * @param max
+ */
+function normalizeRange(minOrRange, max) {
+    const min = (Array.isArray(minOrRange) ? minOrRange[0] : minOrRange) ?? 0;
+    max = (Array.isArray(minOrRange) ? minOrRange[1] : max) ?? 1;
+    return (max < min) ? [max, min] : [min, max];
 }
-function combineB(simplex, bary) {
-    let out = { x: 0, y: 0 };
-    for (let i = 0; i < simplex.length; i++)
-        out = ptAdd(out, ptMultiply(simplex[i].b, bary[i] || 0));
-    return out;
+/**
+ * Clamps a value to a range
+ * @param value
+ * @param min
+ * @param max
+ */
+function clamp(value, min, max) {
+    const range = normalizeRange(min, max);
+    return Math.max(Math.min(value, range[1]), range[0]);
 }
-function closestPointToOrigin(simplex) {
-    // returns { simplex: prunedSimplex, closest: vec, bary: weights[] }
-    if (simplex.length === 1) {
-        return { simplex, closest: simplex[0].p, bary: [1] };
-    }
-    if (simplex.length === 2) {
-        const A = simplex[0], B = simplex[1];
-        const ab = ptSubtract(B.p, A.p);
-        const ab2 = dotProduct(ab, ab);
-        if (ab2 <= 1e-18) {
-            return { simplex: [B], closest: B.p, bary: [1] };
-        }
-        const t = Math.max(0, Math.min(1, -dotProduct(A.p, ab) / ab2));
-        const closest = ptAdd(A.p, ptMultiply(ab, t));
-        if (t <= 1e-9) {
-            return { simplex: [A], closest: A.p, bary: [1] };
-        }
-        if (t >= 1 - 1e-9) {
-            return { simplex: [B], closest: B.p, bary: [1] };
-        }
-        return { simplex: [A, B], closest, bary: [1 - t, t] };
-    }
-    // Triangle case (A,B,C) – use Ericson's closest-point to triangle (p=origin)
-    const A = simplex[0], B = simplex[1], C = simplex[2];
-    const a = A.p, b = B.p, c = C.p;
-    const ab = ptSubtract(b, a), ac = ptSubtract(c, a), ap = { x: -a.x, y: -a.y };
-    const d1 = dotProduct(ab, ap), d2 = dotProduct(ac, ap);
-    if (d1 <= 0 && d2 <= 0)
-        return { simplex: [A], closest: a, bary: [1] };
-    const bp = { x: -b.x, y: -b.y };
-    const d3 = dotProduct(ab, bp), d4 = dotProduct(ac, bp);
-    if (d3 >= 0 && d4 <= d3)
-        return { simplex: [B], closest: b, bary: [1] };
-    const vc = d1 * d4 - d3 * d2;
-    if (vc <= 0 && d1 >= 0 && d3 <= 0) {
-        const v = d1 / (d1 - d3);
-        const closest = ptAdd(a, ptMultiply(ab, v));
-        return { simplex: [A, B], closest, bary: [1 - v, v] };
-    }
-    const cp = { x: -c.x, y: -c.y };
-    const bc = ptSubtract(c, b);
-    const d5 = dotProduct(bc, cp), d6 = dotProduct(ac, cp);
-    if (d6 >= 0 && d5 <= d6)
-        return { simplex: [C], closest: c, bary: [1] };
-    const vb = d5 * d2 - d1 * d6;
-    if (vb <= 0 && d2 >= 0 && d6 <= 0) {
-        const w = d2 / (d2 - d6);
-        const closest = ptAdd(a, ptMultiply(ac, w));
-        return { simplex: [A, C], closest, bary: [1 - w, 0, w] };
-    }
-    const va = d3 * d6 - d5 * d4;
-    if (va <= 0) {
-        const denom = (d4 - d3) + (d5 - d6);
-        const w = denom !== 0 ? (d4 - d3) / denom : 0.5;
-        const closest = ptAdd(b, ptMultiply(bc, w));
-        return { simplex: [B, C], closest, bary: [0, 1 - w, w] };
-    }
-    // Origin inside triangle – distance is zero
-    return { simplex: [A, B, C], closest: { x: 0, y: 0 }, bary: [0, 0, 0] };
+/**
+ * Clamps a value to a range in a way, that when it is over in one end, then it appears from the other end
+ * @param value
+ * @param min
+ * @param max
+ */
+function overflow(value, min, max) {
+    const range = normalizeRange(min, max);
+    const length = range[1] - range[0];
+    return ((((value - range[0]) % length) + length) % length) + range[0];
 }
 /**
- * ====== GJK distance (2D) ======
- * We keep, for each simplex vertex, the Minkowski point p = a - b and the witnesses a,b.
- * @param A
- * @param B
+ * Checks if a number is equal to b number with epsilon tolerance
+ * @param a
+ * @param b
+ * @param epsilon
  */
+function isEqual(a, b, epsilon = null) {
+    epsilon = ObjectUtils.isNumber(epsilon) ? epsilon : EPSILON;
+    return Math.abs(a - b) <= epsilon;
+}
+/**
+ * Checks if a number is equal to zero with epsilon tolerance
+ * @param a
+ * @param epsilon
+ */
+function isZero(a, epsilon = null) {
+    return isEqual(a, 0, epsilon);
+}
+class MathUtils {
+    static equal(a, b, epsilon = null) {
+        return isEqual(a, b, epsilon);
+    }
+    static clamp(value, min, max) {
+        return clamp(value, min, max);
+    }
+    static round(value, precision = 2, divider = 1) {
+        precision = Math.pow(10, precision);
+        return Math.round(value * precision / divider) / precision;
+    }
+    static approxIndex(x, values, epsilon = null) {
+        if (!Array.isArray(values) || values.length == 0) {
+            return -1;
+        }
+        let s = 0;
+        let e = values.length - 1;
+        while (s <= e) {
+            const i = Math.floor((s + e) / 2);
+            const v = values[i];
+            if (MathUtils.equal(v, x, epsilon)) {
+                return i;
+            }
+            if (v < x) {
+                s = i + 1;
+            }
+            else {
+                e = i - 1;
+            }
+        }
+        const m = Math.max(e, 0);
+        const a = values[s];
+        const b = values[m];
+        return Math.abs(a - x) < Math.abs(b - x) ? s : m;
+    }
+    static approximate(x, values, epsilon = null) {
+        const index = MathUtils.approxIndex(x, values, epsilon);
+        return values[index] ?? null;
+    }
+}
+
+const MAX_ITERS = 40;
+// =========================
+// GJK distance (robust)
+// =========================
 function gjkDistance(A, B) {
-    const MAX = 64, EPS = 1e-9;
-    const centerA = { x: A.x, y: A.y }, centerB = { x: B.x, y: B.y };
-    let d = ptSubtract(centerB, centerA);
+    let intersection = gjkIntersection(A, B);
+    if (intersection.hit)
+        return { distance: 0 };
+    const ca = A.center;
+    const cb = B.center;
+    let s = 0;
+    let e = 1;
+    let center = ca;
+    let iters = 0;
+    while (e - s > EPSILON) {
+        iters++;
+        const t = (e + s) / 2;
+        const a = A.move(lerpPts(ca, cb, t));
+        const test = gjkIntersection(a, B);
+        center = a.center;
+        if (test.hit) {
+            intersection = test;
+            e = t;
+            if (iters >= MAX_ITERS)
+                break;
+        }
+        else {
+            s = t;
+        }
+    }
+    const result = distance(ca, center);
+    return {
+        distance: result,
+        pa: result > 0 ? addPts(intersection.pa, subPts(ca, center)) : null,
+        pb: result > 0 ? intersection.pb : null
+    };
+}
+// =========================
+// Boolean GJK (robust)
+// =========================
+function gjkIntersection(A, B) {
+    const MAX = 64, EPS = 1e-12;
+    const sup = (dir) => {
+        const a = ensurePoint(A.support(dir), A.center);
+        const b = ensurePoint(B.support(negatePt(dir)), B.center);
+        return { p: subPts(a, b), a, b };
+    };
+    // initial direction: center-to-center; fall back to x-axis
+    let d = subPts(B.center, A.center);
     if (Math.abs(d.x) < EPS && Math.abs(d.y) < EPS)
         d = { x: 1, y: 0 };
-    const sup = (dir) => {
-        const a = A.support(dir);
-        const b = B.support({ x: -dir.x, y: -dir.y });
-        return { p: ptSubtract(a, b), a, b };
+    const simplex = [sup(d)];
+    d = { x: -simplex[0].p.x, y: -simplex[0].p.y };
+    for (let i = 0; i < MAX; i++) {
+        // If direction collapses, steer toward origin from last point
+        const dLen = Math.hypot(d.x, d.y);
+        if (dLen <= EPS) {
+            const last = simplex[simplex.length - 1];
+            const AO = { x: -last.p.x, y: -last.p.y };
+            const aoLen = Math.hypot(AO.x, AO.y);
+            d = (aoLen > EPS) ? AO : { x: 1, y: 0 };
+        }
+        const a = sup(d);
+        const s = a.p.x * d.x + a.p.y * d.y;
+        if (s < -1e-12)
+            return { hit: false }; // definite separation
+        if (Math.abs(s) <= 1e-12) { // tangential contact: use normal ±d
+            const L = Math.hypot(d.x, d.y) || 1;
+            const n = { x: d.x / L, y: d.y / L };
+            const pa = ensurePoint(A.support(n), A.center);
+            const pb = ensurePoint(B.support(negatePt(n)), B.center);
+            const point = { x: (pa.x + pb.x) / 2, y: (pa.y + pb.y) / 2 };
+            return { hit: true, pa, pb, point };
+        }
+        simplex.push(a);
+        {
+            const info = doSimplexBoolean(simplex, d);
+            if (info.hit)
+                return info;
+        }
+    }
+    // Max iterations without resolution → disjoint
+    return { hit: false };
+}
+function doSimplexBoolean(simplex, d) {
+    const last = simplex[simplex.length - 1];
+    const AO = { x: -last.p.x, y: -last.p.y };
+    if (simplex.length === 2) {
+        const B = simplex[0];
+        const AB = { x: B.p.x - last.p.x, y: B.p.y - last.p.y };
+        // Perpendicular to AB toward origin
+        const abPerp = tripleProduct(AB, AO, AB);
+        const perpLen2 = abPerp.x * abPerp.x + abPerp.y * abPerp.y;
+        if (perpLen2 < 1e-24) {
+            // Colinear: project origin onto segment AB
+            const ab2 = AB.x * AB.x + AB.y * AB.y;
+            if (ab2 > 0) {
+                const t = ((AO.x * AB.x + AO.y * AB.y) / ab2);
+                if (t >= 0 && t <= 1) {
+                    // Contact at segment
+                    const pa = { x: last.a.x + t * (B.a.x - last.a.x), y: last.a.y + t * (B.a.y - last.a.y) };
+                    const pb = { x: last.b.x + t * (B.b.x - last.b.x), y: last.b.y + t * (B.b.y - last.b.y) };
+                    const point = { x: (pa.x + pb.x) / 2, y: (pa.y + pb.y) / 2 };
+                    return { hit: true, pa, pb, point };
+                }
+            }
+            // Otherwise, move toward origin from A, keep only last point to progress
+            d.x = -AO.x;
+            d.y = -AO.y;
+            simplex.splice(0, simplex.length - 1);
+            return { hit: false };
+        }
+        d.x = abPerp.x;
+        d.y = abPerp.y;
+        return { hit: false };
+    }
+    // Triangle case: [C, B, A] with A = last
+    const A = last, B = simplex[simplex.length - 2], C = simplex[simplex.length - 3];
+    const AB = { x: B.p.x - A.p.x, y: B.p.y - A.p.y };
+    const AC = { x: C.p.x - A.p.x, y: C.p.y - A.p.y };
+    const ABperp = tripleProduct(AC, AB, AB);
+    const ACperp = tripleProduct(AB, AC, AC);
+    // If origin is outside AB region
+    if (ABperp.x * AO.x + ABperp.y * AO.y > 0) {
+        simplex.splice(simplex.length - 3, 1);
+        d.x = ABperp.x;
+        d.y = ABperp.y;
+        return { hit: false };
+    }
+    // If origin is outside AC region
+    if (ACperp.x * AO.x + ACperp.y * AO.y > 0) {
+        simplex.splice(simplex.length - 2, 1);
+        d.x = ACperp.x;
+        d.y = ACperp.y;
+        return { hit: false };
+    }
+    // Otherwise the origin is inside the triangle → overlap
+    // Compute barycentric weights of origin w.r.t triangle (A,B,C)
+    const v0 = AB; // B-A
+    const v1 = AC; // C-A
+    const b = { x: -A.p.x, y: -A.p.y };
+    const det = v0.x * v1.y - v0.y * v1.x;
+    let uA, uB, uC;
+    if (Math.abs(det) > 1e-24) {
+        const alpha = (b.x * v1.y - v1.x * b.y) / det; // weight for v0 (B)
+        const beta = (v0.x * b.y - b.x * v0.y) / det; // weight for v1 (C)
+        uB = alpha;
+        uC = beta;
+        uA = 1 - alpha - beta;
+    }
+    else {
+        // Fallback: equal weights
+        uA = uB = uC = 1 / 3;
+    }
+    const pa = {
+        x: uA * A.a.x + uB * B.a.x + uC * C.a.x,
+        y: uA * A.a.y + uB * B.a.y + uC * C.a.y
+    };
+    const pb = {
+        x: uA * A.b.x + uB * B.b.x + uC * C.b.x,
+        y: uA * A.b.y + uB * B.b.y + uC * C.b.y
     };
-    let simplex = [sup(d)];
-    let closest = simplex[0].p; // vector to origin
-    let dir = { x: -closest.x, y: -closest.y };
-    let best2 = dotProduct(closest, closest);
-    for (let iter = 0; iter < MAX; iter++) {
-        if (ptLength(dir) <= EPS) { // origin reached
-            const a = simplex[simplex.length - 1].a, b = simplex[simplex.length - 1].b;
-            return { distance: 0, pa: a, pb: b };
-        }
-        const vtx = sup(dir);
-        // termination: support didn't pass beyond previous closest along dir
-        if (dotProduct(vtx.p, dir) - Math.sqrt(best2) <= EPS) {
-            break;
-        }
-        simplex.push(vtx);
-        const reduced = closestPointToOrigin(simplex);
-        simplex = reduced.simplex;
-        closest = reduced.closest;
-        best2 = dotProduct(closest, closest);
-        dir = { x: -closest.x, y: -closest.y };
-        if (best2 <= EPS * EPS) {
-            const pa = combineA(simplex, reduced.bary);
-            const pb = combineB(simplex, reduced.bary);
-            return { distance: 0, pa, pb };
-        }
-    }
-    const res = closestPointToOrigin(simplex);
-    const pa = combineA(simplex, res.bary);
-    const pb = combineB(simplex, res.bary);
-    return { distance: Math.sqrt(dotProduct(res.closest, res.closest)), pa, pb };
+    const point = { x: (pa.x + pb.x) / 2, y: (pa.y + pb.y) / 2 };
+    return { hit: true, pa, pb, point };
 }
 
 class Shape {
@@ -1904,17 +2069,23 @@ class Shape {
     constructor(x, y) {
         this.pt = { x, y };
     }
-    distance(p) {
-        return ptDistance(this.center, p);
+    intersection(shape) {
+        return gjkIntersection(this, shape);
+    }
+    intersects(shape) {
+        return this.intersection(shape).hit;
     }
     minDistance(shape) {
-        return gjkDistance(this, shape).distance;
+        return gjkDistance(this, shape);
+    }
+    distance(shape) {
+        return this.minDistance(shape).distance;
     }
 }
 class Point extends Shape {
     static { this.Zero = new Point(0, 0); }
     get length() {
-        return ptLength(this);
+        return lengthOfPt(this);
     }
     get perpendicular() {
         return new Point(perpendicular(this));
@@ -1925,32 +2096,35 @@ class Point extends Shape {
         this.pt = isPoint(xOrP) ? xOrP : { x: isNaN(x) ? 0 : xOrP, y };
     }
     support() {
-        return this.pt;
+        return this.center;
+    }
+    move(pos) {
+        return new Point(pos);
     }
     add(p) {
-        return new Point(ptAdd(this, p));
+        return new Point(addPts(this, p));
+    }
+    subtract(p) {
+        return new Point(subPts(this, p));
     }
-    sub(p) {
-        return new Point(ptSubtract(this, p));
+    multiply(p) {
+        return new Point(multiplyPts(this, p));
     }
-    mul(p) {
-        return new Point(ptMultiply(this, p));
+    divide(p) {
+        return new Point(multiplyPts(this, p));
     }
     dot(p) {
         return new Point(dotProduct(this, p));
     }
-    distance(p) {
-        return ptDistance(this, p);
-    }
     lerp(p, ratio) {
-        const diff = p.sub(this);
-        return this.add(diff.mul(ratio));
+        const diff = p.subtract(this);
+        return this.add(diff.multiply(ratio));
     }
     perpendicularTo(p, length) {
-        const diff = p.perpendicular.sub(this.perpendicular);
+        const diff = p.perpendicular.subtract(this.perpendicular);
         const ratio = length / diff.length;
         const center = this.lerp(p, .5);
-        return center.add(diff.mul(ratio));
+        return center.add(diff.multiply(ratio));
     }
     circleWith(a, b) {
         const yDelta_a = b.y - a.y;
@@ -1965,8 +2139,8 @@ class Point extends Shape {
         return new Circle(center.x, center.y, center.distance(this));
     }
     tangents(c) {
-        const pd = ptSubtract(c.center, this);
-        const a = Math.asin(c.radius / ptLength(pd));
+        const pd = subPts(c.center, this);
+        const a = Math.asin(c.radius / lengthOfPt(pd));
         const b = Math.atan2(pd.y, pd.x);
         // Tangent points
         let t = b - a;
@@ -1976,7 +2150,7 @@ class Point extends Shape {
         return [t1, t2];
     }
     angle(p) {
-        const diff = p.sub(this);
+        const diff = p.subtract(this);
         return Math.atan2(diff.y, diff.x) * 180 / Math.PI;
     }
     rotateAround(p, angle) {
@@ -1995,11 +2169,16 @@ class Rect extends Shape {
     }
     support(dir) {
         const ang = this.rotation ?? 0;
-        const dLocal = rotateDeg(dir, -ang);
+        const dLocal = rotateDeg(ensurePoint(dir, { x: 1, y: 0 }), -ang);
         const hw = Math.max(0, this.width / 2), hh = Math.max(0, this.height / 2);
+        if (hw === 0 && hh === 0)
+            return ensurePoint(this.center);
         const lx = dLocal.x >= 0 ? hw : -hw;
         const ly = dLocal.y >= 0 ? hh : -hh;
-        return ptAdd(rotateDeg({ x: lx, y: ly }, ang), { x: this.x, y: this.y });
+        return addPts(rotateDeg({ x: lx, y: ly }, ang), this.center);
+    }
+    move(pos) {
+        return new Rect(pos.x, pos.y, this.width, this.height, this.rotation);
     }
 }
 class Oval extends Shape {
@@ -2011,15 +2190,16 @@ class Oval extends Shape {
     }
     support(dir) {
         const ang = this.rotation ?? 0;
-        const d = rotateDeg(dir, -ang);
-        const a = Math.max(0, this.width / 2);
-        const b = Math.max(0, this.height / 2);
-        if (Math.abs(d.x) < 1e-12 && Math.abs(d.y) < 1e-12)
-            return { x: this.x, y: this.y };
-        const q = Math.hypot(a * d.x, b * d.y) || 1; // sqrt((a*dx)^2 + (b*dy)^2)
-        const lx = (a * a * d.x) / q;
-        const ly = (b * b * d.y) / q;
-        return ptAdd(rotateDeg({ x: lx, y: ly }, ang), { x: this.x, y: this.y });
+        const d = rotateDeg(ensurePoint(dir, { x: 1, y: 0 }), -ang);
+        const a = Math.max(0, this.width / 2), b = Math.max(0, this.height / 2);
+        if (a === 0 && b === 0)
+            return ensurePoint(this.center);
+        const q = Math.hypot(a * d.x, b * d.y) || 1;
+        const lx = (a * a * d.x) / q, ly = (b * b * d.y) / q;
+        return addPts(rotateDeg({ x: lx, y: ly }, ang), this.center);
+    }
+    move(pos) {
+        return new Oval(pos.x, pos.y, this.width, this.height, this.rotation);
     }
 }
 class Circle extends Oval {
@@ -2027,6 +2207,9 @@ class Circle extends Oval {
         super(x, y, radius * 2, radius * 2, rotation);
         this.radius = radius;
     }
+    move(pos) {
+        return new Circle(pos.x, pos.y, this.radius, this.rotation);
+    }
 }
 
 class Initializer {
@@ -2158,49 +2341,6 @@ class LoaderUtils {
     }
 }
 
-const EPSILON = 1e-9;
-class MathUtils {
-    static equal(a, b, epsilon = null) {
-        epsilon = ObjectUtils.isNumber(epsilon) ? epsilon : EPSILON;
-        return Math.abs(a - b) < epsilon;
-    }
-    static clamp(value, min, max) {
-        return Math.max(Math.min(value, max), min);
-    }
-    static round(value, precision = 2, divider = 1) {
-        precision = Math.pow(10, precision);
-        return Math.round(value * precision / divider) / precision;
-    }
-    static approxIndex(x, values, epsilon = null) {
-        if (!Array.isArray(values) || values.length == 0) {
-            return -1;
-        }
-        let s = 0;
-        let e = values.length - 1;
-        while (s <= e) {
-            const i = Math.floor((s + e) / 2);
-            const v = values[i];
-            if (MathUtils.equal(v, x, epsilon)) {
-                return i;
-            }
-            if (v < x) {
-                s = i + 1;
-            }
-            else {
-                e = i - 1;
-            }
-        }
-        const m = Math.max(e, 0);
-        const a = values[s];
-        const b = values[m];
-        return Math.abs(a - x) < Math.abs(b - x) ? s : m;
-    }
-    static approximate(x, values, epsilon = null) {
-        const index = MathUtils.approxIndex(x, values, epsilon);
-        return values[index] ?? null;
-    }
-}
-
 function isBrowser() {
     return typeof window !== "undefined";
 }
@@ -7669,29 +7809,31 @@ class InteractiveItemComponent {
     }
     hit(point) {
         for (const shape of this.shapes) {
-            if (shape.minDistance(point) <= 0)
+            if (shape.intersects(point))
                 return true;
         }
         return false;
     }
-    moveBy(dx, dy) {
-        if (this.direction === "none")
+    moveTo(x, y) {
+        if (!this.canvas || this.direction === "none")
             return;
-        switch (this.direction) {
-            case "horizontal":
-                this.pos = new Point(this.pos.x + dx, this.pos.y);
-                break;
-            case "vertical":
-                this.pos = new Point(this.pos.x, this.pos.y + dy);
-                break;
-            default:
-                this.pos = new Point(this.pos.x + dx, this.pos.y + dy);
-                break;
-        }
+        const target = this.restrictPosition(this.direction === "vertical" ? this.pos.x : x, this.direction === "horizontal" ? this.pos.y : y);
+        this.pos = new Point(target);
         this.calcShapes();
-        this.valid = this.isValidByParams() && this.canvas.items.every(other => this === other || this.isValidByDistance(other));
+        this.valid = this.isValidByParams() &&
+            this.canvas.items.every(other => this === other || this.isValidByDistance(other));
         this.validPos = this.valid ? this.pos : this.validPos;
     }
+    moveBy(dx, dy) {
+        const { x, y } = this.pos;
+        this.moveTo(x + dx, y + dy);
+    }
+    moveX(x) {
+        this.moveTo(x, this.pos.y);
+    }
+    moveY(y) {
+        this.moveTo(this.pos.x, y);
+    }
     moveEnd() {
         if (this.valid)
             return;
@@ -7699,14 +7841,26 @@ class InteractiveItemComponent {
         this.valid = true;
         this.calcShapes();
     }
+    restrictPosition(x, y) {
+        return {
+            x: clamp(x, this.canvas.xRange),
+            y: this.canvas.infinite
+                ? overflow(y, this.canvas.yRange)
+                : clamp(y, this.canvas.yRange)
+        };
+    }
     isValidByParams() {
-        return true;
+        return !this.shapes.some(shape => {
+            return this.canvas.exclusions.some(ex => {
+                return shape.distance(ex) < 1;
+            });
+        });
     }
     isValidByDistance(other) {
         const minPixels = this.distToPixels(this.getMinDistance(other));
         return !this.shapes.some(shape => {
             return other.shapes.some(os => {
-                return os.minDistance(shape) <= minPixels;
+                return shape.distance(os) <= minPixels;
             });
         });
     }
@@ -7760,19 +7914,19 @@ class InteractiveCanvasComponent {
     set hoveredItem(item) {
         this.hoveredIndex = !item ? -1 : this.items.indexOf(item);
     }
-    constructor(renderer, universal, element, rootElement) {
+    constructor(renderer, universal) {
         this.renderer = renderer;
         this.universal = universal;
-        this.element = element;
-        this.rootElement = rootElement;
+        this.infinite = false;
+        this.resizeMode = "fit";
+        this.params = {};
         this.debug = false;
         this.horizontal = false;
         this.selectedIndex = 0;
-        this.resizeMode = "fit";
         this.realWidth = 100;
         this.realHeight = 100;
         this.panOffset = 0;
-        this.params = {};
+        this.renderCtx = {};
         this.beforeItems = [];
         this.afterItems = [];
         this.selectedIndexChange = new EventEmitter();
@@ -7784,16 +7938,21 @@ class InteractiveCanvasComponent {
         this.$items = new BehaviorSubject([]);
         this.tempCanvas = this.universal.isServer ? null : document.createElement("canvas");
         this.shouldDraw = !this.universal.isServer;
-        this.rotation = 0;
+        this.hoveredIndex = null;
+        this.xRange = [0, 1];
+        this.yRange = [0, 1];
+        this.ratio = 1;
+        this.styles = null;
+        this.ctx = null;
         this.canvasWidth = 0;
         this.canvasHeight = 0;
-        this.hoveredIndex = null;
+        this.rotation = 0;
+        this.basePan = 0;
+        this.cycles = [0];
+        this.exclusions = [];
         this.touched = false;
-        this.deltaX = 0;
-        this.deltaY = 0;
-        this.ctrInit();
-    }
-    ctrInit() {
+        this.panStartRotation = 0;
+        this.panStartPos = Point.Zero;
     }
     ngOnInit() {
         this.redraw();
@@ -7807,6 +7966,8 @@ class InteractiveCanvasComponent {
         this.renderCtx = this.renderCtx || {};
         this.beforeItems = this.beforeItems || [];
         this.afterItems = this.afterItems || [];
+        this.xRange = normalizeRange(this.params.xRange || [0, this.realWidth]);
+        this.yRange = normalizeRange(this.params.yRange || [0, this.realHeight]);
         this.resize();
     }
     ngAfterViewInit() {
@@ -7872,20 +8033,21 @@ class InteractiveCanvasComponent {
         this.updateCursor();
     }
     onMouseLeave() {
+        if (this.touched)
+            return;
         this.hoveredIndex = null;
         this.updateCursor();
     }
     onPanStart() {
-        this.deltaX = 0;
-        this.deltaY = 0;
+        this.panStartRotation = this.rotation;
+        this.panStartPos = this.lockedItem?.position || Point.Zero;
     }
     onPanMove($event) {
         const item = this.lockedItem;
-        const deltaX = ($event.deltaX - this.deltaX) / this.ratio;
-        const deltaY = ($event.deltaY - this.deltaY) / this.ratio;
+        const deltaX = $event.deltaX / this.ratio;
+        const deltaY = $event.deltaY / this.ratio;
         const data = {
             canvas: this,
-            pointers: $event.pointers,
             item,
             deltaX,
             deltaY
@@ -7895,22 +8057,19 @@ class InteractiveCanvasComponent {
             data.deltaY = +deltaX;
         }
         if (item) {
-            item.moveBy(data.deltaX, data.deltaY);
+            item.moveTo(this.panStartPos.x + data.deltaX, this.panStartPos.y + data.deltaY);
             this.onItemPan.emit(data);
         }
-        else if (this.resizeMode == "fill") {
-            this.rotation += (this.horizontal ? deltaX : deltaY) / this.realHeight * 360;
+        else if (this.infinite) {
+            this.rotation = this.panStartRotation + (this.horizontal ? deltaX : deltaY) / this.realHeight * 360;
             this.fixRotation();
             this.onPan.emit(data);
         }
-        this.deltaX = $event.deltaX;
-        this.deltaY = $event.deltaY;
     }
     onPanEnd() {
         const item = this.lockedItem;
         const data = {
             canvas: this,
-            pointers: [],
             deltaX: 0,
             deltaY: 0,
             item
@@ -7927,11 +8086,20 @@ class InteractiveCanvasComponent {
     fixRotation() {
         if (this.fullHeight <= 0)
             return;
-        this.rotation = ((this.rotation + 180) % 360 + 360) % 360 - 180;
-        this.rotation = Math.round(this.rotation * 100) / 100;
-        this.basePan = (this.rotation / 360 - 1) * this.fullHeight + this.canvasHeight * this.panOffset;
-        this.cycles = this.resizeMode == "fit"
-            ? [0] : [this.basePan - this.fullHeight, this.basePan, this.basePan + this.fullHeight];
+        this.rotation = overflow(Math.round(this.rotation * 100) / 100, -180, 180);
+        this.basePan = (this.rotation / 360 - 1) * this.fullHeight
+            + this.canvasHeight * this.panOffset;
+        this.cycles = this.infinite
+            ? [this.basePan - this.fullHeight, this.basePan, this.basePan + this.fullHeight] : [0];
+        this.exclusions = (this.params.exclusions || []).flatMap(coords => {
+            const x = (coords[2] + coords[0]) * .5 * this.ratio;
+            const y = (coords[3] + coords[1]) * .5 * this.ratio;
+            const width = Math.abs(coords[2] - coords[0]) * this.ratio;
+            const height = Math.abs(coords[3] - coords[1]) * this.ratio;
+            return this.cycles.map(cycle => {
+                return new Rect(x, y + cycle, width, height);
+            });
+        });
         this.items.forEach(item => {
             item.calcShapes();
         });
@@ -7957,19 +8125,25 @@ class InteractiveCanvasComponent {
                 return;
             item.active = !item.active;
         }
+        this.hoveredIndex = selected;
     }
-    getIndexUnderPointer(pointer) {
-        if (!pointer || !this.canvasElem || !this.items)
+    toCanvasPoint(pointer) {
+        if (!pointer || !this.canvas)
             return null;
-        const canvasRect = this.canvasElem.nativeElement.getBoundingClientRect();
-        const point = this.horizontal
+        const canvasRect = this.canvas?.getBoundingClientRect();
+        return this.horizontal
             ? new Point(canvasRect.bottom - pointer.clientY, pointer.clientX - canvasRect.left)
             : new Point(pointer.clientX - canvasRect.left, pointer.clientY - canvasRect.top);
+    }
+    getIndexUnderPointer(pointer) {
+        const point = this.toCanvasPoint(pointer);
+        if (!point || !this.items)
+            return -1;
         const length = this.items.length;
         for (let ix = 0; ix < length; ix++) {
             const item = this.items[ix];
             if (item?.hit(point)) {
-                return item.disabled ? null : ix;
+                return item.disabled ? -1 : ix;
             }
         }
         return -1;
@@ -8005,17 +8179,15 @@ class InteractiveCanvasComponent {
     }
     async drawItems() {
         const ctx = this.ctx;
+        const lockedItem = this.lockedItem;
         for (const item of this.items) {
-            for (const shape of item.shapes) {
-                ctx.save();
-                ctx.translate(shape.x, shape.y);
-                ctx.lineWidth = 1;
-                ctx.strokeStyle = "black";
-                ctx.fillStyle = "white";
-                await item.draw(ctx);
-                ctx.restore();
+            if (item !== lockedItem) {
+                await this.drawItem(ctx, item);
             }
         }
+        if (lockedItem) {
+            await this.drawItem(ctx, lockedItem);
+        }
         if (!this.debug)
             return;
         ctx.lineWidth = 2;
@@ -8038,6 +8210,17 @@ class InteractiveCanvasComponent {
             }
         }
     }
+    async drawItem(ctx, item) {
+        for (const shape of item.shapes) {
+            ctx.save();
+            ctx.translate(shape.x, shape.y);
+            ctx.lineWidth = 1;
+            ctx.strokeStyle = "black";
+            ctx.fillStyle = "white";
+            await item.draw(ctx);
+            ctx.restore();
+        }
+    }
     async draw() {
         const ctx = this.ctx;
         const canvas = ctx.canvas;
@@ -8063,30 +8246,29 @@ class InteractiveCanvasComponent {
         }
         ctx.restore();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: InteractiveCanvasComponent, deps: [{ token: i0.Renderer2 }, { token: UniversalService }, { token: i0.ElementRef }, { token: ROOT_ELEMENT }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.14", type: InteractiveCanvasComponent, isStandalone: false, selector: "interactive-canvas", inputs: { debug: "debug", horizontal: "horizontal", selectedIndex: "selectedIndex", resizeMode: "resizeMode", realWidth: "realWidth", realHeight: "realHeight", panOffset: "panOffset", params: "params", renderCtx: "renderCtx", beforeItems: "beforeItems", afterItems: "afterItems" }, outputs: { selectedIndexChange: "selectedIndexChange", onRotate: "onRotate", onItemPan: "onItemPan", onItemPanned: "onItemPanned", onPan: "onPan", onPanned: "onPanned" }, host: { listeners: { "window:touchend": "onTouchEnd($event)", "window:mouseup": "onMouseUp($event)" } }, queries: [{ propertyName: "itemList", predicate: InteractiveItemComponent }], viewQueries: [{ propertyName: "containerElem", first: true, predicate: ["containerElem"], descendants: true, static: true }, { propertyName: "canvasElem", first: true, predicate: ["canvasElem"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: "<div #containerElem\n     [ngClass]=\"['interactive-canvas-container', horizontal ? 'horizontal' : 'vertical']\"\n     (resize)=\"resize()\"\n     (touchstart)=\"onTouchStart($event)\"\n     (mousedown)=\"onMouseDown($event)\"\n     (mousemove)=\"onMouseMove($event)\"\n     (mouseleave)=\"onMouseLeave()\"\n     (panend)=\"onPanEnd()\"\n     (panmove)=\"onPanMove($event)\"\n     (panstart)=\"onPanStart()\">\n    <canvas #canvasElem class=\"interactive-canvas-element\"></canvas>\n</div>\n", styles: [".interactive-canvas-container{width:100%;height:100%;position:relative;display:flex;align-items:center;justify-content:center}.interactive-canvas-container .interactive-canvas-element{position:absolute;pointer-events:none}\n"], dependencies: [{ kind: "directive", type: i1$3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: InteractiveCanvasComponent, deps: [{ token: i0.Renderer2 }, { token: UniversalService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.14", type: InteractiveCanvasComponent, isStandalone: false, selector: "interactive-canvas", inputs: { infinite: "infinite", resizeMode: "resizeMode", params: "params", realWidth: "realWidth", realHeight: "realHeight", debug: "debug", horizontal: "horizontal", selectedIndex: "selectedIndex", panOffset: "panOffset", renderCtx: "renderCtx", beforeItems: "beforeItems", afterItems: "afterItems" }, outputs: { selectedIndexChange: "selectedIndexChange", onRotate: "onRotate", onItemPan: "onItemPan", onItemPanned: "onItemPanned", onPan: "onPan", onPanned: "onPanned" }, host: { listeners: { "window:touchend": "onTouchEnd($event)", "window:mouseup": "onMouseUp($event)" } }, queries: [{ propertyName: "itemList", predicate: InteractiveItemComponent }], viewQueries: [{ propertyName: "containerElem", first: true, predicate: ["containerElem"], descendants: true, static: true }, { propertyName: "canvasElem", first: true, predicate: ["canvasElem"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: "<div #containerElem\n     [ngClass]=\"['interactive-canvas-container', horizontal ? 'horizontal' : 'vertical']\"\n     (resize)=\"resize()\"\n     (touchstart)=\"onTouchStart($event)\"\n     (mousedown)=\"onMouseDown($event)\"\n     (mousemove)=\"onMouseMove($event)\"\n     (mouseleave)=\"onMouseLeave()\"\n     (panend)=\"onPanEnd()\"\n     (panmove)=\"onPanMove($event)\"\n     (panstart)=\"onPanStart()\">\n    <canvas #canvasElem class=\"interactive-canvas-element\"></canvas>\n</div>\n", styles: [".interactive-canvas-container{width:100%;height:100%;position:relative;display:flex;align-items:center;justify-content:center}.interactive-canvas-container .interactive-canvas-element{position:absolute;pointer-events:none}\n"], dependencies: [{ kind: "directive", type: i1$3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: InteractiveCanvasComponent, decorators: [{
             type: Component,
             args: [{ standalone: false, selector: "interactive-canvas", template: "<div #containerElem\n     [ngClass]=\"['interactive-canvas-container', horizontal ? 'horizontal' : 'vertical']\"\n     (resize)=\"resize()\"\n     (touchstart)=\"onTouchStart($event)\"\n     (mousedown)=\"onMouseDown($event)\"\n     (mousemove)=\"onMouseMove($event)\"\n     (mouseleave)=\"onMouseLeave()\"\n     (panend)=\"onPanEnd()\"\n     (panmove)=\"onPanMove($event)\"\n     (panstart)=\"onPanStart()\">\n    <canvas #canvasElem class=\"interactive-canvas-element\"></canvas>\n</div>\n", styles: [".interactive-canvas-container{width:100%;height:100%;position:relative;display:flex;align-items:center;justify-content:center}.interactive-canvas-container .interactive-canvas-element{position:absolute;pointer-events:none}\n"] }]
-        }], ctorParameters: () => [{ type: i0.Renderer2 }, { type: UniversalService }, { type: i0.ElementRef }, { type: HTMLElement, decorators: [{
-                    type: Inject,
-                    args: [ROOT_ELEMENT]
-                }] }], propDecorators: { debug: [{
-                type: Input
-            }], horizontal: [{
-                type: Input
-            }], selectedIndex: [{
+        }], ctorParameters: () => [{ type: i0.Renderer2 }, { type: UniversalService }], propDecorators: { infinite: [{
                 type: Input
             }], resizeMode: [{
                 type: Input
+            }], params: [{
+                type: Input
             }], realWidth: [{
                 type: Input
             }], realHeight: [{
                 type: Input
-            }], panOffset: [{
+            }], debug: [{
                 type: Input
-            }], params: [{
+            }], horizontal: [{
+                type: Input
+            }], selectedIndex: [{
+                type: Input
+            }], panOffset: [{
                 type: Input
             }], renderCtx: [{
                 type: Input
@@ -8913,5 +9095,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { API_SERVICE, APP_BASE_URL, AUTH_SERVICE, AclService, AjaxRequestHandler, ApiService, ArrayUtils, AsyncMethodBase, AsyncMethodDirective, AsyncMethodTargetDirective, AuthGuard, BASE_CONFIG, BUTTON_TYPE, BackgroundDirective, BaseDialogService, BaseHttpClient, BaseHttpService, BaseToasterService, BtnComponent, BtnDefaultComponent, CONFIG_SERVICE, CacheService, CanvasColor, CanvasUtils, ChipsComponent, ChunkPipe, Circle, CloseBtnComponent, ComponentLoaderDirective, ComponentLoaderService, ConfigService, DIALOG_SERVICE, DateUtils, DragDropEventPlugin, DropListComponent, DropdownBoxComponent, DropdownContentDirective, DropdownDirective, DropdownToggleDirective, DynamicTableComponent, DynamicTableTemplateDirective, ERROR_HANDLER, EXPRESS_REQUEST, EntriesPipe, ErrorHandlerService, EventsService, ExtraItemPropertiesPipe, FactoryDependencies, FakeModuleComponent, FileSystemEntry, FileUtils, FilterPipe, FindPipe, ForbiddenZone, FormatNumberPipe, FormatterService, GenericValue, GetOffsetPipe, GetTypePipe, GetValuePipe, GlobalTemplateDirective, GlobalTemplatePipe, GlobalTemplateService, GroupByPipe, ICON_MAP, ICON_SERVICE, ICON_TYPE, IConfiguration, IconComponent, IconDefaultComponent, IconDirective, IconService, IncludesPipe, Initializer, InteractiveCanvasComponent, InteractiveCircleComponent, InteractiveItemComponent, InteractiveRectComponent, IsTypePipe, JSONfn, JoinPipe, KeysPipe, LANGUAGE_SERVICE, LanguageService, LoaderUtils, LocalHttpService, MapPipe, MathUtils, MaxPipe, MinPipe, NgxTemplateOutletDirective, NgxUtilsModule, OPTIONS_TOKEN, ObjectType, ObjectUtils, ObservableUtils, OpenApiService, Oval, PROMISE_SERVICE, PaginationDirective, PaginationItemContext, PaginationItemDirective, PaginationMenuComponent, Point, PopPipe, PromiseService, RESIZE_DELAY, RESIZE_STRATEGY, ROOT_ELEMENT, Rect, ReducePipe, ReflectUtils, RemapPipe, ReplacePipe, ResizeEventPlugin, ResourceIfContext, ResourceIfDirective, ReversePipe, RoundPipe, SCRIPT_PARAMS, STATIC_SCHEMAS, SafeHtmlPipe, ScrollEventPlugin, SetUtils, ShiftPipe, SocketClient, SocketService, SplitPipe, StateService, StaticAuthService, StaticLanguageService, StickyClassDirective, StickyDirective, StorageMode, StorageService, StringUtils, TOASTER_SERVICE, TabsComponent, TabsItemDirective, TabsTemplateDirective, TimerUtils, TranslatePipe, TranslatedUrlSerializer, UniqueUtils, UniversalService, UnorderedListComponent, UnorderedListItemDirective, UnorderedListTemplateDirective, UploadComponent, ValuedPromise, ValuesPipe, cachedFactory, cancelablePromise, checkTransitions, computedPrevious, createTypedProvider, cssStyles, cssVariables, dotProduct, drawOval, drawRect, getComponentDef, getCssVariables, getRoot, hashCode, impatientPromise, isBrowser, isPoint, parseSelector, perpendicular, provideEntryComponents, provideWithOptions, ptAdd, ptDistance, ptLength, ptMultiply, ptSubtract, rotateDeg, rotateRad, selectorMatchesList, switchClass, toDegrees, toRadians };
+export { API_SERVICE, APP_BASE_URL, AUTH_SERVICE, AclService, AjaxRequestHandler, ApiService, ArrayUtils, AsyncMethodBase, AsyncMethodDirective, AsyncMethodTargetDirective, AuthGuard, BASE_CONFIG, BUTTON_TYPE, BackgroundDirective, BaseDialogService, BaseHttpClient, BaseHttpService, BaseToasterService, BtnComponent, BtnDefaultComponent, CONFIG_SERVICE, CacheService, CanvasColor, CanvasUtils, ChipsComponent, ChunkPipe, Circle, CloseBtnComponent, ComponentLoaderDirective, ComponentLoaderService, ConfigService, DIALOG_SERVICE, DateUtils, DragDropEventPlugin, DropListComponent, DropdownBoxComponent, DropdownContentDirective, DropdownDirective, DropdownToggleDirective, DynamicTableComponent, DynamicTableTemplateDirective, EPSILON, ERROR_HANDLER, EXPRESS_REQUEST, EntriesPipe, ErrorHandlerService, EventsService, ExtraItemPropertiesPipe, FactoryDependencies, FakeModuleComponent, FileSystemEntry, FileUtils, FilterPipe, FindPipe, ForbiddenZone, FormatNumberPipe, FormatterService, GenericValue, GetOffsetPipe, GetTypePipe, GetValuePipe, GlobalTemplateDirective, GlobalTemplatePipe, GlobalTemplateService, GroupByPipe, ICON_MAP, ICON_SERVICE, ICON_TYPE, IConfiguration, IconComponent, IconDefaultComponent, IconDirective, IconService, IncludesPipe, Initializer, InteractiveCanvasComponent, InteractiveCircleComponent, InteractiveItemComponent, InteractiveRectComponent, IsTypePipe, JSONfn, JoinPipe, KeysPipe, LANGUAGE_SERVICE, LanguageService, LoaderUtils, LocalHttpService, MapPipe, MathUtils, MaxPipe, MinPipe, NgxTemplateOutletDirective, NgxUtilsModule, OPTIONS_TOKEN, ObjectType, ObjectUtils, ObservableUtils, OpenApiService, Oval, PROMISE_SERVICE, PaginationDirective, PaginationItemContext, PaginationItemDirective, PaginationMenuComponent, Point, PopPipe, PromiseService, RESIZE_DELAY, RESIZE_STRATEGY, ROOT_ELEMENT, Rect, ReducePipe, ReflectUtils, RemapPipe, ReplacePipe, ResizeEventPlugin, ResourceIfContext, ResourceIfDirective, ReversePipe, RoundPipe, SCRIPT_PARAMS, STATIC_SCHEMAS, SafeHtmlPipe, ScrollEventPlugin, SetUtils, ShiftPipe, SocketClient, SocketService, SplitPipe, StateService, StaticAuthService, StaticLanguageService, StickyClassDirective, StickyDirective, StorageMode, StorageService, StringUtils, TOASTER_SERVICE, TabsComponent, TabsItemDirective, TabsTemplateDirective, TimerUtils, TranslatePipe, TranslatedUrlSerializer, UniqueUtils, UniversalService, UnorderedListComponent, UnorderedListItemDirective, UnorderedListTemplateDirective, UploadComponent, ValuedPromise, ValuesPipe, addPts, cachedFactory, cancelablePromise, checkTransitions, clamp, computedPrevious, createTypedProvider, cssStyles, cssVariables, distance, distanceSq, dividePts, dotProduct, drawOval, drawRect, ensurePoint, getComponentDef, getCssVariables, getRoot, gjkDistance, gjkIntersection, hashCode, impatientPromise, isBrowser, isPoint, lengthOfPt, lerpPts, multiplyPts, negatePt, normalizePt, normalizeRange, overflow, parseSelector, perpendicular, provideEntryComponents, provideWithOptions, rotateDeg, rotateRad, selectorMatchesList, subPts, switchClass, toDegrees, toRadians, tripleProduct };
 //# sourceMappingURL=stemy-ngx-utils.mjs.map