const show = 0; //min=0 max=1 step=1 (Effect, Source image)
const effect = .5; //min=0 max=1 step=.01
const radius = 14; //min=5 max=30 step=.1
const rings = 17; //min=1 max=30 step=1
const xInterval = .88; //min=.5 max=1 step=.01
const yInterval = 1; //min=.5 max=3 step=.01
const centerIs = 0; //min=0 max=1 step=1 (White, Black)
const frame = 0; //min=0 max=2 step=2 (No, Yes)

// You can find the Turtle API reference here: https://turtletoy.net/syntax
Canvas.setpenopacity(1);

// Global code will be evaluated once.
turtlelib_init();
const turtle = new Turtle();
const polygons = new Polygons();

if(frame) ((polygons, turtle, border) => {if(border > 0){const brd = 100 - border;([[[-120, -brd], [120, -brd], [120, -120], [-120, -120]],[[brd, -120], [brd, 120], [120, 120], [120, -120]],[[-120, brd], [120, brd], [120, 120], [-120, 120]],[[-brd, -120], [-brd, 120], [-120, 120], [-120, -120]]]).forEach((b => {const p = polygons.create();p.addPoints(...b);polygons.draw(turtle, p);}));[[-1,-1],[1,-1],[1,1],[-1,1],[-1,-1]].forEach((i, k) => k == 0? turtle.jump(V.scale(i, brd)): turtle.goto(V.scale(i, brd)))}})(polygons,turtle,frame);

const colIncr = xInterval;
const colPtIncr = radius * 2 * colIncr;
const perRow = (200 / colPtIncr | 0) + 2;
const xOffset = (perRow * colPtIncr - 200) / 2;
const xC = Intersection.circles([0,0], radius, [radius * 2 * colIncr, 0], radius);
const rowPtIncr = xC.point_1[1] * yInterval;
const rows = (200 / rowPtIncr | 0) + 3;

const rIncr = radius / (rings - .5);

const ringArcs = Array.from({length: rings}, (e,i) => PT.circular(1, Math.max(12, (.5 + i + rIncr/2)*2*Math.PI|0)));
const imageData = getImageData();

// The walk function will be called until it returns false.
function walk(i) {
    if(show == 1) return walkImage(i);
    
    const col = i % perRow;
    const row = i / perRow | 0;
    
    const circleCenter = [
        -100 + col * colPtIncr + (row%2==0?0:colPtIncr/2) - xOffset,
        100 + radius - (row + 1) * rowPtIncr
    ];
    
    for(let j = 0; j < rings; j++) {
        const black = (centerIs + j) % 2 == 0;
        const ri = (.5 + j) * rIncr;
        
        const samples = ringArcs[j]
            .map(pt => V.add(V.scale(pt, ri), circleCenter))
            .map(pt => (getImageValueAt(pt) / 255 - .5) * (black?-effect:effect));

        const path = ringArcs[j].map((pt, i) => V.scale(pt, ri + samples[i] * rIncr));
             
        const p = polygons.create();
        p.addPoints(...path.map(pt => V.add(pt, circleCenter)));
        if(black) {
            p.addHatching(1, .15);
        }
        polygons.draw(turtle, p);
    }
    
    return row < rows - 1 || (row == rows - 1 && col < perRow - 1);
}

function getImageValueAt(canvasPt, square = 3) {
    const pt = V.add(canvasPt, [100, 100]).map(v => Math.round(v));
    const s = Math.floor(square/2);
    const pts = Array.from({length: square}).flatMap((e, c) => Array.from({length: square}, (e, r) => V.add(pt, [c-s, r-s]))).filter(pt => 0 <= pt[0] && pt[0] < imageData.width && 0 <= pt[1] && pt[1] < imageData.height);
    return pts.length == 0? 0: pts.map(pt => imageData.data[pt[0] + pt[1] * imageData.width]).reduce((a, c) => a + c, 0) / pts.length;
}

