@2112-lab/central-plant 0.1.4 → 0.1.6

package/dist/esm/src/core/mathUtils.js

@@ -1 +1,570 @@
-import{defineProperty as t,createClass as n,toConsumableArray as r,slicedToArray as e,classCallCheck as u}from"../../_virtual/_rollupPluginBabelHelpers.js";var a,i=n(function t(){u(this,t)});a=i,t(i,"PI",Math.PI),t(i,"TWO_PI",2*Math.PI),t(i,"HALF_PI",Math.PI/2),t(i,"DEG_TO_RAD",Math.PI/180),t(i,"RAD_TO_DEG",180/Math.PI),t(i,"EPSILON",1e-10),t(i,"angle",{toRadians:function(t){return t*a.DEG_TO_RAD},toDegrees:function(t){return t*a.RAD_TO_DEG},normalize:function(t){for(;t<0;)t+=a.TWO_PI;for(;t>=a.TWO_PI;)t-=a.TWO_PI;return t},normalizeSignedAngle:function(t){return(t=a.angle.normalize(t))>Math.PI?t-a.TWO_PI:t},distance:function(t,n){var r=a.angle.normalizeSignedAngle(n-t);return Math.abs(r)},lerp:function(t,n,r){var e=a.angle.normalizeSignedAngle(n-t);return a.angle.normalize(t+e*r)}}),t(i,"interpolation",{linear:function(t,n,r){return t+(n-t)*r},smoothstep:function(t,n,r){var e=r*r*(3-2*r);return a.interpolation.linear(t,n,e)},smootherstep:function(t,n,r){var e=r*r*r*(r*(6*r-15)+10);return a.interpolation.linear(t,n,e)},cosine:function(t,n,r){var e=r*Math.PI,u=.5*(1-Math.cos(e));return t*(1-u)+n*u},cubic:function(t,n,r,e,u){var a=u*u;return.5*(2*n+(-t+r)*u+(2*t-5*n+4*r-e)*a+(3*n-t-3*r+e)*(a*u))}}),t(i,"easing",{easeInQuad:function(t){return t*t},easeOutQuad:function(t){return t*(2-t)},easeInOutQuad:function(t){return t<.5?2*t*t:(4-2*t)*t-1},easeInCubic:function(t){return t*t*t},easeOutCubic:function(t){return--t*t*t+1},easeInOutCubic:function(t){return t<.5?4*t*t*t:(t-1)*(2*t-2)*(2*t-2)+1},easeInQuart:function(t){return t*t*t*t},easeOutQuart:function(t){return 1- --t*t*t*t},easeInOutQuart:function(t){return t<.5?8*t*t*t*t:1-8*--t*t*t*t},easeInQuint:function(t){return t*t*t*t*t},easeOutQuint:function(t){return 1+--t*t*t*t*t},easeInOutQuint:function(t){return t<.5?16*t*t*t*t*t:1+16*--t*t*t*t*t},easeInSine:function(t){return 1-Math.cos(t*a.HALF_PI)},easeOutSine:function(t){return Math.sin(t*a.HALF_PI)},easeInOutSine:function(t){return.5*(1-Math.cos(a.PI*t))},easeInExpo:function(t){return 0===t?0:Math.pow(2,10*(t-1))},easeOutExpo:function(t){return 1===t?1:1-Math.pow(2,-10*t)},easeInOutExpo:function(t){return 0===t?0:1===t?1:t<.5?.5*Math.pow(2,10*(2*t-1)):.5*(2-Math.pow(2,-10*(2*t-1)))},easeInCirc:function(t){return 1-Math.sqrt(1-t*t)},easeOutCirc:function(t){return Math.sqrt(1- --t*t)},easeInOutCirc:function(t){return(t*=2)<1?.5*(1-Math.sqrt(1-t*t)):(t-=2,.5*(Math.sqrt(1-t*t)+1))},easeInElastic:function(t){if(0===t)return 0;if(1===t)return 1;return-Math.pow(2,10*(t-=1))*Math.sin((t-.075)*a.TWO_PI/.3)},easeOutElastic:function(t){if(0===t)return 0;if(1===t)return 1;return Math.pow(2,-10*t)*Math.sin((t-.075)*a.TWO_PI/.3)+1}}),t(i,"geometry",{triangleArea:function(t,n,r){return.5*Math.abs((n[0]-t[0])*(r[1]-t[1])-(r[0]-t[0])*(n[1]-t[1]))},polygonArea:function(t){for(var n=0,r=t.length,e=0;e<r;e++){var u=(e+1)%r;n+=t[e][0]*t[u][1],n-=t[u][0]*t[e][1]}return Math.abs(n)/2},pointInTriangle:function(t,n,r,e){var u=a.geometry.triangleArea(n,r,e),i=a.geometry.triangleArea(t,r,e),o=a.geometry.triangleArea(n,t,e),c=a.geometry.triangleArea(n,r,t);return Math.abs(u-(i+o+c))<a.EPSILON},polygonCentroid:function(t){for(var n=0,r=0,e=0,u=t.length,a=0;a<u;a++){var i=(a+1)%u,o=t[a][0]*t[i][1]-t[i][0]*t[a][1];e+=o,n+=(t[a][0]+t[i][0])*o,r+=(t[a][1]+t[i][1])*o}return[n/=6*(e/=2),r/=6*e]}}),t(i,"random",{float:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;return t+Math.random()*(n-t)},int:function(t,n){return Math.floor(a.random.float(t,n+1))},boolean:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:.5;return Math.random()<t},choice:function(t){return t[a.random.int(0,t.length-1)]},shuffle:function(t){for(var n=r(t),e=n.length-1;e>0;e--){var u=Math.floor(Math.random()*(e+1)),a=[n[u],n[e]];n[e]=a[0],n[u]=a[1]}return n},unitCircle:function(){var t=a.random.float(0,a.TWO_PI);return[Math.cos(t),Math.sin(t)]},insideUnitCircle:function(){var t=a.random.unitCircle(),n=e(t,2),r=n[0],u=n[1],i=Math.sqrt(Math.random());return[r*i,u*i]},unitSphere:function(){var t=Math.random(),n=Math.random(),r=a.TWO_PI*t,e=Math.acos(2*n-1);return[Math.sin(e)*Math.cos(r),Math.sin(e)*Math.sin(r),Math.cos(e)]}}),t(i,"color",{hslToRgb:function(t,n,r){t/=360;var e,u,a,i=(1-Math.abs(2*r-1))*n,o=i*(1-Math.abs(6*t%2-1)),c=r-i/2;return t<1/6?(e=i,u=o,a=0):t<2/6?(e=o,u=i,a=0):t<.5?(e=0,u=i,a=o):t<4/6?(e=0,u=o,a=i):t<5/6?(e=o,u=0,a=i):(e=i,u=0,a=o),[Math.round(255*(e+c)),Math.round(255*(u+c)),Math.round(255*(a+c))]},rgbToHsl:function(t,n,r){t/=255,n/=255,r/=255;var e=Math.max(t,n,r),u=Math.min(t,n,r),a=(e+u)/2;if(e===u)return[0,0,a];var i,o=e-u,c=a>.5?o/(2-e-u):o/(e+u);switch(e){case t:i=(n-r)/o+(n<r?6:0);break;case n:i=(r-t)/o+2;break;case r:i=(t-n)/o+4}return[360*(i/=6),c,a]},lerp:function(t,n,r){return[Math.round(a.interpolation.linear(t[0],n[0],r)),Math.round(a.interpolation.linear(t[1],n[1],r)),Math.round(a.interpolation.linear(t[2],n[2],r))]}}),t(i,"utils",{clamp:function(t,n,r){return Math.max(n,Math.min(r,t))},map:function(t,n,r,e,u){return e+(t-n)*(u-e)/(r-n)},isPowerOfTwo:function(t){return!(t&t-1)},nextPowerOfTwo:function(t){return Math.pow(2,Math.ceil(Math.log2(t)))},gcd:function(t,n){return 0===n?t:a.utils.gcd(n,t%n)},lcm:function(t,n){return Math.abs(t*n)/a.utils.gcd(t,n)},approxEqual:function(t,n){var r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:a.EPSILON;return Math.abs(t-n)<r},round:function(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,r=Math.pow(10,n);return Math.round(t*r)/r}});export{i as MathUtils};
+import { defineProperty as _defineProperty, createClass as _createClass, toConsumableArray as _toConsumableArray, slicedToArray as _slicedToArray, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+
+var _MathUtils;
+/**
+ * MathUtils
+ * Essential mathematical utilities and helper functions
+ */
+
+var MathUtils = /*#__PURE__*/_createClass(function MathUtils() {
+  _classCallCheck(this, MathUtils);
+});
+_MathUtils = MathUtils;
+_defineProperty(MathUtils, "PI", Math.PI);
+_defineProperty(MathUtils, "TWO_PI", 2 * Math.PI);
+_defineProperty(MathUtils, "HALF_PI", Math.PI / 2);
+_defineProperty(MathUtils, "DEG_TO_RAD", Math.PI / 180);
+_defineProperty(MathUtils, "RAD_TO_DEG", 180 / Math.PI);
+_defineProperty(MathUtils, "EPSILON", 1e-10);
+/**
+ * Angle utilities
+ */
+_defineProperty(MathUtils, "angle", {
+  /**
+   * Convert degrees to radians
+   * @param {number} degrees - Angle in degrees
+   * @returns {number} Angle in radians
+   */
+  toRadians: function toRadians(degrees) {
+    return degrees * _MathUtils.DEG_TO_RAD;
+  },
+  /**
+   * Convert radians to degrees
+   * @param {number} radians - Angle in radians
+   * @returns {number} Angle in degrees
+   */
+  toDegrees: function toDegrees(radians) {
+    return radians * _MathUtils.RAD_TO_DEG;
+  },
+  /**
+   * Normalize angle to [0, 2π] range
+   * @param {number} angle - Angle in radians
+   * @returns {number} Normalized angle
+   */
+  normalize: function normalize(angle) {
+    while (angle < 0) angle += _MathUtils.TWO_PI;
+    while (angle >= _MathUtils.TWO_PI) angle -= _MathUtils.TWO_PI;
+    return angle;
+  },
+  /**
+   * Normalize angle to [-π, π] range
+   * @param {number} angle - Angle in radians
+   * @returns {number} Normalized angle
+   */
+  normalizeSignedAngle: function normalizeSignedAngle(angle) {
+    angle = _MathUtils.angle.normalize(angle);
+    return angle > Math.PI ? angle - _MathUtils.TWO_PI : angle;
+  },
+  /**
+   * Calculate shortest angular distance between two angles
+   * @param {number} a - First angle in radians
+   * @param {number} b - Second angle in radians
+   * @returns {number} Angular distance
+   */
+  distance: function distance(a, b) {
+    var diff = _MathUtils.angle.normalizeSignedAngle(b - a);
+    return Math.abs(diff);
+  },
+  /**
+   * Linear interpolation between two angles
+   * @param {number} a - Start angle in radians
+   * @param {number} b - End angle in radians
+   * @param {number} t - Interpolation factor (0-1)
+   * @returns {number} Interpolated angle
+   */
+  lerp: function lerp(a, b, t) {
+    var diff = _MathUtils.angle.normalizeSignedAngle(b - a);
+    return _MathUtils.angle.normalize(a + diff * t);
+  }
+});
+/**
+ * Interpolation utilities
+ */
+_defineProperty(MathUtils, "interpolation", {
+  /**
+   * Linear interpolation
+   * @param {number} a - Start value
+   * @param {number} b - End value
+   * @param {number} t - Factor (0-1)
+   * @returns {number} Interpolated value
+   */
+  linear: function linear(a, b, t) {
+    return a + (b - a) * t;
+  },
+  /**
+   * Smoothstep interpolation
+   * @param {number} a - Start value
+   * @param {number} b - End value
+   * @param {number} t - Factor (0-1)
+   * @returns {number} Smoothly interpolated value
+   */
+  smoothstep: function smoothstep(a, b, t) {
+    var smooth = t * t * (3 - 2 * t);
+    return _MathUtils.interpolation.linear(a, b, smooth);
+  },
+  /**
+   * Smootherstep interpolation
+   * @param {number} a - Start value
+   * @param {number} b - End value
+   * @param {number} t - Factor (0-1)
+   * @returns {number} Smoother interpolated value
+   */
+  smootherstep: function smootherstep(a, b, t) {
+    var smooth = t * t * t * (t * (t * 6 - 15) + 10);
+    return _MathUtils.interpolation.linear(a, b, smooth);
+  },
+  /**
+   * Cosine interpolation
+   * @param {number} a - Start value
+   * @param {number} b - End value
+   * @param {number} t - Factor (0-1)
+   * @returns {number} Cosine interpolated value
+   */
+  cosine: function cosine(a, b, t) {
+    var ft = t * Math.PI;
+    var f = (1 - Math.cos(ft)) * 0.5;
+    return a * (1 - f) + b * f;
+  },
+  /**
+   * Cubic interpolation
+   * @param {number} p0 - Point before start
+   * @param {number} p1 - Start point
+   * @param {number} p2 - End point
+   * @param {number} p3 - Point after end
+   * @param {number} t - Factor (0-1)
+   * @returns {number} Cubic interpolated value
+   */
+  cubic: function cubic(p0, p1, p2, p3, t) {
+    var t2 = t * t;
+    var t3 = t2 * t;
+    return 0.5 * (2 * p1 + (-p0 + p2) * t + (2 * p0 - 5 * p1 + 4 * p2 - p3) * t2 + (-p0 + 3 * p1 - 3 * p2 + p3) * t3);
+  }
+});
+/**
+ * Easing functions
+ */
+_defineProperty(MathUtils, "easing", {
+  // Quadratic
+  easeInQuad: function easeInQuad(t) {
+    return t * t;
+  },
+  easeOutQuad: function easeOutQuad(t) {
+    return t * (2 - t);
+  },
+  easeInOutQuad: function easeInOutQuad(t) {
+    return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+  },
+  // Cubic
+  easeInCubic: function easeInCubic(t) {
+    return t * t * t;
+  },
+  easeOutCubic: function easeOutCubic(t) {
+    return --t * t * t + 1;
+  },
+  easeInOutCubic: function easeInOutCubic(t) {
+    return t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+  },
+  // Quartic
+  easeInQuart: function easeInQuart(t) {
+    return t * t * t * t;
+  },
+  easeOutQuart: function easeOutQuart(t) {
+    return 1 - --t * t * t * t;
+  },
+  easeInOutQuart: function easeInOutQuart(t) {
+    return t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t;
+  },
+  // Quintic
+  easeInQuint: function easeInQuint(t) {
+    return t * t * t * t * t;
+  },
+  easeOutQuint: function easeOutQuint(t) {
+    return 1 + --t * t * t * t * t;
+  },
+  easeInOutQuint: function easeInOutQuint(t) {
+    return t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * --t * t * t * t * t;
+  },
+  // Sine
+  easeInSine: function easeInSine(t) {
+    return 1 - Math.cos(t * _MathUtils.HALF_PI);
+  },
+  easeOutSine: function easeOutSine(t) {
+    return Math.sin(t * _MathUtils.HALF_PI);
+  },
+  easeInOutSine: function easeInOutSine(t) {
+    return 0.5 * (1 - Math.cos(_MathUtils.PI * t));
+  },
+  // Exponential
+  easeInExpo: function easeInExpo(t) {
+    return t === 0 ? 0 : Math.pow(2, 10 * (t - 1));
+  },
+  easeOutExpo: function easeOutExpo(t) {
+    return t === 1 ? 1 : 1 - Math.pow(2, -10 * t);
+  },
+  easeInOutExpo: function easeInOutExpo(t) {
+    if (t === 0) return 0;
+    if (t === 1) return 1;
+    if (t < 0.5) return 0.5 * Math.pow(2, 10 * (2 * t - 1));
+    return 0.5 * (2 - Math.pow(2, -10 * (2 * t - 1)));
+  },
+  // Circular
+  easeInCirc: function easeInCirc(t) {
+    return 1 - Math.sqrt(1 - t * t);
+  },
+  easeOutCirc: function easeOutCirc(t) {
+    return Math.sqrt(1 - --t * t);
+  },
+  easeInOutCirc: function easeInOutCirc(t) {
+    t *= 2;
+    if (t < 1) return 0.5 * (1 - Math.sqrt(1 - t * t));
+    t -= 2;
+    return 0.5 * (Math.sqrt(1 - t * t) + 1);
+  },
+  // Elastic
+  easeInElastic: function easeInElastic(t) {
+    if (t === 0) return 0;
+    if (t === 1) return 1;
+    var p = 0.3;
+    var s = p / 4;
+    return -(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * _MathUtils.TWO_PI / p));
+  },
+  easeOutElastic: function easeOutElastic(t) {
+    if (t === 0) return 0;
+    if (t === 1) return 1;
+    var p = 0.3;
+    var s = p / 4;
+    return Math.pow(2, -10 * t) * Math.sin((t - s) * _MathUtils.TWO_PI / p) + 1;
+  }
+});
+/**
+ * Geometry utilities
+ */
+_defineProperty(MathUtils, "geometry", {
+  /**
+   * Calculate area of triangle given three points
+   * @param {Array} p1 - First point [x, y]
+   * @param {Array} p2 - Second point [x, y]
+   * @param {Array} p3 - Third point [x, y]
+   * @returns {number} Triangle area
+   */
+  triangleArea: function triangleArea(p1, p2, p3) {
+    return 0.5 * Math.abs((p2[0] - p1[0]) * (p3[1] - p1[1]) - (p3[0] - p1[0]) * (p2[1] - p1[1]));
+  },
+  /**
+   * Calculate area of polygon
+   * @param {Array} points - Array of points [[x, y], ...]
+   * @returns {number} Polygon area
+   */
+  polygonArea: function polygonArea(points) {
+    var area = 0;
+    var n = points.length;
+    for (var i = 0; i < n; i++) {
+      var j = (i + 1) % n;
+      area += points[i][0] * points[j][1];
+      area -= points[j][0] * points[i][1];
+    }
+    return Math.abs(area) / 2;
+  },
+  /**
+   * Check if point is inside triangle
+   * @param {Array} p - Point to test [x, y]
+   * @param {Array} p1 - Triangle vertex 1 [x, y]
+   * @param {Array} p2 - Triangle vertex 2 [x, y]
+   * @param {Array} p3 - Triangle vertex 3 [x, y]
+   * @returns {boolean} Whether point is inside triangle
+   */
+  pointInTriangle: function pointInTriangle(p, p1, p2, p3) {
+    var area = _MathUtils.geometry.triangleArea(p1, p2, p3);
+    var area1 = _MathUtils.geometry.triangleArea(p, p2, p3);
+    var area2 = _MathUtils.geometry.triangleArea(p1, p, p3);
+    var area3 = _MathUtils.geometry.triangleArea(p1, p2, p);
+    return Math.abs(area - (area1 + area2 + area3)) < _MathUtils.EPSILON;
+  },
+  /**
+   * Calculate centroid of polygon
+   * @param {Array} points - Array of points [[x, y], ...]
+   * @returns {Array} Centroid [x, y]
+   */
+  polygonCentroid: function polygonCentroid(points) {
+    var x = 0,
+      y = 0;
+    var area = 0;
+    var n = points.length;
+    for (var i = 0; i < n; i++) {
+      var j = (i + 1) % n;
+      var cross = points[i][0] * points[j][1] - points[j][0] * points[i][1];
+      area += cross;
+      x += (points[i][0] + points[j][0]) * cross;
+      y += (points[i][1] + points[j][1]) * cross;
+    }
+    area /= 2;
+    x /= 6 * area;
+    y /= 6 * area;
+    return [x, y];
+  }
+});
+/**
+ * Random utilities
+ */
+_defineProperty(MathUtils, "random", {
+  /**
+   * Random float between min and max
+   * @param {number} min - Minimum value
+   * @param {number} max - Maximum value
+   * @returns {number} Random float
+   */
+  float: function float() {
+    var min = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    var max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+    return min + Math.random() * (max - min);
+  },
+  /**
+   * Random integer between min and max (inclusive)
+   * @param {number} min - Minimum value
+   * @param {number} max - Maximum value
+   * @returns {number} Random integer
+   */
+  int: function int(min, max) {
+    return Math.floor(_MathUtils.random.float(min, max + 1));
+  },
+  /**
+   * Random boolean
+   * @param {number} probability - Probability of true (0-1)
+   * @returns {boolean} Random boolean
+   */
+  boolean: function boolean() {
+    var probability = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.5;
+    return Math.random() < probability;
+  },
+  /**
+   * Random element from array
+   * @param {Array} array - Input array
+   * @returns {*} Random element
+   */
+  choice: function choice(array) {
+    return array[_MathUtils.random.int(0, array.length - 1)];
+  },
+  /**
+   * Shuffle array (Fisher-Yates)
+   * @param {Array} array - Array to shuffle
+   * @returns {Array} Shuffled array
+   */
+  shuffle: function shuffle(array) {
+    var result = _toConsumableArray(array);
+    for (var i = result.length - 1; i > 0; i--) {
+      var j = Math.floor(Math.random() * (i + 1));
+      var _ref = [result[j], result[i]];
+      result[i] = _ref[0];
+      result[j] = _ref[1];
+    }
+    return result;
+  },
+  /**
+   * Random point on unit circle
+   * @returns {Array} Point [x, y]
+   */
+  unitCircle: function unitCircle() {
+    var angle = _MathUtils.random.float(0, _MathUtils.TWO_PI);
+    return [Math.cos(angle), Math.sin(angle)];
+  },
+  /**
+   * Random point inside unit circle
+   * @returns {Array} Point [x, y]
+   */
+  insideUnitCircle: function insideUnitCircle() {
+    var _MathUtils$random$uni = _MathUtils.random.unitCircle(),
+      _MathUtils$random$uni2 = _slicedToArray(_MathUtils$random$uni, 2),
+      x = _MathUtils$random$uni2[0],
+      y = _MathUtils$random$uni2[1];
+    var r = Math.sqrt(Math.random());
+    return [x * r, y * r];
+  },
+  /**
+   * Random point on unit sphere
+   * @returns {Array} Point [x, y, z]
+   */
+  unitSphere: function unitSphere() {
+    var u = Math.random();
+    var v = Math.random();
+    var theta = _MathUtils.TWO_PI * u;
+    var phi = Math.acos(2 * v - 1);
+    var x = Math.sin(phi) * Math.cos(theta);
+    var y = Math.sin(phi) * Math.sin(theta);
+    var z = Math.cos(phi);
+    return [x, y, z];
+  }
+});
+/**
+ * Color utilities
+ */
+_defineProperty(MathUtils, "color", {
+  /**
+   * Convert HSL to RGB
+   * @param {number} h - Hue (0-360)
+   * @param {number} s - Saturation (0-1)
+   * @param {number} l - Lightness (0-1)
+   * @returns {Array} RGB values [r, g, b] (0-255)
+   */
+  hslToRgb: function hslToRgb(h, s, l) {
+    h /= 360;
+    var c = (1 - Math.abs(2 * l - 1)) * s;
+    var x = c * (1 - Math.abs(h * 6 % 2 - 1));
+    var m = l - c / 2;
+    var r, g, b;
+    if (h < 1 / 6) {
+      r = c;
+      g = x;
+      b = 0;
+    } else if (h < 2 / 6) {
+      r = x;
+      g = c;
+      b = 0;
+    } else if (h < 3 / 6) {
+      r = 0;
+      g = c;
+      b = x;
+    } else if (h < 4 / 6) {
+      r = 0;
+      g = x;
+      b = c;
+    } else if (h < 5 / 6) {
+      r = x;
+      g = 0;
+      b = c;
+    } else {
+      r = c;
+      g = 0;
+      b = x;
+    }
+    return [Math.round((r + m) * 255), Math.round((g + m) * 255), Math.round((b + m) * 255)];
+  },
+  /**
+   * Convert RGB to HSL
+   * @param {number} r - Red (0-255)
+   * @param {number} g - Green (0-255)
+   * @param {number} b - Blue (0-255)
+   * @returns {Array} HSL values [h, s, l]
+   */
+  rgbToHsl: function rgbToHsl(r, g, b) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    var max = Math.max(r, g, b);
+    var min = Math.min(r, g, b);
+    var l = (max + min) / 2;
+    if (max === min) {
+      return [0, 0, l]; // Achromatic
+    }
+    var d = max - min;
+    var s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    var h;
+    switch (max) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      case g:
+        h = (b - r) / d + 2;
+        break;
+      case b:
+        h = (r - g) / d + 4;
+        break;
+    }
+    h /= 6;
+    return [h * 360, s, l];
+  },
+  /**
+   * Interpolate between two colors
+   * @param {Array} color1 - First color [r, g, b]
+   * @param {Array} color2 - Second color [r, g, b]
+   * @param {number} t - Interpolation factor (0-1)
+   * @returns {Array} Interpolated color [r, g, b]
+   */
+  lerp: function lerp(color1, color2, t) {
+    return [Math.round(_MathUtils.interpolation.linear(color1[0], color2[0], t)), Math.round(_MathUtils.interpolation.linear(color1[1], color2[1], t)), Math.round(_MathUtils.interpolation.linear(color1[2], color2[2], t))];
+  }
+});
+/**
+ * General utility functions
+ */
+_defineProperty(MathUtils, "utils", {
+  /**
+   * Clamp value between min and max
+   * @param {number} value - Input value
+   * @param {number} min - Minimum value
+   * @param {number} max - Maximum value
+   * @returns {number} Clamped value
+   */
+  clamp: function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+  },
+  /**
+   * Map value from one range to another
+   * @param {number} value - Input value
+   * @param {number} inMin - Input range minimum
+   * @param {number} inMax - Input range maximum
+   * @param {number} outMin - Output range minimum
+   * @param {number} outMax - Output range maximum
+   * @returns {number} Mapped value
+   */
+  map: function map(value, inMin, inMax, outMin, outMax) {
+    return outMin + (value - inMin) * (outMax - outMin) / (inMax - inMin);
+  },
+  /**
+   * Check if value is power of 2
+   * @param {number} value - Value to check
+   * @returns {boolean} Whether value is power of 2
+   */
+  isPowerOfTwo: function isPowerOfTwo(value) {
+    return (value & value - 1) === 0;
+  },
+  /**
+   * Get next power of 2
+   * @param {number} value - Input value
+   * @returns {number} Next power of 2
+   */
+  nextPowerOfTwo: function nextPowerOfTwo(value) {
+    return Math.pow(2, Math.ceil(Math.log2(value)));
+  },
+  /**
+   * Calculate greatest common divisor
+   * @param {number} a - First number
+   * @param {number} b - Second number
+   * @returns {number} GCD
+   */
+  gcd: function gcd(a, b) {
+    return b === 0 ? a : _MathUtils.utils.gcd(b, a % b);
+  },
+  /**
+   * Calculate least common multiple
+   * @param {number} a - First number
+   * @param {number} b - Second number
+   * @returns {number} LCM
+   */
+  lcm: function lcm(a, b) {
+    return Math.abs(a * b) / _MathUtils.utils.gcd(a, b);
+  },
+  /**
+   * Check if number is approximately equal to another
+   * @param {number} a - First number
+   * @param {number} b - Second number
+   * @param {number} epsilon - Tolerance
+   * @returns {boolean} Whether numbers are approximately equal
+   */
+  approxEqual: function approxEqual(a, b) {
+    var epsilon = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _MathUtils.EPSILON;
+    return Math.abs(a - b) < epsilon;
+  },
+  /**
+   * Round to specified decimal places
+   * @param {number} value - Input value
+   * @param {number} decimals - Number of decimal places
+   * @returns {number} Rounded value
+   */
+  round: function round(value) {
+    var decimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var factor = Math.pow(10, decimals);
+    return Math.round(value * factor) / factor;
+  }
+});
+
+export { MathUtils };

