@ue-too/curve 0.15.0 → 0.17.0

package/index.js

@@ -1,5 +1,1780 @@
-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((W,O,_)=>{return W||!$.isEqual(O,this.controlPoints[_])},!1);let N=[];if(G)this.arcLengthLUT=this.getArcLengthLUT(1000);N=[...this.arcLengthLUT.arcLengthLUT.map((W)=>W.length)];let Q=z*this.fullLength,k=0,J=N.length-1;while(k<=J){let W=Math.floor((k+J)/2);if(N[W]==Q)return this.get((W+1)/N.length);else if(N[W]<Q)k=W+1;else J=W-1}return k>=N.length?this.get(1):this.get((k+1)/N.length)}derivativeByPercentage(z){let G=this.arcLengthLUT.controlPoints.length!=this.controlPoints.length;G=G||this.arcLengthLUT.controlPoints.reduce((O,_,Z)=>{return O||!$.isEqual(_,this.controlPoints[Z])},!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,W;while(k<=J){let O=Math.floor((k+J)/2);if(N[O]==Q)return W=(O+1)/N.length,this.derivative(W);else if(N[O]<Q)k=O+1;else J=O-1}return W=k>=N.length?1:(k+1)/N.length,this.derivative(W)}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 d("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 W=0,O;W<Q;W++)O=N*v[W]+N,k+=a[W]*$.magnitude(this.derivative(O));let J=N*k;return this.lengthCache.set(G,J),J}derivative(z){return y(z,this.dControlPoints)}derivativeNormalized(z){return $.unitVector(y(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))),W=$.multiplyVectorByScalar(this.controlPoints[1],3*z*(z-1)*(z-1)),O=$.multiplyVectorByScalar(this.controlPoints[0],-((z-1)*(z-1)*(z-1))),_=$.addVector(O,$.addVector(W,$.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,W=this.getLUTWithTVal(500);W.forEach((Z,K)=>{let X=$.distanceBetweenPoints(Z.point,z);if(X<N)N=X,k={...Z.point},Q=Z.tVal,J=K});let O=W[J].tVal,_=W[J].tVal;if(J<W.length-1)_=W[J+1].tVal;if(J>0)O=W[J-1].tVal;while(O<_&&_-O>0.00001){let Z=O+(_-O)/2,K=Z-O,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,O=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,O=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 W=this.get(G),O=this.get(N),_=this.get(Q),Z=this.fitArc(W,O,_);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]],W=[[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]],O=0.5*(this.determinant3by3(k)/this.determinant3by3(Q)),_=-0.5*(this.determinant3by3(J)/this.determinant3by3(Q)),Z=Math.sqrt(O*O+_*_+this.determinant3by3(W)/this.determinant3by3(Q));return{exists:!0,center:{x:O,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],W=z[1][2],O=z[2][0],_=z[2][1],Z=z[2][2];return G*(J*Z-W*_)-N*(k*Z-O*W)+Q*(k*_-J*O)}curvature(z){let G=y(z,this.dControlPoints),N=y(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 y(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,W)=>{return{x:k.x+N[Q][W]*J.x,y:k.y+N[Q][W]*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),W=$.rotatePoint(J,-G);Q.push(W)}return Q}getExtrema(){let z={x:[],y:[]},G=this.getDerivativeCoefficients(),N=[0,0,0,0],Q=[0,0,0,0];G.forEach((W,O)=>{N[3-O]=W.x,Q[3-O]=W.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((W)=>{if(W>=0&&W<=1)z.x.push(W)}),J.forEach((W)=>{if(W>=0&&W<=1)z.y.push(W)}),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 O=w(N[0],N[1],N[2],N[3]),_=w(Q[0],Q[1],Q[2],Q[3]);O.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((O,_)=>{J[3-_]=O.y}),w(J[0],J[1],J[2],J[3]).forEach((O)=>{if(O>=0&&O<=1){if(z.pointInLine(this.get(O)))N.push(O)}}),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,W=N[0].tVal;N.forEach((F,H)=>{let E=Math.abs($.distanceBetweenPoints(z,F.point));if(E<Q)Q=E,k=H});let O=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,O,G,5,O[_-2]?.distance,O[_-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,O,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,W=k.length-1;while(J<=W){let B=Math.floor((J+W)/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 W=B-1}if(W<0)W=1,J=0;if(J>=k.length)W=k.length-1,J=k.length-2;let O=k[W],_=k[J],Z=_.length-O.length,K=_.tVal-O.tVal;if(Z===0){let B=this.get(O.tVal);return{type:"withinCurve",tVal:O.tVal,point:B}}let X=(Q-O.length)/Z,F=O.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),W=Math.min(N+k,1),O=this.get(W),_=Math.sqrt(Math.pow(O.x-J.x,2)+Math.pow(O.y-J.y,2));if(_>=Q){let Z=Q/_;return{type:"withinCurve",tVal:N+Z*(W-N),point:this.get(N+Z*(W-N))}}Q-=_,N=W}return{type:"withinCurve",tVal:N,point:this.get(N)}}refineBinary(z,G,N,Q,k,J=0,W=0.01){let O=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,O={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>W)O=void 0;return O}findClosest(z,G,N,Q,k=5,J,W){let O=Number.MAX_SAFE_INTEGER,_=J||O,Z=W||O,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<O)O=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,W=[],O=[],_=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),W.push(J),N=Q;return W.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),O.push(J),N=X;break}}if(N<1)J=Z.splitAndTakeMidCurve(N,1),O.push(J)}),O}function e(z){let G=z.getControlPoints(),N=[G[0]],Q=G.length;for(let k=1;k<Q;k++){let J=G[k],W=G[k-1];N[k]={x:(Q-k)/Q*J.x+k/Q*W.x,y:(Q-k)/Q*J.y+k/Q*W.y}}return N[Q]=G[Q-1],new j(N)}function g(z,G,N){if(N!==void 0){let J=z.get(G),W=z.normal(G).direction;return{c:J,n:W,x:J.x+W.x*N,y:J.y+W.y*N}}let Q=z.getControlPoints();if(f(z)){let J=z.normal(0).direction,W=Q.map(function(O){return{x:O.x+G*J.x,y:O.y+G*J.y}});return[new j(W)]}return r(z).map(function(J){if(f(J))return g(J,G)[0];return c(J,G)})}function O0(z,G){let Q=z.getLUTWithTVal(100).map((J)=>{let W=$.unitVector(z.derivative(J.tVal)),O={x:-W.y,y:W.x};return{x:J.point.x+O.x*G,y:J.point.y+O.y*G}}),k={min:{x:Q[0].x,y:Q[0].y},max:{x:Q[0].x,y:Q[0].y}};return Q.forEach((J)=>{if(J.x<k.min.x)k.min.x=J.x;if(J.x>k.max.x)k.max.x=J.x;if(J.y<k.min.y)k.min.y=J.y;if(J.y>k.max.y)k.max.y=J.y}),{points:Q,aabb:k}}function C(z,G,N,Q){let{x:k,y:J}=z,W=G.x,O=G.y,_=N.x,Z=N.y,K=Q.x,X=Q.y;return o(k,J,W,O,_,Z,K,X)}function o(z,G,N,Q,k,J,W,O){let _=(z*Q-G*N)*(k-W)-(z-N)*(k*O-J*W),Z=(z*Q-G*N)*(J-O)-(G-Q)*(k*O-J*W),K=(z-N)*(J-O)-(G-Q)*(k-W);if(K==0)return!1;return{x:_/K,y:Z/K}}function f(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((W,O)=>W+Math.abs(O.y),0)<k/50}function c(z,G){let N=z.getControlPoints().length-1,Q=void 0;if(typeof G==="function")Q=G;if(Q&&N===2)return c(e(z),Q);let k=z.getControlPoints();if(f(z))return p(z,z.normal(0).direction,Q?Q(0):G,Q?Q(1):G);let J=Q?Q(0):G,W=Q?Q(1):G,O=[g(z,0,10),g(z,1,10)],_=[],Z=C(O[0],O[0].c,O[1],O[1].c);if(!Z)return p(z,z.normal(0).direction,J,W);if([0,1].forEach(function(K){let X=JSON.parse(JSON.stringify(k[K*N])),F=O[K];X.x+=(K?W:J)*F.n.x,X.y+=(K?W: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?W:J)*q.x,y:B.y+(K?W: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(W){return{x:(W.x-N)*Math.cos(k)-(W.y-Q)*Math.sin(k),y:(W.x-N)*Math.sin(k)+(W.y-Q)*Math.cos(k)}};return z.map(J)}function x(z,G,N,Q,k){let J=N-G,W=k-Q,O=z-G,_=O/J;return Q+W*_}class d 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,W=z,O=-z+3*G-3*N+Q;if(D(O,0)){if(D(k,0)){if(D(J,0))return[];return[-W/J].filter(A)}let R=Math.sqrt(J*J-4*k*W),L=2*k;return[(R-J)/L,(-J-R)/L].filter(A)}k/=O,J/=O,W/=O;let _=(3*J-k*k)/3,Z=_/3,K=(2*k*k*k-9*k*J+27*W)/27,X=K/2,F=X*X+Z*Z*Z,H,E,B,q,M;if(F<0){let R=-_/3,L=R*R*R,m=Math.sqrt(L),b=-K/(2*m),s=b<-1?-1:b>1?1:b,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 O=k.length;for(let _=0;_<O;_++){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 W=[];J.sort((O,_)=>O.tVal1-_.tVal1);for(let O of J){let _=!1;for(let Z of W){let K=D(O.tVal1,Z.selfT,N),X=D(O.tVal2,Z.otherT,N);if(K&&X){_=!0;break}let F=D(O.tVal1,Z.selfT,N*10),H=D(O.tVal2,Z.otherT,N*10);if(F||H){let E=z.get(O.tVal1),B=G.get(O.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(!_)W.push({selfT:O.tVal1,otherT:O.tVal2})}return W}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 O=G*G-4*z*N;if(Math.abs(O)<0.00000001)return[-G/(2*z)];else if(O>0)return[(-G+Math.sqrt(O))/(2*z),(-G-Math.sqrt(O))/(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),W;if(Math.abs(k)<0.00000001)W=[u(-J)];else if(Math.abs(J)<0.00000001)W=[0].concat(k<0?[Math.sqrt(-k),-Math.sqrt(-k)]:[]);else{let O=J*J/4+k*k*k/27;if(Math.abs(O)<0.00000001)W=[-1.5*J/k,3*J/k];else if(O>0){let _=u(-J/2-Math.sqrt(O)),Z=u(-J/2+Math.sqrt(O));W=[_-k/(3*_)]}else{let _=2*Math.sqrt(-k/3),Z=Math.acos(3*J/k/_)/3,K=2*Math.PI/3;W=[_*Math.cos(Z),_*Math.cos(Z-K),_*Math.cos(Z-2*K)]}}for(let O=0;O<W.length;O++)W[O]-=G/(3*z);return W}function u(z){var G=Math.pow(Math.abs(z),0.3333333333333333);return z<0?-G:G}function y(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]),W=$.subVector(k[1],k[0]),O=$.subVector(k[2],k[0]),_=$.angleFromA2B(J,W),Z=$.angleFromA2B(J,O);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(),W=J.map((O,_)=>(1-_/k)*N+_/k*Q);return new j(J.map((O,_)=>({x:O.x+W[_]*G.x,y:O.y+W[_]*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 W=k/J;if(W>=0&&W<=1)return{intersects:!0,intersection:S.linearInterpolation(z,G,W),offset:W};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 P{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),W=Y.magnitude(J),O=Y.unitVectorFromA2B(this.leftHandle.position,this.position);this.rightHandle.position=Y.addVector(this.position,Y.multiplyVectorByScalar(O,W))}}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),W=Y.subVector(this.position,this.rightHandle.position);this.leftHandle.position=Y.addVector(this.position,Y.multiplyVectorByScalar(W,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 P(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,W=G;G+=J;let O=G;N.push({start:W,end:O})}),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 O=Math.floor((N+Q)/2);if(z<G[O].end)Q=O-1;else if(z>G[O].end)N=O+1;else{N=O;break}}let k=this.lines[N],J=G[N],W=(z-J.start)/(J.end-J.start);return k.lerp(W)}}export{w as solveCubic,r as reduce,N0 as projectPointOntoLine,O0 as offset2,g as offset,G0 as getLineIntersection,V as getIntersectionsBetweenCurves,W0 as getCubicRoots,U as cuberoot2,u as cuberoot,y as computeWithControlPoints,D as approximately,A as accept,d as TValOutofBoundError,k0 as Path,z0 as Line,P as ControlPoint,Q0 as CompositeBCurve,j as BCurve,i as AABBIntersects};
+// 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
+];
 
-//# debugId=601401469D08996164756E2164756E21
+class BCurve {
+  controlPoints;
+  dControlPoints = [];
+  arcLengthLUT = {
+    controlPoints: [],
+    arcLengthLUT: []
+  };
+  _fullLength;
+  static LENGTH_CACHE_MAX_SIZE = 2048;
+  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);
+  }
+  derivativeByPercentage(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;
+    let tVal;
+    while (low <= high) {
+      let mid = Math.floor((low + high) / 2);
+      if (points[mid] == targetLength) {
+        tVal = (mid + 1) / points.length;
+        return this.derivative(tVal);
+      } else if (points[mid] < targetLength) {
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    tVal = low >= points.length ? 1 : (low + 1) / points.length;
+    return this.derivative(tVal);
+  }
+  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;
+    if (this.lengthCache.size >= BCurve.LENGTH_CACHE_MAX_SIZE) {
+      const firstKey = this.lengthCache.keys().next().value;
+      this.lengthCache.delete(firstKey);
+    }
+    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;
+  }
+  getArcs(errorThreshold) {
+    return this.findArcs(errorThreshold);
+  }
+  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.000001)) {
+        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;
+  });
+  const aabb = {
+    min: { x: res[0].x, y: res[0].y },
+    max: { x: res[0].x, y: res[0].y }
+  };
+  res.forEach((offsetPoint) => {
+    if (offsetPoint.x < aabb.min.x) {
+      aabb.min.x = offsetPoint.x;
+    }
+    if (offsetPoint.x > aabb.max.x) {
+      aabb.max.x = offsetPoint.x;
+    }
+    if (offsetPoint.y < aabb.min.y) {
+      aabb.min.y = offsetPoint.y;
+    }
+    if (offsetPoint.y > aabb.max.y) {
+      aabb.max.y = offsetPoint.y;
+    }
+  });
+  return { points: res, aabb };
+}
+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=8C425ECBCBA1EB0F64756E2164756E21
 
 //# sourceMappingURL=index.js.map