function walkImage(i) {
    const col = i % 200;
    const row = i / 200 | 0;

    const p = polygons.create();
    p.addPoints(...[[0, 0], [1, 0], [1, 1], [0, 1]].map(pt => V.add(pt, [col - 100, row - 100])));
    p.addHatching(1, getImageValueAt([col - 100, row - 100], 1) * .005);
    polygons.draw(turtle, p);
        
    return i < 200**2 - 1;
}

function getImageData() {
    return {width: 200, height: 200, data: atob(
        '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'
    ).split('').map(e => e.charCodeAt(0))};
}

// Below is automatically maintained by Turtlelib 1.0
// Changes below this comment might interfere with its correct functioning.
function turtlelib_init() {
	turtlelib_ns_80dcba45dd_Jurgen_Polygons();
	turtlelib_ns_c6665b0e9b_Jurgen_Vector_Math();
	turtlelib_ns_c5f8fa95ed_Jurgen_Intersection();
	turtlelib_ns_2d89bd6d64_Jurgen_Path_tools();
}
// Turtlelib Jurgen Polygons v 1 - start - {"id":"80dcba45dd","package":"Jurgen","name":"Polygons","version":"1"}
function turtlelib_ns_80dcba45dd_Jurgen_Polygons() {
////////////////////////////////////////////////////////////////
// Polygon Clipping utility code - Created by Reinder Nijhoff 2019
// (Polygon binning by Lionel Lemarie 2021) https://turtletoy.net/turtle/95f33bd383
// (Delegated Hatching by Jurgen Westerhof 2024) https://turtletoy.net/turtle/d068ad6040
// (Deferred Polygon Drawing by Jurgen Westerhof 2024) https://turtletoy.net/turtle/6f3d2bc0b5
// https://turtletoy.net/turtle/a5befa1f8d
//
// const polygons = new Polygons();
// const p = polygons.create();
// polygons.draw(turtle, p);
// polygons.list();
// polygons.startDeferSession();
// polygons.stopDeferring();
// polygons.finalizeDeferSession(turtle);
//
// p.addPoints(...[[x,y],]);
// p.addSegments(...[[x,y],]);
// p.addOutline();
// p.addHatching(angle, distance); OR p.addHatching(HatchObject); where HatchObject has a method 'hatch(PolygonClass, thisPolygonInstance)'
// p.inside([x,y]);
// p.boolean(polygon, diff = true);
// p.segment_intersect([x,y], [x,y], [x,y], [x,y]);
////////////////////////////////////////////////////////////////
function Polygons(){const t=[],s=25,e=Array.from({length:s**2},t=>[]),n=class{constructor(){this.cp=[],this.dp=[],this.aabb=[]}addPoints(...t){let s=1e5,e=-1e5,n=1e5,h=-1e5;(this.cp=[...this.cp,...t]).forEach(t=>{s=Math.min(s,t[0]),e=Math.max(e,t[0]),n=Math.min(n,t[1]),h=Math.max(h,t[1])}),this.aabb=[s,n,e,h]}addSegments(...t){t.forEach(t=>this.dp.push(t))}addOutline(){for(let t=0,s=this.cp.length;t<s;t++)this.dp.push(this.cp[t],this.cp[(t+1)%s])}draw(t){for(let s=0,e=this.dp.length;s<e;s+=2)t.jump(this.dp[s]),t.goto(this.dp[s+1])}addHatching(t, s) {if(typeof t == 'object') return t.hatch(n, this);const e=new n;e.cp.push([-1e5,-1e5],[1e5,-1e5],[1e5,1e5],[-1e5,1e5]);const h=Math.sin(t)*s,o=Math.cos(t)*s,a=200*Math.sin(t),i=200*Math.cos(t);for(let t=.5;t<150/s;t++) {e.dp.push([h*t+i,o*t-a],[h*t-i,o*t+a]);e.dp.push([-h*t+i,-o*t-a],[-h*t-i,-o*t+a]);}e.boolean(this,!1);this.dp=[...this.dp,...e.dp]}inside(t){let s=0;for(let e=0,n=this.cp.length;e<n;e++)this.segment_intersect(t,[.1,-1e3],this.cp[e],this.cp[(e+1)%n])&&s++;return 1&s}boolean(t,s=!0){const e=[];for(let n=0,h=this.dp.length;n<h;n+=2){const h=this.dp[n],o=this.dp[n+1],a=[];for(let s=0,e=t.cp.length;s<e;s++){const n=this.segment_intersect(h,o,t.cp[s],t.cp[(s+1)%e]);!1!==n&&a.push(n)}if(0===a.length)s===!t.inside(h)&&e.push(h,o);else{a.push(h,o);const n=o[0]-h[0],i=o[1]-h[1];a.sort((t,s)=>(t[0]-h[0])*n+(t[1]-h[1])*i-(s[0]-h[0])*n-(s[1]-h[1])*i);for(let n=0;n<a.length-1;n++)(a[n][0]-a[n+1][0])**2+(a[n][1]-a[n+1][1])**2>=.001&&s===!t.inside([(a[n][0]+a[n+1][0])/2,(a[n][1]+a[n+1][1])/2])&&e.push(a[n],a[n+1])}}return(this.dp=e).length>0}segment_intersect(t,s,e,n){const h=(n[1]-e[1])*(s[0]-t[0])-(n[0]-e[0])*(s[1]-t[1]);if(0===h)return!1;const o=((n[0]-e[0])*(t[1]-e[1])-(n[1]-e[1])*(t[0]-e[0]))/h,a=((s[0]-t[0])*(t[1]-e[1])-(s[1]-t[1])*(t[0]-e[0]))/h;return o>=0&&o<=1&&a>=0&&a<=1&&[t[0]+o*(s[0]-t[0]),t[1]+o*(s[1]-t[1])]}};const y=function(n,j=[]){const h={},o=200/s;for(var a=0;a<s;a++){const c=a*o-100,r=[0,c,200,c+o];if(!(n[3]<r[1]||n[1]>r[3]))for(var i=0;i<s;i++){const c=i*o-100;r[0]=c,r[2]=c+o,n[0]>r[2]||n[2]<r[0]||e[i+a*s].forEach(s=>{const e=t[s];n[3]<e.aabb[1]||n[1]>e.aabb[3]||n[0]>e.aabb[2]||n[2]<e.aabb[0]||j.includes(s)||(h[s]=1)})}}return Array.from(Object.keys(h),s=>t[s])};return{list:()=>t,create:()=>new n,draw:(n,h,o=!0)=>{rpl=y(h.aabb, this.dei === undefined? []: Array.from({length: t.length - this.dei}).map((e, i) => this.dsi + i));for(let t=0;t<rpl.length&&h.boolean(rpl[t]);t++);const td=n.isdown();if(this.dsi!==undefined&&this.dei===undefined)n.pu();h.draw(n),o&&function(n){t.push(n);const h=t.length-1,o=200/s;e.forEach((t,e)=>{const a=e%s*o-100,i=(e/s|0)*o-100,c=[a,i,a+o,i+o];c[3]<n.aabb[1]||c[1]>n.aabb[3]||c[0]>n.aabb[2]||c[2]<n.aabb[0]||t.push(h)})}(h);if(td)n.pd();},startDeferSession:()=>{if(this.dei!==undefined)throw new Error('Finalize deferring before starting new session');this.dsi=t.length;},stopDeferring:()=>{if(this.dsi === undefined)throw new Error('Start deferring before stopping');this.dei=t.length;},finalizeDeferSession:(n)=>{if(this.dei===undefined)throw new Error('Stop deferring before finalizing');for(let i=this.dsi;i<this.dei;i++) {rpl = y(t[i].aabb,Array.from({length:this.dei-this.dsi+1}).map((e,j)=>i+j));for(let j=0;j<rpl.length&&t[i].boolean(rpl[j]);j++);t[i].draw(n);}this.dsi=undefined;this.dei=undefined;}}}
this.Polygons = Polygons;
}
// Turtlelib Jurgen Polygons v 1 - end
// Turtlelib Jurgen Vector Math v 4 - start - {"id":"c6665b0e9b","package":"Jurgen","name":"Vector Math","version":"4"}
function turtlelib_ns_c6665b0e9b_Jurgen_Vector_Math() {
/////////////////////////////////////////////////////////
// Vector functions - Created by Jurgen Westerhof 2024 //
/////////////////////////////////////////////////////////
class Vector {
    static add  (a,b) { return a.map((v,i)=>v+b[i]); }
    static sub  (a,b) { return a.map((v,i)=>v-b[i]); }
    static mul  (a,b) { return a.map((v,i)=>v*b[i]); }
    static div  (a,b) { return a.map((v,i)=>v/b[i]); }
    static scale(a,s) { return a.map(v=>v*s); }

    static det(m)                { return m.length == 1? m[0][0]: m.length == 2 ? m[0][0]*m[1][1]-m[0][1]*m[1][0]: m[0].reduce((r,e,i) => r+(-1)**(i+2)*e*this.det(m.slice(1).map(c => c.filter((_,j) => i != j))),0); }
    static angle(a)              { return Math.PI - Math.atan2(a[1], -a[0]); } //compatible with turtletoy heading
    static rot2d(angle)          { return [[Math.cos(angle), -Math.sin(angle)], [Math.sin(angle), Math.cos(angle)]]; }
    static rot3d(yaw,pitch,roll) { return [[Math.cos(yaw)*Math.cos(pitch), Math.cos(yaw)*Math.sin(pitch)*Math.sin(roll)-Math.sin(yaw)*Math.cos(roll), Math.cos(yaw)*Math.sin(pitch)*Math.cos(roll)+Math.sin(yaw)*Math.sin(roll)],[Math.sin(yaw)*Math.cos(pitch), Math.sin(yaw)*Math.sin(pitch)*Math.sin(roll)+Math.cos(yaw)*Math.cos(roll), Math.sin(yaw)*Math.sin(pitch)*Math.cos(roll)-Math.cos(yaw)*Math.sin(roll)],[-Math.sin(pitch), Math.cos(pitch)*Math.sin(roll), Math.cos(pitch)*Math.cos(roll)]]; }
    static trans(matrix,a)       { return a.map((v,i) => a.reduce((acc, cur, ci) => acc + cur * matrix[ci][i], 0)); }
    //Mirror vector a in a ray through [0,0] with direction mirror
    static mirror2d(a,mirror)    { return [Math.atan2(...mirror)].map(angle => this.trans(this.rot2d(angle), this.mul([-1,1], this.trans(this.rot2d(-angle), a)))).pop(); }

    static equals(a,b)   { return !a.some((e, i) => e != b[i]); }
    static approx(a,b,p) { return this.len(this.sub(a,b)) < (p === undefined? .001: p); }
    static norm  (a)     { return this.scale(a,1/this.len(a)); }
    static len   (a)     { return Math.hypot(...a); }
    static lenSq (a)     { return a.reduce((a,c)=>a+c**2,0); }
    static lerp  (a,b,t) { return a.map((v, i) => v*(1-t) + b[i]*t); }
    static dist  (a,b)   { return Math.hypot(...this.sub(a,b)); }
    
    static dot  (a,b)   { return a.reduce((a,c,i) => a+c*b[i], 0); }
    static cross(...ab) { return ab[0].map((e, i) => ab.map(v => v.filter((ee, ii) => ii != i))).map((m,i) => (i%2==0?-1:1)*this.det(m)); }
    
    static clamp(a,min,max) { return a.map((e,i) => Math.min(Math.max(e, min[i]), max[i])) };
    static rotateClamp(a,min,max) { return a.map((e,i) => {const d = max[i]-min[i];if(d == 0) return min[i];while(e < min[i]) { e+=d; }while(e > max[i]) { e-=d; }return e;});
    }
}
this.V = Vector;
}
// Turtlelib Jurgen Vector Math v 4 - end
// Turtlelib Jurgen Intersection v 4 - start - {"id":"c5f8fa95ed","package":"Jurgen","name":"Intersection","version":"4"}
function turtlelib_ns_c5f8fa95ed_Jurgen_Intersection() {
///////////////////////////////////////////////////////////////
// Intersection functions - Created by Jurgen Westerhof 2024 //
///////////////////////////////////////////////////////////////
class Intersection {
    //a-start, a-direction, b-start, b-direction
    //returns false on no intersection or [[intersection:x,y], scalar a-direction, scalar b-direction
    static info(as, ad, bs, bd) { const d = V.sub(bs, as), det = -V.det([bd, ad]); if(det === 0) return false; const res = [V.det([d, bd]) / det, V.det([d, ad]) / det]; return [V.add(as, V.scale(ad, res[0])), ...res]; }
    static ray(a, b, c, d) { return this.info(a, b, c, d); }
    static segment(a,b,c,d, inclusiveStart = true, inclusiveEnd = true) { const i = this.info(a, V.sub(b, a), c, V.sub(d, c)); return i === false? false: ( (inclusiveStart? 0<=i[1] && 0<=i[2]: 0<i[1] && 0<i[2]) && (inclusiveEnd?   i[1]<=1 && i[2]<=1: i[1]<1 && i[2]<1) )?i[0]:false;}
    static tour(tour, segmentStart, segmentDirection) { return tour.map((e, i, a) => [i, this.info(e, V.sub(a[(i+1)%a.length], e), segmentStart, segmentDirection)]).filter(e => e[1] !== false && 0 <= e[1][1] && e[1][1] <= 1).filter(e => 0 <= e[1][2]).map(e => ({position: e[1][0],tourIndex: e[0],tourSegmentPortion: e[1][1],segmentPortion: e[1][2],}));}
    static inside(tour, pt) { return tour.map((e,i,a) => this.segment(e, a[(i+1)%a.length], pt, [Number.MAX_SAFE_INTEGER, 0], true, false)).filter(e => e !== false).length % 2 == 1; }
    static circles(centerA, radiusA, centerB, radiusB) {const result = {intersect_count: 0,intersect_occurs: true,one_is_in_other: false,are_equal: false,point_1: [null, null],point_2: [null, null],};const dx = centerB[0] - centerA[0];const dy = centerB[1] - centerA[1];const dist = Math.hypot(dy, dx);if (dist > radiusA + radiusB) {result.intersect_occurs = false;}if (dist < Math.abs(radiusA - radiusB) && !N.approx(dist, Math.abs(radiusA - radiusB))) {result.intersect_occurs = false;result.one_is_in_other = true;}if (V.approx(centerA, centerB) && radiusA === radiusB) {result.are_equal = true;}if (result.intersect_occurs) {const centroid = (radiusA**2 - radiusB**2 + dist * dist) / (2.0 * dist);const x2 = centerA[0] + (dx * centroid) / dist;const y2 = centerA[1] + (dy * centroid) / dist;const prec = 10000;const h = (Math.round(radiusA**2 * prec)/prec - Math.round(centroid**2 * prec)/prec)**.5;const rx = -dy * (h / dist);const ry = dx * (h / dist);result.point_1 = [x2 + rx, y2 + ry];result.point_2 = [x2 - rx, y2 - ry];if (result.are_equal) {result.intersect_count = Infinity;} else if (V.equals(result.point_1, result.point_2)) {result.intersect_count = 1;} else {result.intersect_count = 2;}}return result;}
}
this.Intersection = Intersection;
}
// Turtlelib Jurgen Intersection v 4 - end
// Turtlelib Jurgen Path tools v 3 - start - {"id":"2d89bd6d64","package":"Jurgen","name":"Path tools","version":"3"}
function turtlelib_ns_2d89bd6d64_Jurgen_Path_tools() {
///////////////////////////////////////////////////////
// Path functions - Created by Jurgen Westerhof 2024 //
///////////////////////////////////////////////////////
class PathTools {
    static bezier(p1, cp1, cp2, p2, steps = null) {steps = (steps === null? Math.max(3, (V.len(V.sub(cp1, p1)) + V.len(V.sub(cp2, cp1)) + V.len(V.sub(p2, cp2))) | 0): steps) - 1; return Array.from({length: steps + 1}).map((v, i, a, f = i/steps) => [[V.lerp(p1, cp1, f),V.lerp(cp1, cp2, f),V.lerp(cp2, p2, f)]].map(v => V.lerp(V.lerp(v[0], v[1], f), V.lerp(v[1], v[2], f), f))[0]);}
    // https://stackoverflow.com/questions/18655135/divide-bezier-curve-into-two-equal-halves#18681336
    static splitBezier(p1, cp1, cp2, p2, t=.5) {const e = V.lerp(p1, cp1, t);const f = V.lerp(cp1, cp2, t);const g = V.lerp(cp2, p2, t);const h = V.lerp(e, f, t);const j = V.lerp(f, g, t);const k = V.lerp(h, j, t);return [[p1, e, h, k], [k, j, g, p2]];}
    static circular(radius,verticeCount,rotation=0) {return Array.from({length: verticeCount}).map((e,i,a,f=i*2*Math.PI/verticeCount+rotation) => [radius*Math.cos(f),radius*Math.sin(f)])}
    static circle(r){return this.circular(r,Math.max(12, r*2*Math.PI|0));}
    static arc(radius, extend = 2 * Math.PI, clockWiseStart = 0, steps = null, includeLast = false) { return [steps == null? (radius*extend+1)|0: steps].map(steps => Array.from({length: steps}).map((v, i, a) => [radius * Math.cos(clockWiseStart + extend*i/(a.length-(includeLast?1:0))), radius * Math.sin(clockWiseStart + extend*i/(a.length-(includeLast?1:0)))])).pop(); }
    static draw(turtle, path) {path.forEach((pt, i) => turtle[i==0?'jump':'goto'](pt));}
    static drawTour(turtle, path) {this.draw(turtle, path.concat([path[0]]));}
    static drawPoint(turtle, pt, r = .1) {this.drawTour(turtle, this.circle(r).map(e => V.add(e, pt)));}
    static drawArrow(turtle, s, d, width = 6, length = 3) {turtle.jump(s);const arrowHeadBase = V.add(s,d);turtle.goto(arrowHeadBase);turtle.goto(V.add(arrowHeadBase, V.trans(V.rot2d(-V.angle(d)), [-length, width/2])));turtle.jump(V.add(arrowHeadBase, V.trans(V.rot2d(-V.angle(d)), [-length, -width/2])));turtle.goto(arrowHeadBase);}
    static circlesTangents(c1_center, c1_radius, c2_center, c2_radius, internal = false) {let middle_circle = [V.scale(V.sub(c1_center, c2_center), .5)].map(hwp => [V.add(c2_center, hwp), V.len(hwp)]).pop();if(!internal && c1_radius == c2_radius) {let target = V.sub(c2_center, c1_center);let scaledTarget = V.scale(target, c1_radius/V.len(target));let partResult = [V.add(c1_center, V.trans(V.rot2d(Math.PI/2), scaledTarget)),V.add(c1_center, V.trans(V.rot2d(Math.PI/-2), scaledTarget))];return [partResult,partResult.map(pt => V.add(pt, target))]}let swap = !internal && c2_radius > c1_radius;if(swap) {let t = [[...c1_center], c1_radius];c1_center = c2_center;c1_radius = c2_radius;c2_center = t[0];c2_radius = t[1];}let internal_waypoints = Intersection.circles(c1_center, c1_radius + (internal?c2_radius:-c2_radius), ...middle_circle);if(!internal_waypoints.intersect_occurs) return [];const circlePointAtDirection2 = (circle_center, radius, direction) => V.add(circle_center, V.scale(direction, radius/V.len(direction)));const result = [[circlePointAtDirection2(c1_center, c1_radius, V.sub(internal_waypoints.point_1, c1_center)),circlePointAtDirection2(c1_center, c1_radius, V.sub(internal_waypoints.point_2, c1_center))],[circlePointAtDirection2(c2_center, c2_radius, internal?V.sub(c1_center, internal_waypoints.point_1):V.sub(internal_waypoints.point_1, c1_center)),circlePointAtDirection2(c2_center, c2_radius, internal?V.sub(c1_center, internal_waypoints.point_2):V.sub(internal_waypoints.point_2, c1_center))]];return swap? [[result[1][1],result[1][0]],[result[0][1],result[0][0]]]: result;}
    static vectors(path) {return Array.from({length: path.length - 1}).map((e, i) => V.sub(path[i+1], path[i]));}
    static path(vectors) {return vectors.reduce((a,c) => a.length==0?[c]:[...a, V.add(c, a[a.length-1])], []);}
    static redistributeLinear(path, length = .5) {const p = path.map(pt => [...pt]);const result = [[...p[0]]];let pointer = 1;doneAll: while(pointer < p.length) {let l = length;while(pointer < p.length) {const distance = V.len(V.sub(p[pointer], p[pointer - 1]));if(distance < l) {l-=distance;pointer++;continue;}if(distance == l) {if(pointer < p.length - 1) result.push([...p[pointer]]);pointer++;break doneAll;}if(l < distance) {const newPoint = V.lerp(p[pointer-1], p[pointer], l/distance);if(pointer < p.length - 1) result.push([...newPoint]);p[pointer - 1] = newPoint;break;}}}result.push(p.pop());return result;}
    static length(path) { return this.lengths(path).reduce((c, a) => a + c, 0); }
    static lengths(path) { return path.map((e, i, a) => V.len(V.sub(e, a[(i+1)%a.length]))).filter((e, i, a) => i < a.length - 1); }
    static intersectInfoRay(path, origin, direction) {const vectors = this.vectors(path);const ri = vectors.map((e, i) => [i, Intersection.info(origin, direction, path[i], e)]).filter(e => 0 <= e[1][2] && e[1][2] <= 1 && 0 < e[1][1]).sort(e => e[1][1]);if(ri.length == 0) return false;const hit = ri[0];const lengths = this.lengths(path);const length = lengths.reduce((a, c) => a + c, 0);let l = 0;for(let i = 0; i < hit[0]; i++) {l += lengths[i];}return [hit[1][0], (l + (lengths[hit[0]] * hit[1][2])) / length, hit[1][1]];}
    static lerp(path, part) {if(part < 0 || 1 < part) throw new Error('Range of part is 0 to 1, got ' + path);const lengths = this.lengths(path);const length = lengths.reduce((a, c) => a + c, 0);let l = length * part;for(let i = 0; i < lengths.length; i++) {if(lengths[i] < l) {l-=lengths[i];continue;}return V.lerp(path[i], path[i+1], l / V.len(V.sub(path[i+1], path[i])));}return [...path[path.length - 1]];}
    static boundingBox(path) { return path.reduce((a, c) => [[Math.min(c[0], a[0][0]), Math.min(c[1], a[0][1])],[Math.max(c[0], a[1][0]), Math.max(c[1], a[1][1])]], [path[0], path[0]]); }
}
this.PT = PathTools;
}
// Turtlelib Jurgen Path tools v 3 - end