Try to escape

trying

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

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

// Quaternion from Eular angles
// https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles
function quat(yaw,pitch,roll)
{
let cy = Math.cos(yaw*0.5);
let sy = Math.sin(yaw*0.5);
let cp = Math.cos(pitch*0.5);
let sp = Math.sin(pitch*0.5);
let cr = Math.cos(roll*0.5);
let sr = Math.sin(roll*0.5);

let w = cy * cp * cr + sy * sp * sr;
let x = cy * cp * sr - sy * sp * cr;
let y = sy * cp * sr + cy * sp * cr;
let z = sy * cp * cr - cy * sp * sr;

return [x,y,z,w];
}

// ref https://github.com/toji/gl-matrix/blob/master/src/mat4.js
// fromRotationTranslationScale
// matrix is stored in the row pattern
function make_transform(o,pos,quat,scale)
{
// scale temp vars
let sx = scale[0];
let sy = scale[1];
let sz = scale[2];

// translation temp vars
let tx = pos[0];
let ty = pos[1];
let tz = pos[2];

//Quat calc temp variables
let x = quat[0];
let y = quat[1];
let z = quat[2];
let w = quat[3];

let xx = x*x*2.0;
let xy = x*y*2.0;
let xz = x*z*2.0;
let wx = x*w*2.0;

let yy = y*y*2.0;
let yz = y*z*2.0;
let wy = y*w*2.0;

let zz = z*z*2.0;
let wz = z*w*2.0;

o[0] = (1-yy-zz)*sx;
o[1] = (xy-wz)*sy;
o[2] = (xz+wy)*sz;
o[3] = tx;
o[4] = (xy+wz)*sx;
o[5] = (1-xx-zz)*sy;
o[6] = (yz-wx)*sz;
o[7] = ty;
o[8] = (xz-wy)*sx;
o[9] = (yz+wx)*sy;
o[10] = (1-xx-yy)*sz;
o[11] = tz;
o[12] = 0;
o[13] = 0;
o[14] = 0;
o[15] = 1;

return o;
}

function transform_vector(v,m)
{
let x = v[0], y = v[1], z = v[2], w = v[3];
let o = [0, 0, 0, 0];
o[0] = m[0] * x + m[1] * y + m[2] * z + m[3] * w;
o[1] = m[4] * x + m[5] * y + m[6] * z + m[7] * w;
o[2] = m[8] * x + m[9] * y + m[10] * z + m[11] * w;
o[3] = m[12] * x + m[13] * y + m[14] * z + m[15] * w;
return o;
}

let focus = 200;
function project(v){
let x = v[0];
let y = v[1];
let z = v[2];
let s = focus/z;
return [x*s,y*s];
}

let Mesh = function(verts,edges,tsf)
{
let out = {}
out.verts = verts;
out.edges = edges;
out.transform = tsf
return out;
}

let PI = Math.PI;
let PI2 = Math.PI*2;

// fill in the ellipsoid vertice and edge list
{
let o = {};
o.edges = [];
o.verts = [];
let du = 1.0/nu;
let dv = 1.0/nv;
nu +=1;
nv +=1;
let u = 0,v = 0;
let i = 0,j = 0;

// push vertice
for(let i=0;i<nu;i++)
{
u = i*du;
for(let j=0;j<nv;j++)
{
v = j*dv;

let theta = u*PI;
let phi = v*PI2;

let ct = Math.cos(theta);
let st = Math.sin(theta);
let cp = Math.cos(phi);
let sp = Math.sin(phi);

o.verts.push([x,y,z,1.0]);

//o.verts.push([u,v,1.0,1.0]);
}
}

for(let i=0;i<nu;i++)
{
u = i*du;
for(let j=0;j<nv;j++)
{
v = j*dv;
let id = i*nv+j;
let inext = (i+1)%nu;
let jnext = (j+1)%nv;
let id_down = i*nv+jnext;
let id_right = inext*nv+j;

o.edges.push(id,id_down);
o.edges.push(id,id_right);
}

}
return o;
}

function draw_mesh(tctx,mesh)
{
let edges = mesh.edges;
let verts = mesh.verts;
let tsf = mesh.transform;

for (let i = 0, len = edges.length/2; i < len; i++) {

let i0 = edges[2*i];
let i1 = edges[2*i+1];

// perform transform
let v0 = transform_vector(verts[i0],tsf);
let v1 = transform_vector(verts[i1],tsf);

// projection
v0 = project(v0);
v1 = project(v1);

// draw edge
tctx.penup();
tctx.goto([v0[0],v0[1]]);
tctx.pendown();
tctx.goto([v1[0],v1[1]]);

}
}

function draw_mesh_substep(tctx,mesh,step)
{
let edges = mesh.edges;
let len = edges.length/2;
if(step>=len)
{
return false;
}

let verts = mesh.verts;
let tsf = mesh.transform;

let i0 = edges[2*step];
let i1 = edges[2*step+1];

// perform transform
let v0 = transform_vector(verts[i0],tsf);
let v1 = transform_vector(verts[i1],tsf);

// projection
v0 = project(v0);
v1 = project(v1);

// draw edge
tctx.penup();
tctx.goto([v0[0],v0[1]]);
tctx.pendown();
tctx.goto([v1[0],v1[1]]);
return true;
}

let scale = [1.0,1.0,1.0]
let rotation = quat(0.0,PI*0.2,0.26*PI);
let position = [0,0,60.];
//transfrom matrix
let transform = new Float32Array(16);
let transform2 = new Float32Array(16);

make_transform(transform,position,rotation,scale);
make_transform(transform2,[-7,16,70.],rotation,scale);

let core = make_ellipsoid(50,50,4,4,4,0.95);
let core_mesh = Mesh(core.verts,core.edges,transform2);

let eclip = make_ellipsoid(80,80,15,15,15,0.2);
let eclip_mesh = Mesh(eclip.verts,eclip.edges,transform2);

let eclip2 = make_ellipsoid(15,15,15*1.5,15*1.5,18*1.5,0.05);
let eclip_mesh2 = Mesh(eclip2.verts,eclip2.edges,transform);

let eclip3 = make_ellipsoid(15,15,15*1.5,15*1.5,18*1.5,0.05);
let eclip_mesh3 = Mesh(eclip3.verts,eclip3.edges,transform);

let eclip4 = make_ellipsoid(15,15,15*1.5,20*1.5,18*1.5,0.04);
let eclip_mesh4 = Mesh(eclip4.verts,eclip4.edges,transform);

let eclip5 = make_ellipsoid(15,15,15*1.5,20*1.5,18*1.5,0.04);
let eclip_mesh5 = Mesh(eclip5.verts,eclip5.edges,transform);

// The walk function will be called until it returns false.
function walk(i) {

//draw_mesh(turtle,bottle);
draw_mesh_substep(turtle,core_mesh,i);
let stop = draw_mesh_substep(turtle,eclip_mesh,i);
draw_mesh_substep(turtle,eclip_mesh2,i);
draw_mesh_substep(turtle,eclip_mesh3,i);
draw_mesh_substep(turtle,eclip_mesh4,i);
draw_mesh_substep(turtle,eclip_mesh5,i);
return stop;
}
```