npm - react-three-nurbs - Versions diffs - 0.1.0 → 0.3.0 - Mend

react-three-nurbs 0.1.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.js CHANGED Viewed

@@ -1,9 +1,11 @@
-import Ne, { useMemo as Me, useState as pr, useEffect as mr, isValidElement as Ye, Children as br } from "react";
-import { Vector3 as hr, BufferGeometry as yr, Float32BufferAttribute as Ie, MeshPhongMaterial as gr, DoubleSide as Er, Color as _r, Mesh as Rr } from "three";
-import ue from "verb-nurbs";
-import { Line as Sr } from "@react-three/drei";
-import { useThree as Cr } from "@react-three/fiber";
-var ge = { exports: {} }, ee = {};
+var un = Object.defineProperty;
+var fn = (t, n, e) => n in t ? un(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
+var ct = (t, n, e) => fn(t, typeof n != "symbol" ? n + "" : n, e);
+import Se, { useMemo as V, isValidElement as gt, forwardRef as ie, Children as ht, useRef as et, useCallback as it, useState as hn } from "react";
+import { Vector3 as I, BufferGeometry as pt, Float32BufferAttribute as J, DoubleSide as wt, Plane as dn, Raycaster as gn, Vector2 as pn } from "three";
+import { Line as xt } from "@react-three/drei";
+import { useThree as vn } from "@react-three/fiber";
+var ee = { exports: {} }, jt = {};
 /**
  * @license React
  * react-jsx-runtime.production.min.js
@@ -13,21 +15,21 @@ var ge = { exports: {} }, ee = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var We;
-function Tr() {
-  if (We) return ee;
-  We = 1;
-  var T = Ne, x = Symbol.for("react.element"), y = Symbol.for("react.fragment"), c = Object.prototype.hasOwnProperty, k = T.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, F = { key: !0, ref: !0, __self: !0, __source: !0 };
-  function _(g, f, E) {
-    var p, m = {}, R = null, D = null;
-    E !== void 0 && (R = "" + E), f.key !== void 0 && (R = "" + f.key), f.ref !== void 0 && (D = f.ref);
-    for (p in f) c.call(f, p) && !F.hasOwnProperty(p) && (m[p] = f[p]);
-    if (g && g.defaultProps) for (p in f = g.defaultProps, f) m[p] === void 0 && (m[p] = f[p]);
-    return { $$typeof: x, type: g, key: R, ref: D, props: m, _owner: k.current };
-  }
-  return ee.Fragment = y, ee.jsx = _, ee.jsxs = _, ee;
-}
-var re = {};
+var Pe;
+function mn() {
+  if (Pe) return jt;
+  Pe = 1;
+  var t = Se, n = Symbol.for("react.element"), e = Symbol.for("react.fragment"), r = Object.prototype.hasOwnProperty, s = t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, o = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function i(l, u, a) {
+    var g, f = {}, c = null, h = null;
+    a !== void 0 && (c = "" + a), u.key !== void 0 && (c = "" + u.key), u.ref !== void 0 && (h = u.ref);
+    for (g in u) r.call(u, g) && !o.hasOwnProperty(g) && (f[g] = u[g]);
+    if (l && l.defaultProps) for (g in u = l.defaultProps, u) f[g] === void 0 && (f[g] = u[g]);
+    return { $$typeof: n, type: l, key: c, ref: h, props: f, _owner: s.current };
+  }
+  return jt.Fragment = e, jt.jsx = i, jt.jsxs = i, jt;
+}
+var Rt = {};
 /**
  * @license React
  * react-jsx-runtime.development.js
@@ -37,91 +39,91 @@ var re = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var $e;
-function wr() {
-  return $e || ($e = 1, process.env.NODE_ENV !== "production" && function() {
-    var T = Ne, x = Symbol.for("react.element"), y = Symbol.for("react.portal"), c = Symbol.for("react.fragment"), k = Symbol.for("react.strict_mode"), F = Symbol.for("react.profiler"), _ = Symbol.for("react.provider"), g = Symbol.for("react.context"), f = Symbol.for("react.forward_ref"), E = Symbol.for("react.suspense"), p = Symbol.for("react.suspense_list"), m = Symbol.for("react.memo"), R = Symbol.for("react.lazy"), D = Symbol.for("react.offscreen"), S = Symbol.iterator, b = "@@iterator";
-    function v(e) {
-      if (e === null || typeof e != "object")
+var Ce;
+function yn() {
+  return Ce || (Ce = 1, process.env.NODE_ENV !== "production" && function() {
+    var t = Se, n = Symbol.for("react.element"), e = Symbol.for("react.portal"), r = Symbol.for("react.fragment"), s = Symbol.for("react.strict_mode"), o = Symbol.for("react.profiler"), i = Symbol.for("react.provider"), l = Symbol.for("react.context"), u = Symbol.for("react.forward_ref"), a = Symbol.for("react.suspense"), g = Symbol.for("react.suspense_list"), f = Symbol.for("react.memo"), c = Symbol.for("react.lazy"), h = Symbol.for("react.offscreen"), p = Symbol.iterator, y = "@@iterator";
+    function d(v) {
+      if (v === null || typeof v != "object")
         return null;
-      var r = S && e[S] || e[b];
-      return typeof r == "function" ? r : null;
+      var C = p && v[p] || v[y];
+      return typeof C == "function" ? C : null;
     }
-    var C = T.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-    function s(e) {
+    var m = t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function w(v) {
       {
-        for (var r = arguments.length, t = new Array(r > 1 ? r - 1 : 0), n = 1; n < r; n++)
-          t[n - 1] = arguments[n];
-        W("error", e, t);
+        for (var C = arguments.length, A = new Array(C > 1 ? C - 1 : 0), F = 1; F < C; F++)
+          A[F - 1] = arguments[F];
+        x("error", v, A);
       }
     }
-    function W(e, r, t) {
+    function x(v, C, A) {
       {
-        var n = C.ReactDebugCurrentFrame, i = n.getStackAddendum();
-        i !== "" && (r += "%s", t = t.concat([i]));
-        var u = t.map(function(o) {
-          return String(o);
+        var F = m.ReactDebugCurrentFrame, K = F.getStackAddendum();
+        K !== "" && (C += "%s", A = A.concat([K]));
+        var L = A.map(function($) {
+          return String($);
         });
-        u.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, u);
+        L.unshift("Warning: " + C), Function.prototype.apply.call(console[v], console, L);
       }
     }
-    var H = !1, U = !1, ce = !1, fe = !1, w = !1, l;
-    l = Symbol.for("react.module.reference");
-    function $(e) {
-      return !!(typeof e == "string" || typeof e == "function" || e === c || e === F || w || e === k || e === E || e === p || fe || e === D || H || U || ce || typeof e == "object" && e !== null && (e.$$typeof === R || e.$$typeof === m || e.$$typeof === _ || e.$$typeof === g || e.$$typeof === f || // This needs to include all possible module reference object
+    var _ = !1, b = !1, P = !1, M = !1, S = !1, U;
+    U = Symbol.for("react.module.reference");
+    function j(v) {
+      return !!(typeof v == "string" || typeof v == "function" || v === r || v === o || S || v === s || v === a || v === g || M || v === h || _ || b || P || typeof v == "object" && v !== null && (v.$$typeof === c || v.$$typeof === f || v.$$typeof === i || v.$$typeof === l || v.$$typeof === u || // This needs to include all possible module reference object
       // types supported by any Flight configuration anywhere since
       // we don't know which Flight build this will end up being used
       // with.
-      e.$$typeof === l || e.getModuleId !== void 0));
+      v.$$typeof === U || v.getModuleId !== void 0));
     }
-    function N(e, r, t) {
-      var n = e.displayName;
-      if (n)
-        return n;
-      var i = r.displayName || r.name || "";
-      return i !== "" ? t + "(" + i + ")" : t;
+    function k(v, C, A) {
+      var F = v.displayName;
+      if (F)
+        return F;
+      var K = C.displayName || C.name || "";
+      return K !== "" ? A + "(" + K + ")" : A;
     }
-    function B(e) {
-      return e.displayName || "Context";
+    function E(v) {
+      return v.displayName || "Context";
     }
-    function j(e) {
-      if (e == null)
+    function T(v) {
+      if (v == null)
         return null;
-      if (typeof e.tag == "number" && s("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
-        return e.displayName || e.name || null;
-      if (typeof e == "string")
-        return e;
-      switch (e) {
-        case c:
+      if (typeof v.tag == "number" && w("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof v == "function")
+        return v.displayName || v.name || null;
+      if (typeof v == "string")
+        return v;
+      switch (v) {
+        case r:
           return "Fragment";
-        case y:
+        case e:
           return "Portal";
-        case F:
+        case o:
           return "Profiler";
-        case k:
+        case s:
           return "StrictMode";
-        case E:
+        case a:
           return "Suspense";
-        case p:
+        case g:
           return "SuspenseList";
       }
-      if (typeof e == "object")
-        switch (e.$$typeof) {
-          case g:
-            var r = e;
-            return B(r) + ".Consumer";
-          case _:
-            var t = e;
-            return B(t._context) + ".Provider";
+      if (typeof v == "object")
+        switch (v.$$typeof) {
+          case l:
+            var C = v;
+            return E(C) + ".Consumer";
+          case i:
+            var A = v;
+            return E(A._context) + ".Provider";
+          case u:
+            return k(v, v.render, "ForwardRef");
           case f:
-            return N(e, e.render, "ForwardRef");
-          case m:
-            var n = e.displayName || null;
-            return n !== null ? n : j(e.type) || "Memo";
-          case R: {
-            var i = e, u = i._payload, o = i._init;
+            var F = v.displayName || null;
+            return F !== null ? F : T(v.type) || "Memo";
+          case c: {
+            var K = v, L = K._payload, $ = K._init;
             try {
-              return j(o(u));
+              return T($(L));
             } catch {
               return null;
             }
@@ -129,693 +131,3119 @@ function wr() {
         }
       return null;
     }
-    var M = Object.assign, z = 0, Z, Y, L, I, te, ne, q;
-    function J() {
+    var D = Object.assign, R = 0, W, G, Q, X, nt, lt, At;
+    function St() {
     }
-    J.__reactDisabledLog = !0;
-    function Le() {
+    St.__reactDisabledLog = !0;
+    function N() {
       {
-        if (z === 0) {
-          Z = console.log, Y = console.info, L = console.warn, I = console.error, te = console.group, ne = console.groupCollapsed, q = console.groupEnd;
-          var e = {
+        if (R === 0) {
+          W = console.log, G = console.info, Q = console.warn, X = console.error, nt = console.group, lt = console.groupCollapsed, At = console.groupEnd;
+          var v = {
             configurable: !0,
             enumerable: !0,
-            value: J,
+            value: St,
             writable: !0
           };
           Object.defineProperties(console, {
-            info: e,
-            log: e,
-            warn: e,
-            error: e,
-            group: e,
-            groupCollapsed: e,
-            groupEnd: e
+            info: v,
+            log: v,
+            warn: v,
+            error: v,
+            group: v,
+            groupCollapsed: v,
+            groupEnd: v
           });
         }
-        z++;
+        R++;
       }
     }
-    function Ke() {
+    function _t() {
       {
-        if (z--, z === 0) {
-          var e = {
+        if (R--, R === 0) {
+          var v = {
             configurable: !0,
             enumerable: !0,
             writable: !0
           };
           Object.defineProperties(console, {
-            log: M({}, e, {
-              value: Z
+            log: D({}, v, {
+              value: W
             }),
-            info: M({}, e, {
-              value: Y
+            info: D({}, v, {
+              value: G
             }),
-            warn: M({}, e, {
-              value: L
+            warn: D({}, v, {
+              value: Q
             }),
-            error: M({}, e, {
-              value: I
+            error: D({}, v, {
+              value: X
             }),
-            group: M({}, e, {
-              value: te
+            group: D({}, v, {
+              value: nt
             }),
-            groupCollapsed: M({}, e, {
-              value: ne
+            groupCollapsed: D({}, v, {
+              value: lt
             }),
-            groupEnd: M({}, e, {
-              value: q
+            groupEnd: D({}, v, {
+              value: At
             })
           });
         }
-        z < 0 && s("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+        R < 0 && w("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
       }
     }
-    var le = C.ReactCurrentDispatcher, ve;
-    function ae(e, r, t) {
+    var Bt = m.ReactCurrentDispatcher, Zt;
+    function It(v, C, A) {
       {
-        if (ve === void 0)
+        if (Zt === void 0)
           try {
             throw Error();
-          } catch (i) {
-            var n = i.stack.trim().match(/\n( *(at )?)/);
-            ve = n && n[1] || "";
+          } catch (K) {
+            var F = K.stack.trim().match(/\n( *(at )?)/);
+            Zt = F && F[1] || "";
           }
         return `
-` + ve + e;
+` + Zt + v;
       }
     }
-    var de = !1, oe;
+    var Yt = !1, Ot;
     {
-      var Be = typeof WeakMap == "function" ? WeakMap : Map;
-      oe = new Be();
+      var Ve = typeof WeakMap == "function" ? WeakMap : Map;
+      Ot = new Ve();
     }
-    function Ee(e, r) {
-      if (!e || de)
+    function le(v, C) {
+      if (!v || Yt)
         return "";
       {
-        var t = oe.get(e);
-        if (t !== void 0)
-          return t;
+        var A = Ot.get(v);
+        if (A !== void 0)
+          return A;
       }
-      var n;
-      de = !0;
-      var i = Error.prepareStackTrace;
+      var F;
+      Yt = !0;
+      var K = Error.prepareStackTrace;
       Error.prepareStackTrace = void 0;
-      var u;
-      u = le.current, le.current = null, Le();
+      var L;
+      L = Bt.current, Bt.current = null, N();
       try {
-        if (r) {
-          var o = function() {
+        if (C) {
+          var $ = function() {
             throw Error();
           };
-          if (Object.defineProperty(o.prototype, "props", {
+          if (Object.defineProperty($.prototype, "props", {
             set: function() {
               throw Error();
             }
           }), typeof Reflect == "object" && Reflect.construct) {
             try {
-              Reflect.construct(o, []);
-            } catch (P) {
-              n = P;
+              Reflect.construct($, []);
+            } catch (rt) {
+              F = rt;
             }
-            Reflect.construct(e, [], o);
+            Reflect.construct(v, [], $);
           } else {
             try {
-              o.call();
-            } catch (P) {
-              n = P;
+              $.call();
+            } catch (rt) {
+              F = rt;
             }
-            e.call(o.prototype);
+            v.call($.prototype);
           }
         } else {
           try {
             throw Error();
-          } catch (P) {
-            n = P;
+          } catch (rt) {
+            F = rt;
           }
-          e();
-        }
-      } catch (P) {
-        if (P && n && typeof P.stack == "string") {
-          for (var a = P.stack.split(`
-`), O = n.stack.split(`
-`), d = a.length - 1, h = O.length - 1; d >= 1 && h >= 0 && a[d] !== O[h]; )
-            h--;
-          for (; d >= 1 && h >= 0; d--, h--)
-            if (a[d] !== O[h]) {
-              if (d !== 1 || h !== 1)
+          v();
+        }
+      } catch (rt) {
+        if (rt && F && typeof rt.stack == "string") {
+          for (var O = rt.stack.split(`
+`), tt = F.stack.split(`
+`), Z = O.length - 1, Y = tt.length - 1; Z >= 1 && Y >= 0 && O[Z] !== tt[Y]; )
+            Y--;
+          for (; Z >= 1 && Y >= 0; Z--, Y--)
+            if (O[Z] !== tt[Y]) {
+              if (Z !== 1 || Y !== 1)
                 do
-                  if (d--, h--, h < 0 || a[d] !== O[h]) {
-                    var A = `
-` + a[d].replace(" at new ", " at ");
-                    return e.displayName && A.includes("<anonymous>") && (A = A.replace("<anonymous>", e.displayName)), typeof e == "function" && oe.set(e, A), A;
+                  if (Z--, Y--, Y < 0 || O[Z] !== tt[Y]) {
+                    var ot = `
+` + O[Z].replace(" at new ", " at ");
+                    return v.displayName && ot.includes("<anonymous>") && (ot = ot.replace("<anonymous>", v.displayName)), typeof v == "function" && Ot.set(v, ot), ot;
                   }
-                while (d >= 1 && h >= 0);
+                while (Z >= 1 && Y >= 0);
               break;
             }
         }
       } finally {
-        de = !1, le.current = u, Ke(), Error.prepareStackTrace = i;
+        Yt = !1, Bt.current = L, _t(), Error.prepareStackTrace = K;
       }
-      var X = e ? e.displayName || e.name : "", G = X ? ae(X) : "";
-      return typeof e == "function" && oe.set(e, G), G;
+      var Pt = v ? v.displayName || v.name : "", mt = Pt ? It(Pt) : "";
+      return typeof v == "function" && Ot.set(v, mt), mt;
     }
-    function qe(e, r, t) {
-      return Ee(e, !1);
+    function $e(v, C, A) {
+      return le(v, !1);
     }
-    function Ue(e) {
-      var r = e.prototype;
-      return !!(r && r.isReactComponent);
+    function Ne(v) {
+      var C = v.prototype;
+      return !!(C && C.isReactComponent);
     }
-    function ie(e, r, t) {
-      if (e == null)
+    function Vt(v, C, A) {
+      if (v == null)
         return "";
-      if (typeof e == "function")
-        return Ee(e, Ue(e));
-      if (typeof e == "string")
-        return ae(e);
-      switch (e) {
-        case E:
-          return ae("Suspense");
-        case p:
-          return ae("SuspenseList");
-      }
-      if (typeof e == "object")
-        switch (e.$$typeof) {
+      if (typeof v == "function")
+        return le(v, Ne(v));
+      if (typeof v == "string")
+        return It(v);
+      switch (v) {
+        case a:
+          return It("Suspense");
+        case g:
+          return It("SuspenseList");
+      }
+      if (typeof v == "object")
+        switch (v.$$typeof) {
+          case u:
+            return $e(v.render);
           case f:
-            return qe(e.render);
-          case m:
-            return ie(e.type, r, t);
-          case R: {
-            var n = e, i = n._payload, u = n._init;
+            return Vt(v.type, C, A);
+          case c: {
+            var F = v, K = F._payload, L = F._init;
             try {
-              return ie(u(i), r, t);
+              return Vt(L(K), C, A);
             } catch {
             }
           }
         }
       return "";
     }
-    var Q = Object.prototype.hasOwnProperty, _e = {}, Re = C.ReactDebugCurrentFrame;
-    function se(e) {
-      if (e) {
-        var r = e._owner, t = ie(e.type, e._source, r ? r.type : null);
-        Re.setExtraStackFrame(t);
+    var Et = Object.prototype.hasOwnProperty, ae = {}, ue = m.ReactDebugCurrentFrame;
+    function $t(v) {
+      if (v) {
+        var C = v._owner, A = Vt(v.type, v._source, C ? C.type : null);
+        ue.setExtraStackFrame(A);
       } else
-        Re.setExtraStackFrame(null);
+        ue.setExtraStackFrame(null);
     }
-    function ze(e, r, t, n, i) {
+    function Ke(v, C, A, F, K) {
       {
-        var u = Function.call.bind(Q);
-        for (var o in e)
-          if (u(e, o)) {
-            var a = void 0;
+        var L = Function.call.bind(Et);
+        for (var $ in v)
+          if (L(v, $)) {
+            var O = void 0;
             try {
-              if (typeof e[o] != "function") {
-                var O = Error((n || "React class") + ": " + t + " type `" + o + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[o] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
-                throw O.name = "Invariant Violation", O;
+              if (typeof v[$] != "function") {
+                var tt = Error((F || "React class") + ": " + A + " type `" + $ + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof v[$] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw tt.name = "Invariant Violation", tt;
               }
-              a = e[o](r, o, n, t, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
-            } catch (d) {
-              a = d;
+              O = v[$](C, $, F, A, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (Z) {
+              O = Z;
             }
-            a && !(a instanceof Error) && (se(i), s("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", n || "React class", t, o, typeof a), se(null)), a instanceof Error && !(a.message in _e) && (_e[a.message] = !0, se(i), s("Failed %s type: %s", t, a.message), se(null));
+            O && !(O instanceof Error) && ($t(K), w("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", F || "React class", A, $, typeof O), $t(null)), O instanceof Error && !(O.message in ae) && (ae[O.message] = !0, $t(K), w("Failed %s type: %s", A, O.message), $t(null));
           }
       }
     }
-    var Ge = Array.isArray;
-    function pe(e) {
-      return Ge(e);
+    var We = Array.isArray;
+    function Jt(v) {
+      return We(v);
     }
-    function Je(e) {
+    function Le(v) {
       {
-        var r = typeof Symbol == "function" && Symbol.toStringTag, t = r && e[Symbol.toStringTag] || e.constructor.name || "Object";
-        return t;
+        var C = typeof Symbol == "function" && Symbol.toStringTag, A = C && v[Symbol.toStringTag] || v.constructor.name || "Object";
+        return A;
       }
     }
-    function Ve(e) {
+    function qe(v) {
       try {
-        return Se(e), !1;
+        return fe(v), !1;
       } catch {
         return !0;
       }
     }
-    function Se(e) {
-      return "" + e;
+    function fe(v) {
+      return "" + v;
     }
-    function Ce(e) {
-      if (Ve(e))
-        return s("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Je(e)), Se(e);
+    function he(v) {
+      if (qe(v))
+        return w("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Le(v)), fe(v);
     }
-    var Te = C.ReactCurrentOwner, Xe = {
+    var de = m.ReactCurrentOwner, ze = {
       key: !0,
       ref: !0,
       __self: !0,
       __source: !0
-    }, we, je;
-    function He(e) {
-      if (Q.call(e, "ref")) {
-        var r = Object.getOwnPropertyDescriptor(e, "ref").get;
-        if (r && r.isReactWarning)
+    }, ge, pe;
+    function Be(v) {
+      if (Et.call(v, "ref")) {
+        var C = Object.getOwnPropertyDescriptor(v, "ref").get;
+        if (C && C.isReactWarning)
           return !1;
       }
-      return e.ref !== void 0;
+      return v.ref !== void 0;
     }
-    function Ze(e) {
-      if (Q.call(e, "key")) {
-        var r = Object.getOwnPropertyDescriptor(e, "key").get;
-        if (r && r.isReactWarning)
+    function Ze(v) {
+      if (Et.call(v, "key")) {
+        var C = Object.getOwnPropertyDescriptor(v, "key").get;
+        if (C && C.isReactWarning)
           return !1;
       }
-      return e.key !== void 0;
+      return v.key !== void 0;
     }
-    function Qe(e, r) {
-      typeof e.ref == "string" && Te.current;
+    function Ye(v, C) {
+      typeof v.ref == "string" && de.current;
     }
-    function er(e, r) {
+    function Je(v, C) {
       {
-        var t = function() {
-          we || (we = !0, s("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        var A = function() {
+          ge || (ge = !0, w("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", C));
         };
-        t.isReactWarning = !0, Object.defineProperty(e, "key", {
-          get: t,
+        A.isReactWarning = !0, Object.defineProperty(v, "key", {
+          get: A,
           configurable: !0
         });
       }
     }
-    function rr(e, r) {
+    function Ge(v, C) {
       {
-        var t = function() {
-          je || (je = !0, s("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        var A = function() {
+          pe || (pe = !0, w("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", C));
         };
-        t.isReactWarning = !0, Object.defineProperty(e, "ref", {
-          get: t,
+        A.isReactWarning = !0, Object.defineProperty(v, "ref", {
+          get: A,
           configurable: !0
         });
       }
     }
-    var tr = function(e, r, t, n, i, u, o) {
-      var a = {
+    var He = function(v, C, A, F, K, L, $) {
+      var O = {
         // This tag allows us to uniquely identify this as a React Element
-        $$typeof: x,
+        $$typeof: n,
         // Built-in properties that belong on the element
-        type: e,
-        key: r,
-        ref: t,
-        props: o,
+        type: v,
+        key: C,
+        ref: A,
+        props: $,
         // Record the component responsible for creating this element.
-        _owner: u
+        _owner: L
       };
-      return a._store = {}, Object.defineProperty(a._store, "validated", {
+      return O._store = {}, Object.defineProperty(O._store, "validated", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
         value: !1
-      }), Object.defineProperty(a, "_self", {
+      }), Object.defineProperty(O, "_self", {
         configurable: !1,
         enumerable: !1,
         writable: !1,
-        value: n
-      }), Object.defineProperty(a, "_source", {
+        value: F
+      }), Object.defineProperty(O, "_source", {
         configurable: !1,
         enumerable: !1,
         writable: !1,
-        value: i
-      }), Object.freeze && (Object.freeze(a.props), Object.freeze(a)), a;
+        value: K
+      }), Object.freeze && (Object.freeze(O.props), Object.freeze(O)), O;
     };
-    function nr(e, r, t, n, i) {
+    function Xe(v, C, A, F, K) {
       {
-        var u, o = {}, a = null, O = null;
-        t !== void 0 && (Ce(t), a = "" + t), Ze(r) && (Ce(r.key), a = "" + r.key), He(r) && (O = r.ref, Qe(r, i));
-        for (u in r)
-          Q.call(r, u) && !Xe.hasOwnProperty(u) && (o[u] = r[u]);
-        if (e && e.defaultProps) {
-          var d = e.defaultProps;
-          for (u in d)
-            o[u] === void 0 && (o[u] = d[u]);
-        }
-        if (a || O) {
-          var h = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
-          a && er(o, h), O && rr(o, h);
-        }
-        return tr(e, a, O, i, n, Te.current, o);
-      }
-    }
-    var me = C.ReactCurrentOwner, Oe = C.ReactDebugCurrentFrame;
-    function V(e) {
-      if (e) {
-        var r = e._owner, t = ie(e.type, e._source, r ? r.type : null);
-        Oe.setExtraStackFrame(t);
+        var L, $ = {}, O = null, tt = null;
+        A !== void 0 && (he(A), O = "" + A), Ze(C) && (he(C.key), O = "" + C.key), Be(C) && (tt = C.ref, Ye(C, K));
+        for (L in C)
+          Et.call(C, L) && !ze.hasOwnProperty(L) && ($[L] = C[L]);
+        if (v && v.defaultProps) {
+          var Z = v.defaultProps;
+          for (L in Z)
+            $[L] === void 0 && ($[L] = Z[L]);
+        }
+        if (O || tt) {
+          var Y = typeof v == "function" ? v.displayName || v.name || "Unknown" : v;
+          O && Je($, Y), tt && Ge($, Y);
+        }
+        return He(v, O, tt, K, F, de.current, $);
+      }
+    }
+    var Gt = m.ReactCurrentOwner, ve = m.ReactDebugCurrentFrame;
+    function bt(v) {
+      if (v) {
+        var C = v._owner, A = Vt(v.type, v._source, C ? C.type : null);
+        ve.setExtraStackFrame(A);
       } else
-        Oe.setExtraStackFrame(null);
+        ve.setExtraStackFrame(null);
     }
-    var be;
-    be = !1;
-    function he(e) {
-      return typeof e == "object" && e !== null && e.$$typeof === x;
+    var Ht;
+    Ht = !1;
+    function Xt(v) {
+      return typeof v == "object" && v !== null && v.$$typeof === n;
     }
-    function Pe() {
+    function me() {
       {
-        if (me.current) {
-          var e = j(me.current.type);
-          if (e)
+        if (Gt.current) {
+          var v = T(Gt.current.type);
+          if (v)
             return `
-Check the render method of \`` + e + "`.";
+Check the render method of \`` + v + "`.";
         }
         return "";
       }
     }
-    function ar(e) {
+    function Qe(v) {
       return "";
     }
-    var xe = {};
-    function or(e) {
+    var ye = {};
+    function tn(v) {
       {
-        var r = Pe();
-        if (!r) {
-          var t = typeof e == "string" ? e : e.displayName || e.name;
-          t && (r = `
+        var C = me();
+        if (!C) {
+          var A = typeof v == "string" ? v : v.displayName || v.name;
+          A && (C = `
-Check the top-level render call using <` + t + ">.");
+Check the top-level render call using <` + A + ">.");
         }
-        return r;
+        return C;
       }
     }
-    function ke(e, r) {
+    function we(v, C) {
       {
-        if (!e._store || e._store.validated || e.key != null)
+        if (!v._store || v._store.validated || v.key != null)
           return;
-        e._store.validated = !0;
-        var t = or(r);
-        if (xe[t])
+        v._store.validated = !0;
+        var A = tn(C);
+        if (ye[A])
           return;
-        xe[t] = !0;
-        var n = "";
-        e && e._owner && e._owner !== me.current && (n = " It was passed a child from " + j(e._owner.type) + "."), V(e), s('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', t, n), V(null);
+        ye[A] = !0;
+        var F = "";
+        v && v._owner && v._owner !== Gt.current && (F = " It was passed a child from " + T(v._owner.type) + "."), bt(v), w('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', A, F), bt(null);
       }
     }
-    function Ae(e, r) {
+    function xe(v, C) {
       {
-        if (typeof e != "object")
+        if (typeof v != "object")
           return;
-        if (pe(e))
-          for (var t = 0; t < e.length; t++) {
-            var n = e[t];
-            he(n) && ke(n, r);
+        if (Jt(v))
+          for (var A = 0; A < v.length; A++) {
+            var F = v[A];
+            Xt(F) && we(F, C);
           }
-        else if (he(e))
-          e._store && (e._store.validated = !0);
-        else if (e) {
-          var i = v(e);
-          if (typeof i == "function" && i !== e.entries)
-            for (var u = i.call(e), o; !(o = u.next()).done; )
-              he(o.value) && ke(o.value, r);
+        else if (Xt(v))
+          v._store && (v._store.validated = !0);
+        else if (v) {
+          var K = d(v);
+          if (typeof K == "function" && K !== v.entries)
+            for (var L = K.call(v), $; !($ = L.next()).done; )
+              Xt($.value) && we($.value, C);
         }
       }
     }
-    function ir(e) {
+    function en(v) {
       {
-        var r = e.type;
-        if (r == null || typeof r == "string")
+        var C = v.type;
+        if (C == null || typeof C == "string")
           return;
-        var t;
-        if (typeof r == "function")
-          t = r.propTypes;
-        else if (typeof r == "object" && (r.$$typeof === f || // Note: Memo only checks outer props here.
+        var A;
+        if (typeof C == "function")
+          A = C.propTypes;
+        else if (typeof C == "object" && (C.$$typeof === u || // Note: Memo only checks outer props here.
         // Inner props are checked in the reconciler.
-        r.$$typeof === m))
-          t = r.propTypes;
+        C.$$typeof === f))
+          A = C.propTypes;
         else
           return;
-        if (t) {
-          var n = j(r);
-          ze(t, e.props, "prop", n, e);
-        } else if (r.PropTypes !== void 0 && !be) {
-          be = !0;
-          var i = j(r);
-          s("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", i || "Unknown");
+        if (A) {
+          var F = T(C);
+          Ke(A, v.props, "prop", F, v);
+        } else if (C.PropTypes !== void 0 && !Ht) {
+          Ht = !0;
+          var K = T(C);
+          w("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", K || "Unknown");
         }
-        typeof r.getDefaultProps == "function" && !r.getDefaultProps.isReactClassApproved && s("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+        typeof C.getDefaultProps == "function" && !C.getDefaultProps.isReactClassApproved && w("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
       }
     }
-    function sr(e) {
+    function nn(v) {
       {
-        for (var r = Object.keys(e.props), t = 0; t < r.length; t++) {
-          var n = r[t];
-          if (n !== "children" && n !== "key") {
-            V(e), s("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", n), V(null);
+        for (var C = Object.keys(v.props), A = 0; A < C.length; A++) {
+          var F = C[A];
+          if (F !== "children" && F !== "key") {
+            bt(v), w("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", F), bt(null);
             break;
           }
         }
-        e.ref !== null && (V(e), s("Invalid attribute `ref` supplied to `React.Fragment`."), V(null));
+        v.ref !== null && (bt(v), w("Invalid attribute `ref` supplied to `React.Fragment`."), bt(null));
       }
     }
-    var Fe = {};
-    function De(e, r, t, n, i, u) {
+    var _e = {};
+    function be(v, C, A, F, K, L) {
       {
-        var o = $(e);
-        if (!o) {
-          var a = "";
-          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (a += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
-          var O = ar();
-          O ? a += O : a += Pe();
-          var d;
-          e === null ? d = "null" : pe(e) ? d = "array" : e !== void 0 && e.$$typeof === x ? (d = "<" + (j(e.type) || "Unknown") + " />", a = " Did you accidentally export a JSX literal instead of a component?") : d = typeof e, s("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", d, a);
-        }
-        var h = nr(e, r, t, i, u);
-        if (h == null)
-          return h;
-        if (o) {
-          var A = r.children;
-          if (A !== void 0)
-            if (n)
-              if (pe(A)) {
-                for (var X = 0; X < A.length; X++)
-                  Ae(A[X], e);
-                Object.freeze && Object.freeze(A);
+        var $ = j(v);
+        if (!$) {
+          var O = "";
+          (v === void 0 || typeof v == "object" && v !== null && Object.keys(v).length === 0) && (O += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var tt = Qe();
+          tt ? O += tt : O += me();
+          var Z;
+          v === null ? Z = "null" : Jt(v) ? Z = "array" : v !== void 0 && v.$$typeof === n ? (Z = "<" + (T(v.type) || "Unknown") + " />", O = " Did you accidentally export a JSX literal instead of a component?") : Z = typeof v, w("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", Z, O);
+        }
+        var Y = Xe(v, C, A, K, L);
+        if (Y == null)
+          return Y;
+        if ($) {
+          var ot = C.children;
+          if (ot !== void 0)
+            if (F)
+              if (Jt(ot)) {
+                for (var Pt = 0; Pt < ot.length; Pt++)
+                  xe(ot[Pt], v);
+                Object.freeze && Object.freeze(ot);
               } else
-                s("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+                w("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
             else
-              Ae(A, e);
-        }
-        if (Q.call(r, "key")) {
-          var G = j(e), P = Object.keys(r).filter(function(dr) {
-            return dr !== "key";
-          }), ye = P.length > 0 ? "{key: someKey, " + P.join(": ..., ") + ": ...}" : "{key: someKey}";
-          if (!Fe[G + ye]) {
-            var vr = P.length > 0 ? "{" + P.join(": ..., ") + ": ...}" : "{}";
-            s(`A props object containing a "key" prop is being spread into JSX:
+              xe(ot, v);
+        }
+        if (Et.call(C, "key")) {
+          var mt = T(v), rt = Object.keys(C).filter(function(an) {
+            return an !== "key";
+          }), Qt = rt.length > 0 ? "{key: someKey, " + rt.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!_e[mt + Qt]) {
+            var ln = rt.length > 0 ? "{" + rt.join(": ..., ") + ": ...}" : "{}";
+            w(`A props object containing a "key" prop is being spread into JSX:
   let props = %s;
   <%s {...props} />
 React keys must be passed directly to JSX without using spread:
   let props = %s;
-  <%s key={someKey} {...props} />`, ye, G, vr, G), Fe[G + ye] = !0;
+  <%s key={someKey} {...props} />`, Qt, mt, ln, mt), _e[mt + Qt] = !0;
           }
         }
-        return e === c ? sr(h) : ir(h), h;
+        return v === r ? nn(Y) : en(Y), Y;
       }
     }
-    function ur(e, r, t) {
-      return De(e, r, t, !0);
+    function rn(v, C, A) {
+      return be(v, C, A, !0);
     }
-    function cr(e, r, t) {
-      return De(e, r, t, !1);
+    function on(v, C, A) {
+      return be(v, C, A, !1);
+    }
+    var sn = on, cn = rn;
+    Rt.Fragment = r, Rt.jsx = sn, Rt.jsxs = cn;
+  }()), Rt;
+}
+process.env.NODE_ENV === "production" ? ee.exports = mn() : ee.exports = yn();
+var q = ee.exports;
+function ft(t, n, e, r) {
+  if (e >= r[t + 1]) return t;
+  if (e <= r[n]) return n;
+  let s = n, o = t + 1, i = s + o >> 1;
+  for (; e < r[i] || e >= r[i + 1]; )
+    e < r[i] ? o = i : s = i, i = s + o >> 1;
+  return i;
+}
+function Ct(t, n, e, r) {
+  const s = new Array(e + 1), o = new Array(e + 1), i = new Array(e + 1);
+  s[0] = 1;
+  for (let l = 1; l <= e; l++) {
+    o[l] = n - r[t + 1 - l], i[l] = r[t + l] - n;
+    let u = 0;
+    for (let a = 0; a < l; a++) {
+      const g = s[a] / (i[a + 1] + o[l - a]);
+      s[a] = u + i[a + 1] * g, u = o[l - a] * g;
     }
-    var fr = cr, lr = ur;
-    re.Fragment = c, re.jsx = fr, re.jsxs = lr;
-  }()), re;
+    s[l] = u;
+  }
+  return s;
+}
+function ne(t, n, e, r, s) {
+  const o = Array.from(
+    { length: e + 1 },
+    () => new Array(e + 1).fill(0)
+  ), i = new Array(e + 1), l = new Array(e + 1);
+  o[0][0] = 1;
+  for (let f = 1; f <= e; f++) {
+    i[f] = n - s[t + 1 - f], l[f] = s[t + f] - n;
+    let c = 0;
+    for (let h = 0; h < f; h++) {
+      o[f][h] = l[h + 1] + i[f - h];
+      const p = o[h][f - 1] / o[f][h];
+      o[h][f] = c + l[h + 1] * p, c = i[f - h] * p;
+    }
+    o[f][f] = c;
+  }
+  const u = Array.from(
+    { length: r + 1 },
+    () => new Array(e + 1).fill(0)
+  );
+  for (let f = 0; f <= e; f++)
+    u[0][f] = o[f][e];
+  const a = [new Array(e + 1).fill(0), new Array(e + 1).fill(0)];
+  for (let f = 0; f <= e; f++) {
+    let c = 0, h = 1;
+    a[0][0] = 1;
+    for (let p = 1; p <= r; p++) {
+      let y = 0;
+      const d = f - p, m = e - p;
+      f >= p && (a[h][0] = a[c][0] / o[m + 1][d], y = a[h][0] * o[d][m]);
+      const w = d >= -1 ? 1 : -d, x = f - 1 <= m ? p - 1 : e - f;
+      for (let b = w; b <= x; b++)
+        a[h][b] = (a[c][b] - a[c][b - 1]) / o[m + 1][d + b], y += a[h][b] * o[d + b][m];
+      f <= m && (a[h][p] = -a[c][p - 1] / o[m + 1][f], y += a[h][p] * o[f][m]), u[p][f] = y;
+      const _ = c;
+      c = h, h = _;
+    }
+  }
+  let g = e;
+  for (let f = 1; f <= r; f++) {
+    for (let c = 0; c <= e; c++)
+      u[f][c] *= g;
+    g *= e - f;
+  }
+  return u;
+}
+function Ee(t, n, e) {
+  const { degree: r, knots: s, controlPoints: o, weights: i } = t, l = o.length - 1, u = o[0].length;
+  let a = -1, g = 0;
+  for (let d = 0; d < s.length; d++)
+    s[d] <= n && (a = d), Math.abs(s[d] - n) < 1e-14 && g++;
+  if (e + g > r && (e = r - g), e <= 0) return { ...t };
+  const f = new Array(s.length + e);
+  for (let d = 0; d <= a; d++) f[d] = s[d];
+  for (let d = 1; d <= e; d++) f[a + d] = n;
+  for (let d = a + 1; d < s.length; d++) f[d + e] = s[d];
+  const c = new Array(r + 1), h = new Array(l + e + 1), p = new Array(l + e + 1);
+  for (let d = 0; d <= a - r; d++)
+    h[d] = [...o[d]], p[d] = i[d];
+  for (let d = a - g; d <= l; d++)
+    h[d + e] = [...o[d]], p[d + e] = i[d];
+  for (let d = 0; d <= r - g; d++) {
+    const m = a - r + 1 + d;
+    c[d] = o[m].map((w) => w * i[m]), c[d].push(i[m]);
+  }
+  let y = 0;
+  for (let d = 1; d <= e; d++) {
+    y = a - r + d;
+    for (let x = 0; x <= r - d - g; x++) {
+      const _ = (n - s[y + x]) / (s[x + a + 1] - s[y + x]), b = new Array(u + 1);
+      for (let P = 0; P <= u; P++)
+        b[P] = _ * c[x + 1][P] + (1 - _) * c[x][P];
+      c[x] = b;
+    }
+    const m = c[0][u];
+    h[y] = c[0].slice(0, u).map((x) => m !== 0 ? x / m : x), p[y] = m;
+    const w = c[r - d - g][u];
+    h[a + e - d - g] = c[r - d - g].slice(0, u).map((x) => w !== 0 ? x / w : x), p[a + e - d - g] = w;
+  }
+  for (let d = y + 1; d < a - g; d++) {
+    const m = c[d - y][u];
+    h[d] = c[d - y].slice(0, u).map((w) => m !== 0 ? w / m : w), p[d] = m;
+  }
+  return {
+    degree: r,
+    knots: f,
+    controlPoints: h,
+    weights: p
+  };
+}
+function Lt(t, n) {
+  const e = [...n].sort((s, o) => s - o);
+  let r = t;
+  for (const s of e)
+    r = Ee(r, s, 1);
+  return r;
+}
+function wn(t, n, e) {
+  const { degreeU: r, degreeV: s, knotsU: o, knotsV: i, controlPoints: l, weights: u } = t, a = l.length, g = l[0].length;
+  if (e) {
+    const f = [];
+    for (let c = 0; c < a; c++) {
+      const h = {
+        degree: s,
+        knots: [...i],
+        controlPoints: l[c].map((y) => [...y]),
+        weights: [...u[c]]
+      }, p = Lt(h, n);
+      f.push({ cp: p.controlPoints, w: p.weights, knots: p.knots });
+    }
+    return {
+      degreeU: r,
+      degreeV: s,
+      knotsU: [...o],
+      knotsV: f[0].knots,
+      controlPoints: f.map((c) => c.cp),
+      weights: f.map((c) => c.w)
+    };
+  } else {
+    const f = [], c = [], h = [];
+    for (let m = 0; m < g; m++) {
+      const w = {
+        degree: r,
+        knots: [...o],
+        controlPoints: Array.from({ length: a }, (_, b) => [...l[b][m]]),
+        weights: Array.from({ length: a }, (_, b) => u[b][m])
+      }, x = Lt(w, n);
+      m === 0 && f.push(...x.knots), c.push(x.controlPoints.map((_) => [_])), h.push(x.weights);
+    }
+    const p = c[0].length, y = [], d = [];
+    for (let m = 0; m < p; m++) {
+      y[m] = [], d[m] = [];
+      for (let w = 0; w < g; w++)
+        y[m][w] = c[w][m][0], d[m][w] = h[w][m];
+    }
+    return {
+      degreeU: r,
+      degreeV: s,
+      knotsU: f,
+      knotsV: [...i],
+      controlPoints: y,
+      weights: d
+    };
+  }
+}
+function je(t, n) {
+  if (n <= t.degree) return { ...t };
+  const e = n - t.degree;
+  let r = t;
+  for (let s = 0; s < e; s++)
+    r = xn(r);
+  return r;
+}
+function xn(t) {
+  const { degree: n, knots: e, controlPoints: r, weights: s } = t, o = r.length - 1, i = r[0].length, l = n + 1, u = r.map((d, m) => {
+    const w = s[m];
+    return [...d.map((x) => x * w), w];
+  }), a = [];
+  let g = 0;
+  for (; g < e.length; ) {
+    const d = e[g];
+    let m = 0;
+    for (; g < e.length && Math.abs(e[g] - d) < 1e-14; )
+      m++, g++;
+    a.push({ value: d, mult: m });
+  }
+  const f = [];
+  for (const d of a)
+    for (let m = 0; m < d.mult + 1; m++)
+      f.push(d.value);
+  const c = f.length - l - 2, h = new Array(c + 1);
+  for (let d = 0; d <= c; d++) {
+    const m = d <= 0 ? 0 : d > o ? 1 : d / l, w = Math.max(0, Math.min(o, d - 1)), x = Math.max(0, Math.min(o, d));
+    h[d] = new Array(i + 1);
+    for (let _ = 0; _ <= i; _++)
+      h[d][_] = m * u[w][_] + (1 - m) * u[x][_];
+  }
+  const p = h.map((d) => {
+    const m = d[i];
+    return d.slice(0, i).map((w) => m !== 0 ? w / m : w);
+  }), y = h.map((d) => d[i]);
+  return {
+    degree: l,
+    knots: f,
+    controlPoints: p,
+    weights: y
+  };
+}
+function Re(t) {
+  if (t.length === 0) return [];
+  if (t.length === 1) return [{ ...t[0] }];
+  const n = Math.max(...t.map((s) => s.degree));
+  let e = t.map(
+    (s) => s.degree < n ? je(s, n) : { ...s }
+  );
+  const r = /* @__PURE__ */ new Set();
+  for (const s of e)
+    for (let o = n + 1; o < s.knots.length - n - 1; o++)
+      r.add(s.knots[o]);
+  return e = e.map((s) => {
+    const o = [];
+    for (const i of r)
+      s.knots.some((u) => Math.abs(u - i) < 1e-14) || o.push(i);
+    return o.length > 0 ? Lt(s, o) : s;
+  }), e;
+}
+function Te(t, n) {
+  const e = t.length - 1, r = t[0].length, s = Math.min(n, e), o = new Array(e + 1);
+  o[0] = 0;
+  const i = new Array(e);
+  let l = 0;
+  for (let c = 1; c <= e; c++) {
+    let h = 0;
+    for (let p = 0; p < r; p++)
+      h += (t[c][p] - t[c - 1][p]) ** 2;
+    i[c - 1] = Math.sqrt(h), l += i[c - 1];
+  }
+  l === 0 && (l = 1);
+  for (let c = 1; c <= e; c++)
+    o[c] = o[c - 1] + i[c - 1] / l;
+  o[e] = 1;
+  const u = e + s + 1, a = new Array(u + 1);
+  for (let c = 0; c <= s; c++) a[c] = 0;
+  for (let c = u - s; c <= u; c++) a[c] = 1;
+  for (let c = 1; c <= e - s; c++) {
+    let h = 0;
+    for (let p = c; p <= c + s - 1; p++)
+      h += o[p];
+    a[c + s] = h / s;
+  }
+  const g = Array.from({ length: e + 1 }, () => new Array(e + 1).fill(0));
+  for (let c = 0; c <= e; c++) {
+    const h = ft(e, s, o[c], a), p = Ct(h, o[c], s, a);
+    for (let y = 0; y <= s; y++)
+      g[c][h - s + y] = p[y];
+  }
+  const f = new Array(e + 1);
+  for (let c = 0; c <= e; c++) f[c] = new Array(r);
+  for (let c = 0; c < r; c++) {
+    const h = t.map((y) => y[c]), p = bn(g, h);
+    for (let y = 0; y <= e; y++)
+      f[y][c] = p[y];
+  }
+  return {
+    degree: s,
+    knots: a,
+    controlPoints: f,
+    weights: new Array(e + 1).fill(1)
+  };
+}
+function _n(t, n) {
+  if (t.length < 2) throw new Error("Lofting requires at least 2 curves");
+  const e = Re(t), r = e[0].degree, s = e[0].knots, o = e[0].controlPoints.length, i = e.length, l = Math.min(n, i - 1), u = [];
+  for (let p = 0; p < o; p++) {
+    const y = [];
+    for (let d = 0; d < i; d++)
+      y.push(e[d].controlPoints[p]);
+    u.push(y);
+  }
+  const a = u.map(
+    (p) => Te(p, l)
+  ), g = a[0].knots, f = a[0].controlPoints.length, c = [], h = [];
+  for (let p = 0; p < o; p++) {
+    c[p] = [], h[p] = [];
+    for (let y = 0; y < f; y++)
+      c[p][y] = a[p].controlPoints[y], h[p][y] = 1;
+  }
+  return {
+    degreeU: r,
+    degreeV: l,
+    knotsU: s,
+    knotsV: g,
+    controlPoints: c,
+    weights: h
+  };
+}
+function bn(t, n) {
+  const e = n.length, r = t.map((o, i) => [...o, n[i]]);
+  for (let o = 0; o < e; o++) {
+    let i = o, l = Math.abs(r[o][o]);
+    for (let a = o + 1; a < e; a++)
+      Math.abs(r[a][o]) > l && (l = Math.abs(r[a][o]), i = a);
+    i !== o && ([r[o], r[i]] = [r[i], r[o]]);
+    const u = r[o][o];
+    if (!(Math.abs(u) < 1e-14))
+      for (let a = o + 1; a < e; a++) {
+        const g = r[a][o] / u;
+        for (let f = o; f <= e; f++)
+          r[a][f] -= g * r[o][f];
+      }
+  }
+  const s = new Array(e).fill(0);
+  for (let o = e - 1; o >= 0; o--) {
+    let i = r[o][e];
+    for (let l = o + 1; l < e; l++)
+      i -= r[o][l] * s[l];
+    s[o] = Math.abs(r[o][o]) > 1e-14 ? i / r[o][o] : 0;
+  }
+  return s;
 }
