@ue-too/curve 0.9.5 → 0.11.0

package/index.js

@@ -1,1591 +1,3 @@
-// src/b-curve.ts
-import { PointCal } from "@ue-too/math";
-var T = [
-  -0.06405689286260563,
-  0.06405689286260563,
-  -0.1911188674736163,
-  0.1911188674736163,
-  -0.3150426796961634,
-  0.3150426796961634,
-  -0.4337935076260451,
-  0.4337935076260451,
-  -0.5454214713888396,
-  0.5454214713888396,
-  -0.6480936519369755,
-  0.6480936519369755,
-  -0.7401241915785544,
-  0.7401241915785544,
-  -0.820001985973903,
-  0.820001985973903,
-  -0.8864155270044011,
-  0.8864155270044011,
-  -0.9382745520027328,
-  0.9382745520027328,
-  -0.9747285559713095,
-  0.9747285559713095,
-  -0.9951872199970213,
-  0.9951872199970213
-];
-var C = [
-  0.12793819534675216,
-  0.12793819534675216,
-  0.1258374563468283,
-  0.1258374563468283,
-  0.12167047292780339,
-  0.12167047292780339,
-  0.1155056680537256,
-  0.1155056680537256,
-  0.10744427011596563,
-  0.10744427011596563,
-  0.09761865210411388,
-  0.09761865210411388,
-  0.08619016153195327,
-  0.08619016153195327,
-  0.0733464814110803,
-  0.0733464814110803,
-  0.05929858491543678,
-  0.05929858491543678,
-  0.04427743881741981,
-  0.04427743881741981,
-  0.028531388628933663,
-  0.028531388628933663,
-  0.0123412297999872,
-  0.0123412297999872
-];
+import{PointCal as $}from"@ue-too/math";var v=[-0.06405689286260563,0.06405689286260563,-0.1911188674736163,0.1911188674736163,-0.3150426796961634,0.3150426796961634,-0.4337935076260451,0.4337935076260451,-0.5454214713888396,0.5454214713888396,-0.6480936519369755,0.6480936519369755,-0.7401241915785544,0.7401241915785544,-0.820001985973903,0.820001985973903,-0.8864155270044011,0.8864155270044011,-0.9382745520027328,0.9382745520027328,-0.9747285559713095,0.9747285559713095,-0.9951872199970213,0.9951872199970213],a=[0.12793819534675216,0.12793819534675216,0.1258374563468283,0.1258374563468283,0.12167047292780339,0.12167047292780339,0.1155056680537256,0.1155056680537256,0.10744427011596563,0.10744427011596563,0.09761865210411388,0.09761865210411388,0.08619016153195327,0.08619016153195327,0.0733464814110803,0.0733464814110803,0.05929858491543678,0.05929858491543678,0.04427743881741981,0.04427743881741981,0.028531388628933663,0.028531388628933663,0.0123412297999872,0.0123412297999872];class j{controlPoints;dControlPoints=[];arcLengthLUT={controlPoints:[],arcLengthLUT:[]};_fullLength;lengthCache=new Map;getCacheStats(){return{size:this.lengthCache.size,hitRate:0}}preWarmCache(z=100){let G=1/z;for(let N=0;N<=1;N+=G)this.lengthAtT(N)}clearCache(){this.lengthCache.clear()}constructor(z){this.controlPoints=z,this.dControlPoints=this.getDerivativeControlPoints(this.controlPoints),this._fullLength=this.calculateFullLength(),this.arcLengthLUT={controlPoints:[],arcLengthLUT:[]},this.clearCache()}getPointbyPercentage(z){let G=this.arcLengthLUT.controlPoints.length!=this.controlPoints.length;G=G||this.arcLengthLUT.controlPoints.reduce((O,W,_)=>{return O||!$.isEqual(W,this.controlPoints[_])},!1);let N=[];if(G)this.arcLengthLUT=this.getArcLengthLUT(1000);N=[...this.arcLengthLUT.arcLengthLUT.map((O)=>O.length)];let Q=z*this.fullLength,k=0,J=N.length-1;while(k<=J){let O=Math.floor((k+J)/2);if(N[O]==Q)return this.get((O+1)/N.length);else if(N[O]<Q)k=O+1;else J=O-1}return k>=N.length?this.get(1):this.get((k+1)/N.length)}getDerivativeControlPoints(z){let G=[];for(let N=1;N<z.length;N++)G.push($.multiplyVectorByScalar($.subVector(z[N],z[N-1]),z.length-1));return G}validateTVal(z){if(z>1||z<0)throw new c("tVal is greater than 1 or less than 0")}getControlPoints(){return this.controlPoints}setControlPoints(z){this.controlPoints=z,this.dControlPoints=this.getDerivativeControlPoints(this.controlPoints),this._fullLength=this.calculateFullLength(),this.arcLengthLUT={controlPoints:[],arcLengthLUT:[]},this.clearCache()}setControlPointAtIndex(z,G){if(z<0||z>=this.controlPoints.length)return!1;return this.controlPoints[z]=G,this.dControlPoints=this.getDerivativeControlPoints(this.controlPoints),this._fullLength=this.calculateFullLength(),this.arcLengthLUT={controlPoints:[],arcLengthLUT:[]},this.clearCache(),!0}compute(z){this.validateTVal(z);let G=this.controlPoints;while(G.length>1){let N=G.slice(1);for(let Q=0;Q<N.length;Q++)N[Q]=$.addVector($.multiplyVectorByScalar(G[Q],1-z),$.multiplyVectorByScalar(G[Q+1],z));G=N}return G[0]}get(z){if(this.validateTVal(z),this.controlPoints.length==3){let G=$.multiplyVectorByScalar(this.controlPoints[0],(1-z)*(1-z)),N=$.multiplyVectorByScalar(this.controlPoints[1],2*(1-z)*z),Q=$.multiplyVectorByScalar(this.controlPoints[2],z*z);return $.addVector($.addVector(G,N),Q)}if(this.controlPoints.length==4){let G=$.multiplyVectorByScalar(this.controlPoints[0],(1-z)*(1-z)*(1-z)),N=$.multiplyVectorByScalar(this.controlPoints[1],3*(1-z)*(1-z)*z),Q=$.multiplyVectorByScalar(this.controlPoints[2],3*(1-z)*z*z),k=$.multiplyVectorByScalar(this.controlPoints[3],z*z*z);return $.addVector($.addVector(G,N),$.addVector(Q,k))}return this.compute(z)}getLUT(z=100){let G=1/z,N=[],Q=0;N.push(this.get(Q));for(let k=0;k<z;k+=1){if(Q+=G,Q>1&&Q-G<1||k==z-1)Q=1;N.push(this.get(Q))}return N}getLUTWithTVal(z){if(z==null)z=100;let G=1/z,N=[],Q=0;N.push({point:this.get(Q),tVal:Q});for(let k=0;k<z;k+=1){if(Q+=G,Q>1&&Q-G<1||k==z-1)Q=1;N.push({point:this.get(Q),tVal:Q})}return N}get fullLength(){return this._fullLength}calculateFullLength(){return this.lengthAtT(1)}lengthAtT(z){this.validateTVal(z);let G=Math.round(z*1e6)/1e6;if(this.lengthCache.has(G))return this.lengthCache.get(G);let N=z/2,Q=v.length,k=0;for(let O=0,W;O<Q;O++)W=N*v[O]+N,k+=a[O]*$.magnitude(this.derivative(W));let J=N*k;return this.lengthCache.set(G,J),J}derivative(z){return b(z,this.dControlPoints)}derivativeNormalized(z){return $.unitVector(b(z,this.dControlPoints))}getArcLengthLUT(z=50){if(this.arcLengthLUT.controlPoints.length!==this.controlPoints.length||this.arcLengthLUT.controlPoints.some((N,Q)=>!$.isEqual(N,this.controlPoints[Q]))||this.arcLengthLUT.arcLengthLUT.length===0){this.clearCache();let N=[],Q=1/z;for(let k=0;k<=1;k+=Q)N.push({tVal:k,length:this.lengthAtT(k)});this.arcLengthLUT={controlPoints:[...this.controlPoints],arcLengthLUT:N}}return this.arcLengthLUT}splitIntoCurves(z){let G=this.split(z);return[new j(G[0]),new j(G[1])]}split(z){if(this.validateTVal(z),this.controlPoints.length==3){let F=this.controlPoints[0],H=$.subVector($.multiplyVectorByScalar(this.controlPoints[1],z),$.multiplyVectorByScalar(this.controlPoints[0],z-1)),E=$.subVector($.multiplyVectorByScalar(this.controlPoints[2],z*z),$.multiplyVectorByScalar(this.controlPoints[1],2*z*(z-1)));E=$.addVector(E,$.multiplyVectorByScalar(this.controlPoints[0],(z-1)*(z-1)));let B=$.subVector($.multiplyVectorByScalar(this.controlPoints[2],z),$.multiplyVectorByScalar(this.controlPoints[1],z-1)),q=this.controlPoints[2];return[[F,H,E],[E,B,q]]}let G=this.controlPoints[0],N=$.subVector($.multiplyVectorByScalar(this.controlPoints[1],z),$.multiplyVectorByScalar(this.controlPoints[0],z-1)),Q=$.addVector($.multiplyVectorByScalar(this.controlPoints[2],z*z),$.addVector($.multiplyVectorByScalar(this.controlPoints[1],-(2*z*(z-1))),$.multiplyVectorByScalar(this.controlPoints[0],(z-1)*(z-1)))),k=$.multiplyVectorByScalar(this.controlPoints[3],z*z*z),J=$.multiplyVectorByScalar(this.controlPoints[2],-(3*z*z*(z-1))),O=$.multiplyVectorByScalar(this.controlPoints[1],3*z*(z-1)*(z-1)),W=$.multiplyVectorByScalar(this.controlPoints[0],-((z-1)*(z-1)*(z-1))),_=$.addVector(W,$.addVector(O,$.addVector(k,J))),Z=$.addVector($.addVector($.multiplyVectorByScalar(this.controlPoints[3],z*z),$.multiplyVectorByScalar(this.controlPoints[2],-(2*z*(z-1)))),$.multiplyVectorByScalar(this.controlPoints[1],(z-1)*(z-1))),K=$.addVector($.multiplyVectorByScalar(this.controlPoints[3],z),$.multiplyVectorByScalar(this.controlPoints[2],-(z-1))),X=this.controlPoints[3];return[[G,N,Q,_],[_,Z,K,X]]}splitIn3WithControlPoints(z,G){if(G<z)console.warn("tVal2 is less than tVal, swapping them"),[z,G]=[G,z];let N=this.split(z),Q=new j(N[1]),k=x(G,z,1,0,1),J=Q.split(k);return[N[0],J[0],J[1]]}splitIn3Curves(z,G){if(G<z)console.warn("tVal2 is less than tVal, swapping them"),[z,G]=[G,z];let N=this.split(z),Q=new j(N[1]),k=x(G,z,1,0,1),J=Q.split(k);return[new j(N[0]),new j(J[0]),new j(J[1])]}splitAndTakeMidCurve(z,G){let[N,Q,k]=this.splitIn3Curves(z,G);return Q}getProjection(z){let N=Number.MAX_VALUE,Q=0,k=this.get(0),J=0,O=this.getLUTWithTVal(500);O.forEach((Z,K)=>{let X=$.distanceBetweenPoints(Z.point,z);if(X<N)N=X,k={...Z.point},Q=Z.tVal,J=K});let W=O[J].tVal,_=O[J].tVal;if(J<O.length-1)_=O[J+1].tVal;if(J>0)W=O[J-1].tVal;while(W<_&&_-W>0.00001){let Z=W+(_-W)/2,K=Z-W,X=Z+K/2,F=Z+K/2,H=N;if(X<=1&&X>=0){let E=$.distanceBetweenPoints(this.get(X),z);if(E<N)N=E,k=this.get(X),Q=X,_=X+K/2,W=X-K/2}if(F<=1&&F>=0){let E=$.distanceBetweenPoints(this.get(F),z);if(E<N)N=E,k=this.get(F),Q=F,_=F+K/2,W=F-K/2}if(H==N)break}return{projection:k,tVal:Q}}findArcs(z){let G=0,N=[];while(G<1){let Q=this.findArcStartingAt(z,G);if(Q==null||Q.arc==null)break;if(N.push(Q.arc),G=Q.arc.endT,G>=1)break}return N}findArcStartingAt(z,G){let N=1,Q=G+(N-G)/2,k={good:!1},J=0;while(!0){if(J++,Q=G+(N-G)/2,N>1||Q>1)if(k.good)return k;else return null;let O=this.get(G),W=this.get(N),_=this.get(Q),Z=this.fitArc(O,W,_);if(!Z.exists||Z.center==null||Z.radius==null)return null;let K=N-Q,X=Q-K/2,F=Q+K/2,H=this.get(X),E=this.get(F),B=$.distanceBetweenPoints(H,Z.center),q=$.distanceBetweenPoints(E,Z.center);if(Math.abs(B-Z.radius)>z||Math.abs(q-Z.radius)>z){if(k.good==!0)return k;k.good=!1,N=Q}else{if(k.good=!0,Z.startPoint!==void 0&&Z.endPoint!==void 0)k.arc={center:Z.center,radius:Z.radius,startPoint:Z.startPoint,endPoint:Z.endPoint,startT:G,endT:N};N=N+(Q-G)}}}fitArc(z,G,N){let Q=[[z.x,z.y,1],[N.x,N.y,1],[G.x,G.y,1]];if(this.determinant3by3(Q)==0)return{exists:!1};let k=[[z.x*z.x+z.y*z.y,z.y,1],[N.x*N.x+N.y*N.y,N.y,1],[G.x*G.x+G.y*G.y,G.y,1]],J=[[z.x*z.x+z.y*z.y,z.x,1],[N.x*N.x+N.y*N.y,N.x,1],[G.x*G.x+G.y*G.y,G.x,1]],O=[[z.x*z.x+z.y*z.y,z.x,z.y],[N.x*N.x+N.y*N.y,N.x,N.y],[G.x*G.x+G.y*G.y,G.x,G.y]],W=0.5*(this.determinant3by3(k)/this.determinant3by3(Q)),_=-0.5*(this.determinant3by3(J)/this.determinant3by3(Q)),Z=Math.sqrt(W*W+_*_+this.determinant3by3(O)/this.determinant3by3(Q));return{exists:!0,center:{x:W,y:_},radius:Z,startPoint:z,endPoint:G}}determinant3by3(z){let G=z[0][0],N=z[0][1],Q=z[0][2],k=z[1][0],J=z[1][1],O=z[1][2],W=z[2][0],_=z[2][1],Z=z[2][2];return G*(J*Z-O*_)-N*(k*Z-W*O)+Q*(k*_-J*W)}curvature(z){let G=b(z,this.dControlPoints),N=b(z,this.getDerivativeControlPoints(this.dControlPoints)),Q=G.x*N.y-N.x*G.y,k=Math.pow(G.x*G.x+G.y*G.y,1.5);if(k==0)return NaN;return Q/k}secondDerivative(z){return b(z,this.getDerivativeControlPoints(this.dControlPoints))}getCoefficientOfTTerms(){return this.getCoefficientOfTTermsWithControlPoints(this.controlPoints)}getDerivativeCoefficients(){return this.getCoefficientOfTTermsWithControlPoints(this.dControlPoints)}getCoefficientOfTTermsWithControlPoints(z){let G=[],N=[];if(z.length==3)N=[[1,0,0],[-2,2,0],[1,-2,1]];else if(z.length==4)N=[[1,0,0,0],[-3,3,0,0],[3,-6,3,0],[-1,3,-3,1]];else if(z.length==2)N=[[1,0],[-1,1]];else throw Error("number of control points is wrong");for(let Q=0;Q<z.length;Q++)G.push(z.reduce((k,J,O)=>{return{x:k.x+N[Q][O]*J.x,y:k.y+N[Q][O]*J.y}},{x:0,y:0}));return G}getControlPointsAlignedWithXAxis(){let z=$.unitVectorFromA2B(this.controlPoints[0],this.controlPoints[this.controlPoints.length-1]),G=$.angleFromA2B({x:1,y:0},z),N=this.controlPoints[0],Q=[{x:0,y:0}];for(let k=1;k<this.controlPoints.length;k++){let J=$.subVector(this.controlPoints[k],N),O=$.rotatePoint(J,-G);Q.push(O)}return Q}getExtrema(){let z={x:[],y:[]},G=this.getDerivativeCoefficients(),N=[0,0,0,0],Q=[0,0,0,0];G.forEach((O,W)=>{N[3-W]=O.x,Q[3-W]=O.y});let k=w(N[0],N[1],N[2],N[3]),J=w(Q[0],Q[1],Q[2],Q[3]);if(k.forEach((O)=>{if(O>=0&&O<=1)z.x.push(O)}),J.forEach((O)=>{if(O>=0&&O<=1)z.y.push(O)}),G.length>=3){N=[0,0,0,0],Q=[0,0,0,0],this.getCoefficientOfTTermsWithControlPoints(this.getDerivativeControlPoints(this.dControlPoints)).forEach((Z,K)=>{N[3-K]=Z.x,Q[3-K]=Z.y});let W=w(N[0],N[1],N[2],N[3]),_=w(Q[0],Q[1],Q[2],Q[3]);W.forEach((Z)=>{if(Z>=0&&Z<=1)z.x.push(Z)}),_.forEach((Z)=>{if(Z>=0&&Z<=1)z.y.push(Z)})}return z}translateRotateControlPoints(z,G){let N=[];for(let Q=0;Q<this.controlPoints.length;Q++)N.push($.rotatePoint($.addVector(this.controlPoints[Q],z),G));return N}getLineIntersections(z){let G=z.getTranslationRotationToAlginXAxis(),N=[],Q=this.translateRotateControlPoints(G.translation,G.rotationAngle),k=this.getCoefficientOfTTermsWithControlPoints(Q),J=[0,0,0,0];return k.forEach((W,_)=>{J[3-_]=W.y}),w(J[0],J[1],J[2],J[3]).forEach((W)=>{if(W>=0&&W<=1){if(z.pointInLine(this.get(W)))N.push(W)}}),N}getSelfIntersections(){let[z,G]=this.split(0.5),N=new j(z),Q=new j(G),k=V(N,Q);return k.forEach((J)=>{J.selfT=J.selfT*0.5,J.otherT=J.otherT*0.5+0.5}),k.shift(),k}getCircleIntersections(z,G){let N=this.getLUTWithTVal(500),Q=Number.MAX_VALUE,k=0,J=N[0].point,O=N[0].tVal;N.forEach((F,H)=>{let E=Math.abs($.distanceBetweenPoints(z,F.point));if(E<Q)Q=E,k=H});let W=N.map((F,H)=>{return{...F,distance:0}});Q=Number.MAX_VALUE;let _=0,Z=0,K=[];while(++Z<25){let F=this.findClosest(z.x,z.y,W,G,5,W[_-2]?.distance,W[_-1]?.distance);if(F<_)break;if(F>0&&F==_)break;K.push(F),_=F+2}let X=[];return K.forEach((F)=>{let H=this.refineBinary(this,z.x,z.y,W,F,G);if(H!=null)X.push({intersection:H.point,tVal:H.tVal})}),X}advanceAtTWithLength(z,G){let Q=this.lengthAtT(z)+G;if(z===0&&G<0)return{type:"beforeCurve",remainLength:-G};if(z===1&&G>0)return{type:"afterCurve",remainLength:G};if(Q>this.fullLength)return{type:"afterCurve",remainLength:Q-this.fullLength};else if(Q<0)return{type:"beforeCurve",remainLength:-Q};if(this.arcLengthLUT.arcLengthLUT.length===0)this.arcLengthLUT=this.getArcLengthLUT(1000);let k=this.arcLengthLUT.arcLengthLUT,J=0,O=k.length-1;while(J<=O){let B=Math.floor((J+O)/2),q=k[B].length;if(D(q,Q,0.01)){let M=k[B].tVal,I=this.get(M);return{type:"withinCurve",tVal:M,point:I}}else if(q<Q)J=B+1;else O=B-1}if(O<0)O=1,J=0;if(J>=k.length)O=k.length-1,J=k.length-2;let W=k[O],_=k[J],Z=_.length-W.length,K=_.tVal-W.tVal;if(Z===0){let B=this.get(W.tVal);return{type:"withinCurve",tVal:W.tVal,point:B}}let X=(Q-W.length)/Z,F=W.tVal+X*K,H=Math.max(0,Math.min(1,F)),E=this.get(H);return{type:"withinCurve",tVal:H,point:E}}advanceByDistance(z,G){let N=z,Q=G,k=0.01;if(G>this.fullLength)return{type:"afterCurve",remainLength:G-this.fullLength};else if(G<0)return{type:"beforeCurve",remainLength:-G};while(Q>0&&N<1){let J=this.get(N),O=Math.min(N+k,1),W=this.get(O),_=Math.sqrt(Math.pow(W.x-J.x,2)+Math.pow(W.y-J.y,2));if(_>=Q){let Z=Q/_;return{type:"withinCurve",tVal:N+Z*(O-N),point:this.get(N+Z*(O-N))}}Q-=_,N=O}return{type:"withinCurve",tVal:N,point:this.get(N)}}refineBinary(z,G,N,Q,k,J=0,O=0.01){let W=Q[k],_=1,Z=Number.MAX_SAFE_INTEGER;do{let K=k===0?0:k-1,X=k===Q.length-1?Q.length-1:k+1,F=Q[K].tVal,H=Q[X].tVal,E=[],B=(H-F)/4;if(B<0.001)break;E.push(Q[K]);for(let q=1;q<=3;q++){let M=z.get(F+q*B),I=Math.abs($.distanceBetweenPoints(M,{x:G,y:N})-J);if(I<Z)Z=I,W={point:M,tVal:F+q*B,distance:I},k=q;E.push({point:M,tVal:F+q*B,distance:I})}E.push(Q[X]),Q=E}while(_++<25);if(J&&Z>O)W=void 0;return W}findClosest(z,G,N,Q,k=5,J,O){let W=Number.MAX_SAFE_INTEGER,_=J||W,Z=O||W,K=-1;for(let X=0,F=N.length;X<F;X++){let H=N[X].point;if(N[X].distance=Math.abs($.distanceBetweenPoints({x:z,y:G},H)-Q),Z<k&&_>Z&&Z<N[X].distance){K=X-1;break}if(N[X].distance<W)W=N[X].distance;_=Z,Z=N[X].distance}return K}getCurveIntersections(z,G){return V(this,z,G)}get AABB(){let z=this.getExtrema(),G=[0,1],N={x:Number.MAX_VALUE,y:Number.MAX_VALUE},Q={x:-Number.MAX_VALUE,y:-Number.MAX_VALUE};return z.x.forEach((k)=>{G.push(k)}),z.y.forEach((k)=>{G.push(k)}),G.forEach((k)=>{let J=this.get(k);N.x=Math.min(N.x,J.x),N.y=Math.min(N.y,J.y),Q.x=Math.max(Q.x,J.x),Q.y=Math.max(Q.y,J.y)}),{min:N,max:Q}}normal(z){let G=this.derivative(z),N=Math.sqrt(G.x*G.x+G.y*G.y);return{tVal:z,direction:{x:-G.y/N,y:G.x/N}}}}function r(z){let G,N=0,Q=0,k=0.01,J,O=[],W=[],_=z.getExtrema().x;if(_.indexOf(0)===-1)_=[0].concat(_);if(_.indexOf(1)===-1)_.push(1);for(N=_[0],G=1;G<_.length;G++)Q=_[G],J=z.splitAndTakeMidCurve(N,Q),O.push(J),N=Q;return O.forEach((Z)=>{N=0,Q=0;while(Q<=1)for(Q=N+k;Q<=1+k;Q+=k){let K=Math.min(Q,1);if(J=Z.splitAndTakeMidCurve(N,K),!t(J)){if(Q-=k,Math.abs(N-Q)<k)return[];let X=Math.min(Q,1);J=Z.splitAndTakeMidCurve(N,X),W.push(J),N=X;break}}if(N<1)J=Z.splitAndTakeMidCurve(N,1),W.push(J)}),W}function e(z){let G=z.getControlPoints(),N=[G[0]],Q=G.length;for(let k=1;k<Q;k++){let J=G[k],O=G[k-1];N[k]={x:(Q-k)/Q*J.x+k/Q*O.x,y:(Q-k)/Q*J.y+k/Q*O.y}}return N[Q]=G[Q-1],new j(N)}function u(z,G,N){if(N!==void 0){let J=z.get(G),O=z.normal(G).direction;return{c:J,n:O,x:J.x+O.x*N,y:J.y+O.y*N}}let Q=z.getControlPoints();if(g(z)){let J=z.normal(0).direction,O=Q.map(function(W){return{x:W.x+G*J.x,y:W.y+G*J.y}});return[new j(O)]}return r(z).map(function(J){if(g(J))return u(J,G)[0];return P(J,G)})}function O0(z,G){return z.getLUTWithTVal(100).map((k)=>{let J=$.unitVector(z.derivative(k.tVal)),O={x:-J.y,y:J.x};return{x:k.point.x+O.x*G,y:k.point.y+O.y*G}})}function C(z,G,N,Q){let{x:k,y:J}=z,O=G.x,W=G.y,_=N.x,Z=N.y,K=Q.x,X=Q.y;return o(k,J,O,W,_,Z,K,X)}function o(z,G,N,Q,k,J,O,W){let _=(z*Q-G*N)*(k-O)-(z-N)*(k*W-J*O),Z=(z*Q-G*N)*(J-W)-(G-Q)*(k*W-J*O),K=(z-N)*(J-W)-(G-Q)*(k-O);if(K==0)return!1;return{x:_/K,y:Z/K}}function g(z){let G=z.getControlPoints().length-1,N=z.getControlPoints(),Q=n(N,{p1:N[0],p2:N[G]}),k=$.distanceBetweenPoints(N[0],N[G]);return Q.reduce((O,W)=>O+Math.abs(W.y),0)<k/50}function P(z,G){let N=z.getControlPoints().length-1,Q=void 0;if(typeof G==="function")Q=G;if(Q&&N===2)return P(e(z),Q);let k=z.getControlPoints();if(g(z))return p(z,z.normal(0).direction,Q?Q(0):G,Q?Q(1):G);let J=Q?Q(0):G,O=Q?Q(1):G,W=[u(z,0,10),u(z,1,10)],_=[],Z=C(W[0],W[0].c,W[1],W[1].c);if(!Z)return p(z,z.normal(0).direction,J,O);if([0,1].forEach(function(K){let X=JSON.parse(JSON.stringify(k[K*N])),F=W[K];X.x+=(K?O:J)*F.n.x,X.y+=(K?O:J)*F.n.y,_[K*N]=X}),!Q)return[0,1].forEach((K)=>{if(N===2&&!!K)return;let X=_[K*N],F=z.derivative(K),H={x:X.x+F.x,y:X.y+F.y},E=C(X,H,Z,k[K+1]);if(E)_[K+1]=E;else{let B=k[K+1],q=z.normal((K+1)/N).direction;_[K+1]={x:B.x+(K?O:J)*q.x,y:B.y+(K?O:J)*q.y}}}),new j(_);return[0,1].forEach(function(K){if(N===2&&!!K)return;let X=k[K+1],F={x:X.x-Z.x,y:X.y-Z.y},H=Q((K+1)/N),E=Math.sqrt(F.x*F.x+F.y*F.y);F.x/=E,F.y/=E,_[K+1]={x:X.x+H*F.x,y:X.y+H*F.y}}),new j(_)}function n(z,G){let N=G.p1.x,Q=G.p1.y,k=-Math.atan2(G.p2.y-Q,G.p2.x-N),J=function(O){return{x:(O.x-N)*Math.cos(k)-(O.y-Q)*Math.sin(k),y:(O.x-N)*Math.sin(k)+(O.y-Q)*Math.cos(k)}};return z.map(J)}function x(z,G,N,Q,k){let J=N-G,O=k-Q,W=z-G,_=W/J;return Q+O*_}class c extends Error{constructor(z){super(z)}}function i(z,G){if(z.min.x<=G.max.x&&G.min.x<=z.max.x&&(z.min.y<=G.max.y&&G.min.y<=z.max.y))return!0;return!1}function D(z,G,N){return Math.abs(z-G)<=(N||0.000001)}function U(z){if(z<0)return-Math.pow(-z,0.3333333333333333);return Math.pow(z,0.3333333333333333)}function A(z){return 0<=z&&z<=1}function W0(z,G,N,Q){let k=3*z-6*G+3*N,J=-3*z+3*G,O=z,W=-z+3*G-3*N+Q;if(D(W,0)){if(D(k,0)){if(D(J,0))return[];return[-O/J].filter(A)}let R=Math.sqrt(J*J-4*k*O),y=2*k;return[(R-J)/y,(-J-R)/y].filter(A)}k/=W,J/=W,O/=W;let _=(3*J-k*k)/3,Z=_/3,K=(2*k*k*k-9*k*J+27*O)/27,X=K/2,F=X*X+Z*Z*Z,H,E,B,q,M;if(F<0){let R=-_/3,y=R*R*R,m=Math.sqrt(y),L=-K/(2*m),s=L<-1?-1:L>1?1:L,T=Math.acos(s),l=U(m),h=2*l;return B=h*Math.cos(T/3)-k/3,q=h*Math.cos((T+2*Math.PI)/3)-k/3,M=h*Math.cos((T+4*Math.PI)/3)-k/3,[B,q,M].filter(A)}if(F===0)return H=X<0?U(-X):-U(X),B=2*H-k/3,q=-H-k/3,[B,q].filter(A);var I=Math.sqrt(F);return H=U(I-X),E=U(I+X),B=H-E-k/3,[B].filter(A)}function V(z,G,N=0.01){let k=[{curve1:{curve:z,startTVal:0,endTVal:1},curve2:{curve:G,startTVal:0,endTVal:1}}],J=[];while(k.length>0){let W=k.length;for(let _=0;_<W;_++){let Z=k.shift();if(Z==null)break;let K=Z.curve1.curve.AABB,X=Z.curve2.curve.AABB,F=i(K,X);if(Z.curve1.curve.fullLength<0.5&&Z.curve2.curve.fullLength<0.5){J.push({intersection:Z.curve1.curve.get(0.5),tVal1:(Z.curve1.startTVal+Z.curve1.endTVal)*0.5,tVal2:(Z.curve2.startTVal+Z.curve2.endTVal)*0.5});continue}if(F){let[H,E]=Z.curve1.curve.split(0.5),[B,q]=Z.curve2.curve.split(0.5);k.push({curve1:{curve:new j(H),startTVal:Z.curve1.startTVal,endTVal:Z.curve1.startTVal+(Z.curve1.endTVal-Z.curve1.startTVal)*0.5},curve2:{curve:new j(B),startTVal:Z.curve2.startTVal,endTVal:Z.curve2.startTVal+(Z.curve2.endTVal-Z.curve2.startTVal)*0.5}}),k.push({curve1:{curve:new j(H),startTVal:Z.curve1.startTVal,endTVal:Z.curve1.startTVal+(Z.curve1.endTVal-Z.curve1.startTVal)*0.5},curve2:{curve:new j(q),startTVal:Z.curve2.startTVal+(Z.curve2.endTVal-Z.curve2.startTVal)*0.5,endTVal:Z.curve2.endTVal}}),k.push({curve1:{curve:new j(E),startTVal:Z.curve1.startTVal+(Z.curve1.endTVal-Z.curve1.startTVal)*0.5,endTVal:Z.curve1.endTVal},curve2:{curve:new j(B),startTVal:Z.curve2.startTVal,endTVal:Z.curve2.startTVal+(Z.curve2.endTVal-Z.curve2.startTVal)*0.5}}),k.push({curve1:{curve:new j(E),startTVal:Z.curve1.startTVal+(Z.curve1.endTVal-Z.curve1.startTVal)*0.5,endTVal:Z.curve1.endTVal},curve2:{curve:new j(q),startTVal:Z.curve2.startTVal+(Z.curve2.endTVal-Z.curve2.startTVal)*0.5,endTVal:Z.curve2.endTVal}})}}}let O=[];J.sort((W,_)=>W.tVal1-_.tVal1);for(let W of J){let _=!1;for(let Z of O){let K=D(W.tVal1,Z.selfT,N),X=D(W.tVal2,Z.otherT,N);if(K&&X){_=!0;break}let F=D(W.tVal1,Z.selfT,N*10),H=D(W.tVal2,Z.otherT,N*10);if(F||H){let E=z.get(W.tVal1),B=G.get(W.tVal2),q=z.get(Z.selfT),M=G.get(Z.otherT),I=$.distanceBetweenPoints(E,q),R=$.distanceBetweenPoints(B,M);if(I<N*100&&R<N*100){_=!0;break}}}if(!_)O.push({selfT:W.tVal1,otherT:W.tVal2})}return O}function w(z,G,N,Q){if(Math.abs(z)<0.00000001){if(z=G,G=N,N=Q,Math.abs(z)<0.00000001){if(z=G,G=N,Math.abs(z)<0.00000001)return[];return[-G/z]}let W=G*G-4*z*N;if(Math.abs(W)<0.00000001)return[-G/(2*z)];else if(W>0)return[(-G+Math.sqrt(W))/(2*z),(-G-Math.sqrt(W))/(2*z)];return[]}let k=(3*z*N-G*G)/(3*z*z),J=(2*G*G*G-9*z*G*N+27*z*z*Q)/(27*z*z*z),O;if(Math.abs(k)<0.00000001)O=[f(-J)];else if(Math.abs(J)<0.00000001)O=[0].concat(k<0?[Math.sqrt(-k),-Math.sqrt(-k)]:[]);else{let W=J*J/4+k*k*k/27;if(Math.abs(W)<0.00000001)O=[-1.5*J/k,3*J/k];else if(W>0){let _=f(-J/2-Math.sqrt(W)),Z=f(-J/2+Math.sqrt(W));O=[_-k/(3*_)]}else{let _=2*Math.sqrt(-k/3),Z=Math.acos(3*J/k/_)/3,K=2*Math.PI/3;O=[_*Math.cos(Z),_*Math.cos(Z-K),_*Math.cos(Z-2*K)]}}for(let W=0;W<O.length;W++)O[W]-=G/(3*z);return O}function f(z){var G=Math.pow(Math.abs(z),0.3333333333333333);return z<0?-G:G}function b(z,G){let N=[...G];while(N.length>1){let Q=N.slice(1);for(let k=0;k<Q.length;k++)Q[k]=$.addVector($.multiplyVectorByScalar(N[k],1-z),$.multiplyVectorByScalar(N[k+1],z));N=Q}return N[0]}function t(z){if(z.getControlPoints().length===4){let k=z.getControlPoints(),J=$.subVector(k[3],k[0]),O=$.subVector(k[1],k[0]),W=$.subVector(k[2],k[0]),_=$.angleFromA2B(J,O),Z=$.angleFromA2B(J,W);if(_>0&&Z<0||_<0&&Z>0)return!1}let G=z.normal(0).direction,N=z.normal(1).direction,Q=G.x*N.x+G.y*N.y;return Math.abs(Math.acos(Q))<Math.PI/3}function p(z,G,N,Q){let k=z.getControlPoints().length-1,J=z.getControlPoints(),O=J.map((W,_)=>(1-_/k)*N+_/k*Q);return new j(J.map((W,_)=>({x:W.x+O[_]*G.x,y:W.y+O[_]*G.y})))}import{PointCal as S}from"@ue-too/math";class z0{startPoint;endPoint;constructor(z,G){this.startPoint=z,this.endPoint=G}getStartPoint(){return this.startPoint}getEndPoint(){return this.endPoint}intersectionWithAnotherLine(z){return G0(this.startPoint,this.endPoint,z.getStartPoint(),z.getEndPoint())}projectPoint(z){return N0(z,this.getStartPoint(),this.getEndPoint())}length(){return S.distanceBetweenPoints(this.startPoint,this.endPoint)}getTranslationRotationToAlginXAxis(){let z=S.subVector({x:0,y:0},this.startPoint),G=S.angleFromA2B(S.subVector(this.endPoint,this.startPoint),{x:1,y:0});return{translation:z,rotationAngle:G}}pointInLine(z){let G=S.unitVectorFromA2B(this.startPoint,this.endPoint),N=S.subVector(z,this.startPoint),Q=S.dotProduct(N,G),k=S.unitVector(N),J=S.distanceBetweenPoints(this.startPoint,this.endPoint)*0.0001;return Q<=S.distanceBetweenPoints(this.startPoint,this.endPoint)&&Q>=0&&Math.abs(k.x-G.x)<0.0001&&Math.abs(k.y-G.y)<0.0001}lerp(z){return S.linearInterpolation(this.startPoint,this.endPoint,z)}}function G0(z,G,N,Q){let k=(Q.x-N.x)*(z.y-N.y)-(Q.y-N.y)*(z.x-N.x),J=(Q.y-N.y)*(G.x-z.x)-(Q.x-N.x)*(G.y-z.y);if(J===0)return{intersects:!1};let O=k/J;if(O>=0&&O<=1)return{intersects:!0,intersection:S.linearInterpolation(z,G,O),offset:O};else return{intersects:!1}}function N0(z,G,N){let Q=S.unitVector(S.subVector(N,G)),k=S.subVector(z,G),J=S.dotProduct(k,Q);if(J<0||J>S.magnitude(S.subVector(N,G)))return{within:!1};return{within:!0,projectionPoint:S.addVector(G,S.multiplyVectorByScalar(Q,J)),offset:J/S.magnitude(S.subVector(N,G))}}import{PointCal as Y}from"@ue-too/math";class d{position;leftHandle;rightHandle;constructor(z,G,N){this.position=z,this.leftHandle=G,this.rightHandle=N}setPosition(z,G,N){let Q=Y.subVector(z,this.position);if(this.position=z,this.leftHandle.position=Y.addVector(this.leftHandle.position,Q),this.rightHandle.position=Y.addVector(this.rightHandle.position,Q),this.leftHandle.type=="VECTOR"&&G){let k=Y.subVector(G.getPosition(),this.position);if(k=Y.multiplyVectorByScalar(k,0.3333333333333333),this.leftHandle.position=Y.addVector(this.position,k),this.rightHandle.type=="ALIGNED"){let J=Y.subVector(this.rightHandle.position,this.position),O=Y.magnitude(J),W=Y.unitVectorFromA2B(this.leftHandle.position,this.position);this.rightHandle.position=Y.addVector(this.position,Y.multiplyVectorByScalar(W,O))}}if(this.rightHandle.type=="VECTOR"&&N){let k=Y.subVector(N.getPosition(),this.position);if(k=Y.multiplyVectorByScalar(k,0.3333333333333333),this.rightHandle.position=Y.addVector(this.position,k),this.leftHandle.type=="ALIGNED"){let J=Y.distanceBetweenPoints(this.leftHandle.position,this.position),O=Y.subVector(this.position,this.rightHandle.position);this.leftHandle.position=Y.addVector(this.position,Y.multiplyVectorByScalar(O,J))}}if(G!==void 0&&G.getRightHandle().type=="VECTOR"){let k=Y.subVector(this.position,G.getPosition());k=Y.multiplyVectorByScalar(k,0.3333333333333333),G.setRightHandlePosition(Y.addVector(G.getPosition(),k))}if(N!==void 0&&N.getLeftHandle().type=="VECTOR"){let k=Y.subVector(this.position,N.getPosition());k=Y.multiplyVectorByScalar(k,0.3333333333333333),N.setLeftHandlePosition(Y.addVector(N.getPosition(),k))}}getPosition(){return this.position}setLeftHandleTypeVector(z){if(this.rightHandle.type!="VECTOR")this.rightHandle.type="FREE";let G;if(z==null)G=Y.subVector(this.leftHandle.position,this.position);else G=Y.subVector(z.getPosition(),this.position),G=Y.multiplyVectorByScalar(G,0.3333333333333333);this.leftHandle.position=Y.addVector(this.position,G)}setLeftHandleTypeAligned(){if(this.leftHandle.type="ALIGNED",this.rightHandle.type=="VECTOR"){let z=Y.unitVectorFromA2B(this.rightHandle.position,this.position),G=Y.distanceBetweenPoints(this.position,this.leftHandle.position);this.leftHandle.position=Y.addVector(this.position,Y.multiplyVectorByScalar(z,G))}}setLeftHandleTypeFree(){this.leftHandle.type="FREE"}setRightHandleTypeVector(z){if(this.leftHandle.type!="VECTOR")this.leftHandle.type="FREE";let G;if(z==null)G=Y.subVector(this.rightHandle.position,this.position);else G=Y.subVector(z.getPosition(),this.position),G=Y.multiplyVectorByScalar(G,0.3333333333333333);this.rightHandle.position=Y.addVector(this.position,G)}setRightHandleTypeAligned(){if(this.rightHandle.type="ALIGNED",this.leftHandle.type=="VECTOR"){let z=Y.unitVectorFromA2B(this.leftHandle.position,this.position),G=Y.distanceBetweenPoints(this.position,this.rightHandle.position);this.rightHandle.position=Y.addVector(this.position,Y.multiplyVectorByScalar(z,G))}}setRightHandleTypeFree(){this.rightHandle.type="FREE"}setLeftHandlePosition(z){switch(this.leftHandle.type){case"ALIGNED":if(this.rightHandle.type=="VECTOR"){let N=Y.subVector(z,this.position),Q=Y.unitVectorFromA2B(this.rightHandle.position,this.position),k=Y.dotProduct(N,Q),J=Y.multiplyVectorByScalar(Q,k);this.leftHandle.position=Y.addVector(this.position,J)}else if(this.rightHandle.type=="ALIGNED"){this.leftHandle.position=z;let N=Y.distanceBetweenPoints(this.rightHandle.position,this.position),Q=Y.unitVectorFromA2B(this.leftHandle.position,this.position),k=Y.multiplyVectorByScalar(Q,N);this.rightHandle.position=Y.addVector(k,this.position)}else this.leftHandle.position=z;break;case"FREE":this.leftHandle.position=z;break;case"VECTOR":break;default:throw Error("Unknown left handle type for control point")}}setRightHandlePosition(z){switch(this.rightHandle.type){case"ALIGNED":if(this.leftHandle.type=="VECTOR"){let N=Y.subVector(z,this.position),Q=Y.unitVectorFromA2B(this.leftHandle.position,this.position),k=Y.dotProduct(N,Q),J=Y.multiplyVectorByScalar(Q,k);this.rightHandle.position=Y.addVector(this.position,J)}else if(this.rightHandle.type=="ALIGNED"){this.rightHandle.position=z;let N=Y.distanceBetweenPoints(this.leftHandle.position,this.position),Q=Y.unitVectorFromA2B(this.rightHandle.position,this.position),k=Y.multiplyVectorByScalar(Q,N);this.leftHandle.position=Y.addVector(k,this.position)}else this.rightHandle.position=z;break;case"FREE":this.rightHandle.position=z;break;case"VECTOR":break;default:throw Error("Unknown left handle type for control point")}}getLeftHandle(){return this.leftHandle}getRightHandle(){return this.rightHandle}}class Q0{controlPoints;constructor(z=[]){this.controlPoints=z}getControlPoints(){return this.controlPoints}appendControlPoint(z){let G=Y.addVector(z,{x:-100,y:0}),N=Y.addVector(z,{x:100,y:0}),J=new d(z,{position:G,type:"FREE"},{position:N,type:"FREE"});this.controlPoints.push(J)}setLeftHandlePositionOfControlPoint(z,G){if(z>=this.controlPoints.length||z<0)return;this.controlPoints[z].setLeftHandlePosition(G)}setRightHandlePositionOfControlPoint(z,G){if(z>=this.controlPoints.length||z<0)return;this.controlPoints[z].setRightHandlePosition(G)}setPositionOfControlPoint(z,G){if(z>=this.controlPoints.length||z<0)return;let N=void 0,Q=void 0;if(z+1<this.controlPoints.length)Q=this.controlPoints[z+1];if(z-1>=0)N=this.controlPoints[z-1];this.controlPoints[z].setPosition(G,N,Q)}}class k0{lines;constructor(z){this.lines=z}append(z){this.lines.push(z)}clear(){this.lines=[]}prepend(z){this.lines.unshift(z)}getLines(){return this.lines}getLength(){let z=0;return this.lines.forEach((G)=>{z+=G.length()}),z}getPercentages(){let z=this.getLength(),G=0,N=[];return this.lines.forEach((Q)=>{let J=Q.length()/z,O=G;G+=J;let W=G;N.push({start:O,end:W})}),N[N.length-1].end=1,N}getPointByPercentage(z){if(z<0||z>1)throw Error("Percentage must be between 0 and 1");let G=this.getPercentages(),N=0,Q=G.length-1;while(N<=Q){let W=Math.floor((N+Q)/2);if(z<G[W].end)Q=W-1;else if(z>G[W].end)N=W+1;else{N=W;break}}let k=this.lines[N],J=G[N],O=(z-J.start)/(J.end-J.start);return k.lerp(O)}}export{w as solveCubic,r as reduce,N0 as projectPointOntoLine,O0 as offset2,u as offset,G0 as getLineIntersection,V as getIntersectionsBetweenCurves,W0 as getCubicRoots,U as cuberoot2,f as cuberoot,b as computeWithControlPoints,D as approximately,A as accept,c as TValOutofBoundError,k0 as Path,z0 as Line,d as ControlPoint,Q0 as CompositeBCurve,j as BCurve,i as AABBIntersects};
 