package/dist/esm/src/core/nameUtils.js

@@ -1 +1,87 @@
-function n(n){if(!n)return null;var r=n.toUpperCase().replace(/\s+COMPONENT$/i,"").replace(/\s+/g,"-").replace(/[^A-Z0-9\-]/g,"");return r=r.replace(/-COMPONENT$/,"")}function r(r,u){if(!r||!u)return null;var l=null;return r.traverse(function(r){var i;if(!l)if(r.uuid!==u)if((null===(i=r.userData)||void 0===i?void 0:i.originalUuid)!==u){if(r.name&&n(r.name)===u)return void(l=r)}else l=r;else l=r}),l}function u(r){var u;return r?null!==(u=r.userData)&&void 0!==u&&u.originalUuid?r.userData.originalUuid:r.uuid&&!r.uuid.includes("-")&&r.uuid.length>10?r.uuid:r.name?n(r.name):null:null}export{r as findObjectByHardcodedUuid,n as generateUuidFromName,u as getHardcodedUuid};
+/**
+ * Name Utilities
+ * Common helper functions for name and UUID generation
+ */
+
+/**
+ * Generate UUID from name using consistent transformation rules
+ * @param {string} name - The name to convert to UUID
+ * @returns {string} The generated UUID
+ */
+function generateUuidFromName(name) {
+  if (!name) return null;
+
+  // Convert name to uppercase and replace spaces with hyphens
+  var uuid = name.toUpperCase().replace(/\s+COMPONENT$/i, '') // Remove "Component" suffix
+  .replace(/\s+/g, '-') // Replace spaces with hyphens
+  .replace(/[^A-Z0-9\-]/g, ''); // Remove special characters except hyphens
+
+  // Clean up any duplicate "COMPONENT" text that might have been left behind
+  uuid = uuid.replace(/-COMPONENT$/, '');
+  return uuid;
+}
+
+/**
+ * Find an object in a Three.js scene by hardcoded UUID with fallback strategies
+ * @param {THREE.Scene} scene - The Three.js scene to search
+ * @param {string} targetUuid - The UUID to search for
+ * @returns {THREE.Object3D|null} The found object or null
+ */
+function findObjectByHardcodedUuid(scene, targetUuid) {
+  if (!scene || !targetUuid) return null;
+  var foundObject = null;
+  scene.traverse(function (child) {
+    var _child$userData;
+    if (foundObject) return; // Stop if already found
+
+    // Strategy 1: Direct UUID match (HIGHEST PRIORITY)
+    if (child.uuid === targetUuid) {
+      foundObject = child;
+      return;
+    }
+
+    // Strategy 2: Original hardcoded UUID match
+    if (((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.originalUuid) === targetUuid) {
+      foundObject = child;
+      return;
+    }
+
+    // Strategy 3: Name-based UUID match (FALLBACK)
+    if (child.name) {
+      var generatedUuid = generateUuidFromName(child.name);
+      if (generatedUuid === targetUuid) {
+        foundObject = child;
+        return;
+      }
+    }
+  });
+  return foundObject;
+}
+
+/**
+ * Get the hardcoded UUID for an object, prioritizing original over current
+ * @param {THREE.Object3D} object - The Three.js object
+ * @returns {string|null} The hardcoded UUID or null
+ */
+function getHardcodedUuid(object) {
+  var _object$userData;
+  if (!object) return null;
+
+  // Priority 1: Original hardcoded UUID stored in userData
+  if ((_object$userData = object.userData) !== null && _object$userData !== void 0 && _object$userData.originalUuid) {
+    return object.userData.originalUuid;
+  }
+
+  // Priority 2: Current UUID (if it looks like a hardcoded one)
+  if (object.uuid && !object.uuid.includes('-') && object.uuid.length > 10) {
+    return object.uuid;
+  }
+
+  // Priority 3: Generate from name if available
+  if (object.name) {
+    return generateUuidFromName(object.name);
+  }
+  return null;
+}
+
+export { findObjectByHardcodedUuid, generateUuidFromName, getHardcodedUuid };