-process.env.NODE_ENV === "production" ? ge.exports = Tr() : ge.exports = wr();
-var K = ge.exports;
-const jr = ({
-  points: T,
-  degree: x = 3,
-  weights: y,
-  knots: c,
-  curveResolution: k = 50,
-  color: F = "black",
-  segments: _,
-  dashed: g = !1,
-  vertexColors: f,
-  ...E
+let B = class dt {
+  constructor(n) {
+    ct(this, "_degree");
+    ct(this, "_knots");
+    ct(this, "_controlPoints");
+    ct(this, "_weights");
+    this._degree = n.degree, this._knots = n.knots, this._controlPoints = n.controlPoints, this._weights = n.weights;
+  }
+  // --- Construction ---
+  static byKnotsControlPointsWeights(n, e, r, s) {
+    return new dt({ degree: n, knots: e, controlPoints: r, weights: s });
+  }
+  static byPoints(n, e) {
+    const r = Te(n, e);
+    return new dt(r);
+  }
+  // --- Evaluation ---
+  /**
+   * Evaluate curve point at parameter t (Algorithm A4.1).
+   * Rational curve: C(t) = Σ R_i(t) * P_i where R_i = N_i*w_i / Σ N_j*w_j
+   */
+  point(n) {
+    const e = this._controlPoints.length - 1, r = ft(e, this._degree, n, this._knots), s = Ct(r, n, this._degree, this._knots), o = this._controlPoints[0].length, i = new Array(o).fill(0);
+    let l = 0;
+    for (let u = 0; u <= this._degree; u++) {
+      const a = r - this._degree + u, g = this._weights[a], f = s[u] * g;
+      l += f;
+      for (let c = 0; c < o; c++)
+        i[c] += f * this._controlPoints[a][c];
+    }
+    if (l !== 0)
+      for (let u = 0; u < o; u++)
+        i[u] /= l;
+    return i;
+  }
+  /**
+   * Compute derivatives of the rational curve at parameter t.
+   * Uses Algorithm A4.2 + Eq. 4.20 from The NURBS Book.
+   *
+   * Returns: derivatives[k] = kth derivative vector
+   */
+  derivatives(n, e) {
+    const r = this._controlPoints.length - 1, s = this._controlPoints[0].length, o = Math.min(e, this._degree), i = ft(r, this._degree, n, this._knots), l = ne(i, n, this._degree, o, this._knots), u = [], a = [];
+    for (let f = 0; f <= o; f++) {
+      const c = new Array(s).fill(0);
+      let h = 0;
+      for (let p = 0; p <= this._degree; p++) {
+        const y = i - this._degree + p, d = this._weights[y];
+        for (let m = 0; m < s; m++)
+          c[m] += l[f][p] * d * this._controlPoints[y][m];
+        h += l[f][p] * d;
+      }
+      u.push(c), a.push(h);
+    }
+    const g = [];
+    for (let f = 0; f <= o; f++) {
+      const c = [...u[f]];
+      for (let h = 1; h <= f; h++) {
+        const p = Pn(f, h);
+        for (let y = 0; y < s; y++)
+          c[y] -= p * a[h] * g[f - h][y];
+      }
+      for (let h = 0; h < s; h++)
+        c[h] /= a[0];
+      g.push(c);
+    }
+    for (let f = o + 1; f <= e; f++)
+      g.push(new Array(s).fill(0));
+    return g;
+  }
+  /**
+   * Compute tangent vector (first derivative, NOT normalized) at parameter t.
+   */
+  tangent(n) {
+    return this.derivatives(n, 1)[1];
+  }
+  /**
+   * Compute arc length using Gauss-Legendre quadrature.
+   */
+  length() {
+    return this.lengthBetween(this._knots[this._degree], this._knots[this._knots.length - this._degree - 1]);
+  }
+  lengthBetween(n, e) {
+    const r = [-0.9061798459, -0.5384693101, 0, 0.5384693101, 0.9061798459], s = [0.2369268851, 0.4786286705, 0.5688888889, 0.4786286705, 0.2369268851], o = Math.max(this._controlPoints.length * 2, 8);
+    let i = 0;
+    for (let l = 0; l < o; l++) {
+      const u = n + (e - n) * l / o, a = n + (e - n) * (l + 1) / o, g = (a - u) / 2, f = (u + a) / 2;
+      let c = 0;
+      for (let h = 0; h < r.length; h++) {
+        const p = f + g * r[h], y = this.tangent(p), d = Math.sqrt(y.reduce((m, w) => m + w * w, 0));
+        c += s[h] * d;
+      }
+      i += g * c;
+    }
+    return i;
+  }
+  /**
+   * Find the parameter of the closest point on the curve to a given point.
+   * Implements Algorithm A6.1 from "The NURBS Book" (Piegl & Tiller), Section 6.1.
+   *
+   * Phase 1: Initial guess via control polygon (Greville abscissa of closest control point)
+   *          + refinement by sampling within the support of that basis function.
+   * Phase 2: Newton iteration with four convergence criteria:
+   *   (1) Point coincidence:  ||C(t) - P|| < eps1
+   *   (2) Zero cosine:        |C'(t) · (C(t) - P)| / (|C'(t)| · |C(t) - P|) < eps2
+   *   (3) Parameter correction: |Δt| · |C'(t)| < eps1
+   *   (4) Domain bounds
+   */
+  closestParam(n) {
+    const e = n.length, r = 1e-8, s = 1e-6, o = this._knots[this._degree], i = this._knots[this._knots.length - this._degree - 1], l = this._controlPoints.length - 1;
+    let u = o, a = 1 / 0;
+    for (let m = 0; m <= l; m++) {
+      let w = 0;
+      for (let x = 0; x < e; x++)
+        w += (this._controlPoints[m][x] - n[x]) ** 2;
+      if (w < a) {
+        a = w;
+        let x = 0;
+        for (let _ = 1; _ <= this._degree; _++)
+          x += this._knots[m + _];
+        x /= this._degree, u = Math.max(o, Math.min(i, x));
+      }
+    }
+    const g = 0.2 * (i - o), f = Math.max(o, u - g), c = Math.min(i, u + g), h = 20;
+    for (let m = 0; m <= h; m++) {
+      const w = f + (c - f) * m / h, x = this.point(w);
+      let _ = 0;
+      for (let b = 0; b < e; b++) _ += (x[b] - n[b]) ** 2;
+      _ < a && (a = _, u = w);
+    }
+    const p = Math.max(l * 4, 20);
+    for (let m = 0; m <= p; m++) {
+      const w = o + (i - o) * m / p, x = this.point(w);
+      let _ = 0;
+      for (let b = 0; b < e; b++) _ += (x[b] - n[b]) ** 2;
+      _ < a && (a = _, u = w);
+    }
+    let y = u;
+    const d = Math.min(2, this._degree);
+    for (let m = 0; m < 50; m++) {
+      const w = this.derivatives(y, d), x = w[0], _ = w[1], b = x.map((D, R) => D - n[R]);
+      let P = 0;
+      for (let D = 0; D < e; D++) P += b[D] ** 2;
+      if (Math.sqrt(P) < r) break;
+      let M = 0, S = 0;
+      for (let D = 0; D < e; D++)
+        M += _[D] * b[D], S += _[D] ** 2;
+      S = Math.sqrt(S);
+      const U = Math.sqrt(P);
+      if (S > 0 && U > 0 && Math.abs(M) / (S * U) < s)
+        break;
+      let j = M, k = S * S;
+      if (d >= 2) {
+        const D = w[2];
+        for (let R = 0; R < e; R++)
+          k += D[R] * b[R];
+      }
+      if (Math.abs(k) < 1e-14) break;
+      const E = -j / k;
+      if (Math.abs(E) * S < r) break;
+      const T = Math.max(o, Math.min(i, y + E));
+      if (Math.abs(T - y) < 1e-14) break;
+      y = T;
+    }
+    return y;
+  }
+  closestPoint(n) {
+    return this.point(this.closestParam(n));
+  }
+  /**
+   * Split curve at parameter t by inserting knot until multiplicity = degree.
+   * Returns two NurbsCurve objects.
+   */
+  split(n) {
+    let e = 0;
+    for (const i of this._knots)
+      Math.abs(i - n) < 1e-10 && e++;
+    const r = this._degree - e;
+    if (r <= 0)
+      return this._splitAtFullMult(n);
+    let s = this.asData();
+    for (let i = 0; i < r; i++)
+      s = Ee(s, n, 1);
+    return new dt(s)._splitAtFullMult(n);
+  }
+  _splitAtFullMult(n) {
+    let e = -1;
+    for (let g = 0; g < this._knots.length; g++)
+      if (Math.abs(this._knots[g] - n) < 1e-10) {
+        e = g;
+        break;
+      }
+    if (e === -1) return [this.clone()];
+    const r = this._degree, s = this._knots.slice(0, e + 1);
+    for (let g = 0; g < r + 1; g++) s.push(n);
+    const o = this._controlPoints.slice(0, e - r + 1), i = this._weights.slice(0, e - r + 1), l = [];
+    for (let g = 0; g < r + 1; g++) l.push(n);
+    l.push(...this._knots.slice(e + 1));
+    const u = this._controlPoints.slice(e - r), a = this._weights.slice(e - r);
+    return [
+      new dt({ degree: r, knots: s, controlPoints: o, weights: i }),
+      new dt({ degree: r, knots: l, controlPoints: u, weights: a })
+    ];
+  }
+  reverse() {
+    const n = this._knots[this._knots.length - 1], e = this._knots[0];
+    return new dt({
+      degree: this._degree,
+      knots: this._knots.map((r) => n + e - r).reverse(),
+      controlPoints: [...this._controlPoints].reverse(),
+      weights: [...this._weights].reverse()
+    });
+  }
+  clone() {
+    return new dt({
+      degree: this._degree,
+      knots: [...this._knots],
+      controlPoints: this._controlPoints.map((n) => [...n]),
+      weights: [...this._weights]
+    });
+  }
+  // --- Accessors ---
+  degree() {
+    return this._degree;
+  }
+  knots() {
+    return this._knots;
+  }
+  controlPoints() {
+    return this._controlPoints;
+  }
+  weights() {
+    return this._weights;
+  }
+  asData() {
+    return {
+      degree: this._degree,
+      knots: [...this._knots],
+      controlPoints: this._controlPoints.map((n) => [...n]),
+      weights: [...this._weights]
+    };
+  }
+};
+function Pn(t, n) {
+  if (n < 0 || n > t) return 0;
+  if (n === 0 || n === t) return 1;
+  let e = 1;
+  for (let r = 0; r < n; r++)
+    e = e * (t - r) / (r + 1);
+  return Math.round(e);
+}
+let ut = class Wt {
+  // [u][v]
+  constructor(n) {
+    ct(this, "_degreeU");
+    ct(this, "_degreeV");
+    ct(this, "_knotsU");
+    ct(this, "_knotsV");
+    ct(this, "_controlPoints");
+    // [u][v][xyz]
+    ct(this, "_weights");
+    this._degreeU = n.degreeU, this._degreeV = n.degreeV, this._knotsU = n.knotsU, this._knotsV = n.knotsV, this._controlPoints = n.controlPoints, this._weights = n.weights;
+  }
+  // --- Construction ---
+  static byKnotsControlPointsWeights(n, e, r, s, o, i) {
+    return new Wt({ degreeU: n, degreeV: e, knotsU: r, knotsV: s, controlPoints: o, weights: i });
+  }
+  static byLoftingCurves(n, e) {
+    return new Wt(_n(n.map((r) => r.asData()), e));
+  }
+  static byCorners(n, e, r, s) {
+    return new Wt({
+      degreeU: 1,
+      degreeV: 1,
+      knotsU: [0, 0, 1, 1],
+      knotsV: [0, 0, 1, 1],
+      controlPoints: [[n, s], [e, r]],
+      weights: [[1, 1], [1, 1]]
+    });
+  }
+  // --- Evaluation ---
+  /**
+   * Evaluate surface point at (u, v) — Algorithm A4.3 (rational tensor product).
+   */
+  point(n, e) {
+    const r = this._controlPoints.length - 1, s = this._controlPoints[0].length - 1, o = this._controlPoints[0][0].length, i = ft(r, this._degreeU, n, this._knotsU), l = ft(s, this._degreeV, e, this._knotsV), u = Ct(i, n, this._degreeU, this._knotsU), a = Ct(l, e, this._degreeV, this._knotsV), g = new Array(o).fill(0);
+    let f = 0;
+    for (let c = 0; c <= this._degreeU; c++) {
+      const h = i - this._degreeU + c;
+      for (let p = 0; p <= this._degreeV; p++) {
+        const y = l - this._degreeV + p, d = this._weights[h][y], m = u[c] * a[p] * d;
+        f += m;
+        for (let w = 0; w < o; w++)
+          g[w] += m * this._controlPoints[h][y][w];
+      }
+    }
+    if (f !== 0)
+      for (let c = 0; c < o; c++)
+        g[c] /= f;
+    return g;
+  }
+  /**
+   * Compute surface normal at (u, v) as cross product of partial derivatives.
+   */
+  normal(n, e) {
+    const r = this.derivatives(n, e, 1), s = r[1][0], o = r[0][1];
+    return [
+      s[1] * o[2] - s[2] * o[1],
+      s[2] * o[0] - s[0] * o[2],
+      s[0] * o[1] - s[1] * o[0]
+    ];
+  }
+  /**
+   * Compute partial derivatives of the rational surface at (u, v).
+   * Returns ders[k][l] = mixed partial derivative ∂^(k+l)S / ∂u^k ∂v^l.
+   * Algorithm A4.4 adapted for rational surfaces (Eq. 4.20 generalized).
+   */
+  derivatives(n, e, r) {
+    const s = this._controlPoints.length - 1, o = this._controlPoints[0].length - 1, i = this._controlPoints[0][0].length, l = Math.min(r, this._degreeU), u = Math.min(r, this._degreeV), a = ft(s, this._degreeU, n, this._knotsU), g = ft(o, this._degreeV, e, this._knotsV), f = ne(a, n, this._degreeU, l, this._knotsU), c = ne(g, e, this._degreeV, u, this._knotsV), h = [], p = [];
+    for (let d = 0; d <= l; d++) {
+      h[d] = [], p[d] = [];
+      for (let m = 0; m <= u; m++) {
+        const w = new Array(i).fill(0);
+        let x = 0;
+        for (let _ = 0; _ <= this._degreeU; _++) {
+          const b = a - this._degreeU + _;
+          for (let P = 0; P <= this._degreeV; P++) {
+            const M = g - this._degreeV + P, S = this._weights[b][M], U = f[d][_] * c[m][P] * S;
+            for (let j = 0; j < i; j++)
+              w[j] += U * this._controlPoints[b][M][j];
+            x += U;
+          }
+        }
+        h[d][m] = w, p[d][m] = x;
+      }
+    }
+    const y = [];
+    for (let d = 0; d <= r; d++) {
+      y[d] = [];
+      for (let m = 0; m <= r; m++) {
+        if (d > l || m > u) {
+          y[d][m] = new Array(i).fill(0);
+          continue;
+        }
+        const w = [...h[d][m]];
+        for (let x = 1; x <= m; x++) {
+          const _ = ke(m, x);
+          for (let b = 0; b < i; b++)
+            w[b] -= _ * p[0][x] * y[d][m - x][b];
+        }
+        for (let x = 1; x <= d; x++) {
+          const _ = ke(d, x);
+          for (let b = 0; b < i; b++)
+            w[b] -= _ * p[x][0] * y[d - x][m][b];
+        }
+        for (let x = 0; x < i; x++)
+          w[x] /= p[0][0];
+        y[d][m] = w;
+      }
+    }
+    return y;
+  }
+  /**
+   * Find closest UV parameters to a 3D point.
+   * Implements the surface point projection from "The NURBS Book" Section 6.1.
+   *
+   * Phase 1: Initial guess via closest control point (Greville abscissa)
+   *          + grid refinement near the best candidate.
+   * Phase 2: Newton iteration with four convergence criteria:
+   *   (1) Point coincidence:  ||S(u,v) - P|| < eps1
+   *   (2) Zero cosine (U):   |S_u · (S - P)| / (|S_u| · |S - P|) < eps2
+   *   (2) Zero cosine (V):   |S_v · (S - P)| / (|S_v| · |S - P|) < eps2
+   *   (3) Parameter correction: |Δu·S_u + Δv·S_v| < eps1
+   *   (4) Domain bounds
+   */
+  closestParam(n) {
+    const e = n.length, r = this._controlPoints.length - 1, s = this._controlPoints[0].length - 1, o = this._knotsU[this._degreeU], i = this._knotsU[r + 1], l = this._knotsV[this._degreeV], u = this._knotsV[s + 1], a = 1e-8, g = 1e-6;
+    let f = (o + i) / 2, c = (l + u) / 2, h = 1 / 0;
+    for (let m = 0; m <= r; m++) {
+      let w = 0;
+      for (let x = 1; x <= this._degreeU; x++) w += this._knotsU[m + x];
+      w /= this._degreeU;
+      for (let x = 0; x <= s; x++) {
+        let _ = 0;
+        for (let b = 0; b < e; b++)
+          _ += (this._controlPoints[m][x][b] - n[b]) ** 2;
+        if (_ < h) {
+          h = _, f = Math.max(o, Math.min(i, w));
+          let b = 0;
+          for (let P = 1; P <= this._degreeV; P++) b += this._knotsV[x + P];
+          b /= this._degreeV, c = Math.max(l, Math.min(u, b));
+        }
+      }
+    }
+    const p = 20;
+    for (let m = 0; m <= p; m++)
+      for (let w = 0; w <= p; w++) {
+        const x = o + (i - o) * m / p, _ = l + (u - l) * w / p, b = this.point(x, _);
+        let P = 0;
+        for (let M = 0; M < e; M++) P += (b[M] - n[M]) ** 2;
+        P < h && (h = P, f = x, c = _);
+      }
+    let y = f, d = c;
+    for (let m = 0; m < 50; m++) {
+      const w = this.derivatives(y, d, 1), x = w[0][0], _ = w[1][0], b = w[0][1], P = x.map((N, _t) => N - n[_t]);
+      let M = 0;
+      for (let N = 0; N < e; N++) M += P[N] ** 2;
+      const S = Math.sqrt(M);
+      if (S < a) break;
+      let U = 0, j = 0, k = 0, E = 0;
+      for (let N = 0; N < e; N++)
+        U += _[N] * P[N], j += b[N] * P[N], k += _[N] ** 2, E += b[N] ** 2;
+      k = Math.sqrt(k), E = Math.sqrt(E);
+      const T = k > 0 && S > 0 ? Math.abs(U) / (k * S) : 0, D = E > 0 && S > 0 ? Math.abs(j) / (E * S) : 0;
+      if (T < g && D < g) break;
+      let R = 0, W = 0, G = 0;
+      for (let N = 0; N < e; N++)
+        R += _[N] * _[N], W += _[N] * b[N], G += b[N] * b[N];
+      const Q = R * G - W * W;
+      if (Math.abs(Q) < 1e-14) break;
+      const X = -(G * U - W * j) / Q, nt = -(R * j - W * U) / Q;
+      let lt = 0;
+      for (let N = 0; N < e; N++) {
+        const _t = X * _[N] + nt * b[N];
+        lt += _t * _t;
+      }
+      if (Math.sqrt(lt) < a) break;
+      const At = Math.max(o, Math.min(i, y + X)), St = Math.max(l, Math.min(u, d + nt));
+      if (Math.abs(At - y) + Math.abs(St - d) < 1e-14) break;
+      y = At, d = St;
+    }
+    return [y, d];
+  }
+  /**
+   * Extract an iso-parametric curve from the surface.
+   * If useV=false: fix u=param, extract curve in V direction.
+   * If useV=true: fix v=param, extract curve in U direction.
+   */
+  /**
+   * Extract an iso-parametric curve from the surface.
+   * If useV=true: fix v=param, extract curve in U direction.
+   * If useV=false: fix u=param, extract curve in V direction.
+   *
+   * Works in homogeneous coordinates: for each row/column, blend the
+   * homogeneous control points (w*P, w) using basis functions, then
+   * store the result as the new curve's control points and weights.
+   */
+  isocurve(n, e) {
+    if (e) {
+      const r = this._controlPoints.length - 1, s = this._controlPoints[0].length - 1, o = this._controlPoints[0][0].length, i = ft(s, this._degreeV, n, this._knotsV), l = Ct(i, n, this._degreeV, this._knotsV), u = [], a = [];
+      for (let g = 0; g <= r; g++) {
+        const f = new Array(o).fill(0);
+        let c = 0;
+        for (let h = 0; h <= this._degreeV; h++) {
+          const p = i - this._degreeV + h, y = this._weights[g][p];
+          for (let d = 0; d < o; d++)
+            f[d] += l[h] * y * this._controlPoints[g][p][d];
+          c += l[h] * y;
+        }
+        u.push(c !== 0 ? f.map((h) => h / c) : f), a.push(c);
+      }
+      return B.byKnotsControlPointsWeights(this._degreeU, [...this._knotsU], u, a);
+    } else {
+      const r = this._controlPoints.length - 1, s = this._controlPoints[0].length - 1, o = this._controlPoints[0][0].length, i = ft(r, this._degreeU, n, this._knotsU), l = Ct(i, n, this._degreeU, this._knotsU), u = [], a = [];
+      for (let g = 0; g <= s; g++) {
+        const f = new Array(o).fill(0);
+        let c = 0;
+        for (let h = 0; h <= this._degreeU; h++) {
+          const p = i - this._degreeU + h, y = this._weights[p][g];
+          for (let d = 0; d < o; d++)
+            f[d] += l[h] * y * this._controlPoints[p][g][d];
+          c += l[h] * y;
+        }
+        u.push(c !== 0 ? f.map((h) => h / c) : f), a.push(c);
+      }
+      return B.byKnotsControlPointsWeights(this._degreeV, [...this._knotsV], u, a);
+    }
+  }
+  // --- Accessors ---
+  degreeU() {
+    return this._degreeU;
+  }
+  degreeV() {
+    return this._degreeV;
+  }
+  knotsU() {
+    return this._knotsU;
+  }
+  knotsV() {
+    return this._knotsV;
+  }
+  controlPoints() {
+    return this._controlPoints;
+  }
+  weights() {
+    return this._weights;
+  }
+  asData() {
+    return {
+      degreeU: this._degreeU,
+      degreeV: this._degreeV,
+      knotsU: [...this._knotsU],
+      knotsV: [...this._knotsV],
+      controlPoints: this._controlPoints.map((n) => n.map((e) => [...e])),
+      weights: this._weights.map((n) => [...n])
+    };
+  }
+};
+function ke(t, n) {
+  if (n < 0 || n > t) return 0;
+  if (n === 0 || n === t) return 1;
+  let e = 1;
+  for (let r = 0; r < n; r++)
+    e = e * (t - r) / (r + 1);
+  return Math.round(e);
+}
+function at(t, n) {
+  return t.map((e, r) => e + n[r]);
+}
+function qt(t, n) {
+  return t.map((e, r) => e - n[r]);
+}
+function st(t, n) {
+  return t.map((e) => e * n);
+}
+function ce(t, n) {
+  return t.reduce((e, r, s) => e + r * n[s], 0);
+}
+function Cn(t, n) {
+  return [
+    t[1] * n[2] - t[2] * n[1],
+    t[2] * n[0] - t[0] * n[2],
+    t[0] * n[1] - t[1] * n[0]
+  ];
+}
+function re(t) {
+  const n = Math.sqrt(ce(t, t));
+  return n > 0 ? st(t, 1 / n) : t;
+}
+function kn(t) {
+  return Math.sqrt(ce(t, t));
+}
+function zt(t, n, e, r, s, o) {
+  const i = re(n), l = re(e);
+  let u = o - s;
+  u < 0 && (u += 2 * Math.PI);
+  let a;
+  u <= Math.PI / 2 ? a = 1 : u <= Math.PI ? a = 2 : u <= 3 * Math.PI / 2 ? a = 3 : a = 4;
+  const g = u / a, f = Math.cos(g / 2);
+  let c = at(t, at(st(i, r * Math.cos(s)), st(l, r * Math.sin(s)))), h = at(st(i, -Math.sin(s)), st(l, Math.cos(s)));
+  const p = [c], y = [1];
+  let d = s;
+  for (let w = 0; w < a; w++) {
+    d += g;
+    const x = at(t, at(st(i, r * Math.cos(d)), st(l, r * Math.sin(d)))), _ = at(st(i, -Math.sin(d)), st(l, Math.cos(d))), b = qt(x, c), P = h[0] * _[1] - h[1] * _[0];
+    let M;
+    if (Math.abs(P) > 1e-14)
+      M = (b[0] * _[1] - b[1] * _[0]) / P;
+    else {
+      const U = h[0] * _[2] - h[2] * _[0];
+      Math.abs(U) > 1e-14 ? M = (b[0] * _[2] - b[2] * _[0]) / U : M = (b[1] * _[2] - b[2] * _[1]) / (h[1] * _[2] - h[2] * _[1]);
+    }
+    const S = at(c, st(h, M));
+    p.push(S, x), y.push(f, 1), c = x, h = _;
+  }
+  const m = [];
+  m.push(0, 0, 0);
+  for (let w = 1; w < a; w++) {
+    const x = w / a;
+    m.push(x, x);
+  }
+  return m.push(1, 1, 1), { degree: 2, knots: m, controlPoints: p, weights: y };
+}
+function Mn(t, n, e, r) {
+  return zt(t, n, e, r, 0, 2 * Math.PI);
+}
+function An(t, n) {
+  const e = t.controlPoints, r = e.map((s) => at(s, n));
+  return {
+    degreeU: t.degree,
+    degreeV: 1,
+    knotsU: [...t.knots],
+    knotsV: [0, 0, 1, 1],
+    controlPoints: e.map((s, o) => [s, r[o]]),
+    weights: t.weights.map((s) => [s, s])
+  };
+}
+function Sn(t, n, e, r) {
+  const s = re(e), o = zt(
+    [0, 0, 0],
+    [1, 0, 0],
+    [0, 1, 0],
+    1,
+    0,
+    r
+  ), i = o.controlPoints.length, l = [], u = [];
+  for (let f = 0; f < t.controlPoints.length; f++) {
+    const c = t.controlPoints[f], h = t.weights[f], p = qt(c, n), y = ce(p, s), d = at(n, st(s, y)), m = qt(c, d), w = kn(m);
+    if (w < 1e-14) {
+      l[f] = [], u[f] = [];
+      for (let P = 0; P < i; P++)
+        l[f][P] = [...c], u[f][P] = h * o.weights[P];
+      continue;
+    }
+    const x = st(m, 1 / w), _ = Cn(s, x), b = zt(d, x, _, w, 0, r);
+    l[f] = [], u[f] = [];
+    for (let P = 0; P < b.controlPoints.length; P++)
+      l[f][P] = b.controlPoints[P], u[f][P] = h * b.weights[P];
+  }
+  const a = [], g = [];
+  for (let f = 0; f < i; f++) {
+    a[f] = [], g[f] = [];
+    for (let c = 0; c < t.controlPoints.length; c++)
+      a[f][c] = l[c][f], g[f][c] = u[c][f];
+  }
+  return {
+    degreeU: 2,
+    // arc degree
+    degreeV: t.degree,
+    knotsU: o.knots,
+    knotsV: [...t.knots],
+    controlPoints: a,
+    weights: g
+  };
+}
+function En(t, n) {
+  const e = t.controlPoints.length, r = n.controlPoints.length, s = n.controlPoints[0], o = [], i = [];
+  for (let l = 0; l < r; l++) {
+    o[l] = [], i[l] = [];
+    const u = qt(n.controlPoints[l], s);
+    for (let a = 0; a < e; a++)
+      o[l][a] = at(t.controlPoints[a], u), i[l][a] = n.weights[l] * t.weights[a];
+  }
+  return {
+    degreeU: n.degree,
+    degreeV: t.degree,
+    knotsU: [...n.knots],
+    knotsV: [...t.knots],
+    controlPoints: o,
+    weights: i
+  };
+}
+function jn(t, n, e = 1e-3, r = 40) {
+  const s = r, o = [], i = [];
+  for (let a = 0; a <= s; a++) {
+    o[a] = [], i[a] = [];
+    for (let g = 0; g <= s; g++) {
+      const f = a / s, c = g / s, h = t.point(f, c), p = n.closestParam(h), y = n.point(p[0], p[1]), d = t.normal(f, c), m = Math.sqrt(d[0] ** 2 + d[1] ** 2 + d[2] ** 2), w = [h[0] - y[0], h[1] - y[1], h[2] - y[2]];
+      let _ = Math.sqrt(w[0] ** 2 + w[1] ** 2 + w[2] ** 2);
+      m > 1e-14 && (_ = (w[0] * d[0] + w[1] * d[1] + w[2] * d[2]) / m), o[a][g] = _, i[a][g] = h;
+    }
+  }
+  const l = [];
+  for (let a = 0; a < s; a++)
+    for (let g = 0; g < s; g++) {
+      const f = [
+        { d: o[a][g], pt: i[a][g] },
+        { d: o[a + 1][g], pt: i[a + 1][g] },
+        { d: o[a + 1][g + 1], pt: i[a + 1][g + 1] },
+        { d: o[a][g + 1], pt: i[a][g + 1] }
+      ];
+      for (let c = 0; c < 4; c++) {
+        const h = f[c], p = f[(c + 1) % 4];
+        if (h.d >= 0 != p.d >= 0) {
+          const y = h.d / (h.d - p.d);
+          l.push([
+            h.pt[0] + y * (p.pt[0] - h.pt[0]),
+            h.pt[1] + y * (p.pt[1] - h.pt[1]),
+            h.pt[2] + y * (p.pt[2] - h.pt[2])
+          ]);
+        }
+      }
+    }
+  return l.length < 2 ? [] : Rn(l, e * 10).map((a) => ({ points: a }));
+}
+function Rn(t, n) {
+  if (t.length === 0) return [];
+  const e = /* @__PURE__ */ new Set(), r = [];
+  for (; e.size < t.length; ) {
+    let s = -1;
+    for (let l = 0; l < t.length; l++)
+      if (!e.has(l)) {
+        s = l;
+        break;
+      }
+    if (s === -1) break;
+    const o = [t[s]];
+    e.add(s);
+    let i = !0;
+    for (; i; ) {
+      i = !1;
+      const l = o[o.length - 1];
+      let u = -1, a = n * n;
+      for (let g = 0; g < t.length; g++) {
+        if (e.has(g)) continue;
+        const f = t[g][0] - l[0], c = t[g][1] - l[1], h = t[g][2] - l[2], p = f * f + c * c + h * h;
+        p < a && (a = p, u = g);
+      }
+      u >= 0 && (o.push(t[u]), e.add(u), i = !0);
+    }
+    o.length >= 2 && r.push(o);
+  }
+  return r;
+}
+function H(t, n) {
+  const e = t + n + 1;
+  return Array(e).fill(0).map((r, s) => s < n + 1 ? 0 : s >= e - n - 1 ? 1 : (s - n) / (e - 2 * n - 1));
+}
+function Tn(t, n, e) {
+  const r = t.point(n, e);
+  return new I(r[0], r[1], r[2]);
+}
+function Dn(t, n, e) {
+  try {
+    const r = t.normal(n, e), s = new I(r[0], r[1], r[2]), o = s.length();
+    return o > 0 ? s.divideScalar(o) : new I(0, 1, 0);
+  } catch {
+    const s = t.point(n, e), o = t.point(Math.min(n + 1e-4, 1), e), i = t.point(n, Math.min(e + 1e-4, 1)), l = new I().subVectors(new I(...o), new I(...s)), u = new I().subVectors(new I(...i), new I(...s)), a = new I().crossVectors(l, u).normalize();
+    return a.length() > 0 ? a : new I(0, 1, 0);
+  }
+}
+function ur(t, n = 100) {
+  return Array.from({ length: n }, (e, r) => {
+    const s = r / (n - 1), o = t.point(s);
+    return [o[0], o[1]];
+  });
+}
+function Un(t, n = 5, e = 10) {
+  const r = (a) => [a[0], a[1]], s = (a, g, f) => {
+    const c = [g[0] - a[0], g[1] - a[1]], h = [f[0] - g[0], f[1] - g[1]], p = c[0] * h[0] + c[1] * h[1], y = Math.sqrt(c[0] * c[0] + c[1] * c[1]), d = Math.sqrt(h[0] * h[0] + h[1] * h[1]);
+    return y === 0 || d === 0 ? 0 : Math.acos(Math.max(-1, Math.min(1, p / (y * d)))) * (180 / Math.PI);
+  };
+  function o(a, g, f) {
+    const c = r(t.point(a)), h = r(t.point((a + g) / 2)), p = r(t.point(g));
+    if (s(c, h, p) > n && f < e) {
+      const d = o(a, (a + g) / 2, f + 1), m = o((a + g) / 2, g, f + 1);
+      return [...d.slice(0, -1), ...m];
+    } else
+      return [c, p];
+  }
+  const i = [], l = 10;
+  let u = null;
+  for (let a = 0; a < l; a++) {
+    const g = o(a / l, (a + 1) / l, 0);
+    for (const f of g)
+      (!u || f[0] !== u[0] || f[1] !== u[1]) && (i.push(f), u = f);
+  }
+  return i;
+}
+function fr(t, n) {
+  try {
+    const e = t.closestParam(n);
+    return [e[0], e[1]];
+  } catch {
+    return null;
+  }
+}
+function Fn(t, n, e = 100) {
+  const r = [], s = n.point(0), o = t.closestParam(s);
+  r.push([o[0], o[1]]);
+  for (let i = 1; i <= e; i++) {
+    const l = i / e, u = n.point(l), a = r[r.length - 1], g = In(t, u, a[0], a[1]);
+    r.push(g);
+  }
+  return r;
+}
+function In(t, n, e, r) {
+  const s = n.length, o = 1e-8, i = 1e-6;
+  let l = e, u = r;
+  for (let a = 0; a < 20; a++) {
+    const g = t.derivatives(l, u, 1), f = g[0][0], c = g[1][0], h = g[0][1], p = f.map((k, E) => k - n[E]);
+    let y = 0;
+    for (let k = 0; k < s; k++) y += p[k] ** 2;
+    if (Math.sqrt(y) < o) break;
+    let d = 0, m = 0, w = 0, x = 0;
+    for (let k = 0; k < s; k++)
+      d += c[k] * p[k], m += h[k] * p[k], w += c[k] ** 2, x += h[k] ** 2;
+    w = Math.sqrt(w), x = Math.sqrt(x);
+    const _ = Math.sqrt(y);
+    if (w > 0 && x > 0 && _ > 0 && Math.abs(d) / (w * _) < i && Math.abs(m) / (x * _) < i)
+      break;
+    let b = 0, P = 0, M = 0;
+    for (let k = 0; k < s; k++)
+      b += c[k] * c[k], P += c[k] * h[k], M += h[k] * h[k];
+    const S = b * M - P * P;
+    if (Math.abs(S) < 1e-14) break;
+    const U = -(M * d - P * m) / S, j = -(b * m - P * d) / S;
+    l = Math.max(0, Math.min(1, l + U)), u = Math.max(0, Math.min(1, u + j));
+  }
+  return [l, u];
+}
+const Mt = ({
+  points: t,
+  degree: n = 3,
+  weights: e,
+  knots: r,
+  resolution: s = 50,
+  color: o = "black",
+  segments: i,
+  dashed: l = !1,
+  vertexColors: u,
+  ...a
 }) => {
-  const p = Me(() => {
-    if (!c)
-      return console.error("NurbsCurve requires knots to be provided"), [];
+  const g = V(() => {
     try {
-      const m = Array(T.length).fill(1), R = ue.geom.NurbsCurve.byKnotsControlPointsWeights(
-        x,
-        c,
-        T,
-        y ?? m
-      );
-      return Array.from({ length: k + 1 }, (D, S) => {
-        const b = S / k, v = R.point(b);
-        return new hr(v[0], v[1], v[2]);
+      const f = r ?? H(t.length, n), c = Array(t.length).fill(1), h = B.byKnotsControlPointsWeights(
+        n,
+        f,
+        t,
+        e ?? c
+      ), p = s;
+      return Array.from({ length: p + 1 }, (y, d) => {
+        const m = d / p, w = h.point(m);
+        return new I(w[0], w[1], w[2]);
       });
-    } catch (m) {
-      return console.error("Error creating NURBS curve:", m), [];
+    } catch (f) {
+      return console.error("Error creating NURBS curve:", f), [];
     }
-  }, [T, x, y, c, k]);
-  return p.length === 0 ? null : /* @__PURE__ */ K.jsx(
-    Sr,
+  }, [t, n, e, r, s]);
+  return g.length === 0 ? null : /* @__PURE__ */ q.jsx(
+    xt,
     {
-      points: p,
-      color: F,
-      segments: _,
-      dashed: g,
-      vertexColors: f,
-      ...E
+      points: g,
+      color: o,
+      segments: i,
+      dashed: l,
+      vertexColors: u,
+      ...a
     }
   );
+}, On = /* @__PURE__ */ new Set([
+  "meshBasicMaterial",
+  "meshStandardMaterial",
+  "meshPhongMaterial",
+  "meshLambertMaterial",
+  "meshToonMaterial",
+  "meshNormalMaterial",
+  "meshMatcapMaterial",
+  "meshDepthMaterial",
+  "meshDistanceMaterial",
+  "meshPhysicalMaterial",
+  "pointsMaterial",
+  "lineBasicMaterial",
+  "lineDashedMaterial",
+  "spriteMaterial",
+  "shadowMaterial",
+  "rawShaderMaterial",
+  "shaderMaterial"
+]);
+function vt(t) {
+  return gt(t) ? typeof t.type == "string" ? On.has(t.type) : !!(t.type && t.type.prototype && "isMaterial" in t.type.prototype) : !1;
+}
+const De = ie(function({
+  controlPoints: n,
+  weights: e,
+  degreeU: r,
+  degreeV: s,
+  knotsU: o,
+  knotsV: i,
+  resolutionU: l = 20,
+  resolutionV: u = 20,
+  color: a = "#ffffff",
+  wireframe: g = !1,
+  fastNormals: f = !1,
+  children: c,
+  ...h
+}, p) {
+  const y = V(() => {
+    if (!c) return null;
+    const w = ht.toArray(c);
+    for (const x of w)
+      if (vt(x))
+        return x;
+    return console.warn("NurbsSurface children must be a material component"), null;
+  }, [c]), d = et(null), m = V(() => {
+    if (!n || n.length === 0) return null;
+    try {
+      const w = o ?? H(n.length, r), x = i ?? H(n[0].length, s), _ = ut.byKnotsControlPointsWeights(
+        r,
+        s,
+        w,
+        x,
+        n,
+        e
+      ), b = (l + 1) * (u + 1), P = new Float32Array(b * 3), M = new Float32Array(b * 2);
+      let S = 0, U = 0;
+      for (let R = 0; R <= l; R++)
+        for (let W = 0; W <= u; W++) {
+          const G = R / l, Q = W / u, X = _.point(G, Q);
+          P[S++] = X[0], P[S++] = X[1], P[S++] = X[2], M[U++] = G, M[U++] = Q;
+        }
+      let j = null;
+      if (!f) {
+        j = new Float32Array(b * 3);
+        let R = 0;
+        for (let W = 0; W <= l; W++)
+          for (let G = 0; G <= u; G++) {
+            const Q = W / l, X = G / u;
+            try {
+              const nt = _.normal(Q, X), lt = Math.sqrt(nt[0] ** 2 + nt[1] ** 2 + nt[2] ** 2);
+              lt > 0 ? (j[R++] = nt[0] / lt, j[R++] = nt[1] / lt, j[R++] = nt[2] / lt) : (j[R++] = 0, j[R++] = 1, j[R++] = 0);
+            } catch {
+              j[R++] = 0, j[R++] = 1, j[R++] = 0;
+            }
+          }
+      }
+      const k = l * u * 6, E = new Uint32Array(k);
+      let T = 0;
+      for (let R = 0; R < l; R++)
+        for (let W = 0; W < u; W++) {
+          const G = R * (u + 1) + W, Q = G + 1, X = (R + 1) * (u + 1) + W, nt = X + 1;
+          E[T++] = G, E[T++] = Q, E[T++] = X, E[T++] = Q, E[T++] = nt, E[T++] = X;
+        }
+      const D = d.current ?? new pt();
+      return D.setAttribute("position", new J(P, 3)), j && D.setAttribute("normal", new J(j, 3)), D.setAttribute("uv", new J(M, 2)), D.setIndex(Array.from(E)), j || D.computeVertexNormals(), D.computeBoundingSphere(), d.current = D, D;
+    } catch (w) {
+      return console.error("Error creating NURBS surface:", w), null;
+    }
+  }, [n, e, r, s, o, i, l, u, f]);
+  return !m || c && !y ? null : /* @__PURE__ */ q.jsx("mesh", { ref: p, ...h, geometry: m, children: y || /* @__PURE__ */ q.jsx("meshPhongMaterial", { color: a, wireframe: g, side: wt }) });
+}), hr = ({
+  degreeV: t = 3,
+  resolutionU: n = 20,
+  resolutionV: e = 20,
+  color: r = "#ff0000",
+  wireframe: s = !1,
+  children: o
+}) => {
+  const { curveChildren: i, materialChild: l } = V(() => {
+    const g = [];
+    let f = null;
+    return ht.forEach(o, (c) => {
+      gt(c) && c.type === Mt ? g.push(c) : vt(c) && (f = c);
+    }), { curveChildren: g, materialChild: f };
+  }, [o]), u = et(null), a = V(() => {
+    if (i.length < 2)
+      return console.error("LoftedSurface requires at least 2 NurbsCurve children"), null;
+    try {
+      const g = i.map((d) => {
+        const { points: m, degree: w = 3, weights: x, knots: _ } = d.props, b = Array(m.length).fill(1), P = _ ?? H(m.length, w);
+        return B.byKnotsControlPointsWeights(
+          w,
+          P,
+          m,
+          x ?? b
+        );
+      }), f = ut.byLoftingCurves(g, t), c = [], h = [], p = [];
+      for (let d = 0; d <= n; d++)
+        for (let m = 0; m <= e; m++) {
+          const w = d / n, x = m / e, _ = f.point(w, x);
+          c.push(_[0], _[1], _[2]), p.push(w, x);
+        }
+      for (let d = 0; d < n; d++)
+        for (let m = 0; m < e; m++) {
+          const w = d * (e + 1) + m, x = w + 1, _ = (d + 1) * (e + 1) + m, b = _ + 1;
+          h.push(w, x, _), h.push(x, b, _);
+        }
+      const y = u.current ?? new pt();
+      return y.setAttribute("position", new J(c, 3)), y.setAttribute("uv", new J(p, 2)), y.setIndex(h), y.computeVertexNormals(), y.computeBoundingSphere(), u.current = y, y;
+    } catch (g) {
+      return console.error("Error creating lofted surface:", g), null;
+    }
+  }, [i, t, n, e]);
+  return a ? /* @__PURE__ */ q.jsx("mesh", { geometry: a, children: l || /* @__PURE__ */ q.jsx("meshStandardMaterial", { color: r, wireframe: s, side: wt }) }) : null;
 };
-function Fr({
-  controlPoints: T,
-  weights: x,
-  degreeU: y,
-  degreeV: c,
-  color: k = "#ffffff",
-  wireframe: F = !1,
-  children: _,
-  ...g
+function Vn(t, n, e = 2) {
+  const r = n && n.length, s = r ? n[0] * e : t.length;
+  let o = Ue(t, 0, s, e, !0);
+  const i = [];
+  if (!o || o.next === o.prev) return i;
+  let l, u, a;
+  if (r && (o = Ln(t, n, o, e)), t.length > 80 * e) {
+    l = t[0], u = t[1];
+    let g = l, f = u;
+    for (let c = e; c < s; c += e) {
+      const h = t[c], p = t[c + 1];
+      h < l && (l = h), p < u && (u = p), h > g && (g = h), p > f && (f = p);
+    }
+    a = Math.max(g - l, f - u), a = a !== 0 ? 32767 / a : 0;
+  }
+  return Dt(o, i, e, l, u, a, 0), i;
+}
+function Ue(t, n, e, r, s) {
+  let o;
+  if (s === tr(t, n, e, r) > 0)
+    for (let i = n; i < e; i += r) o = Me(i / r | 0, t[i], t[i + 1], o);
+  else
+    for (let i = e - r; i >= n; i -= r) o = Me(i / r | 0, t[i], t[i + 1], o);
+  return o && kt(o, o.next) && (Ft(o), o = o.next), o;
+}
+function yt(t, n) {
+  if (!t) return t;
+  n || (n = t);
+  let e = t, r;
+  do
+    if (r = !1, !e.steiner && (kt(e, e.next) || z(e.prev, e, e.next) === 0)) {
+      if (Ft(e), e = n = e.prev, e === e.next) break;
+      r = !0;
+    } else
+      e = e.next;
+  while (r || e !== n);
+  return n;
+}
+function Dt(t, n, e, r, s, o, i) {
+  if (!t) return;
+  !i && o && Yn(t, r, s, o);
+  let l = t;
+  for (; t.prev !== t.next; ) {
+    const u = t.prev, a = t.next;
+    if (o ? Nn(t, r, s, o) : $n(t)) {
+      n.push(u.i, t.i, a.i), Ft(t), t = a.next, l = a.next;
+      continue;
+    }
+    if (t = a, t === l) {
+      i ? i === 1 ? (t = Kn(yt(t), n), Dt(t, n, e, r, s, o, 2)) : i === 2 && Wn(t, n, e, r, s, o) : Dt(yt(t), n, e, r, s, o, 1);
+      break;
+    }
+  }
+}
+function $n(t) {
+  const n = t.prev, e = t, r = t.next;
+  if (z(n, e, r) >= 0) return !1;
+  const s = n.x, o = e.x, i = r.x, l = n.y, u = e.y, a = r.y, g = Math.min(s, o, i), f = Math.min(l, u, a), c = Math.max(s, o, i), h = Math.max(l, u, a);
+  let p = r.next;
+  for (; p !== n; ) {
+    if (p.x >= g && p.x <= c && p.y >= f && p.y <= h && Tt(s, l, o, u, i, a, p.x, p.y) && z(p.prev, p, p.next) >= 0) return !1;
+    p = p.next;
+  }
+  return !0;
+}
+function Nn(t, n, e, r) {
+  const s = t.prev, o = t, i = t.next;
+  if (z(s, o, i) >= 0) return !1;
+  const l = s.x, u = o.x, a = i.x, g = s.y, f = o.y, c = i.y, h = Math.min(l, u, a), p = Math.min(g, f, c), y = Math.max(l, u, a), d = Math.max(g, f, c), m = oe(h, p, n, e, r), w = oe(y, d, n, e, r);
+  let x = t.prevZ, _ = t.nextZ;
+  for (; x && x.z >= m && _ && _.z <= w; ) {
+    if (x.x >= h && x.x <= y && x.y >= p && x.y <= d && x !== s && x !== i && Tt(l, g, u, f, a, c, x.x, x.y) && z(x.prev, x, x.next) >= 0 || (x = x.prevZ, _.x >= h && _.x <= y && _.y >= p && _.y <= d && _ !== s && _ !== i && Tt(l, g, u, f, a, c, _.x, _.y) && z(_.prev, _, _.next) >= 0)) return !1;
+    _ = _.nextZ;
+  }
+  for (; x && x.z >= m; ) {
+    if (x.x >= h && x.x <= y && x.y >= p && x.y <= d && x !== s && x !== i && Tt(l, g, u, f, a, c, x.x, x.y) && z(x.prev, x, x.next) >= 0) return !1;
+    x = x.prevZ;
+  }
+  for (; _ && _.z <= w; ) {
+    if (_.x >= h && _.x <= y && _.y >= p && _.y <= d && _ !== s && _ !== i && Tt(l, g, u, f, a, c, _.x, _.y) && z(_.prev, _, _.next) >= 0) return !1;
+    _ = _.nextZ;
+  }
+  return !0;
+}
+function Kn(t, n) {
+  let e = t;
+  do {
+    const r = e.prev, s = e.next.next;
+    !kt(r, s) && Ie(r, e, e.next, s) && Ut(r, s) && Ut(s, r) && (n.push(r.i, e.i, s.i), Ft(e), Ft(e.next), e = t = s), e = e.next;
+  } while (e !== t);
+  return yt(e);
+}
+function Wn(t, n, e, r, s, o) {
+  let i = t;
+  do {
+    let l = i.next.next;
+    for (; l !== i.prev; ) {
+      if (i.i !== l.i && Hn(i, l)) {
+        let u = Oe(i, l);
+        i = yt(i, i.next), u = yt(u, u.next), Dt(i, n, e, r, s, o, 0), Dt(u, n, e, r, s, o, 0);
+        return;
+      }
+      l = l.next;
+    }
+    i = i.next;
+  } while (i !== t);
+}
+function Ln(t, n, e, r) {
+  const s = [];
+  for (let o = 0, i = n.length; o < i; o++) {
+    const l = n[o] * r, u = o < i - 1 ? n[o + 1] * r : t.length, a = Ue(t, l, u, r, !1);
+    a === a.next && (a.steiner = !0), s.push(Gn(a));
+  }
+  s.sort(qn);
+  for (let o = 0; o < s.length; o++)
+    e = zn(s[o], e);
+  return e;
+}
+function qn(t, n) {
+  let e = t.x - n.x;
+  if (e === 0 && (e = t.y - n.y, e === 0)) {
+    const r = (t.next.y - t.y) / (t.next.x - t.x), s = (n.next.y - n.y) / (n.next.x - n.x);
+    e = r - s;
+  }
+  return e;
+}
+function zn(t, n) {
+  const e = Bn(t, n);
+  if (!e)
+    return n;
+  const r = Oe(e, t);
+  return yt(r, r.next), yt(e, e.next);
+}
+function Bn(t, n) {
+  let e = n;
+  const r = t.x, s = t.y;
+  let o = -1 / 0, i;
+  if (kt(t, e)) return e;
+  do {
+    if (kt(t, e.next)) return e.next;
+    if (s <= e.y && s >= e.next.y && e.next.y !== e.y) {
+      const f = e.x + (s - e.y) * (e.next.x - e.x) / (e.next.y - e.y);
+      if (f <= r && f > o && (o = f, i = e.x < e.next.x ? e : e.next, f === r))
+        return i;
+    }
+    e = e.next;
+  } while (e !== n);
+  if (!i) return null;
+  const l = i, u = i.x, a = i.y;
+  let g = 1 / 0;
+  e = i;
+  do {
+    if (r >= e.x && e.x >= u && r !== e.x && Fe(s < a ? r : o, s, u, a, s < a ? o : r, s, e.x, e.y)) {
+      const f = Math.abs(s - e.y) / (r - e.x);
+      Ut(e, t) && (f < g || f === g && (e.x > i.x || e.x === i.x && Zn(i, e))) && (i = e, g = f);
+    }
+    e = e.next;
+  } while (e !== l);
+  return i;
+}
+function Zn(t, n) {
+  return z(t.prev, t, n.prev) < 0 && z(n.next, t, t.next) < 0;
+}
+function Yn(t, n, e, r) {
+  let s = t;
+  do
+    s.z === 0 && (s.z = oe(s.x, s.y, n, e, r)), s.prevZ = s.prev, s.nextZ = s.next, s = s.next;
+  while (s !== t);
+  s.prevZ.nextZ = null, s.prevZ = null, Jn(s);
+}
+function Jn(t) {
+  let n, e = 1;
+  do {
+    let r = t, s;
+    t = null;
+    let o = null;
+    for (n = 0; r; ) {
+      n++;
+      let i = r, l = 0;
+      for (let a = 0; a < e && (l++, i = i.nextZ, !!i); a++)
+        ;
+      let u = e;
+      for (; l > 0 || u > 0 && i; )
+        l !== 0 && (u === 0 || !i || r.z <= i.z) ? (s = r, r = r.nextZ, l--) : (s = i, i = i.nextZ, u--), o ? o.nextZ = s : t = s, s.prevZ = o, o = s;
+      r = i;
+    }
+    o.nextZ = null, e *= 2;
+  } while (n > 1);
+  return t;
+}
+function oe(t, n, e, r, s) {
+  return t = (t - e) * s | 0, n = (n - r) * s | 0, t = (t | t << 8) & 16711935, t = (t | t << 4) & 252645135, t = (t | t << 2) & 858993459, t = (t | t << 1) & 1431655765, n = (n | n << 8) & 16711935, n = (n | n << 4) & 252645135, n = (n | n << 2) & 858993459, n = (n | n << 1) & 1431655765, t | n << 1;
+}
+function Gn(t) {
+  let n = t, e = t;
+  do
+    (n.x < e.x || n.x === e.x && n.y < e.y) && (e = n), n = n.next;
+  while (n !== t);
+  return e;
+}
+function Fe(t, n, e, r, s, o, i, l) {
+  return (s - i) * (n - l) >= (t - i) * (o - l) && (t - i) * (r - l) >= (e - i) * (n - l) && (e - i) * (o - l) >= (s - i) * (r - l);
+}
+function Tt(t, n, e, r, s, o, i, l) {
+  return !(t === i && n === l) && Fe(t, n, e, r, s, o, i, l);
+}
+function Hn(t, n) {
+  return t.next.i !== n.i && t.prev.i !== n.i && !Xn(t, n) && // doesn't intersect other edges
+  (Ut(t, n) && Ut(n, t) && Qn(t, n) && // locally visible
+  (z(t.prev, t, n.prev) || z(t, n.prev, n)) || // does not create opposite-facing sectors
+  kt(t, n) && z(t.prev, t, t.next) > 0 && z(n.prev, n, n.next) > 0);
+}
+function z(t, n, e) {
+  return (n.y - t.y) * (e.x - n.x) - (n.x - t.x) * (e.y - n.y);
+}
+function kt(t, n) {
+  return t.x === n.x && t.y === n.y;
+}
+function Ie(t, n, e, r) {
+  const s = Kt(z(t, n, e)), o = Kt(z(t, n, r)), i = Kt(z(e, r, t)), l = Kt(z(e, r, n));
+  return !!(s !== o && i !== l || s === 0 && Nt(t, e, n) || o === 0 && Nt(t, r, n) || i === 0 && Nt(e, t, r) || l === 0 && Nt(e, n, r));
+}
+function Nt(t, n, e) {
+  return n.x <= Math.max(t.x, e.x) && n.x >= Math.min(t.x, e.x) && n.y <= Math.max(t.y, e.y) && n.y >= Math.min(t.y, e.y);
+}
+function Kt(t) {
+  return t > 0 ? 1 : t < 0 ? -1 : 0;
+}
+function Xn(t, n) {
+  let e = t;
+  do {
+    if (e.i !== t.i && e.next.i !== t.i && e.i !== n.i && e.next.i !== n.i && Ie(e, e.next, t, n)) return !0;
+    e = e.next;
+  } while (e !== t);
+  return !1;
+}
+function Ut(t, n) {
+  return z(t.prev, t, t.next) < 0 ? z(t, n, t.next) >= 0 && z(t, t.prev, n) >= 0 : z(t, n, t.prev) < 0 || z(t, t.next, n) < 0;
+}
+function Qn(t, n) {
+  let e = t, r = !1;
+  const s = (t.x + n.x) / 2, o = (t.y + n.y) / 2;
+  do
+    e.y > o != e.next.y > o && e.next.y !== e.y && s < (e.next.x - e.x) * (o - e.y) / (e.next.y - e.y) + e.x && (r = !r), e = e.next;
+  while (e !== t);
+  return r;
+}
+function Oe(t, n) {
+  const e = se(t.i, t.x, t.y), r = se(n.i, n.x, n.y), s = t.next, o = n.prev;
+  return t.next = n, n.prev = t, e.next = s, s.prev = e, r.next = e, e.prev = r, o.next = r, r.prev = o, r;
+}
+function Me(t, n, e, r) {
+  const s = se(t, n, e);
+  return r ? (s.next = r.next, s.prev = r, r.next.prev = s, r.next = s) : (s.prev = s, s.next = s), s;
+}
+function Ft(t) {
+  t.next.prev = t.prev, t.prev.next = t.next, t.prevZ && (t.prevZ.nextZ = t.nextZ), t.nextZ && (t.nextZ.prevZ = t.prevZ);
+}
+function se(t, n, e) {
+  return {
+    i: t,
+    // vertex index in coordinates array
+    x: n,
+    y: e,
+    // vertex coordinates
+    prev: null,
+    // previous and next vertex nodes in a polygon ring
+    next: null,
+    z: 0,
+    // z-order curve value
+    prevZ: null,
+    // previous and next nodes in z-order
+    nextZ: null,
+    steiner: !1
+    // indicates whether this is a steiner point
+  };
+}
+function tr(t, n, e, r) {
+  let s = 0;
+  for (let o = n, i = e - r; o < e; o += r)
+    s += (t[i] - t[o]) * (t[o + 1] + t[i + 1]), i = o;
+  return s;
+}
+function dr({
+  color: t = "#ffffff",
+  trimCurveResolution: n = 200,
+  adaptiveMaxAngleDeg: e = 5,
+  adaptiveMaxDepth: r = 10,
+  wireframe: s = !1,
+  world: o = !1,
+  children: i,
+  ...l
 }) {
-  const { scene: f } = Cr(), [E, p] = pr(null);
-  return mr(() => {
-    const m = T.length + y + 1, R = T[0].length + c + 1, D = Array(m).fill(0).map((w, l) => l < y + 1 ? 0 : l >= m - y - 1 ? 1 : (l - y) / (m - 2 * y - 1)), S = Array(R).fill(0).map((w, l) => l < c + 1 ? 0 : l >= R - c - 1 ? 1 : (l - c) / (R - 2 * c - 1)), b = ue.geom.NurbsSurface.byKnotsControlPointsWeights(
-      y,
-      c,
-      D,
-      S,
-      T,
-      x
-    ), v = new yr(), C = [], s = [], W = [], H = 20, U = 20, ce = 1 / H, fe = 1 / U;
-    for (let w = 0; w <= H; w++)
-      for (let l = 0; l <= U; l++) {
-        const $ = w * ce, N = l * fe, B = b.point($, N), j = 1e-4, M = b.point($ + j, N), z = b.point($, N + j), Z = b.point($, N), Y = M.map((q, J) => (q - Z[J]) / j), L = z.map((q, J) => (q - Z[J]) / j), I = [
-          Y[1] * L[2] - Y[2] * L[1],
-          Y[2] * L[0] - Y[0] * L[2],
-          Y[0] * L[1] - Y[1] * L[0]
-        ], te = Math.sqrt(
-          I[0] * I[0] + I[1] * I[1] + I[2] * I[2]
-        ), ne = I.map((q) => q / te);
-        C.push(...B), s.push(...ne);
-      }
-    for (let w = 0; w < H; w++)
-      for (let l = 0; l < U; l++) {
-        const $ = w * (U + 1) + l, N = $ + 1, B = (w + 1) * (U + 1) + l, j = B + 1;
-        W.push($, N, B), W.push(N, j, B);
-      }
-    if (v.setAttribute("position", new Ie(C, 3)), v.setAttribute("normal", new Ie(s, 3)), v.setIndex(W), p(v), !_) {
-      const w = new gr({
-        color: new _r(k),
-        side: Er,
-        wireframe: F
-      }), l = new Rr(v, w);
-      return f.add(l), () => {
-        f.remove(l), v.dispose(), w.dispose();
-      };
+  const { surfaceChild: u, curveChildren: a, materialChild: g } = V(() => {
+    const h = ht.toArray(i);
+    let p = null;
+    const y = [];
+    let d = null;
+    for (const m of h)
+      gt(m) && (m.type === De || m.type === "NurbsSurface" ? p = m : m.type === Mt || m.type === "NurbsCurve" ? y.push(m) : vt(m) && (d = m));
+    return { surfaceChild: p, curveChildren: y, materialChild: d };
+  }, [i]), f = et(null), c = V(() => {
+    if (!u || a.length === 0)
+      return u || console.warn("TrimmedSurface requires a NurbsSurface child"), a.length === 0 && console.warn("TrimmedSurface requires at least one NurbsCurve"), null;
+    try {
+      const h = u.props, p = H(h.controlPoints.length, h.degreeU), y = H(h.controlPoints[0].length, h.degreeV), d = ut.byKnotsControlPointsWeights(
+        h.degreeU,
+        h.degreeV,
+        p,
+        y,
+        h.controlPoints,
+        h.weights
+      ), w = a.map((E) => {
+        const T = E.props, D = T.knots ?? H(T.points.length, T.degree ?? 2), R = B.byKnotsControlPointsWeights(
+          T.degree ?? 2,
+          D,
+          T.points,
+          T.weights ?? Array(T.points.length).fill(1)
+        );
+        if (o) {
+          const W = Fn(
+            d,
+            R,
+            n
+          );
+          if (W.length > 1) {
+            const G = H(W.length, T.degree ?? 2);
+            return B.byKnotsControlPointsWeights(
+              T.degree ?? 2,
+              G,
+              W.map(([Q, X]) => [Q, X, 0]),
+              Array(W.length).fill(1)
+            );
+          }
+          return null;
+        }
+        return R;
+      }).filter((E) => E !== null).map(
+        (E) => Un(E, e, r)
+      ), x = [], _ = [];
+      let b = 0;
+      w.forEach((E, T) => {
+        T > 0 && _.push(b), E.forEach(([D, R]) => {
+          x.push(D, R), b++;
+        });
+      });
+      const P = Vn(x, _, 2), M = [], S = [], U = [], j = [];
+      for (let E = 0; E < x.length; E += 2)
+        j.push([x[E], x[E + 1]]);
+      for (const [E, T] of j) {
+        const D = Tn(d, E, T), R = Dn(d, E, T);
+        M.push(D.x, D.y, D.z), S.push(R.x, R.y, R.z), U.push(E, T);
+      }
+      const k = f.current ?? new pt();
+      return k.setAttribute("position", new J(M, 3)), k.setAttribute("normal", new J(S, 3)), k.setAttribute("uv", new J(U, 2)), k.setIndex(Array.from(P)), k.computeBoundingSphere(), f.current = k, k;
+    } catch (h) {
+      return console.error("Error creating trimmed surface:", h), null;
     }
-    return () => {
-      v.dispose();
-    };
   }, [
-    T,
-    x,
-    y,
-    c,
-    k,
-    F,
-    f,
-    _
-  ]), E && _ ? !Ye(_) || !_.type.toString().includes("Material") ? (console.warn("NurbsSurface children must be a material component"), null) : /* @__PURE__ */ K.jsxs("mesh", { ...g, children: [
-    /* @__PURE__ */ K.jsx("primitive", { object: E, attach: "geometry" }),
-    _
-  ] }) : null;
-}
-const Dr = ({
-  degreeV: T = 3,
-  knotsV: x,
-  resolutionU: y = 20,
-  resolutionV: c = 20,
-  color: k = "#ff0000",
-  wireframe: F = !1,
-  children: _
+    u,
+    a,
+    n,
+    e,
+    r,
+    o
+  ]);
+  return !c || !g ? (!g && u && a.length > 0 && console.warn("TrimmedSurface requires a material as a direct child"), null) : /* @__PURE__ */ q.jsx("mesh", { ...l, geometry: c, children: g });
+}
+const gr = ({
+  center: t = [0, 0, 0],
+  axis: n = [1, 0, 0],
+  angle: e = 2 * Math.PI,
+  resolutionU: r = 20,
+  resolutionV: s = 20,
+  color: o = "#ff0000",
+  wireframe: i = !1,
+  children: l,
+  ...u
 }) => {
-  const g = Me(() => {
-    const f = br.toArray(_).filter(
-      (E) => Ye(E) && E.type === jr
-    );
-    if (f.length < 2)
-      return console.error("LoftedSurface requires at least 2 NurbsCurve children"), null;
+  const { profileChild: a, materialChild: g } = V(() => {
+    let h = null, p = null;
+    const y = ht.toArray(l);
+    for (const d of y)
+      gt(d) && (d.type === Mt ? h = d : vt(d) && (p = d));
+    return { profileChild: h, materialChild: p };
+  }, [l]), f = et(null), c = V(() => {
+    if (!a)
+      return console.error("RevolvedSurface requires a NurbsCurve child"), null;
     try {
-      const E = f.map((S) => {
-        const { points: b, degree: v = 3, weights: C, knots: s } = S.props, W = Array(b.length).fill(1);
-        return ue.geom.NurbsCurve.byKnotsControlPointsWeights(
-          v,
-          s,
+      const { points: h, degree: p = 3, weights: y, knots: d } = a.props, m = Array(h.length).fill(1);
+      if (!h || h.length < 2) return null;
+      const w = Math.sqrt(n[0] ** 2 + n[1] ** 2 + n[2] ** 2);
+      if (w === 0) return null;
+      const x = [
+        n[0] / w,
+        n[1] / w,
+        n[2] / w
+      ], _ = d ?? H(h.length, p), b = B.byKnotsControlPointsWeights(
+        p,
+        _,
+        h,
+        y ?? m
+      ), P = new ut(
+        Sn(b.asData(), t, x, e)
+      ), M = [], S = [], U = [];
+      for (let k = 0; k <= r; k++)
+        for (let E = 0; E <= s; E++) {
+          const T = k / r, D = E / s, R = P.point(T, D);
+          M.push(R[0], R[1], R[2]), U.push(T, D);
+        }
+      for (let k = 0; k < r; k++)
+        for (let E = 0; E < s; E++) {
+          const T = k * (s + 1) + E, D = T + 1, R = (k + 1) * (s + 1) + E, W = R + 1;
+          S.push(T, D, R), S.push(D, W, R);
+        }
+      const j = f.current ?? new pt();
+      return j.setAttribute("position", new J(M, 3)), j.setAttribute("uv", new J(U, 2)), j.setIndex(S), j.computeVertexNormals(), j.computeBoundingSphere(), f.current = j, j;
+    } catch (h) {
+      return console.error("Error creating revolved surface:", h), null;
+    }
+  }, [a, t, n, e, r, s]);
+  return c ? /* @__PURE__ */ q.jsx("mesh", { ...u, geometry: c, children: g || /* @__PURE__ */ q.jsx("meshStandardMaterial", { color: o, wireframe: i, side: wt }) }) : null;
+}, pr = ({
+  direction: t,
+  resolutionU: n = 20,
+  resolutionV: e = 20,
+  color: r = "#ff0000",
+  wireframe: s = !1,
+  children: o,
+  ...i
+}) => {
+  const { profileChild: l, materialChild: u } = V(() => {
+    let f = null, c = null;
+    const h = ht.toArray(o);
+    for (const p of h)
+      gt(p) && (p.type === Mt ? f = p : vt(p) && (c = p));
+    return { profileChild: f, materialChild: c };
+  }, [o]), a = et(null), g = V(() => {
+    if (!l)
+      return console.error("ExtrudedSurface requires a NurbsCurve child"), null;
+    try {
+      const { points: f, degree: c = 3, weights: h, knots: p } = l.props, y = Array(f.length).fill(1), d = p ?? H(f.length, c), m = B.byKnotsControlPointsWeights(
+        c,
+        d,
+        f,
+        h ?? y
+      ), w = new ut(
+        An(m.asData(), t)
+      ), x = [], _ = [], b = [];
+      for (let M = 0; M <= n; M++)
+        for (let S = 0; S <= e; S++) {
+          const U = M / n, j = S / e, k = w.point(U, j);
+          x.push(k[0], k[1], k[2]), b.push(U, j);
+        }
+      for (let M = 0; M < n; M++)
+        for (let S = 0; S < e; S++) {
+          const U = M * (e + 1) + S, j = U + 1, k = (M + 1) * (e + 1) + S, E = k + 1;
+          _.push(U, j, k), _.push(j, E, k);
+        }
+      const P = a.current ?? new pt();
+      return P.setAttribute("position", new J(x, 3)), P.setAttribute("uv", new J(b, 2)), P.setIndex(_), P.computeVertexNormals(), P.computeBoundingSphere(), a.current = P, P;
+    } catch (f) {
+      return console.error("Error creating extruded surface:", f), null;
+    }
+  }, [l, t, n, e]);
+  return g ? /* @__PURE__ */ q.jsx("mesh", { ...i, geometry: g, children: u || /* @__PURE__ */ q.jsx("meshStandardMaterial", { color: r, wireframe: s, side: wt }) }) : null;
+}, vr = ({
+  resolutionU: t = 20,
+  resolutionV: n = 20,
+  color: e = "#ff0000",
+  wireframe: r = !1,
+  children: s,
+  ...o
+}) => {
+  const { profileChild: i, railChild: l, materialChild: u } = V(() => {
+    const f = [];
+    let c = null;
+    const h = ht.toArray(s);
+    for (const p of h)
+      gt(p) && (p.type === Mt ? f.push(p) : vt(p) && (c = p));
+    return {
+      profileChild: f[0] ?? null,
+      railChild: f[1] ?? null,
+      materialChild: c
+    };
+  }, [s]), a = et(null), g = V(() => {
+    if (!i || !l)
+      return console.error("SweptSurface requires exactly 2 NurbsCurve children (profile and rail)"), null;
+    try {
+      const f = (x) => {
+        const { points: _, degree: b = 3, weights: P, knots: M } = x, S = M ?? H(_.length, b);
+        return B.byKnotsControlPointsWeights(
           b,
-          C ?? W
+          S,
+          _,
+          P ?? Array(_.length).fill(1)
         );
-      }), p = ue.geom.NurbsSurface.byLoftingCurves(
-        E,
-        T
-      ), m = [], R = [], D = [];
-      for (let S = 0; S <= y; S++)
-        for (let b = 0; b <= c; b++) {
-          const v = S / y, C = b / c, s = p.point(v, C);
-          m.push(s[0], s[1], s[2]), D.push(v, C);
-        }
-      for (let S = 0; S < y; S++)
-        for (let b = 0; b < c; b++) {
-          const v = S * (c + 1) + b, C = v + 1, s = (S + 1) * (c + 1) + b, W = s + 1;
-          R.push(v, C, s), R.push(C, W, s);
-        }
-      return {
-        vertices: m,
-        indices: R,
-        uvs: D
-      };
-    } catch (E) {
-      return console.error("Error creating lofted surface:", E), null;
-    }
-  }, [_, T, x, y, c]);
-  return g ? /* @__PURE__ */ K.jsxs("mesh", { children: [
-    /* @__PURE__ */ K.jsxs("bufferGeometry", { children: [
-      /* @__PURE__ */ K.jsx(
-        "bufferAttribute",
-        {
-          attach: "attributes-position",
-          count: g.vertices.length / 3,
-          array: new Float32Array(g.vertices),
-          itemSize: 3
-        }
-      ),
-      /* @__PURE__ */ K.jsx(
-        "bufferAttribute",
-        {
-          attach: "attributes-uv",
-          count: g.uvs.length / 2,
-          array: new Float32Array(g.uvs),
-          itemSize: 2
-        }
-      ),
-      /* @__PURE__ */ K.jsx(
-        "bufferAttribute",
+      }, c = f(i.props), h = f(l.props), p = new ut(
+        En(c.asData(), h.asData())
+      ), y = [], d = [], m = [];
+      for (let x = 0; x <= t; x++)
+        for (let _ = 0; _ <= n; _++) {
+          const b = x / t, P = _ / n, M = p.point(b, P);
+          y.push(M[0], M[1], M[2]), m.push(b, P);
+        }
+      for (let x = 0; x < t; x++)
+        for (let _ = 0; _ < n; _++) {
+          const b = x * (n + 1) + _, P = b + 1, M = (x + 1) * (n + 1) + _, S = M + 1;
+          d.push(b, P, M), d.push(P, S, M);
+        }
+      const w = a.current ?? new pt();
+      return w.setAttribute("position", new J(y, 3)), w.setAttribute("uv", new J(m, 2)), w.setIndex(d), w.computeVertexNormals(), w.computeBoundingSphere(), a.current = w, w;
+    } catch (f) {
+      return console.error("Error creating swept surface:", f), null;
+    }
+  }, [i, l, t, n]);
+  return g ? /* @__PURE__ */ q.jsx("mesh", { ...o, geometry: g, children: u || /* @__PURE__ */ q.jsx("meshStandardMaterial", { color: e, wireframe: r, side: wt }) }) : null;
+};
+function Ae(t) {
+  const n = t.knotsU ?? H(t.controlPoints.length, t.degreeU), e = t.knotsV ?? H(t.controlPoints[0].length, t.degreeV);
+  return ut.byKnotsControlPointsWeights(
+    t.degreeU,
+    t.degreeV,
+    n,
+    e,
+    t.controlPoints,
+    t.weights
+  );
+}
+function er({
+  surface0: t,
+  surface1: n,
+  tolerance: e = 1e-3
+}) {
+  return { curves: V(() => {
+    if (!t || !n) return [];
+    try {
+      const s = Ae(t), o = Ae(n);
+      return jn(
+        s,
+        o,
+        e
+      ).map((l) => ({
+        points: l.points.map(
+          (u) => new I(u[0], u[1], u[2])
+        )
+      }));
+    } catch (s) {
+      return console.error("useSurfaceIntersection: Error computing intersection:", s), [];
+    }
+  }, [t, n, e]) };
+}
+const mr = ({
+  tolerance: t = 1e-3,
+  lineColor: n = "#ff0000",
+  lineWidth: e = 2,
+  children: r
+}) => {
+  const s = V(() => {
+    const i = [];
+    return ht.forEach(r, (l) => {
+      if (gt(l) && (l.type === De || l.type === "NurbsSurface")) {
+        const u = l.props;
+        i.push({
+          controlPoints: u.controlPoints,
+          weights: u.weights,
+          degreeU: u.degreeU,
+          degreeV: u.degreeV,
+          knotsU: u.knotsU,
+          knotsV: u.knotsV
+        });
+      }
+    }), i;
+  }, [r]), { curves: o } = er({
+    surface0: s[0] ?? null,
+    surface1: s[1] ?? null,
+    tolerance: t
+  });
+  return s.length < 2 ? (console.warn("SurfaceIntersection requires exactly 2 NurbsSurface children"), null) : /* @__PURE__ */ q.jsxs("group", { children: [
+    r,
+    o.map(
+      (i, l) => i.points.length >= 2 ? /* @__PURE__ */ q.jsx(
+        xt,
         {
-          attach: "index",
-          count: g.indices.length,
-          array: new Uint32Array(g.indices),
-          itemSize: 1
-        }
-      )
-    ] }),
-    /* @__PURE__ */ K.jsx("meshStandardMaterial", { color: k, wireframe: F })
-  ] }) : null;
+          points: i.points,
+          color: n,
+          lineWidth: e
+        },
+        l
+      ) : null
+    )
+  ] });
+}, yr = ({
+  throughPoints: t,
+  degree: n = 3,
+  resolution: e = 50,
+  color: r = "black",
+  ...s
+}) => {
+  const o = V(() => {
+    if (!t || t.length < 2) return [];
+    try {
+      const i = B.byPoints(t, n);
+      return Array.from({ length: e + 1 }, (l, u) => {
+        const a = u / e, g = i.point(a);
+        return new I(g[0], g[1], g[2]);
+      });
+    } catch (i) {
+      return console.error("InterpolatedCurve: Error creating curve:", i), [];
+    }
+  }, [t, n, e]);
+  return o.length === 0 ? null : /* @__PURE__ */ q.jsx(xt, { points: o, color: r, ...s });
 };
+function nr({
+  points: t,
+  degreeU: n = 3,
+  degreeV: e = 3,
+  resolutionU: r = 20,
+  resolutionV: s = 20
+}) {
+  const o = V(() => {
+    if (!t || t.length < 2) return null;
+    for (const l of t)
+      if (!l || l.length < 2) return null;
+    try {
+      const l = t.map(
+        (u) => B.byPoints(u, Math.min(n, u.length - 1))
+      );
+      return ut.byLoftingCurves(
+        l,
+        Math.min(e, l.length - 1)
+      );
+    } catch (l) {
+      return console.error("useInterpolatedSurface: Error creating surface:", l), null;
+    }
+  }, [t, n, e]), i = V(() => {
+    if (!o) return null;
+    try {
+      const l = (r + 1) * (s + 1), u = new Float32Array(l * 3), a = new Float32Array(l * 3), g = new Float32Array(l * 2);
+      let f = 0, c = 0, h = 0;
+      for (let m = 0; m <= r; m++)
+        for (let w = 0; w <= s; w++) {
+          const x = m / r, _ = w / s, b = o.point(x, _);
+          u[f++] = b[0], u[f++] = b[1], u[f++] = b[2];
+          try {
+            const P = o.normal(x, _), M = Math.sqrt(P[0] ** 2 + P[1] ** 2 + P[2] ** 2);
+            M > 0 ? (a[c++] = P[0] / M, a[c++] = P[1] / M, a[c++] = P[2] / M) : (a[c++] = 0, a[c++] = 1, a[c++] = 0);
+          } catch {
+            a[c++] = 0, a[c++] = 1, a[c++] = 0;
+          }
+          g[h++] = x, g[h++] = _;
+        }
+      const p = r * s * 6, y = new Uint32Array(p);
+      let d = 0;
+      for (let m = 0; m < r; m++)
+        for (let w = 0; w < s; w++) {
+          const x = m * (s + 1) + w, _ = x + 1, b = (m + 1) * (s + 1) + w, P = b + 1;
+          y[d++] = x, y[d++] = _, y[d++] = b, y[d++] = _, y[d++] = P, y[d++] = b;
+        }
+      return { vertices: u, normals: a, uvs: g, indices: y };
+    } catch (l) {
+      return console.error("useInterpolatedSurface: Error generating geometry:", l), null;
+    }
+  }, [o, r, s]);
+  return { surface: o, geometry: i };
+}
+const wr = ie(
+  function({
+    points: n,
+    degreeU: e = 3,
+    degreeV: r = 3,
+    resolutionU: s = 20,
+    resolutionV: o = 20,
+    color: i = "#ffffff",
+    wireframe: l = !1,
+    children: u,
+    ...a
+  }, g) {
+    const f = V(() => {
+      if (!u) return null;
+      const y = ht.toArray(u);
+      for (const d of y)
+        if (vt(d)) return d;
+      return null;
+    }, [u]), { geometry: c } = nr({
+      points: n,
+      degreeU: e,
+      degreeV: r,
+      resolutionU: s,
+      resolutionV: o
+    }), h = et(null), p = V(() => {
+      if (!c) return null;
+      const y = h.current ?? new pt();
+      return y.setAttribute("position", new J(c.vertices, 3)), y.setAttribute("normal", new J(c.normals, 3)), y.setAttribute("uv", new J(c.uvs, 2)), y.setIndex(Array.from(c.indices)), y.computeBoundingSphere(), h.current = y, y;
+    }, [c]);
+    return p ? /* @__PURE__ */ q.jsx("mesh", { ref: g, ...a, geometry: p, children: f || /* @__PURE__ */ q.jsx("meshPhongMaterial", { color: i, wireframe: l, side: wt }) }) : null;
+  }
+), xr = ({
+  center: t = [0, 0, 0],
+  radius: n = 1,
+  xaxis: e = [1, 0, 0],
+  yaxis: r = [0, 1, 0],
+  resolution: s = 64,
+  color: o = "black",
+  ...i
+}) => {
+  const l = V(() => {
+    try {
+      const u = new B(Mn(t, e, r, n));
+      return Array.from({ length: s + 1 }, (a, g) => {
+        const f = g / s, c = u.point(f);
+        return new I(c[0], c[1], c[2]);
+      });
+    } catch (u) {
+      return console.error("NurbsCircle: Error creating circle:", u), [];
+    }
+  }, [t, e, r, n, s]);
+  return l.length === 0 ? null : /* @__PURE__ */ q.jsx(xt, { points: l, color: o, ...i });
+}, _r = ({
+  center: t = [0, 0, 0],
+  radius: n = 1,
+  xaxis: e = [1, 0, 0],
+  yaxis: r = [0, 1, 0],
+  startAngle: s = 0,
+  endAngle: o = Math.PI / 2,
+  resolution: i = 50,
+  color: l = "black",
+  ...u
+}) => {
+  const a = V(() => {
+    try {
+      const g = new B(zt(t, e, r, n, s, o));
+      return Array.from({ length: i + 1 }, (f, c) => {
+        const h = c / i, p = g.point(h);
+        return new I(p[0], p[1], p[2]);
+      });
+    } catch (g) {
+      return console.error("NurbsArc: Error creating arc:", g), [];
+    }
+  }, [t, e, r, n, s, o, i]);
+  return a.length === 0 ? null : /* @__PURE__ */ q.jsx(xt, { points: a, color: l, ...u });
+}, br = ({
+  surface: t,
+  countU: n = 10,
+  countV: e = 10,
+  color: r = "#666666",
+  lineWidth: s = 1,
+  resolution: o = 50
+}) => {
+  const i = V(() => {
+    if (!t) return [];
+    const l = [];
+    for (let u = 0; u <= n; u++) {
+      const a = u / n;
+      try {
+        const g = t.isocurve(a, !1), f = Array.from({ length: o + 1 }, (c, h) => {
+          const p = h / o, y = g.point(p);
+          return new I(y[0], y[1], y[2]);
+        });
+        l.push({ points: f, key: `u-${u}` });
+      } catch {
+      }
+    }
+    for (let u = 0; u <= e; u++) {
+      const a = u / e;
+      try {
+        const g = t.isocurve(a, !0), f = Array.from({ length: o + 1 }, (c, h) => {
+          const p = h / o, y = g.point(p);
+          return new I(y[0], y[1], y[2]);
+        });
+        l.push({ points: f, key: `v-${u}` });
+      } catch {
+      }
+    }
+    return l;
+  }, [t, n, e, o]);
+  return /* @__PURE__ */ q.jsx("group", { children: i.map((l) => /* @__PURE__ */ q.jsx(
+    xt,
+    {
+      points: l.points,
+      color: r,
+      lineWidth: s
+    },
+    l.key
+  )) });
+};
+function rr(t, n, e, r, s, o) {
+  const i = t.point(0), l = t.point(1), u = n.point(0), a = n.point(1), g = (s + 1) * (o + 1), f = new Float32Array(g * 3), c = new Float32Array(g * 2);
+  let h = 0, p = 0;
+  for (let x = 0; x <= s; x++)
+    for (let _ = 0; _ <= o; _++) {
+      const b = x / s, P = _ / o, M = t.point(b), S = n.point(b), U = e.point(P), j = r.point(P);
+      for (let k = 0; k < 3; k++) {
+        const E = (1 - P) * M[k] + P * S[k], T = (1 - b) * U[k] + b * j[k], D = (1 - b) * (1 - P) * i[k] + b * (1 - P) * l[k] + (1 - b) * P * u[k] + b * P * a[k];
+        f[h++] = E + T - D;
+      }
+      c[p++] = b, c[p++] = P;
+    }
+  const y = s * o * 6, d = new Uint32Array(y);
+  let m = 0;
+  for (let x = 0; x < s; x++)
+    for (let _ = 0; _ < o; _++) {
+      const b = x * (o + 1) + _, P = b + 1, M = (x + 1) * (o + 1) + _, S = M + 1;
+      d[m++] = b, d[m++] = P, d[m++] = M, d[m++] = P, d[m++] = S, d[m++] = M;
+    }
+  const w = new pt();
+  return w.setAttribute("position", new J(f, 3)), w.setAttribute("uv", new J(c, 2)), w.setIndex(Array.from(d)), w.computeVertexNormals(), w.computeBoundingSphere(), w;
+}
+const Pr = ie(function({
+  resolutionU: n = 20,
+  resolutionV: e = 20,
+  color: r = "#ff0000",
+  wireframe: s = !1,
+  children: o,
+  ...i
+}, l) {
+  const { curveChildren: u, materialChild: a } = V(() => {
+    const c = [];
+    let h = null;
+    const p = ht.toArray(o);
+    for (const y of p)
+      gt(y) && y.type === Mt ? c.push(y) : vt(y) && (h = y);
+    return { curveChildren: c, materialChild: h };
+  }, [o]), g = et(null), f = V(() => {
+    if (u.length !== 4)
+      return console.error("CoonsPatch requires exactly 4 NurbsCurve children (bottom, top, left, right)"), null;
+    try {
+      const c = u.map((p) => {
+        const { points: y, degree: d = 3, weights: m, knots: w } = p.props, x = w ?? H(y.length, d);
+        return B.byKnotsControlPointsWeights(
+          d,
+          x,
+          y,
+          m ?? Array(y.length).fill(1)
+        );
+      }), h = rr(
+        c[0],
+        c[1],
+        c[2],
+        c[3],
+        n,
+        e
+      );
+      return g.current && g.current !== h && g.current.dispose(), g.current = h, h;
+    } catch (c) {
+      return console.error("Error creating Coons patch:", c), null;
+    }
+  }, [u, n, e]);
+  return f ? /* @__PURE__ */ q.jsx("mesh", { ref: l, ...i, geometry: f, children: a || /* @__PURE__ */ q.jsx("meshPhongMaterial", { color: r, wireframe: s, side: wt }) }) : null;
+}), Cr = ({
+  sourcePoints: t,
+  sourceDegree: n = 3,
+  sourceKnots: e,
+  sourceWeights: r,
+  sourceCurve: s,
+  distance: o,
+  planeNormal: i = [0, 0, 1],
+  samples: l = 50,
+  degree: u = 3,
+  resolution: a = 50,
+  color: g = "black",
+  ...f
+}) => {
+  const c = V(() => {
+    try {
+      let h = s ?? null;
+      if (!h && t && t.length >= 2) {
+        const m = e ?? H(t.length, n);
+        h = B.byKnotsControlPointsWeights(
+          n,
+          m,
+          t,
+          r ?? Array(t.length).fill(1)
+        );
+      }
+      if (!h || o === 0) return [];
+      const p = new I(...i).normalize(), y = [];
+      for (let m = 0; m <= l; m++) {
+        const w = m / l, x = h.point(w), _ = h.tangent(w), b = new I(_[0], _[1], _[2]).normalize(), P = new I().crossVectors(b, p).normalize();
+        y.push([
+          x[0] + P.x * o,
+          x[1] + P.y * o,
+          x[2] + P.z * o
+        ]);
+      }
+      const d = B.byPoints(
+        y,
+        Math.min(u, y.length - 1)
+      );
+      return Array.from({ length: a + 1 }, (m, w) => {
+        const x = w / a, _ = d.point(x);
+        return new I(_[0], _[1], _[2]);
+      });
+    } catch (h) {
+      return console.error("OffsetCurve: Error creating offset:", h), [];
+    }
+  }, [t, n, e, r, s, o, i, l, u, a]);
+  return c.length === 0 ? null : /* @__PURE__ */ q.jsx(xt, { points: c, color: g, ...f });
+};
+function kr({
+  points: t,
+  degree: n = 3,
+  weights: e,
+  knots: r,
+  resolution: s = 50
+}) {
+  const o = V(() => {
+    if (!t || t.length < 2) return null;
+    try {
+      const f = r ?? H(t.length, n), c = e ?? Array(t.length).fill(1);
+      return B.byKnotsControlPointsWeights(
+        n,
+        f,
+        t,
+        c
+      );
+    } catch (f) {
+      return console.error("useNurbsCurve: Error creating curve:", f), null;
+    }
+  }, [t, n, e, r]), i = V(() => o ? Array.from({ length: s + 1 }, (f, c) => {
+    const h = c / s, p = o.point(h);
+    return new I(p[0], p[1], p[2]);
+  }) : [], [o, s]), l = it(
+    (f) => {
+      if (!o) return null;
+      const c = o.point(f);
+      return new I(c[0], c[1], c[2]);
+    },
+    [o]
+  ), u = it(
+    (f) => {
+      if (!o) return null;
+      try {
+        const c = o.tangent(f);
+        return new I(c[0], c[1], c[2]).normalize();
+      } catch {
+        return null;
+      }
+    },
+    [o]
+  ), a = it(() => {
+    if (!o) return 0;
+    try {
+      return o.length();
+    } catch {
+      return 0;
+    }
+  }, [o]), g = it(
+    (f) => {
+      if (!o) return null;
+      try {
+        return o.closestParam([f.x, f.y, f.z]);
+      } catch {
+        return null;
+      }
+    },
+    [o]
+  );
+  return {
+    curve: o,
+    points: i,
+    point: l,
+    tangent: u,
+    length: a,
+    closestParam: g
+  };
+}
+function Mr({
+  controlPoints: t,
+  weights: n,
+  degreeU: e,
+  degreeV: r,
+  knotsU: s,
+  knotsV: o,
+  resolutionU: i = 20,
+  resolutionV: l = 20
+}) {
+  const u = V(() => {
+    if (!t || t.length === 0) return null;
+    try {
+      const h = s ?? H(t.length, e), p = o ?? H(t[0].length, r);
+      return ut.byKnotsControlPointsWeights(
+        e,
+        r,
+        h,
+        p,
+        t,
+        n
+      );
+    } catch (h) {
+      return console.error("useNurbsSurface: Error creating surface:", h), null;
+    }
+  }, [t, n, e, r, s, o]), a = V(() => {
+    if (!u) return null;
+    try {
+      const h = (i + 1) * (l + 1), p = new Float32Array(h * 3), y = new Float32Array(h * 3), d = new Float32Array(h * 2);
+      let m = 0, w = 0, x = 0;
+      for (let M = 0; M <= i; M++)
+        for (let S = 0; S <= l; S++) {
+          const U = M / i, j = S / l, k = u.point(U, j);
+          p[m++] = k[0], p[m++] = k[1], p[m++] = k[2];
+          try {
+            const E = u.normal(U, j), T = Math.sqrt(E[0] ** 2 + E[1] ** 2 + E[2] ** 2);
+            T > 0 ? (y[w++] = E[0] / T, y[w++] = E[1] / T, y[w++] = E[2] / T) : (y[w++] = 0, y[w++] = 1, y[w++] = 0);
+          } catch {
+            y[w++] = 0, y[w++] = 1, y[w++] = 0;
+          }
+          d[x++] = U, d[x++] = j;
+        }
+      const _ = i * l * 6, b = new Uint32Array(_);
+      let P = 0;
+      for (let M = 0; M < i; M++)
+        for (let S = 0; S < l; S++) {
+          const U = M * (l + 1) + S, j = U + 1, k = (M + 1) * (l + 1) + S, E = k + 1;
+          b[P++] = U, b[P++] = j, b[P++] = k, b[P++] = j, b[P++] = E, b[P++] = k;
+        }
+      return { vertices: p, normals: y, uvs: d, indices: b };
+    } catch (h) {
+      return console.error("useNurbsSurface: Error generating geometry:", h), null;
+    }
+  }, [u, i, l]), g = it(
+    (h, p) => {
+      if (!u) return null;
+      const y = u.point(h, p);
+      return new I(y[0], y[1], y[2]);
+    },
+    [u]
+  ), f = it(
+    (h, p) => {
+      if (!u) return null;
+      try {
+        const y = u.normal(h, p);
+        return new I(y[0], y[1], y[2]).normalize();
+      } catch {
+        return null;
+      }
+    },
+    [u]
+  ), c = it(
+    (h) => {
+      if (!u) return null;
+      try {
+        const p = u.closestParam([h.x, h.y, h.z]);
+        return [p[0], p[1]];
+      } catch {
+        return null;
+      }
+    },
+    [u]
+  );
+  return { surface: u, geometry: a, point: g, normal: f, closestParam: c };
+}
+function te(t) {
+  return Array.isArray(t[0]) && Array.isArray(t[0][0]);
+}
+function or(t, n) {
+  switch (t) {
+    case "xy":
+      return new I(0, 0, 1);
+    case "xz":
+      return new I(0, 1, 0);
+    case "yz":
+      return new I(1, 0, 0);
+    case "screen":
+    default:
+      return n.clone().negate();
+  }
+}
+function Ar({
+  controlPoints: t,
+  onControlPointChange: n,
+  dragPlane: e = "screen"
+}) {
+  const { camera: r } = vn(), [s, o] = hn(null), i = et(null), l = et(new dn()), u = et(new gn()), a = et(t), g = et(n), f = et(null), c = et(null);
+  a.current = t, g.current = n;
+  const h = it(
+    (m, w) => {
+      m.stopPropagation(), i.current = w, o(w);
+      const x = m.point.clone(), _ = new I();
+      r.getWorldDirection(_);
+      const b = or(e, _);
+      l.current.setFromNormalAndCoplanarPoint(b, x);
+    },
+    [r, e]
+  ), p = it(
+    (m) => {
+      if (!i.current) return;
+      m.stopPropagation();
+      const x = m.ray ?? u.current.ray;
+      if (m.ray === void 0) {
+        const b = new pn(m.pointer.x, m.pointer.y);
+        u.current.setFromCamera(b, r);
+      }
+      const _ = new I();
+      x.intersectPlane(l.current, _) && (c.current = [_.x, _.y, _.z], f.current === null && (f.current = requestAnimationFrame(() => {
+        f.current = null;
+        const b = c.current, P = i.current;
+        if (!b || !P) return;
+        const M = a.current;
+        if (te(M)) {
+          const S = M.map((U) => U.map((j) => [...j]));
+          S[P[0]][P[1]] = b, g.current(S, P);
+        } else {
+          const S = M.map((U) => [...U]);
+          S[P[0]] = b, g.current(S, P);
+        }
+      })));
+    },
+    [r]
+  ), y = it(() => {
+    f.current !== null && (cancelAnimationFrame(f.current), f.current = null);
+    const m = c.current, w = i.current;
+    if (m && w) {
+      const x = a.current;
+      if (te(x)) {
+        const _ = x.map((b) => b.map((P) => [...P]));
+        _[w[0]][w[1]] = m, g.current(_, w);
+      } else {
+        const _ = x.map((b) => [...b]);
+        _[w[0]] = m, g.current(_, w);
+      }
+    }
+    c.current = null, i.current = null, o(null);
+  }, []);
+  return {
+    handles: V(() => {
+      const m = [];
+      if (te(t))
+        for (let w = 0; w < t.length; w++)
+          for (let x = 0; x < t[w].length; x++) {
+            const _ = t[w][x], b = [w, x];
+            m.push({
+              position: [_[0], _[1], _[2] ?? 0],
+              index: b,
+              bind: {
+                onPointerDown: (P) => h(P, b)
+              }
+            });
+          }
+      else
+        for (let w = 0; w < t.length; w++) {
+          const x = t[w], _ = [w];
+          m.push({
+            position: [x[0], x[1], x[2] ?? 0],
+            index: _,
+            bind: {
+              onPointerDown: (b) => h(b, _)
+            }
+          });
+        }
+      return m;
+    }, [t, h]),
+    isDragging: s !== null,
+    activeIndex: s,
+    dragBind: {
+      onPointerMove: p,
+      onPointerUp: y
+    }
+  };
+}
+function Sr({
+  throughPoints: t,
+  degree: n = 3,
+  resolution: e = 50
+}) {
+  const r = V(() => {
+    if (!t || t.length < 2) return null;
+    try {
+      return B.byPoints(t, n);
+    } catch (l) {
+      return console.error("useInterpolatedCurve: Error creating curve:", l), null;
+    }
+  }, [t, n]), s = V(() => r ? Array.from({ length: e + 1 }, (l, u) => {
+    const a = u / e, g = r.point(a);
+    return new I(g[0], g[1], g[2]);
+  }) : [], [r, e]), o = it(
+    (l) => {
+      if (!r) return null;
+      const u = r.point(l);
+      return new I(u[0], u[1], u[2]);
+    },
+    [r]
+  ), i = it(
+    (l) => {
+      if (!r) return null;
+      try {
+        const u = r.tangent(l);
+        return new I(u[0], u[1], u[2]).normalize();
+      } catch {
+        return null;
+      }
+    },
+    [r]
+  );
+  return { curve: r, points: s, point: o, tangent: i };
+}
+function Er({
+  curve: t,
+  distance: n,
+  planeNormal: e = [0, 0, 1],
+  samples: r = 50,
+  degree: s = 3,
+  resolution: o = 50
+}) {
+  const i = V(() => {
+    if (!t || n === 0) return null;
+    try {
+      const u = new I(...e).normalize(), a = [];
+      for (let g = 0; g <= r; g++) {
+        const f = g / r, c = t.point(f), h = t.tangent(f), p = new I(h[0], h[1], h[2]).normalize(), y = new I().crossVectors(p, u).normalize();
+        a.push([
+          c[0] + y.x * n,
+          c[1] + y.y * n,
+          c[2] + y.z * n
+        ]);
+      }
+      return B.byPoints(
+        a,
+        Math.min(s, a.length - 1)
+      );
+    } catch (u) {
+      return console.error("useOffsetCurve: Error creating offset curve:", u), null;
+    }
+  }, [t, n, e, r, s]), l = V(() => i ? Array.from({ length: o + 1 }, (u, a) => {
+    const g = a / o, f = i.point(g);
+    return new I(f[0], f[1], f[2]);
+  }) : [], [i, o]);
+  return { curve: i, points: l };
+}
+function jr(t, n, e) {
+  if (!t || t.length === 0)
+    return "controlPoints must be a non-empty 3D array";
+  const r = t[0].length;
+  for (let s = 1; s < t.length; s++)
+    if (t[s].length !== r)
+      return `controlPoints row ${s} has length ${t[s].length}, expected ${r}`;
+  if (t.length < n + 1)
+    return `controlPoints has ${t.length} rows but degreeU=${n} requires at least ${n + 1}`;
+  if (r < e + 1)
+    return `controlPoints has ${r} columns but degreeV=${e} requires at least ${e + 1}`;
+  for (let s = 0; s < t.length; s++)
+    for (let o = 0; o < t[s].length; o++)
+      if (!Array.isArray(t[s][o]) || t[s][o].length < 2)
+        return `controlPoints[${s}][${o}] must be an array of at least 2 numbers`;
+  return null;
+}
+function Rr(t, n, e, r = "knots") {
+  const s = n + e + 1;
+  if (t.length !== s)
+    return `${r} has length ${t.length}, expected ${s} (numControlPoints=${n}, degree=${e})`;
+  for (let o = 1; o < t.length; o++)
+    if (t[o] < t[o - 1])
+      return `${r} must be non-decreasing, but ${r}[${o}]=${t[o]} < ${r}[${o - 1}]=${t[o - 1]}`;
+  return null;
+}
+function Tr(t, n) {
+  if (!t || t.length === 0)
+    return "weights must be a non-empty 2D array";
+  if (t.length !== n.length)
+    return `weights has ${t.length} rows, expected ${n.length} to match controlPoints`;
+  for (let e = 0; e < t.length; e++)
+    if (t[e].length !== n[e].length)
+      return `weights[${e}] has length ${t[e].length}, expected ${n[e].length}`;
+  return null;
+}
+function Dr(t, n) {
+  return t.length !== n ? `weights has length ${t.length}, expected ${n}` : null;
+}
+function Ur(t, n, e = "degree") {
+  return t < 1 ? `${e} must be >= 1, got ${t}` : t >= n ? `${e}=${t} must be < numControlPoints=${n}` : null;
+}
+function Fr(t, n) {
+  const e = Lt(t.asData(), n);
+  return new B(e);
+}
+function Ir(t, n, e) {
+  const r = wn(t.asData(), n, e);
+  return new ut(r);
+}
+function Or(t, n) {
+  const e = je(t.asData(), n);
+  return new B(e);
+}
+function Vr(t) {
+  const n = t.map((r) => r.asData());
+  return Re(n).map((r) => new B(r));
+}
 export {
-  Dr as LoftedSurface,
-  jr as NurbsCurve,
-  Fr as NurbsSurface
+  Pr as CoonsPatch,
+  pr as ExtrudedSurface,
+  yr as InterpolatedCurve,
+  wr as InterpolatedSurface,
+  br as IsoCurves,
+  hr as LoftedSurface,
+  _r as NurbsArc,
+  xr as NurbsCircle,
+  Mt as NurbsCurve,
+  De as NurbsSurface,
+  Cr as OffsetCurve,
+  gr as RevolvedSurface,
+  mr as SurfaceIntersection,
+  vr as SweptSurface,
+  dr as TrimmedSurface,
+  Un as adaptiveSampleNurbsCurve2D,
+  rr as computeCoonsPatch,
+  Dn as computeNormal,
+  Or as curveElevateDegree,
+  Fr as curveKnotRefine,
+  H as generateUniformKnots,
+  vt as isMaterialElement,
+  Fn as projectCurveOntoSurface,
+  Tn as projectPointToSurface,
+  fr as projectPointToSurfaceUV,
+  ur as sampleNurbsCurve2D,
+  Ir as surfaceKnotRefine,
+  Vr as unifyCurveKnots,
+  Ar as useControlPointDrag,
+  Sr as useInterpolatedCurve,
+  nr as useInterpolatedSurface,
+  kr as useNurbsCurve,
+  Mr as useNurbsSurface,
+  Er as useOffsetCurve,
+  er as useSurfaceIntersection,
+  jr as validateControlPoints,
+  Ur as validateDegree,
+  Rr as validateKnots,
+  Dr as validateWeights1D,
+  Tr as validateWeights2D
 };