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

react-three-nurbs 0.2.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 Ye, { useMemo as ge, useState as mr, useEffect as hr, isValidElement as Ee, Children as br } from "react";
-import { Vector3 as yr, BufferGeometry as gr, Float32BufferAttribute as $e, MeshPhongMaterial as Er, DoubleSide as Le, 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 _e = { 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 _e = { 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 Me;
-function Tr() {
-  if (Me) return ee;
-  Me = 1;
-  var T = Ye, S = Symbol.for("react.element"), d = Symbol.for("react.fragment"), h = Object.prototype.hasOwnProperty, k = T.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, A = { key: !0, ref: !0, __self: !0, __source: !0 };
-  function E(P, s, _) {
-    var f, u = {}, R = null, F = null;
-    _ !== void 0 && (R = "" + _), s.key !== void 0 && (R = "" + s.key), s.ref !== void 0 && (F = s.ref);
-    for (f in s) h.call(s, f) && !A.hasOwnProperty(f) && (u[f] = s[f]);
-    if (P && P.defaultProps) for (f in s = P.defaultProps, s) u[f] === void 0 && (u[f] = s[f]);
-    return { $$typeof: S, type: P, key: R, ref: F, props: u, _owner: k.current };
-  }
-  return ee.Fragment = d, ee.jsx = E, ee.jsxs = E, 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 Ne;
-function wr() {
-  return Ne || (Ne = 1, process.env.NODE_ENV !== "production" && function() {
-    var T = Ye, S = Symbol.for("react.element"), d = Symbol.for("react.portal"), h = Symbol.for("react.fragment"), k = Symbol.for("react.strict_mode"), A = Symbol.for("react.profiler"), E = Symbol.for("react.provider"), P = Symbol.for("react.context"), s = Symbol.for("react.forward_ref"), _ = Symbol.for("react.suspense"), f = Symbol.for("react.suspense_list"), u = Symbol.for("react.memo"), R = Symbol.for("react.lazy"), F = Symbol.for("react.offscreen"), C = Symbol.iterator, b = "@@iterator";
-    function g(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 = C && e[C] || e[b];
-      return typeof r == "function" ? r : null;
+      var C = p && v[p] || v[y];
+      return typeof C == "function" ? C : null;
     }
-    var p = T.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-    function c(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 = p.ReactDebugCurrentFrame, i = n.getStackAddendum();
-        i !== "" && (r += "%s", t = t.concat([i]));
-        var l = 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($);
         });
-        l.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, l);
+        L.unshift("Warning: " + C), Function.prototype.apply.call(console[v], console, L);
       }
     }
-    var H = !1, U = !1, ce = !1, le = !1, w = !1, v;
-    v = Symbol.for("react.module.reference");
-    function $(e) {
-      return !!(typeof e == "string" || typeof e == "function" || e === h || e === A || w || e === k || e === _ || e === f || le || e === F || H || U || ce || typeof e == "object" && e !== null && (e.$$typeof === R || e.$$typeof === u || e.$$typeof === E || e.$$typeof === P || e.$$typeof === s || // 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 === v || e.getModuleId !== void 0));
+      v.$$typeof === U || v.getModuleId !== void 0));
     }
-    function M(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" && c("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 h:
+      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 d:
+        case e:
           return "Portal";
-        case A:
+        case o:
           return "Profiler";
-        case k:
+        case s:
           return "StrictMode";
-        case _:
+        case a:
           return "Suspense";
-        case f:
+        case g:
           return "SuspenseList";
       }
-      if (typeof e == "object")
-        switch (e.$$typeof) {
-          case P:
-            var r = e;
-            return B(r) + ".Consumer";
-          case E:
-            var t = e;
-            return B(t._context) + ".Provider";
-          case s:
-            return M(e, e.render, "ForwardRef");
+      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:
-            var n = e.displayName || null;
-            return n !== null ? n : j(e.type) || "Memo";
-          case R: {
-            var i = e, l = i._payload, o = i._init;
+            return k(v, v.render, "ForwardRef");
+          case f:
+            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(l));
+              return T($(L));
             } catch {
               return null;
             }
@@ -129,695 +131,3119 @@ function wr() {
         }
       return null;
     }
-    var N = 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 Ke() {
+    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 Be() {
+    function _t() {
       {
-        if (z--, z === 0) {
-          var e = {
+        if (R--, R === 0) {
+          var v = {
             configurable: !0,
             enumerable: !0,
             writable: !0
           };
           Object.defineProperties(console, {
-            log: N({}, e, {
-              value: Z
+            log: D({}, v, {
+              value: W
             }),
-            info: N({}, e, {
-              value: Y
+            info: D({}, v, {
+              value: G
             }),
-            warn: N({}, e, {
-              value: L
+            warn: D({}, v, {
+              value: Q
             }),
-            error: N({}, e, {
-              value: I
+            error: D({}, v, {
+              value: X
             }),
-            group: N({}, e, {
-              value: te
+            group: D({}, v, {
+              value: nt
             }),
-            groupCollapsed: N({}, e, {
-              value: ne
+            groupCollapsed: D({}, v, {
+              value: lt
             }),
-            groupEnd: N({}, e, {
-              value: q
+            groupEnd: D({}, v, {
+              value: At
             })
           });
         }
-        z < 0 && c("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 fe = p.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 qe = typeof WeakMap == "function" ? WeakMap : Map;
-      oe = new qe();
+      var Ve = typeof WeakMap == "function" ? WeakMap : Map;
+      Ot = new Ve();
     }
-    function Re(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 l;
-      l = fe.current, fe.current = null, Ke();
+      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 (x) {
-              n = x;
+              Reflect.construct($, []);
+            } catch (rt) {
+              F = rt;
             }
-            Reflect.construct(e, [], o);
+            Reflect.construct(v, [], $);
           } else {
             try {
-              o.call();
-            } catch (x) {
-              n = x;
+              $.call();
+            } catch (rt) {
+              F = rt;
             }
-            e.call(o.prototype);
+            v.call($.prototype);
           }
         } else {
           try {
             throw Error();
-          } catch (x) {
-            n = x;
+          } catch (rt) {
+            F = rt;
           }
-          e();
-        }
-      } catch (x) {
-        if (x && n && typeof x.stack == "string") {
-          for (var a = x.stack.split(`
-`), O = n.stack.split(`
-`), m = a.length - 1, y = O.length - 1; m >= 1 && y >= 0 && a[m] !== O[y]; )
-            y--;
-          for (; m >= 1 && y >= 0; m--, y--)
-            if (a[m] !== O[y]) {
-              if (m !== 1 || y !== 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 (m--, y--, y < 0 || a[m] !== O[y]) {
-                    var D = `
-` + a[m].replace(" at new ", " at ");
-                    return e.displayName && D.includes("<anonymous>") && (D = D.replace("<anonymous>", e.displayName)), typeof e == "function" && oe.set(e, D), D;
+                  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 (m >= 1 && y >= 0);
+                while (Z >= 1 && Y >= 0);
               break;
             }
         }
       } finally {
-        de = !1, fe.current = l, Be(), 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 Ue(e, r, t) {
-      return Re(e, !1);
+    function $e(v, C, A) {
+      return le(v, !1);
     }
-    function ze(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 Re(e, ze(e));
-      if (typeof e == "string")
-        return ae(e);
-      switch (e) {
-        case _:
-          return ae("Suspense");
-        case f:
-          return ae("SuspenseList");
-      }
-      if (typeof e == "object")
-        switch (e.$$typeof) {
-          case s:
-            return Ue(e.render);
+      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 ie(e.type, r, t);
-          case R: {
-            var n = e, i = n._payload, l = n._init;
+            return $e(v.render);
+          case f:
+            return Vt(v.type, C, A);
+          case c: {
+            var F = v, K = F._payload, L = F._init;
             try {
-              return ie(l(i), r, t);
+              return Vt(L(K), C, A);
             } catch {
             }
           }
         }
       return "";
     }
-    var Q = Object.prototype.hasOwnProperty, Se = {}, Ce = p.ReactDebugCurrentFrame;
-    function se(e) {
-      if (e) {
-        var r = e._owner, t = ie(e.type, e._source, r ? r.type : null);
-        Ce.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
-        Ce.setExtraStackFrame(null);
+        ue.setExtraStackFrame(null);
     }
-    function Ge(e, r, t, n, i) {
+    function Ke(v, C, A, F, K) {
       {
-        var l = Function.call.bind(Q);
-        for (var o in e)
-          if (l(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 (m) {
-              a = m;
+              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), c("%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 Se) && (Se[a.message] = !0, se(i), c("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 Je = Array.isArray;
-    function pe(e) {
-      return Je(e);
+    var We = Array.isArray;
+    function Jt(v) {
+      return We(v);
     }
-    function Ve(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 Xe(e) {
+    function qe(v) {
       try {
-        return Te(e), !1;
+        return fe(v), !1;
       } catch {
         return !0;
       }
     }
-    function Te(e) {
-      return "" + e;
+    function fe(v) {
+      return "" + v;
     }
-    function we(e) {
-      if (Xe(e))
-        return c("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Ve(e)), Te(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 je = p.ReactCurrentOwner, He = {
+    var de = m.ReactCurrentOwner, ze = {
       key: !0,
       ref: !0,
       __self: !0,
       __source: !0
-    }, Oe, Pe;
-    function Ze(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 Qe(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 er(e, r) {
-      typeof e.ref == "string" && je.current;
+    function Ye(v, C) {
+      typeof v.ref == "string" && de.current;
     }
-    function rr(e, r) {
+    function Je(v, C) {
       {
-        var t = function() {
-          Oe || (Oe = !0, c("%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 tr(e, r) {
+    function Ge(v, C) {
       {
-        var t = function() {
-          Pe || (Pe = !0, c("%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 nr = function(e, r, t, n, i, l, 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: S,
+        $$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: l
+        _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 ar(e, r, t, n, i) {
+    function Xe(v, C, A, F, K) {
       {
-        var l, o = {}, a = null, O = null;
-        t !== void 0 && (we(t), a = "" + t), Qe(r) && (we(r.key), a = "" + r.key), Ze(r) && (O = r.ref, er(r, i));
-        for (l in r)
-          Q.call(r, l) && !He.hasOwnProperty(l) && (o[l] = r[l]);
-        if (e && e.defaultProps) {
-          var m = e.defaultProps;
-          for (l in m)
-            o[l] === void 0 && (o[l] = m[l]);
-        }
-        if (a || O) {
-          var y = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
-          a && rr(o, y), O && tr(o, y);
-        }
-        return nr(e, a, O, i, n, je.current, o);
-      }
-    }
-    var me = p.ReactCurrentOwner, xe = p.ReactDebugCurrentFrame;
-    function V(e) {
-      if (e) {
-        var r = e._owner, t = ie(e.type, e._source, r ? r.type : null);
-        xe.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
-        xe.setExtraStackFrame(null);
+        ve.setExtraStackFrame(null);
     }
-    var he;
-    he = !1;
-    function be(e) {
-      return typeof e == "object" && e !== null && e.$$typeof === S;
+    var Ht;
+    Ht = !1;
+    function Xt(v) {
+      return typeof v == "object" && v !== null && v.$$typeof === n;
     }
-    function ke() {
+    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 or(e) {
+    function Qe(v) {
       return "";
     }
-    var Ae = {};
-    function ir(e) {
+    var ye = {};
+    function tn(v) {
       {
-        var r = ke();
-        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 Fe(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 = ir(r);
-        if (Ae[t])
+        v._store.validated = !0;
+        var A = tn(C);
+        if (ye[A])
           return;
-        Ae[t] = !0;
-        var n = "";
-        e && e._owner && e._owner !== me.current && (n = " It was passed a child from " + j(e._owner.type) + "."), V(e), c('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 De(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];
-            be(n) && Fe(n, r);
+        if (Jt(v))
+          for (var A = 0; A < v.length; A++) {
+            var F = v[A];
+            Xt(F) && we(F, C);
           }
-        else if (be(e))
-          e._store && (e._store.validated = !0);
-        else if (e) {
-          var i = g(e);
-          if (typeof i == "function" && i !== e.entries)
-            for (var l = i.call(e), o; !(o = l.next()).done; )
-              be(o.value) && Fe(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 sr(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 === s || // 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 === u))
-          t = r.propTypes;
+        C.$$typeof === f))
+          A = C.propTypes;
         else
           return;
-        if (t) {
-          var n = j(r);
-          Ge(t, e.props, "prop", n, e);
-        } else if (r.PropTypes !== void 0 && !he) {
-          he = !0;
-          var i = j(r);
-          c("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 && c("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 ur(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), c("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), c("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 Ie = {};
-    function We(e, r, t, n, i, l) {
+    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 = or();
-          O ? a += O : a += ke();
-          var m;
-          e === null ? m = "null" : pe(e) ? m = "array" : e !== void 0 && e.$$typeof === S ? (m = "<" + (j(e.type) || "Unknown") + " />", a = " Did you accidentally export a JSX literal instead of a component?") : m = typeof e, c("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", m, a);
-        }
-        var y = ar(e, r, t, i, l);
-        if (y == null)
-          return y;
-        if (o) {
-          var D = r.children;
-          if (D !== void 0)
-            if (n)
-              if (pe(D)) {
-                for (var X = 0; X < D.length; X++)
-                  De(D[X], e);
-                Object.freeze && Object.freeze(D);
+        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
-                c("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
-              De(D, e);
-        }
-        if (Q.call(r, "key")) {
-          var G = j(e), x = Object.keys(r).filter(function(pr) {
-            return pr !== "key";
-          }), ye = x.length > 0 ? "{key: someKey, " + x.join(": ..., ") + ": ...}" : "{key: someKey}";
-          if (!Ie[G + ye]) {
-            var dr = x.length > 0 ? "{" + x.join(": ..., ") + ": ...}" : "{}";
-            c(`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, dr, G), Ie[G + ye] = !0;
+  <%s key={someKey} {...props} />`, Qt, mt, ln, mt), _e[mt + Qt] = !0;
           }
         }
-        return e === h ? ur(y) : sr(y), y;
+        return v === r ? nn(Y) : en(Y), Y;
+      }
+    }
+    function rn(v, C, A) {
+      return be(v, C, A, !0);
+    }
+    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;
+    }
+    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;
+}
+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);
     }
-    function cr(e, r, t) {
-      return We(e, r, t, !0);
+    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));
+      }
     }
-    function lr(e, r, t) {
-      return We(e, r, t, !1);
+    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);
     }
-    var fr = lr, vr = cr;
-    re.Fragment = h, re.jsx = fr, re.jsxs = vr;
-  }()), re;
+    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);
 }
-process.env.NODE_ENV === "production" ? _e.exports = Tr() : _e.exports = wr();
-var K = _e.exports;
-const jr = ({
-  points: T,
-  degree: S = 3,
-  weights: d,
-  knots: h,
-  resolution: k = 50,
-  color: A = "black",
-  segments: E,
-  dashed: P = !1,
-  vertexColors: s,
-  ..._
+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 f = ge(() => {
-    if (!h)
-      return console.error("NurbsCurve requires knots to be provided"), [];
+  const g = V(() => {
     try {
-      const u = Array(T.length).fill(1), R = ue.geom.NurbsCurve.byKnotsControlPointsWeights(
-        S,
-        h,
-        T,
-        d ?? u
-      ), F = k;
-      return Array.from({ length: F + 1 }, (C, b) => {
-        const g = b / F, p = R.point(g);
-        return new yr(p[0], p[1], p[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 (u) {
-      return console.error("Error creating NURBS curve:", u), [];
+    } catch (f) {
+      return console.error("Error creating NURBS curve:", f), [];
     }
-  }, [T, S, d, h, k]);
-  return f.length === 0 ? null : /* @__PURE__ */ K.jsx(
-    Sr,
+  }, [t, n, e, r, s]);
+  return g.length === 0 ? null : /* @__PURE__ */ q.jsx(
+    xt,
     {
-      points: f,
-      color: A,
-      segments: E,
-      dashed: P,
-      vertexColors: s,
-      ..._
+      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: S,
-  degreeU: d,
-  degreeV: h,
-  color: k = "#ffffff",
-  wireframe: A = !1,
-  children: E,
-  ...P
+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: s } = Cr(), [_, f] = mr(null);
-  return hr(() => {
-    const u = T.length + d + 1, R = T[0].length + h + 1, F = Array(u).fill(0).map((w, v) => v < d + 1 ? 0 : v >= u - d - 1 ? 1 : (v - d) / (u - 2 * d - 1)), C = Array(R).fill(0).map((w, v) => v < h + 1 ? 0 : v >= R - h - 1 ? 1 : (v - h) / (R - 2 * h - 1)), b = ue.geom.NurbsSurface.byKnotsControlPointsWeights(
-      d,
-      h,
-      F,
-      C,
-      T,
-      S
-    ), g = new gr(), p = [], c = [], W = [], H = 20, U = 20, ce = 1 / H, le = 1 / U;
-    for (let w = 0; w <= H; w++)
-      for (let v = 0; v <= U; v++) {
-        const $ = w * ce, M = v * le, B = b.point($, M), j = 1e-4, N = b.point($ + j, M), z = b.point($, M + j), Z = b.point($, M), Y = N.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);
-        p.push(...B), c.push(...ne);
-      }
-    for (let w = 0; w < H; w++)
-      for (let v = 0; v < U; v++) {
-        const $ = w * (U + 1) + v, M = $ + 1, B = (w + 1) * (U + 1) + v, j = B + 1;
-        W.push($, M, B), W.push(M, j, B);
-      }
-    if (g.setAttribute("position", new $e(p, 3)), g.setAttribute("normal", new $e(c, 3)), g.setIndex(W), f(g), !E) {
-      const w = new Er({
-        color: new _r(k),
-        side: Le,
-        wireframe: A
-      }), v = new Rr(g, w);
-      return s.add(v), () => {
-        s.remove(v), g.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 () => {
-      g.dispose();
-    };
   }, [
-    T,
-    S,
-    d,
-    h,
-    k,
-    A,
-    s,
-    E
-  ]), _ && E ? !Ee(E) || !E.type.toString().includes("Material") ? (console.warn("NurbsSurface children must be a material component"), null) : /* @__PURE__ */ K.jsxs("mesh", { ...P, children: [
-    /* @__PURE__ */ K.jsx("primitive", { object: _, attach: "geometry" }),
-    E
-  ] }) : null;
-}
-const Dr = ({
-  degreeV: T = 3,
-  resolutionU: S = 20,
-  resolutionV: d = 20,
-  color: h = "#ff0000",
-  wireframe: k = !1,
-  children: A
+    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 { curveChildren: E, materialChild: P } = ge(() => {
-    const _ = [];
-    let f = null;
-    return br.forEach(A, (u) => {
-      Ee(u) && u.type === jr ? _.push(u) : Ee(u) && u.type && u.type.prototype && "isMaterial" in u.type.prototype && (f = u);
-    }), { curveChildren: _, materialChild: f };
-  }, [A]), s = ge(() => {
-    if (E.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 { 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 _ = E.map((C) => {
-        const { points: b, degree: g = 3, weights: p, knots: c } = C.props, W = Array(b.length).fill(1);
-        return ue.geom.NurbsCurve.byKnotsControlPointsWeights(
-          g,
-          c,
+      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,
-          p ?? W
+          S,
+          _,
+          P ?? Array(_.length).fill(1)
         );
-      }), f = ue.geom.NurbsSurface.byLoftingCurves(
-        _,
-        T
-      ), u = [], R = [], F = [];
-      for (let C = 0; C <= S; C++)
-        for (let b = 0; b <= d; b++) {
-          const g = C / S, p = b / d, c = f.point(g, p);
-          u.push(c[0], c[1], c[2]), F.push(g, p);
-        }
-      for (let C = 0; C < S; C++)
-        for (let b = 0; b < d; b++) {
-          const g = C * (d + 1) + b, p = g + 1, c = (C + 1) * (d + 1) + b, W = c + 1;
-          R.push(g, p, c), R.push(p, W, c);
-        }
-      return {
-        vertices: u,
-        indices: R,
-        uvs: F
-      };
-    } catch (_) {
-      return console.error("Error creating lofted surface:", _), null;
-    }
-  }, [E, T, S, d]);
-  return s ? /* @__PURE__ */ K.jsxs("mesh", { children: [
-    /* @__PURE__ */ K.jsxs("bufferGeometry", { children: [
-      /* @__PURE__ */ K.jsx(
-        "bufferAttribute",
-        {
-          attach: "attributes-position",
-          count: s.vertices.length / 3,
-          array: new Float32Array(s.vertices),
-          itemSize: 3
-        }
-      ),
-      /* @__PURE__ */ K.jsx(
-        "bufferAttribute",
-        {
-          attach: "attributes-uv",
-          count: s.uvs.length / 2,
-          array: new Float32Array(s.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: s.indices.length,
-          array: new Uint32Array(s.indices),
-          itemSize: 1
-        }
-      )
-    ] }),
-    P || /* @__PURE__ */ K.jsx("meshStandardMaterial", { color: h, wireframe: k, side: Le })
-  ] }) : 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
 };