-class BCurve {
-  controlPoints;
-  dControlPoints = [];
-  arcLengthLUT = { controlPoints: [], arcLengthLUT: [] };
-  _fullLength;
-  lengthCache = new Map;
-  getCacheStats() {
-    return {
-      size: this.lengthCache.size,
-      hitRate: 0
-    };
-  }
-  preWarmCache(steps = 100) {
-    const tSteps = 1 / steps;
-    for (let tVal = 0;tVal <= 1; tVal += tSteps) {
-      this.lengthAtT(tVal);
-    }
-  }
-  clearCache() {
-    this.lengthCache.clear();
-  }
-  constructor(controlPoints) {
-    this.controlPoints = controlPoints;
-    this.dControlPoints = this.getDerivativeControlPoints(this.controlPoints);
-    this._fullLength = this.calculateFullLength();
-    this.arcLengthLUT = { controlPoints: [], arcLengthLUT: [] };
-    this.clearCache();
-  }
-  getPointbyPercentage(percentage) {
-    let controlPointsChangedSinceLastArcLengthLUT = this.arcLengthLUT.controlPoints.length != this.controlPoints.length;
-    controlPointsChangedSinceLastArcLengthLUT = controlPointsChangedSinceLastArcLengthLUT || this.arcLengthLUT.controlPoints.reduce((prevVal, curVal, index) => {
-      return prevVal || !PointCal.isEqual(curVal, this.controlPoints[index]);
-    }, false);
-    let points = [];
-    if (controlPointsChangedSinceLastArcLengthLUT) {
-      this.arcLengthLUT = this.getArcLengthLUT(1000);
-    }
-    points = [...this.arcLengthLUT.arcLengthLUT.map((item) => item.length)];
-    let targetLength = percentage * this.fullLength;
-    let low = 0;
-    let high = points.length - 1;
-    while (low <= high) {
-      let mid = Math.floor((low + high) / 2);
-      if (points[mid] == targetLength) {
-        return this.get((mid + 1) / points.length);
-      } else if (points[mid] < targetLength) {
-        low = mid + 1;
-      } else {
-        high = mid - 1;
-      }
-    }
-    return low >= points.length ? this.get(1) : this.get((low + 1) / points.length);
-  }
-  getDerivativeControlPoints(controlPoints) {
-    const derivativeControlPoints = [];
-    for (let index = 1;index < controlPoints.length; index++) {
-      derivativeControlPoints.push(PointCal.multiplyVectorByScalar(PointCal.subVector(controlPoints[index], controlPoints[index - 1]), controlPoints.length - 1));
-    }
-    return derivativeControlPoints;
-  }
-  validateTVal(tVal) {
-    if (tVal > 1 || tVal < 0) {
-      throw new TValOutofBoundError("tVal is greater than 1 or less than 0");
-    }
-  }
-  getControlPoints() {
-    return this.controlPoints;
-  }
-  setControlPoints(controlPoints) {
-    this.controlPoints = controlPoints;
-    this.dControlPoints = this.getDerivativeControlPoints(this.controlPoints);
-    this._fullLength = this.calculateFullLength();
-    this.arcLengthLUT = { controlPoints: [], arcLengthLUT: [] };
-    this.clearCache();
-  }
-  setControlPointAtIndex(index, newPoint) {
-    if (index < 0 || index >= this.controlPoints.length) {
-      return false;
-    }
-    this.controlPoints[index] = newPoint;
-    this.dControlPoints = this.getDerivativeControlPoints(this.controlPoints);
-    this._fullLength = this.calculateFullLength();
-    this.arcLengthLUT = { controlPoints: [], arcLengthLUT: [] };
-    this.clearCache();
-    return true;
-  }
-  compute(tVal) {
-    this.validateTVal(tVal);
-    let points = this.controlPoints;
-    while (points.length > 1) {
-      let lowerLevelPoints = points.slice(1);
-      for (let index = 0;index < lowerLevelPoints.length; index++) {
-        lowerLevelPoints[index] = PointCal.addVector(PointCal.multiplyVectorByScalar(points[index], 1 - tVal), PointCal.multiplyVectorByScalar(points[index + 1], tVal));
-      }
-      points = lowerLevelPoints;
-    }
-    return points[0];
-  }
-  get(tVal) {
-    this.validateTVal(tVal);
-    if (this.controlPoints.length == 3) {
-      let firstTerm = PointCal.multiplyVectorByScalar(this.controlPoints[0], (1 - tVal) * (1 - tVal));
-      let secondTerm = PointCal.multiplyVectorByScalar(this.controlPoints[1], 2 * (1 - tVal) * tVal);
-      let thirdTerm = PointCal.multiplyVectorByScalar(this.controlPoints[2], tVal * tVal);
-      let res = PointCal.addVector(PointCal.addVector(firstTerm, secondTerm), thirdTerm);
-      return res;
-    }
-    if (this.controlPoints.length == 4) {
-      let firstTerm = PointCal.multiplyVectorByScalar(this.controlPoints[0], (1 - tVal) * (1 - tVal) * (1 - tVal));
-      let secondTerm = PointCal.multiplyVectorByScalar(this.controlPoints[1], 3 * (1 - tVal) * (1 - tVal) * tVal);
-      let thirdTerm = PointCal.multiplyVectorByScalar(this.controlPoints[2], 3 * (1 - tVal) * tVal * tVal);
-      let forthTerm = PointCal.multiplyVectorByScalar(this.controlPoints[3], tVal * tVal * tVal);
-      let res = PointCal.addVector(PointCal.addVector(firstTerm, secondTerm), PointCal.addVector(thirdTerm, forthTerm));
-      return res;
-    }
-    return this.compute(tVal);
-  }
-  getLUT(steps = 100) {
-    const stepSpan = 1 / steps;
-    const res = [];
-    let tVal = 0;
-    res.push(this.get(tVal));
-    for (let index = 0;index < steps; index += 1) {
-      tVal += stepSpan;
-      if (tVal > 1 && tVal - stepSpan < 1 || index == steps - 1) {
-        tVal = 1;
-      }
-      res.push(this.get(tVal));
-    }
-    return res;
-  }
-  getLUTWithTVal(steps) {
-    if (steps == undefined) {
-      steps = 100;
-    }
-    const stepSpan = 1 / steps;
-    const res = [];
-    let tVal = 0;
-    res.push({ point: this.get(tVal), tVal });
-    for (let index = 0;index < steps; index += 1) {
-      tVal += stepSpan;
-      if (tVal > 1 && tVal - stepSpan < 1 || index == steps - 1) {
-        tVal = 1;
-      }
-      res.push({ point: this.get(tVal), tVal });
-    }
-    return res;
-  }
-  get fullLength() {
-    return this._fullLength;
-  }
-  calculateFullLength() {
-    return this.lengthAtT(1);
-  }
-  lengthAtT(tVal) {
-    this.validateTVal(tVal);
-    const cacheKey = Math.round(tVal * 1e6) / 1e6;
-    if (this.lengthCache.has(cacheKey)) {
-      return this.lengthCache.get(cacheKey);
-    }
-    const z = tVal / 2, len = T.length;
-    let sum = 0;
-    for (let i = 0, t;i < len; i++) {
-      t = z * T[i] + z;
-      sum += C[i] * PointCal.magnitude(this.derivative(t));
-    }
-    const result = z * sum;
-    this.lengthCache.set(cacheKey, result);
-    return result;
-  }
-  derivative(tVal) {
-    return computeWithControlPoints(tVal, this.dControlPoints);
-  }
-  derivativeNormalized(tVal) {
-    return PointCal.unitVector(computeWithControlPoints(tVal, this.dControlPoints));
-  }
-  getArcLengthLUT(steps = 50) {
-    const controlPointsChanged = this.arcLengthLUT.controlPoints.length !== this.controlPoints.length || this.arcLengthLUT.controlPoints.some((cp, index) => !PointCal.isEqual(cp, this.controlPoints[index]));
-    if (controlPointsChanged || this.arcLengthLUT.arcLengthLUT.length === 0) {
-      this.clearCache();
-      let res = [];
-      let tSteps = 1 / steps;
-      for (let tVal = 0;tVal <= 1; tVal += tSteps) {
-        res.push({ tVal, length: this.lengthAtT(tVal) });
-      }
-      this.arcLengthLUT = { controlPoints: [...this.controlPoints], arcLengthLUT: res };
-    }
-    return this.arcLengthLUT;
-  }
-  splitIntoCurves(tVal) {
-    const res = this.split(tVal);
-    return [new BCurve(res[0]), new BCurve(res[1])];
-  }
-  split(tVal) {
-    this.validateTVal(tVal);
-    if (this.controlPoints.length == 3) {
-      let newControlPoint12 = this.controlPoints[0];
-      let newControlPoint22 = PointCal.subVector(PointCal.multiplyVectorByScalar(this.controlPoints[1], tVal), PointCal.multiplyVectorByScalar(this.controlPoints[0], tVal - 1));
-      let newControlPoint32 = PointCal.subVector(PointCal.multiplyVectorByScalar(this.controlPoints[2], tVal * tVal), PointCal.multiplyVectorByScalar(this.controlPoints[1], 2 * tVal * (tVal - 1)));
-      newControlPoint32 = PointCal.addVector(newControlPoint32, PointCal.multiplyVectorByScalar(this.controlPoints[0], (tVal - 1) * (tVal - 1)));
-      let newControlPoint42 = PointCal.subVector(PointCal.multiplyVectorByScalar(this.controlPoints[2], tVal), PointCal.multiplyVectorByScalar(this.controlPoints[1], tVal - 1));
-      let newControlPoint52 = this.controlPoints[2];
-      return [[newControlPoint12, newControlPoint22, newControlPoint32], [newControlPoint32, newControlPoint42, newControlPoint52]];
-    }
-    let newControlPoint1 = this.controlPoints[0];
-    let newControlPoint2 = PointCal.subVector(PointCal.multiplyVectorByScalar(this.controlPoints[1], tVal), PointCal.multiplyVectorByScalar(this.controlPoints[0], tVal - 1));
-    let newControlPoint3 = PointCal.addVector(PointCal.multiplyVectorByScalar(this.controlPoints[2], tVal * tVal), PointCal.addVector(PointCal.multiplyVectorByScalar(this.controlPoints[1], -(2 * tVal * (tVal - 1))), PointCal.multiplyVectorByScalar(this.controlPoints[0], (tVal - 1) * (tVal - 1))));
-    let term1 = PointCal.multiplyVectorByScalar(this.controlPoints[3], tVal * tVal * tVal);
-    let term2 = PointCal.multiplyVectorByScalar(this.controlPoints[2], -(3 * tVal * tVal * (tVal - 1)));
-    let term3 = PointCal.multiplyVectorByScalar(this.controlPoints[1], 3 * tVal * (tVal - 1) * (tVal - 1));
-    let term4 = PointCal.multiplyVectorByScalar(this.controlPoints[0], -((tVal - 1) * (tVal - 1) * (tVal - 1)));
-    let newControlPoint4 = PointCal.addVector(term4, PointCal.addVector(term3, PointCal.addVector(term1, term2)));
-    let newControlPoint5 = PointCal.addVector(PointCal.addVector(PointCal.multiplyVectorByScalar(this.controlPoints[3], tVal * tVal), PointCal.multiplyVectorByScalar(this.controlPoints[2], -(2 * tVal * (tVal - 1)))), PointCal.multiplyVectorByScalar(this.controlPoints[1], (tVal - 1) * (tVal - 1)));
-    let newControlPoint6 = PointCal.addVector(PointCal.multiplyVectorByScalar(this.controlPoints[3], tVal), PointCal.multiplyVectorByScalar(this.controlPoints[2], -(tVal - 1)));
-    let newControlPoint7 = this.controlPoints[3];
-    return [[newControlPoint1, newControlPoint2, newControlPoint3, newControlPoint4], [newControlPoint4, newControlPoint5, newControlPoint6, newControlPoint7]];
-  }
-  splitIn3WithControlPoints(tVal, tVal2) {
-    if (tVal2 < tVal) {
-      console.warn("tVal2 is less than tVal, swapping them");
-      [tVal, tVal2] = [tVal2, tVal];
-    }
-    const firstSplit = this.split(tVal);
-    const secondHalf = new BCurve(firstSplit[1]);
-    const mappedTVal2 = map(tVal2, tVal, 1, 0, 1);
-    const secondSplit = secondHalf.split(mappedTVal2);
-    return [firstSplit[0], secondSplit[0], secondSplit[1]];
-  }
-  splitIn3Curves(tVal, tVal2) {
-    if (tVal2 < tVal) {
-      console.warn("tVal2 is less than tVal, swapping them");
-      [tVal, tVal2] = [tVal2, tVal];
-    }
-    const firstSplit = this.split(tVal);
-    const secondHalf = new BCurve(firstSplit[1]);
-    const mappedTVal2 = map(tVal2, tVal, 1, 0, 1);
-    const secondSplit = secondHalf.split(mappedTVal2);
-    return [new BCurve(firstSplit[0]), new BCurve(secondSplit[0]), new BCurve(secondSplit[1])];
-  }
-  splitAndTakeMidCurve(tVal, tVal2) {
-    const [firstSplit, secondSplit, thirdSplit] = this.splitIn3Curves(tVal, tVal2);
-    return secondSplit;
-  }
-  getProjection(point) {
-    const threshold = 0.00001;
-    let distance = Number.MAX_VALUE;
-    let preliminaryProjectionTVal = 0;
-    let preliminaryProjectionPoint = this.get(0);
-    let preliminaryProjectionIndex = 0;
-    const LUT = this.getLUTWithTVal(500);
-    LUT.forEach((curvePoint, index) => {
-      const curDistance = PointCal.distanceBetweenPoints(curvePoint.point, point);
-      if (curDistance < distance) {
-        distance = curDistance;
-        preliminaryProjectionPoint = { ...curvePoint.point };
-        preliminaryProjectionTVal = curvePoint.tVal;
-        preliminaryProjectionIndex = index;
-      }
-    });
-    let low = LUT[preliminaryProjectionIndex].tVal;
-    let high = LUT[preliminaryProjectionIndex].tVal;
-    if (preliminaryProjectionIndex < LUT.length - 1) {
-      high = LUT[preliminaryProjectionIndex + 1].tVal;
-    }
-    if (preliminaryProjectionIndex > 0) {
-      low = LUT[preliminaryProjectionIndex - 1].tVal;
-    }
-    while (low < high && high - low > threshold) {
-      let mid = low + (high - low) / 2;
-      let halfSpan = mid - low;
-      let lowMidMid = mid + halfSpan / 2;
-      let highMidMid = mid + halfSpan / 2;
-      let prevDist = distance;
-      if (lowMidMid <= 1 && lowMidMid >= 0) {
-        let curDist = PointCal.distanceBetweenPoints(this.get(lowMidMid), point);
-        if (curDist < distance) {
-          distance = curDist;
-          preliminaryProjectionPoint = this.get(lowMidMid);
-          preliminaryProjectionTVal = lowMidMid;
-          high = lowMidMid + halfSpan / 2;
-          low = lowMidMid - halfSpan / 2;
-        }
-      }
-      if (highMidMid <= 1 && highMidMid >= 0) {
-        let curDist = PointCal.distanceBetweenPoints(this.get(highMidMid), point);
-        if (curDist < distance) {
-          distance = curDist;
-          preliminaryProjectionPoint = this.get(highMidMid);
-          preliminaryProjectionTVal = highMidMid;
-          high = highMidMid + halfSpan / 2;
-          low = highMidMid - halfSpan / 2;
-        }
-      }
-      if (prevDist == distance) {
-        break;
-      }
-    }
-    return { projection: preliminaryProjectionPoint, tVal: preliminaryProjectionTVal };
-  }
-  findArcs(errorThreshold) {
-    let low = 0;
-    const res = [];
-    while (low < 1) {
-      let loopRes = this.findArcStartingAt(errorThreshold, low);
-      if (loopRes == null || loopRes.arc == undefined) {
-        break;
-      }
-      res.push(loopRes.arc);
-      low = loopRes.arc.endT;
-      if (low >= 1) {
-        break;
-      }
-    }
-    return res;
-  }
-  findArcStartingAt(errorThreshold, low) {
-    let high = 1;
-    let mid = low + (high - low) / 2;
-    let prevArc = { good: false };
-    let count = 0;
-    while (true) {
-      count++;
-      mid = low + (high - low) / 2;
-      if (high > 1 || mid > 1) {
-        if (prevArc.good) {
-          return prevArc;
-        } else {
-          return null;
-        }
-      }
-      const lowPoint = this.get(low);
-      const highPoint = this.get(high);
-      const midPoint = this.get(mid);
-      const fitArcRes = this.fitArc(lowPoint, highPoint, midPoint);
-      if (!fitArcRes.exists || fitArcRes.center == null || fitArcRes.radius == null) {
-        return null;
-      }
-      const n = high - mid;
-      const e1 = mid - n / 2;
-      const e2 = mid + n / 2;
-      const checkPoint1 = this.get(e1);
-      const checkPoint2 = this.get(e2);
-      const checkRadius = PointCal.distanceBetweenPoints(checkPoint1, fitArcRes.center);
-      const checkRadius2 = PointCal.distanceBetweenPoints(checkPoint2, fitArcRes.center);
-      if (Math.abs(checkRadius - fitArcRes.radius) > errorThreshold || Math.abs(checkRadius2 - fitArcRes.radius) > errorThreshold) {
-        if (prevArc.good == true) {
-          return prevArc;
-        }
-        prevArc.good = false;
-        high = mid;
-      } else {
-        prevArc.good = true;
-        if (fitArcRes.startPoint !== undefined && fitArcRes.endPoint !== undefined) {
-          prevArc.arc = { center: fitArcRes.center, radius: fitArcRes.radius, startPoint: fitArcRes.startPoint, endPoint: fitArcRes.endPoint, startT: low, endT: high };
-        }
-        high = high + (mid - low);
-      }
-    }
-  }
-  fitArc(startPoint, endPoint, midPoint) {
-    const M11 = [[startPoint.x, startPoint.y, 1], [midPoint.x, midPoint.y, 1], [endPoint.x, endPoint.y, 1]];
-    if (this.determinant3by3(M11) == 0) {
-      return { exists: false };
-    }
-    const M12 = [
-      [startPoint.x * startPoint.x + startPoint.y * startPoint.y, startPoint.y, 1],
-      [midPoint.x * midPoint.x + midPoint.y * midPoint.y, midPoint.y, 1],
-      [endPoint.x * endPoint.x + endPoint.y * endPoint.y, endPoint.y, 1]
-    ];
-    const M13 = [
-      [startPoint.x * startPoint.x + startPoint.y * startPoint.y, startPoint.x, 1],
-      [midPoint.x * midPoint.x + midPoint.y * midPoint.y, midPoint.x, 1],
-      [endPoint.x * endPoint.x + endPoint.y * endPoint.y, endPoint.x, 1]
-    ];
-    const M14 = [
-      [startPoint.x * startPoint.x + startPoint.y * startPoint.y, startPoint.x, startPoint.y],
-      [midPoint.x * midPoint.x + midPoint.y * midPoint.y, midPoint.x, midPoint.y],
-      [endPoint.x * endPoint.x + endPoint.y * endPoint.y, endPoint.x, endPoint.y]
-    ];
-    const centerX = 1 / 2 * (this.determinant3by3(M12) / this.determinant3by3(M11));
-    const centerY = -1 / 2 * (this.determinant3by3(M13) / this.determinant3by3(M11));
-    const radius = Math.sqrt(centerX * centerX + centerY * centerY + this.determinant3by3(M14) / this.determinant3by3(M11));
-    return { exists: true, center: { x: centerX, y: centerY }, radius, startPoint, endPoint };
-  }
-  determinant3by3(matrix) {
-    const a = matrix[0][0];
-    const b = matrix[0][1];
-    const c = matrix[0][2];
-    const d = matrix[1][0];
-    const e = matrix[1][1];
-    const f = matrix[1][2];
-    const g = matrix[2][0];
-    const h = matrix[2][1];
-    const i = matrix[2][2];
-    return a * (e * i - f * h) - b * (d * i - g * f) + c * (d * h - e * g);
-  }
-  curvature(tVal) {
-    const derivative = computeWithControlPoints(tVal, this.dControlPoints);
-    const secondDerivative = computeWithControlPoints(tVal, this.getDerivativeControlPoints(this.dControlPoints));
-    const numerator = derivative.x * secondDerivative.y - secondDerivative.x * derivative.y;
-    const denominator = Math.pow(derivative.x * derivative.x + derivative.y * derivative.y, 3 / 2);
-    if (denominator == 0)
-      return NaN;
-    return numerator / denominator;
-  }
-  secondDerivative(tVal) {
-    return computeWithControlPoints(tVal, this.getDerivativeControlPoints(this.dControlPoints));
-  }
-  getCoefficientOfTTerms() {
-    return this.getCoefficientOfTTermsWithControlPoints(this.controlPoints);
-  }
-  getDerivativeCoefficients() {
-    return this.getCoefficientOfTTermsWithControlPoints(this.dControlPoints);
-  }
-  getCoefficientOfTTermsWithControlPoints(controlPoints) {
-    const terms = [];
-    let matrix = [];
-    if (controlPoints.length == 3) {
-      matrix = [[1, 0, 0], [-2, 2, 0], [1, -2, 1]];
-    } else if (controlPoints.length == 4) {
-      matrix = [[1, 0, 0, 0], [-3, 3, 0, 0], [3, -6, 3, 0], [-1, 3, -3, 1]];
-    } else if (controlPoints.length == 2) {
-      matrix = [[1, 0], [-1, 1]];
-    } else {
-      throw new Error("number of control points is wrong");
-    }
-    for (let index = 0;index < controlPoints.length; index++) {
-      terms.push(controlPoints.reduce((prevVal, curVal, jindex) => {
-        return { x: prevVal.x + matrix[index][jindex] * curVal.x, y: prevVal.y + matrix[index][jindex] * curVal.y };
-      }, { x: 0, y: 0 }));
-    }
-    return terms;
-  }
-  getControlPointsAlignedWithXAxis() {
-    const alignedAxis = PointCal.unitVectorFromA2B(this.controlPoints[0], this.controlPoints[this.controlPoints.length - 1]);
-    const angle = PointCal.angleFromA2B({ x: 1, y: 0 }, alignedAxis);
-    const startingPoint = this.controlPoints[0];
-    const res = [{ x: 0, y: 0 }];
-    for (let index = 1;index < this.controlPoints.length; index++) {
-      const vector = PointCal.subVector(this.controlPoints[index], startingPoint);
-      const rotatedVector = PointCal.rotatePoint(vector, -angle);
-      res.push(rotatedVector);
-    }
-    return res;
-  }
-  getExtrema() {
-    const res = { x: [], y: [] };
-    const derivativeCoefficients = this.getDerivativeCoefficients();
-    let xCoefficients = [0, 0, 0, 0];
-    let yCoefficients = [0, 0, 0, 0];
-    derivativeCoefficients.forEach((coefficient, index) => {
-      xCoefficients[3 - index] = coefficient.x;
-      yCoefficients[3 - index] = coefficient.y;
-    });
-    const xRoots = solveCubic(xCoefficients[0], xCoefficients[1], xCoefficients[2], xCoefficients[3]);
-    const yRoots = solveCubic(yCoefficients[0], yCoefficients[1], yCoefficients[2], yCoefficients[3]);
-    xRoots.forEach((root) => {
-      if (root >= 0 && root <= 1) {
-        res.x.push(root);
-      }
-    });
-    yRoots.forEach((root) => {
-      if (root >= 0 && root <= 1) {
-        res.y.push(root);
-      }
-    });
-    if (derivativeCoefficients.length >= 3) {
-      xCoefficients = [0, 0, 0, 0];
-      yCoefficients = [0, 0, 0, 0];
-      const secondDerivativeCoefficients = this.getCoefficientOfTTermsWithControlPoints(this.getDerivativeControlPoints(this.dControlPoints));
-      secondDerivativeCoefficients.forEach((coefficient, index) => {
-        xCoefficients[3 - index] = coefficient.x;
-        yCoefficients[3 - index] = coefficient.y;
-      });
-      const secondXRoots = solveCubic(xCoefficients[0], xCoefficients[1], xCoefficients[2], xCoefficients[3]);
-      const secondYRoots = solveCubic(yCoefficients[0], yCoefficients[1], yCoefficients[2], yCoefficients[3]);
-      secondXRoots.forEach((root) => {
-        if (root >= 0 && root <= 1) {
-          res.x.push(root);
-        }
-      });
-      secondYRoots.forEach((root) => {
-        if (root >= 0 && root <= 1) {
-          res.y.push(root);
-        }
-      });
-    }
-    return res;
-  }
-  translateRotateControlPoints(translation, rotationAngle) {
-    const res = [];
-    for (let index = 0;index < this.controlPoints.length; index++) {
-      res.push(PointCal.rotatePoint(PointCal.addVector(this.controlPoints[index], translation), rotationAngle));
-    }
-    return res;
-  }
-  getLineIntersections(line) {
-    const translationRotation = line.getTranslationRotationToAlginXAxis();
-    const res = [];
-    const alignedControlPoints = this.translateRotateControlPoints(translationRotation.translation, translationRotation.rotationAngle);
-    const coefficients = this.getCoefficientOfTTermsWithControlPoints(alignedControlPoints);
-    let yCoefficients = [0, 0, 0, 0];
-    coefficients.forEach((coefficient, index) => {
-      yCoefficients[3 - index] = coefficient.y;
-    });
-    const yRoots = solveCubic(yCoefficients[0], yCoefficients[1], yCoefficients[2], yCoefficients[3]);
-    yRoots.forEach((root) => {
-      if (root >= 0 && root <= 1) {
-        if (line.pointInLine(this.get(root))) {
-          res.push(root);
-        }
-      }
-    });
-    return res;
-  }
-  getSelfIntersections() {
-    const [subCurveControlPoints1, subCurveControlPoints2] = this.split(0.5);
-    const subCurve1 = new BCurve(subCurveControlPoints1);
-    const subCurve2 = new BCurve(subCurveControlPoints2);
-    let initialRes = getIntersectionsBetweenCurves(subCurve1, subCurve2);
-    initialRes.forEach((intersection) => {
-      intersection.selfT = intersection.selfT * 0.5;
-      intersection.otherT = intersection.otherT * 0.5 + 0.5;
-    });
-    initialRes.shift();
-    return initialRes;
-  }
-  getCircleIntersections(circleCenter, circleRadius) {
-    const LUT = this.getLUTWithTVal(500);
-    let distanceError = Number.MAX_VALUE;
-    let preliminaryIntersectionIndex = 0;
-    let preliminaryIntersectionPoint = LUT[0].point;
-    let preliminaryIntersectionTVal = LUT[0].tVal;
-    LUT.forEach((curvePoint, index) => {
-      let curDistanceError = Math.abs(PointCal.distanceBetweenPoints(circleCenter, curvePoint.point));
-      if (curDistanceError < distanceError) {
-        distanceError = curDistanceError;
-        preliminaryIntersectionIndex = index;
-      }
-    });
-    const LUTD = LUT.map((curvePoint, index) => {
-      return { ...curvePoint, distance: 0 };
-    });
-    distanceError = Number.MAX_VALUE;
-    let start = 0;
-    let count = 0;
-    let indices = [];
-    while (++count < 25) {
-      let i = this.findClosest(circleCenter.x, circleCenter.y, LUTD, circleRadius, 5, LUTD[start - 2]?.distance, LUTD[start - 1]?.distance);
-      if (i < start)
-        break;
-      if (i > 0 && i == start)
-        break;
-      indices.push(i);
-      start = i + 2;
-    }
-    const finalList = [];
-    indices.forEach((index) => {
-      let res = this.refineBinary(this, circleCenter.x, circleCenter.y, LUTD, index, circleRadius);
-      if (res != null) {
-        finalList.push({ intersection: res.point, tVal: res.tVal });
-      }
-    });
-    return finalList;
-  }
-  advanceAtTWithLength(tVal, length) {
-    const currentLength = this.lengthAtT(tVal);
-    const targetLength = currentLength + length;
-    if (tVal === 0 && length < 0) {
-      return { type: "beforeCurve", remainLength: -length };
-    }
-    if (tVal === 1 && length > 0) {
-      return { type: "afterCurve", remainLength: length };
-    }
-    if (targetLength > this.fullLength) {
-      return { type: "afterCurve", remainLength: targetLength - this.fullLength };
-    } else if (targetLength < 0) {
-      return { type: "beforeCurve", remainLength: -targetLength };
-    }
-    if (this.arcLengthLUT.arcLengthLUT.length === 0) {
-      this.arcLengthLUT = this.getArcLengthLUT(1000);
-    }
-    const points = this.arcLengthLUT.arcLengthLUT;
-    let low = 0;
-    let high = points.length - 1;
-    while (low <= high) {
-      const mid = Math.floor((low + high) / 2);
-      const midLength = points[mid].length;
-      if (approximately(midLength, targetLength, 0.01)) {
-        const resultTVal = points[mid].tVal;
-        const point2 = this.get(resultTVal);
-        return { type: "withinCurve", tVal: resultTVal, point: point2 };
-      } else if (midLength < targetLength) {
-        low = mid + 1;
-      } else {
-        high = mid - 1;
-      }
-    }
-    if (high < 0) {
-      high = 1;
-      low = 0;
-    }
-    if (low >= points.length) {
-      high = points.length - 1;
-      low = points.length - 2;
-    }
-    const p1 = points[high];
-    const p2 = points[low];
-    const lengthRange = p2.length - p1.length;
-    const tRange = p2.tVal - p1.tVal;
-    if (lengthRange === 0) {
-      const point2 = this.get(p1.tVal);
-      return { type: "withinCurve", tVal: p1.tVal, point: point2 };
-    }
-    const ratio = (targetLength - p1.length) / lengthRange;
-    const interpolatedT = p1.tVal + ratio * tRange;
-    const clampedT = Math.max(0, Math.min(1, interpolatedT));
-    const point = this.get(clampedT);
-    return { type: "withinCurve", tVal: clampedT, point };
-  }
-  advanceByDistance(startT, distance) {
-    let currentT = startT;
-    let remainingDistance = distance;
-    const stepSize = 0.01;
-    if (distance > this.fullLength) {
-      return { type: "afterCurve", remainLength: distance - this.fullLength };
-    } else if (distance < 0) {
-      return { type: "beforeCurve", remainLength: -distance };
-    }
-    while (remainingDistance > 0 && currentT < 1) {
-      const currentPoint = this.get(currentT);
-      const nextT = Math.min(currentT + stepSize, 1);
-      const nextPoint = this.get(nextT);
-      const segmentLength = Math.sqrt(Math.pow(nextPoint.x - currentPoint.x, 2) + Math.pow(nextPoint.y - currentPoint.y, 2));
-      if (segmentLength >= remainingDistance) {
-        const ratio = remainingDistance / segmentLength;
-        return { type: "withinCurve", tVal: currentT + ratio * (nextT - currentT), point: this.get(currentT + ratio * (nextT - currentT)) };
-      }
-      remainingDistance -= segmentLength;
-      currentT = nextT;
-    }
-    return { type: "withinCurve", tVal: currentT, point: this.get(currentT) };
-  }
-  refineBinary(curve, x, y, LUT, i, targetDistance = 0, epsilon = 0.01) {
-    let q = LUT[i], count = 1, distance = Number.MAX_SAFE_INTEGER;
-    do {
-      let i1 = i === 0 ? 0 : i - 1, i2 = i === LUT.length - 1 ? LUT.length - 1 : i + 1, t1 = LUT[i1].tVal, t2 = LUT[i2].tVal, lut = [], step = (t2 - t1) / 4;
-      if (step < 0.001)
-        break;
-      lut.push(LUT[i1]);
-      for (let j = 1;j <= 3; j++) {
-        let n = curve.get(t1 + j * step);
-        let nDistance = Math.abs(PointCal.distanceBetweenPoints(n, { x, y }) - targetDistance);
-        if (nDistance < distance) {
-          distance = nDistance;
-          q = { point: n, tVal: t1 + j * step, distance: nDistance };
-          i = j;
-        }
-        lut.push({ point: n, tVal: t1 + j * step, distance: nDistance });
-      }
-      lut.push(LUT[i2]);
-      LUT = lut;
-    } while (count++ < 25);
-    if (targetDistance && distance > epsilon) {
-      q = undefined;
-    }
-    return q;
-  }
-  findClosest(x, y, LUT, circleRadius, distanceEpsilon = 5, pd2, pd1) {
-    let distance = Number.MAX_SAFE_INTEGER, prevDistance2 = pd2 || distance, prevDistance1 = pd1 || distance, i = -1;
-    for (let index = 0, e = LUT.length;index < e; index++) {
-      let p = LUT[index].point;
-      LUT[index].distance = Math.abs(PointCal.distanceBetweenPoints({ x, y }, p) - circleRadius);
-      if (prevDistance1 < distanceEpsilon && prevDistance2 > prevDistance1 && prevDistance1 < LUT[index].distance) {
-        i = index - 1;
-        break;
-      }
-      if (LUT[index].distance < distance) {
-        distance = LUT[index].distance;
-      }
-      prevDistance2 = prevDistance1;
-      prevDistance1 = LUT[index].distance;
-    }
-    return i;
-  }
-  getCurveIntersections(curve, deduplicationTolerance) {
-    return getIntersectionsBetweenCurves(this, curve, deduplicationTolerance);
-  }
-  get AABB() {
-    const extrema = this.getExtrema();
-    const tVals = [0, 1];
-    let min = { x: Number.MAX_VALUE, y: Number.MAX_VALUE };
-    let max = { x: -Number.MAX_VALUE, y: -Number.MAX_VALUE };
-    extrema.x.forEach((tVal) => {
-      tVals.push(tVal);
-    });
-    extrema.y.forEach((tVal) => {
-      tVals.push(tVal);
-    });
-    tVals.forEach((tVal) => {
-      const curPoint = this.get(tVal);
-      min.x = Math.min(min.x, curPoint.x);
-      min.y = Math.min(min.y, curPoint.y);
-      max.x = Math.max(max.x, curPoint.x);
-      max.y = Math.max(max.y, curPoint.y);
-    });
-    return { min, max };
-  }
-  normal(tVal) {
-    const d = this.derivative(tVal);
-    const q = Math.sqrt(d.x * d.x + d.y * d.y);
-    return { tVal, direction: { x: -d.y / q, y: d.x / q } };
-  }
-}
-function reduce(curve) {
-  let i, t1 = 0, t2 = 0, step = 0.01, segment, pass1 = [], pass2 = [];
-  let extrema = curve.getExtrema().x;
-  if (extrema.indexOf(0) === -1) {
-    extrema = [0].concat(extrema);
-  }
-  if (extrema.indexOf(1) === -1) {
-    extrema.push(1);
-  }
-  for (t1 = extrema[0], i = 1;i < extrema.length; i++) {
-    t2 = extrema[i];
-    segment = curve.splitAndTakeMidCurve(t1, t2);
-    pass1.push(segment);
-    t1 = t2;
-  }
-  pass1.forEach((p1) => {
-    t1 = 0;
-    t2 = 0;
-    while (t2 <= 1) {
-      for (t2 = t1 + step;t2 <= 1 + step; t2 += step) {
-        const clampedT2 = Math.min(t2, 1);
-        segment = p1.splitAndTakeMidCurve(t1, clampedT2);
-        if (!curveIsSimple(segment)) {
-          t2 -= step;
-          if (Math.abs(t1 - t2) < step) {
-            return [];
-          }
-          const finalT2 = Math.min(t2, 1);
-          segment = p1.splitAndTakeMidCurve(t1, finalT2);
-          pass2.push(segment);
-          t1 = finalT2;
-          break;
-        }
-      }
-    }
-    if (t1 < 1) {
-      segment = p1.splitAndTakeMidCurve(t1, 1);
-      pass2.push(segment);
-    }
-  });
-  return pass2;
-}
-function raiseCurveOrder(curve) {
-  const p = curve.getControlPoints(), np = [p[0]], k = p.length;
-  for (let i = 1;i < k; i++) {
-    const pi = p[i];
-    const pim = p[i - 1];
-    np[i] = {
-      x: (k - i) / k * pi.x + i / k * pim.x,
-      y: (k - i) / k * pi.y + i / k * pim.y
-    };
-  }
-  np[k] = p[k - 1];
-  return new BCurve(np);
-}
-function offset(curve, t, d) {
-  if (d !== undefined) {
-    const c = curve.get(t), n = curve.normal(t).direction;
-    const ret = {
-      c,
-      n,
-      x: c.x + n.x * d,
-      y: c.y + n.y * d
-    };
-    return ret;
-  }
-  const points = curve.getControlPoints();
-  const linear = curveIsLinear(curve);
-  if (linear) {
-    const nv = curve.normal(0).direction, coords = points.map(function(p) {
-      const ret = {
-        x: p.x + t * nv.x,
-        y: p.y + t * nv.y
-      };
-      return ret;
-    });
-    return [new BCurve(coords)];
-  }
-  return reduce(curve).map(function(s) {
-    if (curveIsLinear(s)) {
-      return offset(s, t)[0];
-    }
-    return scaleCurve(s, t);
-  });
-}
-function offset2(curve, d) {
-  const lut = curve.getLUTWithTVal(100);
-  const res = lut.map((item) => {
-    const derivative = PointCal.unitVector(curve.derivative(item.tVal));
-    const normal = { x: -derivative.y, y: derivative.x };
-    const offsetPoint = { x: item.point.x + normal.x * d, y: item.point.y + normal.y * d };
-    return offsetPoint;
-  });
-  return res;
-}
-function lli4(p1, p2, p3, p4) {
-  const { x: x1, y: y1 } = p1, x2 = p2.x, y2 = p2.y, x3 = p3.x, y3 = p3.y, x4 = p4.x, y4 = p4.y;
-  return lli8(x1, y1, x2, y2, x3, y3, x4, y4);
-}
-function lli8(x1, y1, x2, y2, x3, y3, x4, y4) {
-  const nx = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4);
-  const ny = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4);
-  const d = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
-  if (d == 0) {
-    return false;
-  }
-  return { x: nx / d, y: ny / d };
-}
-function curveIsLinear(curve) {
-  const order = curve.getControlPoints().length - 1;
-  const points = curve.getControlPoints();
-  const alignedPoints = alignPointsToLine(points, { p1: points[0], p2: points[order] });
-  const baseLength = PointCal.distanceBetweenPoints(points[0], points[order]);
-  const linear = alignedPoints.reduce((t, p) => t + Math.abs(p.y), 0) < baseLength / 50;
-  return linear;
-}
-function scaleCurve(curve, d) {
-  const order = curve.getControlPoints().length - 1;
-  let distanceFn = undefined;
-  if (typeof d === "function") {
-    distanceFn = d;
-  }
-  if (distanceFn && order === 2) {
-    return scaleCurve(raiseCurveOrder(curve), distanceFn);
-  }
-  const points = curve.getControlPoints();
-  if (curveIsLinear(curve)) {
-    return translate(curve, curve.normal(0).direction, distanceFn ? distanceFn(0) : d, distanceFn ? distanceFn(1) : d);
-  }
-  const r1 = distanceFn ? distanceFn(0) : d;
-  const r2 = distanceFn ? distanceFn(1) : d;
-  const v = [offset(curve, 0, 10), offset(curve, 1, 10)];
-  const np = [];
-  const o = lli4(v[0], v[0].c, v[1], v[1].c);
-  if (!o) {
-    return translate(curve, curve.normal(0).direction, r1, r2);
-  }
-  [0, 1].forEach(function(t) {
-    const p = JSON.parse(JSON.stringify(points[t * order]));
-    const vt = v[t];
-    p.x += (t ? r2 : r1) * vt.n.x;
-    p.y += (t ? r2 : r1) * vt.n.y;
-    np[t * order] = p;
-  });
-  if (!distanceFn) {
-    [0, 1].forEach((t) => {
-      if (order === 2 && !!t)
-        return;
-      const p = np[t * order];
-      const derivativeAtT = curve.derivative(t);
-      const p2 = { x: p.x + derivativeAtT.x, y: p.y + derivativeAtT.y };
-      const intersection = lli4(p, p2, o, points[t + 1]);
-      if (intersection) {
-        np[t + 1] = intersection;
-      } else {
-        const originalPoint = points[t + 1];
-        const normal = curve.normal((t + 1) / order).direction;
-        np[t + 1] = {
-          x: originalPoint.x + (t ? r2 : r1) * normal.x,
-          y: originalPoint.y + (t ? r2 : r1) * normal.y
-        };
-      }
-    });
-    return new BCurve(np);
-  }
-  [0, 1].forEach(function(t) {
-    if (order === 2 && !!t)
-      return;
-    const p = points[t + 1];
-    const ov = {
-      x: p.x - o.x,
-      y: p.y - o.y
-    };
-    let rc = distanceFn((t + 1) / order);
-    const m = Math.sqrt(ov.x * ov.x + ov.y * ov.y);
-    ov.x /= m;
-    ov.y /= m;
-    np[t + 1] = {
-      x: p.x + rc * ov.x,
-      y: p.y + rc * ov.y
-    };
-  });
-  return new BCurve(np);
-}
-function alignPointsToLine(points, line) {
-  const tx = line.p1.x, ty = line.p1.y, a = -Math.atan2(line.p2.y - ty, line.p2.x - tx), d = function(v) {
-    return {
-      x: (v.x - tx) * Math.cos(a) - (v.y - ty) * Math.sin(a),
-      y: (v.x - tx) * Math.sin(a) + (v.y - ty) * Math.cos(a)
-    };
-  };
-  return points.map(d);
-}
-function map(v, ds, de, ts, te) {
-  const d1 = de - ds, d2 = te - ts, v2 = v - ds, r = v2 / d1;
-  return ts + d2 * r;
-}
-
-class TValOutofBoundError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-function AABBIntersects(AABB1, AABB2) {
-  if (AABB1.min.x <= AABB2.max.x && AABB2.min.x <= AABB1.max.x && (AABB1.min.y <= AABB2.max.y && AABB2.min.y <= AABB1.max.y)) {
-    return true;
-  }
-  return false;
-}
-function approximately(a, b, precision) {
-  const epsilon = 0.000001;
-  return Math.abs(a - b) <= (precision || epsilon);
-}
-function cuberoot2(v) {
-  if (v < 0)
-    return -Math.pow(-v, 1 / 3);
-  return Math.pow(v, 1 / 3);
-}
-function accept(t) {
-  return 0 <= t && t <= 1;
-}
-function getCubicRoots(pa, pb, pc, pd) {
-  let a = 3 * pa - 6 * pb + 3 * pc, b = -3 * pa + 3 * pb, c = pa, d = -pa + 3 * pb - 3 * pc + pd;
-  if (approximately(d, 0)) {
-    if (approximately(a, 0)) {
-      if (approximately(b, 0)) {
-        return [];
-      }
-      return [-c / b].filter(accept);
-    }
-    let q3 = Math.sqrt(b * b - 4 * a * c), a2 = 2 * a;
-    return [(q3 - b) / a2, (-b - q3) / a2].filter(accept);
-  }
-  a /= d;
-  b /= d;
-  c /= d;
-  let p = (3 * b - a * a) / 3, p3 = p / 3, q = (2 * a * a * a - 9 * a * b + 27 * c) / 27, q2 = q / 2, discriminant = q2 * q2 + p3 * p3 * p3;
-  let u1, v1, root1, root2, root3;
-  if (discriminant < 0) {
-    let mp3 = -p / 3, mp33 = mp3 * mp3 * mp3, r = Math.sqrt(mp33), t = -q / (2 * r), cosphi = t < -1 ? -1 : t > 1 ? 1 : t, phi = Math.acos(cosphi), crtr = cuberoot2(r), t1 = 2 * crtr;
-    root1 = t1 * Math.cos(phi / 3) - a / 3;
-    root2 = t1 * Math.cos((phi + 2 * Math.PI) / 3) - a / 3;
-    root3 = t1 * Math.cos((phi + 4 * Math.PI) / 3) - a / 3;
-    return [root1, root2, root3].filter(accept);
-  }
-  if (discriminant === 0) {
-    u1 = q2 < 0 ? cuberoot2(-q2) : -cuberoot2(q2);
-    root1 = 2 * u1 - a / 3;
-    root2 = -u1 - a / 3;
-    return [root1, root2].filter(accept);
-  }
-  var sd = Math.sqrt(discriminant);
-  u1 = cuberoot2(sd - q2);
-  v1 = cuberoot2(sd + q2);
-  root1 = u1 - v1 - a / 3;
-  return [root1].filter(accept);
-}
-function getIntersectionsBetweenCurves(curve, curve2, deduplicationTolerance = 0.01) {
-  const threshold = 0.5;
-  let pairs = [{ curve1: { curve, startTVal: 0, endTVal: 1 }, curve2: { curve: curve2, startTVal: 0, endTVal: 1 } }];
-  const finalRes = [];
-  while (pairs.length > 0) {
-    let curLength = pairs.length;
-    for (let index = 0;index < curLength; index++) {
-      let pair = pairs.shift();
-      if (pair == undefined) {
-        break;
-      }
-      let aabb1 = pair.curve1.curve.AABB;
-      let aabb2 = pair.curve2.curve.AABB;
-      let intersects = AABBIntersects(aabb1, aabb2);
-      if (pair.curve1.curve.fullLength < threshold && pair.curve2.curve.fullLength < threshold) {
-        finalRes.push({ intersection: pair.curve1.curve.get(0.5), tVal1: (pair.curve1.startTVal + pair.curve1.endTVal) * 0.5, tVal2: (pair.curve2.startTVal + pair.curve2.endTVal) * 0.5 });
-        continue;
-      }
-      if (intersects) {
-        let [subCurveControlPoints1, subCurveControlPoints2] = pair.curve1.curve.split(0.5);
-        let [subCurveControlPoints3, subCurveControlPoints4] = pair.curve2.curve.split(0.5);
-        pairs.push({
-          curve1: {
-            curve: new BCurve(subCurveControlPoints1),
-            startTVal: pair.curve1.startTVal,
-            endTVal: pair.curve1.startTVal + (pair.curve1.endTVal - pair.curve1.startTVal) * 0.5
-          },
-          curve2: {
-            curve: new BCurve(subCurveControlPoints3),
-            startTVal: pair.curve2.startTVal,
-            endTVal: pair.curve2.startTVal + (pair.curve2.endTVal - pair.curve2.startTVal) * 0.5
-          }
-        });
-        pairs.push({
-          curve1: {
-            curve: new BCurve(subCurveControlPoints1),
-            startTVal: pair.curve1.startTVal,
-            endTVal: pair.curve1.startTVal + (pair.curve1.endTVal - pair.curve1.startTVal) * 0.5
-          },
-          curve2: {
-            curve: new BCurve(subCurveControlPoints4),
-            startTVal: pair.curve2.startTVal + (pair.curve2.endTVal - pair.curve2.startTVal) * 0.5,
-            endTVal: pair.curve2.endTVal
-          }
-        });
-        pairs.push({
-          curve1: {
-            curve: new BCurve(subCurveControlPoints2),
-            startTVal: pair.curve1.startTVal + (pair.curve1.endTVal - pair.curve1.startTVal) * 0.5,
-            endTVal: pair.curve1.endTVal
-          },
-          curve2: {
-            curve: new BCurve(subCurveControlPoints3),
-            startTVal: pair.curve2.startTVal,
-            endTVal: pair.curve2.startTVal + (pair.curve2.endTVal - pair.curve2.startTVal) * 0.5
-          }
-        });
-        pairs.push({
-          curve1: {
-            curve: new BCurve(subCurveControlPoints2),
-            startTVal: pair.curve1.startTVal + (pair.curve1.endTVal - pair.curve1.startTVal) * 0.5,
-            endTVal: pair.curve1.endTVal
-          },
-          curve2: {
-            curve: new BCurve(subCurveControlPoints4),
-            startTVal: pair.curve2.startTVal + (pair.curve2.endTVal - pair.curve2.startTVal) * 0.5,
-            endTVal: pair.curve2.endTVal
-          }
-        });
-      }
-    }
-  }
-  const tVals = [];
-  finalRes.sort((a, b) => a.tVal1 - b.tVal1);
-  for (const intersection of finalRes) {
-    let isDuplicate = false;
-    for (const existing of tVals) {
-      const selfTClose = approximately(intersection.tVal1, existing.selfT, deduplicationTolerance);
-      const otherTClose = approximately(intersection.tVal2, existing.otherT, deduplicationTolerance);
-      if (selfTClose && otherTClose) {
-        isDuplicate = true;
-        break;
-      }
-      const selfTVeryClose = approximately(intersection.tVal1, existing.selfT, deduplicationTolerance * 10);
-      const otherTVeryClose = approximately(intersection.tVal2, existing.otherT, deduplicationTolerance * 10);
-      if (selfTVeryClose || otherTVeryClose) {
-        const point1 = curve.get(intersection.tVal1);
-        const point2 = curve2.get(intersection.tVal2);
-        const existingPoint1 = curve.get(existing.selfT);
-        const existingPoint2 = curve2.get(existing.otherT);
-        const distance1 = PointCal.distanceBetweenPoints(point1, existingPoint1);
-        const distance2 = PointCal.distanceBetweenPoints(point2, existingPoint2);
-        if (distance1 < deduplicationTolerance * 100 && distance2 < deduplicationTolerance * 100) {
-          isDuplicate = true;
-          break;
-        }
-      }
-    }
-    if (!isDuplicate) {
-      tVals.push({ selfT: intersection.tVal1, otherT: intersection.tVal2 });
-    }
-  }
-  return tVals;
-}
-function solveCubic(a, b, c, d) {
-  if (Math.abs(a) < 0.00000001) {
-    a = b;
-    b = c;
-    c = d;
-    if (Math.abs(a) < 0.00000001) {
-      a = b;
-      b = c;
-      if (Math.abs(a) < 0.00000001)
-        return [];
-      return [-b / a];
-    }
-    let D = b * b - 4 * a * c;
-    if (Math.abs(D) < 0.00000001)
-      return [-b / (2 * a)];
-    else if (D > 0)
-      return [(-b + Math.sqrt(D)) / (2 * a), (-b - Math.sqrt(D)) / (2 * a)];
-    return [];
-  }
-  let p = (3 * a * c - b * b) / (3 * a * a);
-  let q = (2 * b * b * b - 9 * a * b * c + 27 * a * a * d) / (27 * a * a * a);
-  let roots;
-  if (Math.abs(p) < 0.00000001) {
-    roots = [cuberoot(-q)];
-  } else if (Math.abs(q) < 0.00000001) {
-    roots = [0].concat(p < 0 ? [Math.sqrt(-p), -Math.sqrt(-p)] : []);
-  } else {
-    let D = q * q / 4 + p * p * p / 27;
-    if (Math.abs(D) < 0.00000001) {
-      roots = [-1.5 * q / p, 3 * q / p];
-    } else if (D > 0) {
-      let u = cuberoot(-q / 2 - Math.sqrt(D));
-      let v = cuberoot(-q / 2 + Math.sqrt(D));
-      roots = [u - p / (3 * u)];
-    } else {
-      let u = 2 * Math.sqrt(-p / 3);
-      let t = Math.acos(3 * q / p / u) / 3;
-      let k = 2 * Math.PI / 3;
-      roots = [u * Math.cos(t), u * Math.cos(t - k), u * Math.cos(t - 2 * k)];
-    }
-  }
-  for (let i = 0;i < roots.length; i++)
-    roots[i] -= b / (3 * a);
-  return roots;
-}
-function cuberoot(x) {
-  var y = Math.pow(Math.abs(x), 1 / 3);
-  return x < 0 ? -y : y;
-}
-function computeWithControlPoints(tVal, controlPoints) {
-  let points = [...controlPoints];
-  while (points.length > 1) {
-    let lowerLevelPoints = points.slice(1);
-    for (let index = 0;index < lowerLevelPoints.length; index++) {
-      lowerLevelPoints[index] = PointCal.addVector(PointCal.multiplyVectorByScalar(points[index], 1 - tVal), PointCal.multiplyVectorByScalar(points[index + 1], tVal));
-    }
-    points = lowerLevelPoints;
-  }
-  return points[0];
-}
-function curveIsSimple(curve) {
-  if (curve.getControlPoints().length === 4) {
-    const points = curve.getControlPoints();
-    const p0ToP3Vector = PointCal.subVector(points[3], points[0]);
-    const p0ToP1Vector = PointCal.subVector(points[1], points[0]);
-    const p0ToP2Vector = PointCal.subVector(points[2], points[0]);
-    const a1 = PointCal.angleFromA2B(p0ToP3Vector, p0ToP1Vector);
-    const a2 = PointCal.angleFromA2B(p0ToP3Vector, p0ToP2Vector);
-    if (a1 > 0 && a2 < 0 || a1 < 0 && a2 > 0)
-      return false;
-  }
-  const n1 = curve.normal(0).direction;
-  const n2 = curve.normal(1).direction;
-  let s = n1.x * n2.x + n1.y * n2.y;
-  return Math.abs(Math.acos(s)) < Math.PI / 3;
-}
-function translate(curve, vector, d1, d2) {
-  const order = curve.getControlPoints().length - 1;
-  const points = curve.getControlPoints();
-  const d = points.map((_, i) => (1 - i / order) * d1 + i / order * d2);
-  return new BCurve(points.map((p, i) => ({ x: p.x + d[i] * vector.x, y: p.y + d[i] * vector.y })));
-}
-// src/line.ts
-import { PointCal as PointCal2 } from "@ue-too/math";
-
-class Line {
-  startPoint;
-  endPoint;
-  constructor(startPoint, endPoint) {
-    this.startPoint = startPoint;
-    this.endPoint = endPoint;
-  }
-  getStartPoint() {
-    return this.startPoint;
-  }
-  getEndPoint() {
-    return this.endPoint;
-  }
-  intersectionWithAnotherLine(lineToIntersect) {
-    return getLineIntersection(this.startPoint, this.endPoint, lineToIntersect.getStartPoint(), lineToIntersect.getEndPoint());
-  }
-  projectPoint(point) {
-    return projectPointOntoLine(point, this.getStartPoint(), this.getEndPoint());
-  }
-  length() {
-    return PointCal2.distanceBetweenPoints(this.startPoint, this.endPoint);
-  }
-  getTranslationRotationToAlginXAxis() {
-    const translation = PointCal2.subVector({ x: 0, y: 0 }, this.startPoint);
-    const rotationAngle = PointCal2.angleFromA2B(PointCal2.subVector(this.endPoint, this.startPoint), { x: 1, y: 0 });
-    return { translation, rotationAngle };
-  }
-  pointInLine(point) {
-    const baseVector = PointCal2.unitVectorFromA2B(this.startPoint, this.endPoint);
-    const start2PointVector = PointCal2.subVector(point, this.startPoint);
-    const length = PointCal2.dotProduct(start2PointVector, baseVector);
-    const start2PointUnitVector = PointCal2.unitVector(start2PointVector);
-    const errorThreshold = PointCal2.distanceBetweenPoints(this.startPoint, this.endPoint) * 0.0001;
-    return length <= PointCal2.distanceBetweenPoints(this.startPoint, this.endPoint) && length >= 0 && Math.abs(start2PointUnitVector.x - baseVector.x) < 0.0001 && Math.abs(start2PointUnitVector.y - baseVector.y) < 0.0001;
-  }
-  lerp(ratio) {
-    return PointCal2.linearInterpolation(this.startPoint, this.endPoint, ratio);
-  }
-}
-function getLineIntersection(startPoint, endPoint, startPoint2, endPoint2) {
-  const numerator = (endPoint2.x - startPoint2.x) * (startPoint.y - startPoint2.y) - (endPoint2.y - startPoint2.y) * (startPoint.x - startPoint2.x);
-  const denominator = (endPoint2.y - startPoint2.y) * (endPoint.x - startPoint.x) - (endPoint2.x - startPoint2.x) * (endPoint.y - startPoint.y);
-  if (denominator === 0) {
-    return { intersects: false };
-  }
-  const t = numerator / denominator;
-  if (t >= 0 && t <= 1) {
-    return {
-      intersects: true,
-      intersection: PointCal2.linearInterpolation(startPoint, endPoint, t),
-      offset: t
-    };
-  } else {
-    return {
-      intersects: false
-    };
-  }
-}
-function projectPointOntoLine(point, lineStartPoint, lineEndPoint) {
-  const baseVector = PointCal2.unitVector(PointCal2.subVector(lineEndPoint, lineStartPoint));
-  const vectorToPoint = PointCal2.subVector(point, lineStartPoint);
-  const res = PointCal2.dotProduct(vectorToPoint, baseVector);
-  if (res < 0 || res > PointCal2.magnitude(PointCal2.subVector(lineEndPoint, lineStartPoint))) {
-    return {
-      within: false
-    };
-  }
-  return {
-    within: true,
-    projectionPoint: PointCal2.addVector(lineStartPoint, PointCal2.multiplyVectorByScalar(baseVector, res)),
-    offset: res / PointCal2.magnitude(PointCal2.subVector(lineEndPoint, lineStartPoint))
-  };
-}
-// src/composite-curve.ts
-import { PointCal as PointCal3 } from "@ue-too/math";
-
-class ControlPoint {
-  position;
-  leftHandle;
-  rightHandle;
-  constructor(position, leftHandle, rightHandle) {
-    this.position = position;
-    this.leftHandle = leftHandle;
-    this.rightHandle = rightHandle;
-  }
-  setPosition(destinationPosition, prevControlPoint, nextControlPoint) {
-    let diff = PointCal3.subVector(destinationPosition, this.position);
-    this.position = destinationPosition;
-    this.leftHandle.position = PointCal3.addVector(this.leftHandle.position, diff);
-    this.rightHandle.position = PointCal3.addVector(this.rightHandle.position, diff);
-    if (this.leftHandle.type == "VECTOR" && prevControlPoint) {
-      let relativeVector = PointCal3.subVector(prevControlPoint.getPosition(), this.position);
-      relativeVector = PointCal3.multiplyVectorByScalar(relativeVector, 1 / 3);
-      this.leftHandle.position = PointCal3.addVector(this.position, relativeVector);
-      if (this.rightHandle.type == "ALIGNED") {
-        let relativeVector2 = PointCal3.subVector(this.rightHandle.position, this.position);
-        let mag = PointCal3.magnitude(relativeVector2);
-        let direction = PointCal3.unitVectorFromA2B(this.leftHandle.position, this.position);
-        this.rightHandle.position = PointCal3.addVector(this.position, PointCal3.multiplyVectorByScalar(direction, mag));
-      }
-    }
-    if (this.rightHandle.type == "VECTOR" && nextControlPoint) {
-      let relativeVector = PointCal3.subVector(nextControlPoint.getPosition(), this.position);
-      relativeVector = PointCal3.multiplyVectorByScalar(relativeVector, 1 / 3);
-      this.rightHandle.position = PointCal3.addVector(this.position, relativeVector);
-      if (this.leftHandle.type == "ALIGNED") {
-        let mag = PointCal3.distanceBetweenPoints(this.leftHandle.position, this.position);
-        let direction = PointCal3.subVector(this.position, this.rightHandle.position);
-        this.leftHandle.position = PointCal3.addVector(this.position, PointCal3.multiplyVectorByScalar(direction, mag));
-      }
-    }
-    if (prevControlPoint !== undefined && prevControlPoint.getRightHandle().type == "VECTOR") {
-      let relativeVector = PointCal3.subVector(this.position, prevControlPoint.getPosition());
-      relativeVector = PointCal3.multiplyVectorByScalar(relativeVector, 1 / 3);
-      prevControlPoint.setRightHandlePosition(PointCal3.addVector(prevControlPoint.getPosition(), relativeVector));
-    }
-    if (nextControlPoint !== undefined && nextControlPoint.getLeftHandle().type == "VECTOR") {
-      let relativeVector = PointCal3.subVector(this.position, nextControlPoint.getPosition());
-      relativeVector = PointCal3.multiplyVectorByScalar(relativeVector, 1 / 3);
-      nextControlPoint.setLeftHandlePosition(PointCal3.addVector(nextControlPoint.getPosition(), relativeVector));
-    }
-  }
-  getPosition() {
-    return this.position;
-  }
-  setLeftHandleTypeVector(prevControlPoint) {
-    if (this.rightHandle.type != "VECTOR") {
-      this.rightHandle.type = "FREE";
-    }
-    let relativeVector;
-    if (prevControlPoint == undefined) {
-      relativeVector = PointCal3.subVector(this.leftHandle.position, this.position);
-    } else {
-      relativeVector = PointCal3.subVector(prevControlPoint.getPosition(), this.position);
-      relativeVector = PointCal3.multiplyVectorByScalar(relativeVector, 1 / 3);
-    }
-    this.leftHandle.position = PointCal3.addVector(this.position, relativeVector);
-  }
-  setLeftHandleTypeAligned() {
-    this.leftHandle.type = "ALIGNED";
-    if (this.rightHandle.type == "VECTOR") {
-      let direction = PointCal3.unitVectorFromA2B(this.rightHandle.position, this.position);
-      let mag = PointCal3.distanceBetweenPoints(this.position, this.leftHandle.position);
-      this.leftHandle.position = PointCal3.addVector(this.position, PointCal3.multiplyVectorByScalar(direction, mag));
-    }
-  }
-  setLeftHandleTypeFree() {
-    this.leftHandle.type = "FREE";
-  }
-  setRightHandleTypeVector(nextControlPoint) {
-    if (this.leftHandle.type != "VECTOR") {
-      this.leftHandle.type = "FREE";
-    }
-    let relativeVector;
-    if (nextControlPoint == undefined) {
-      relativeVector = PointCal3.subVector(this.rightHandle.position, this.position);
-    } else {
-      relativeVector = PointCal3.subVector(nextControlPoint.getPosition(), this.position);
-      relativeVector = PointCal3.multiplyVectorByScalar(relativeVector, 1 / 3);
-    }
-    this.rightHandle.position = PointCal3.addVector(this.position, relativeVector);
-  }
-  setRightHandleTypeAligned() {
-    this.rightHandle.type = "ALIGNED";
-    if (this.leftHandle.type == "VECTOR") {
-      let direciton = PointCal3.unitVectorFromA2B(this.leftHandle.position, this.position);
-      let mag = PointCal3.distanceBetweenPoints(this.position, this.rightHandle.position);
-      this.rightHandle.position = PointCal3.addVector(this.position, PointCal3.multiplyVectorByScalar(direciton, mag));
-    }
-  }
-  setRightHandleTypeFree() {
-    this.rightHandle.type = "FREE";
-  }
-  setLeftHandlePosition(destPos) {
-    let leftHandleType = this.leftHandle.type;
-    switch (leftHandleType) {
-      case "ALIGNED":
-        if (this.rightHandle.type == "VECTOR") {
-          let diff = PointCal3.subVector(destPos, this.position);
-          let rightHandleDiff = PointCal3.unitVectorFromA2B(this.rightHandle.position, this.position);
-          let resMag = PointCal3.dotProduct(diff, rightHandleDiff);
-          let res = PointCal3.multiplyVectorByScalar(rightHandleDiff, resMag);
-          this.leftHandle.position = PointCal3.addVector(this.position, res);
-        } else if (this.rightHandle.type == "ALIGNED") {
-          this.leftHandle.position = destPos;
-          let mag = PointCal3.distanceBetweenPoints(this.rightHandle.position, this.position);
-          let direction = PointCal3.unitVectorFromA2B(this.leftHandle.position, this.position);
-          let res = PointCal3.multiplyVectorByScalar(direction, mag);
-          this.rightHandle.position = PointCal3.addVector(res, this.position);
-        } else {
-          this.leftHandle.position = destPos;
-        }
-        break;
-      case "FREE":
-        this.leftHandle.position = destPos;
-        break;
-      case "VECTOR":
-        break;
-      default:
-        throw new Error(`Unknown left handle type for control point`);
-    }
-  }
-  setRightHandlePosition(destPos) {
-    let rightHandleType = this.rightHandle.type;
-    switch (rightHandleType) {
-      case "ALIGNED":
-        if (this.leftHandle.type == "VECTOR") {
-          let diff = PointCal3.subVector(destPos, this.position);
-          let leftHandleDiff = PointCal3.unitVectorFromA2B(this.leftHandle.position, this.position);
-          let resMag = PointCal3.dotProduct(diff, leftHandleDiff);
-          let res = PointCal3.multiplyVectorByScalar(leftHandleDiff, resMag);
-          this.rightHandle.position = PointCal3.addVector(this.position, res);
-        } else if (this.rightHandle.type == "ALIGNED") {
-          this.rightHandle.position = destPos;
-          let mag = PointCal3.distanceBetweenPoints(this.leftHandle.position, this.position);
-          let direction = PointCal3.unitVectorFromA2B(this.rightHandle.position, this.position);
-          let res = PointCal3.multiplyVectorByScalar(direction, mag);
-          this.leftHandle.position = PointCal3.addVector(res, this.position);
-        } else {
-          this.rightHandle.position = destPos;
-        }
-        break;
-      case "FREE":
-        this.rightHandle.position = destPos;
-        break;
-      case "VECTOR":
-        break;
-      default:
-        throw new Error(`Unknown left handle type for control point`);
-    }
-  }
-  getLeftHandle() {
-    return this.leftHandle;
-  }
-  getRightHandle() {
-    return this.rightHandle;
-  }
-}
-
-class CompositeBCurve {
-  controlPoints;
-  constructor(controlPoints = []) {
-    this.controlPoints = controlPoints;
-  }
-  getControlPoints() {
-    return this.controlPoints;
-  }
-  appendControlPoint(position) {
-    let leftHandlePosition = PointCal3.addVector(position, { x: -100, y: 0 });
-    let rightHandlePosition = PointCal3.addVector(position, { x: 100, y: 0 });
-    let leftHandlePoint = {
-      position: leftHandlePosition,
-      type: "FREE"
-    };
-    let rightHandlePoint = {
-      position: rightHandlePosition,
-      type: "FREE"
-    };
-    let newControlPoint = new ControlPoint(position, leftHandlePoint, rightHandlePoint);
-    this.controlPoints.push(newControlPoint);
-  }
-  setLeftHandlePositionOfControlPoint(controlPointIndex, destPos) {
-    if (controlPointIndex >= this.controlPoints.length || controlPointIndex < 0) {
-      return;
-    }
-    this.controlPoints[controlPointIndex].setLeftHandlePosition(destPos);
-  }
-  setRightHandlePositionOfControlPoint(controlPointIndex, destPos) {
-    if (controlPointIndex >= this.controlPoints.length || controlPointIndex < 0) {
-      return;
-    }
-    this.controlPoints[controlPointIndex].setRightHandlePosition(destPos);
-  }
-  setPositionOfControlPoint(controlPointIndex, destPos) {
-    if (controlPointIndex >= this.controlPoints.length || controlPointIndex < 0) {
-      return;
-    }
-    let prevControlPoint = undefined;
-    let nextControlPoint = undefined;
-    if (controlPointIndex + 1 < this.controlPoints.length) {
-      nextControlPoint = this.controlPoints[controlPointIndex + 1];
-    }
-    if (controlPointIndex - 1 >= 0) {
-      prevControlPoint = this.controlPoints[controlPointIndex - 1];
-    }
-    this.controlPoints[controlPointIndex].setPosition(destPos, prevControlPoint, nextControlPoint);
-  }
-}
-// src/path.ts
-class Path {
-  lines;
-  constructor(lines) {
-    this.lines = lines;
-  }
-  append(line) {
-    this.lines.push(line);
-  }
-  clear() {
-    this.lines = [];
-  }
-  prepend(line) {
-    this.lines.unshift(line);
-  }
-  getLines() {
-    return this.lines;
-  }
-  getLength() {
-    let res = 0;
-    this.lines.forEach((line) => {
-      res += line.length();
-    });
-    return res;
-  }
-  getPercentages() {
-    const length = this.getLength();
-    let currentCurvePercentage = 0;
-    const res = [];
-    this.lines.forEach((line) => {
-      const lineLength = line.length();
-      const linePercentage = lineLength / length;
-      let start = currentCurvePercentage;
-      currentCurvePercentage += linePercentage;
-      let end = currentCurvePercentage;
-      res.push({ start, end });
-    });
-    res[res.length - 1].end = 1;
-    return res;
-  }
-  getPointByPercentage(percentage) {
-    if (percentage < 0 || percentage > 1) {
-      throw new Error("Percentage must be between 0 and 1");
-    }
-    const percentages = this.getPercentages();
-    let left = 0;
-    let right = percentages.length - 1;
-    while (left <= right) {
-      const mid = Math.floor((left + right) / 2);
-      if (percentage < percentages[mid].end) {
-        right = mid - 1;
-      } else if (percentage > percentages[mid].end) {
-        left = mid + 1;
-      } else {
-        left = mid;
-        break;
-      }
-    }
-    const line = this.lines[left];
-    const linePercentage = percentages[left];
-    const ratio = (percentage - linePercentage.start) / (linePercentage.end - linePercentage.start);
-    return line.lerp(ratio);
-  }
-}
-export {
-  solveCubic,
-  reduce,
-  projectPointOntoLine,
-  offset2,
-  offset,
-  getLineIntersection,
-  getIntersectionsBetweenCurves,
-  getCubicRoots,
-  cuberoot2,
-  cuberoot,
-  computeWithControlPoints,
-  approximately,
-  accept,
-  TValOutofBoundError,
-  Path,
-  Line,
-  ControlPoint,
-  CompositeBCurve,
-  BCurve,
-  AABBIntersects
-};
-
-//# debugId=EABF32F5EF0F7EC864756E2164756E21
+//# debugId=B487176DCF176FA664756E2164756E21