ByoungSooPark/modeling-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move the wasm lib, and cleanup rust directory and all references (#5585)

Browse Source 
* git mv src/wasm-lib rust

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* mv wasm-lib to workspace

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* mv kcl-lib

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* mv derive docs

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* resolve file paths

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* clippy

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* move more shit

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix more paths

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* make yarn build:wasm work

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix scripts

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fixups

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* better references

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix cargo ci

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix reference

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix more ci

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix tests

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* cargo sort

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix script

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fmt

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fix a dep

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* sort

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* remove unused deps

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* Revert "remove unused deps"

This reverts commit fbabdb062e275fd5cbc1476f8480a1afee15d972.

* updates

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* deps;

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* fixes

Signed-off-by: Jess Frazelle <github@jessfraz.com>

* updates

Signed-off-by: Jess Frazelle <github@jessfraz.com>

---------

Signed-off-by: Jess Frazelle <github@jessfraz.com>
This commit is contained in:
Jess Frazelle
2025-03-01 13:59:01 -08:00
committed by GitHub
parent 0a2bf4b55f
commit c3bdc6f106
1443 changed files with 509 additions and 4274 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160050
rust/kcl-lib/e2e/executor/inputs/2-5-long-m8-chc-screw.stl Normal file
View File

File diff suppressed because it is too large Load Diff

9
rust/kcl-lib/e2e/executor/inputs/angled_line.kcl Normal file
View File

@ -0,0 +1,9 @@
const part001 = startSketchOn('XY')
|> startProfileAt([4.83, 12.56], %)
|> line(end = [15.1, 2.48])
|> line(end = [3.15, -9.85], tag = $seg01)
|> line(end = [-15.17, -4.1])
|> angledLine([segAng(seg01), 12.35], %)
|> line(end = [-13.02, 10.03])
|> close()
|> extrude(length = 4)

8
rust/kcl-lib/e2e/executor/inputs/basic_fillet_cube_close_opposite.kcl Normal file
View File

@ -0,0 +1,8 @@
const part001 = startSketchOn('XY')
|> startProfileAt([0,0], %)
|> line(end = [0, 10], tag = $thing)
|> line(end = [10, 0])
|> line(end = [0, -10], tag = $thing2)
|> close(tag = $thing3)
|> extrude(length = 10)
|> fillet(radius = 2, tags = [thing3, getOppositeEdge(thing3)])

8
rust/kcl-lib/e2e/executor/inputs/basic_fillet_cube_end.kcl Normal file
View File

@ -0,0 +1,8 @@
const part001 = startSketchOn('XY')
|> startProfileAt([0,0], %)
|> line(end = [0, 10], tag = $thing)
|> line(end = [10, 0])
|> line(end = [0, -10], tag = $thing2)
|> close()
|> extrude(length = 10)
|> fillet(radius = 2, tags = [thing, getOppositeEdge(thing)])

8
rust/kcl-lib/e2e/executor/inputs/basic_fillet_cube_next_adjacent.kcl Normal file
View File

@ -0,0 +1,8 @@
const part001 = startSketchOn('XY')
|> startProfileAt([0,0], %)
|> line(end = [0, 10], tag = $thing)
|> line(end = [10, 0], tag = $thing1)
|> line(end = [0, -10], tag = $thing2)
|> close(tag = $thing3)
|> extrude(length = 10)
|> fillet(radius = 2, tags = [getNextAdjacentEdge(thing3)], %)

8
rust/kcl-lib/e2e/executor/inputs/basic_fillet_cube_previous_adjacent.kcl Normal file
View File

@ -0,0 +1,8 @@
const part001 = startSketchOn('XY')
|> startProfileAt([0,0], %)
|> line(end = [0, 10], tag = $thing)
|> line(end = [10, 0], tag = $thing1)
|> line(end = [0, -10], tag = $thing2)
|> close(tag = $thing3)
|> extrude(length = 10)
|> fillet(radius = 2, tags = [getPreviousAdjacentEdge(thing3)])

9
rust/kcl-lib/e2e/executor/inputs/basic_fillet_cube_start.kcl Normal file
View File

@ -0,0 +1,9 @@
const part001 = startSketchOn('XY')
|> startProfileAt([0,0], %)
|> line(end = [0, 10], tag = $thing)
|> line(end = [10, 0])
|> line(end = [0, -10], tag = $thing2)
|> close()
|> extrude(length = 10)
|> fillet(radius = 2, tags = [thing, thing2])

9
rust/kcl-lib/e2e/executor/inputs/big_number_angle_to_match_length_x.kcl Normal file
View File

@ -0,0 +1,9 @@
const part001 = startSketchOn('XY')
|> startProfileAt([0, 0], %)
|> line(end = [1, 3.82], tag = $seg01)
|> angledLineToX([
-angleToMatchLengthX(seg01, 3, %),
3
], %)
|> close()
|> extrude(length = 10)

9
rust/kcl-lib/e2e/executor/inputs/big_number_angle_to_match_length_y.kcl Normal file
View File

@ -0,0 +1,9 @@
const part001 = startSketchOn('XY')
|> startProfileAt([0, 0], %)
|> line(end = [1, 3.82], tag = $seg01)
|> angledLineToX([
-angleToMatchLengthY(seg01, 3, %),
3
], %)
|> close()
|> extrude(length = 10)

44
rust/kcl-lib/e2e/executor/inputs/broken-code-test.kcl Normal file
View File

@ -0,0 +1,44 @@
// Shelf Bracket
// This is a shelf bracket made out of 6061-T6 aluminum sheet metal. The required thickness is calculated based on a point load of 300 lbs applied to the end of the shelf. There are two brackets holding up the shelf, so the moment experienced is divided by 2. The shelf is 1 foot long from the wall.
// Define our bracket feet lengths
const shelfMountL = 8 // The length of the bracket holding up the shelf is 6 inches
const wallMountL = 6 // the length of the bracket
// Define constants required to calculate the thickness needed to support 300 lbs
const sigmaAllow = 35000 // psi
const width = 6 // inch
const p = 300 // Force on shelf - lbs
const L = 12 // inches
const M = L * p / 2 // Moment experienced at fixed end of bracket
const FOS = 2 // Factor of safety of 2 to be conservative
// Calculate the thickness off the bending stress and factor of safety
const thickness = sqrt(6 * M * FOS / (width * sigmaAllow))
// 0.25 inch fillet radius
const filletR = 0.25
// Sketch the bracket and extrude with fillets
const bracket = startSketchOn('XY')
|> startProfileAt([0, 0], %)
|> line(end = [0, wallMountL], tag = 'outerEdge')
|> line(end = [-shelfMountL, 0])
|> line(end = [0, -thickness])
|> line(end = [shelfMountL - thickness, 0], tag = 'innerEdge')
|> line(end = [0, -wallMountL + thickness])
|> close()
|> extrude(length = width)
|> fillet(
radius = filletR,
tags = [
getPreviousAdjacentEdge('innerEdge', %)
]
)
|> fillet(
radius = filletR + thickness,
tags = [
getPreviousAdjacentEdge('outerEdge', %)
]
)

23
rust/kcl-lib/e2e/executor/inputs/circular_pattern3d_a_pattern.kcl Normal file
View File

@ -0,0 +1,23 @@
exampleSketch = startSketchOn('XZ')
|> startProfileAt([0, 0], %)
|> line(end = [0, 2])
|> line(end = [3, 1])
|> line(end = [0, -4])
|> close()
|> extrude(length = 1)
pattn1 = patternLinear3d(
exampleSketch,
axis = [1, 0, 0],
instances = 7,
distance = 6,
)
pattn2 = patternCircular3d(
pattn1,
axis = [0,0, 1],
center = [-20, -20, -20],
instances = 41,
arcDegrees = 360,
rotateDuplicates = false,
)

9
rust/kcl-lib/e2e/executor/inputs/close_arc.kcl Normal file
View File

@ -0,0 +1,9 @@
const center = [0,0]
const radius = 40
const height = 3
const body = startSketchOn('XY')
|> startProfileAt([center[0]+radius, center[1]], %)
|> arc({angleEnd: 360, angleStart: 0, radius}, %)
|> close()
|> extrude(length = height)

16
rust/kcl-lib/e2e/executor/inputs/computed_var.kcl Normal file
View File

@ -0,0 +1,16 @@
// This tests computed properties.
const arr = [0, 0, 0, 10]
const i = 3
const ten = arr[i]
assertEqual(ten, 10, 0.000001, "oops")
const p = "foo"
const obj = {
foo: 1,
bar: 0,
}
const one = obj[p]
assertEqual(one, 1, 0.0000001, "oops")

108
rust/kcl-lib/e2e/executor/inputs/cube-embedded.gltf Normal file
View File

@ -0,0 +1,108 @@
{
"asset": {
"generator": "Khronos glTF Blender I/O v3.4.50",
"version": "2.0"
},
"scene": 0,
"scenes": [
{
"name": "Scene",
"nodes": [0]
}
],
"nodes": [
{
"mesh": 0,
"name": "Cube"
}
],
"materials": [
{
"doubleSided": true,
"name": "Material",
"pbrMetallicRoughness": {
"baseColorFactor": [
0.800000011920929, 0.800000011920929, 0.800000011920929, 1
],
"metallicFactor": 0,
"roughnessFactor": 0.5
}
}
],
"meshes": [
{
"name": "Cube",
"primitives": [
{
"attributes": {
"POSITION": 0,
"TEXCOORD_0": 1,
"NORMAL": 2
},
"indices": 3,
"material": 0
}
]
}
],
"accessors": [
{
"bufferView": 0,
"componentType": 5126,
"count": 24,
"max": [1, 1, 1],
"min": [-1, -1, -1],
"type": "VEC3"
},
{
"bufferView": 1,
"componentType": 5126,
"count": 24,
"type": "VEC2"
},
{
"bufferView": 2,
"componentType": 5126,
"count": 24,
"type": "VEC3"
},
{
"bufferView": 3,
"componentType": 5123,
"count": 36,
"type": "SCALAR"
}
],
"bufferViews": [
{
"buffer": 0,
"byteLength": 288,
"byteOffset": 0,
"target": 34962
},
{
"buffer": 0,
"byteLength": 192,
"byteOffset": 288,
"target": 34962
},
{
"buffer": 0,
"byteLength": 288,
"byteOffset": 480,
"target": 34962
},
{
"buffer": 0,
"byteLength": 72,
"byteOffset": 768,
"target": 34963
}
],
"buffers": [
{
"byteLength": 840,
"uri": "data:application/octet-stream;base64,AACAPwAAgD8AAIC/AACAPwAAgD8AAIC/AACAPwAAgD8AAIC/AACAPwAAgL8AAIC/AACAPwAAgL8AAIC/AACAPwAAgL8AAIC/AACAPwAAgD8AAIA/AACAPwAAgD8AAIA/AACAPwAAgD8AAIA/AACAPwAAgL8AAIA/AACAPwAAgL8AAIA/AACAPwAAgL8AAIA/AACAvwAAgD8AAIC/AACAvwAAgD8AAIC/AACAvwAAgD8AAIC/AACAvwAAgL8AAIC/AACAvwAAgL8AAIC/AACAvwAAgL8AAIC/AACAvwAAgD8AAIA/AACAvwAAgD8AAIA/AACAvwAAgD8AAIA/AACAvwAAgL8AAIA/AACAvwAAgL8AAIA/AACAvwAAgL8AAIA/AAAgPwAAAD8AACA/AAAAPwAAID8AAAA/AADAPgAAAD8AAMA+AAAAPwAAwD4AAAA/AAAgPwAAgD4AACA/AACAPgAAID8AAIA+AADAPgAAgD4AAMA+AACAPgAAwD4AAIA+AAAgPwAAQD8AACA/AABAPwAAYD8AAAA/AAAAPgAAAD8AAMA+AABAPwAAwD4AAEA/AAAgPwAAAAAAACA/AACAPwAAYD8AAIA+AAAAPgAAgD4AAMA+AAAAAAAAwD4AAIA/AAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAPwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAAAAAAAAgL8AAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAAAAAAAAgD8AAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAQAOABQAAQAUAAcACgAGABIACgASABYAFwATAAwAFwAMABAADwADAAkADwAJABUABQACAAgABQAIAAsAEQANAAAAEQAAAAQA"
}
]
}

BIN
rust/kcl-lib/e2e/executor/inputs/cube.bin Normal file
View File

Binary file not shown.

BIN
rust/kcl-lib/e2e/executor/inputs/cube.glb Normal file
View File

Binary file not shown.

108
rust/kcl-lib/e2e/executor/inputs/cube.gltf Normal file
View File

@ -0,0 +1,108 @@
{
"asset": {
"generator": "Khronos glTF Blender I/O v3.4.50",
"version": "2.0"
},
"scene": 0,
"scenes": [
{
"name": "Scene",
"nodes": [0]
}
],
"nodes": [
{
"mesh": 0,
"name": "Cube"
}
],
"materials": [
{
"doubleSided": true,
"name": "Material",
"pbrMetallicRoughness": {
"baseColorFactor": [
0.800000011920929, 0.800000011920929, 0.800000011920929, 1
],
"metallicFactor": 0,
"roughnessFactor": 0.5
}
}
],
"meshes": [
{
"name": "Cube",
"primitives": [
{
"attributes": {
"POSITION": 0,
"TEXCOORD_0": 1,
"NORMAL": 2
},
"indices": 3,
"material": 0
}
]
}
],
"accessors": [
{
"bufferView": 0,
"componentType": 5126,
"count": 24,
"max": [1, 1, 1],
"min": [-1, -1, -1],
"type": "VEC3"
},
{
"bufferView": 1,
"componentType": 5126,
"count": 24,
"type": "VEC2"
},
{
"bufferView": 2,
"componentType": 5126,
"count": 24,
"type": "VEC3"
},
{
"bufferView": 3,
"componentType": 5123,
"count": 36,
"type": "SCALAR"
}
],
"bufferViews": [
{
"buffer": 0,
"byteLength": 288,
"byteOffset": 0,
"target": 34962
},
{
"buffer": 0,
"byteLength": 192,
"byteOffset": 288,
"target": 34962
},
{
"buffer": 0,
"byteLength": 288,
"byteOffset": 480,
"target": 34962
},
{
"buffer": 0,
"byteLength": 72,
"byteOffset": 768,
"target": 34963
}
],
"buffers": [
{
"byteLength": 840,
"uri": "cube.bin"
}
]
}

19
rust/kcl-lib/e2e/executor/inputs/cube.kcl Normal file
View File

@ -0,0 +1,19 @@
fn cube(length, center) {
l = length/2
x = center[0]
y = center[1]
p0 = [-l + x, -l + y]
p1 = [-l + x, l + y]
p2 = [ l + x, l + y]
p3 = [ l + x, -l + y]
return startSketchAt(p0)
|> line(endAbsolute = p1)
|> line(endAbsolute = p2)
|> line(endAbsolute = p3)
|> line(endAbsolute = p0)
|> close()
|> extrude(length = length)
}
myCube = cube(40, [0,0])

12
rust/kcl-lib/e2e/executor/inputs/cube.mtl Normal file
View File

@ -0,0 +1,12 @@
# Blender MTL File: 'None'
# Material Count: 1
newmtl Material
Ns 359.999993
Ka 1.000000 1.000000 1.000000
Kd 0.800000 0.800000 0.800000
Ks 0.500000 0.500000 0.500000
Ke 0.000000 0.000000 0.000000
Ni 1.450000
d 1.000000
illum 2

40
rust/kcl-lib/e2e/executor/inputs/cube.obj Normal file
View File

@ -0,0 +1,40 @@
# Blender v3.2.2 OBJ File: ''
# www.blender.org
mtllib cube.mtl
o Cube
v -1.000000 -1.000000 1.000000
v -1.000000 -1.000000 -1.000000
v -1.000000 1.000000 1.000000
v -1.000000 1.000000 -1.000000
v 1.000000 -1.000000 1.000000
v 1.000000 -1.000000 -1.000000
v 1.000000 1.000000 1.000000
v 1.000000 1.000000 -1.000000
vt 0.625000 0.500000
vt 0.875000 0.500000
vt 0.875000 0.750000
vt 0.625000 0.750000
vt 0.375000 0.750000
vt 0.625000 1.000000
vt 0.375000 1.000000
vt 0.375000 0.000000
vt 0.625000 0.000000
vt 0.625000 0.250000
vt 0.375000 0.250000
vt 0.125000 0.500000
vt 0.375000 0.500000
vt 0.125000 0.750000
vn 0.0000 0.0000 1.0000
vn 0.0000 1.0000 0.0000
vn 1.0000 0.0000 0.0000
vn 0.0000 0.0000 -1.0000
vn -1.0000 0.0000 0.0000
vn 0.0000 -1.0000 0.0000
usemtl Material
s off
f 1/1/1 5/2/1 7/3/1 3/4/1
f 4/5/2 3/4/2 7/6/2 8/7/2
f 8/8/3 7/9/3 5/10/3 6/11/3
f 6/12/4 2/13/4 4/5/4 8/14/4
f 2/13/5 1/1/5 3/4/5 4/5/5
f 6/11/6 5/10/6 1/1/6 2/13/6

3
rust/kcl-lib/e2e/executor/inputs/cylinder.kcl Normal file
View File

@ -0,0 +1,3 @@
const cylinder = startSketchOn('XY')
|> circle(center= [0, 0], radius= 22)
|> extrude(length = 14)

7
rust/kcl-lib/e2e/executor/inputs/dimensions_match.kcl Normal file
View File

@ -0,0 +1,7 @@
const part001 = startSketchOn('XY')
|> startProfileAt([-10, -10], %)
|> line(end = [20, 0])
|> line(end = [0, 20])
|> line(end = [-20, 0])
|> close()
|> extrude(length = 10)

24
rust/kcl-lib/e2e/executor/inputs/e2e-can-sketch-on-chamfer-no-pipeExpr.kcl Normal file
View File

@ -0,0 +1,24 @@
const sketch001 = startSketchOn('XZ')
|> startProfileAt([75.8, 317.2], %)
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26
], %, $seg01)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
], %, $yo)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)], tag = $seg02)
|> close()
const extrude001 = extrude(sketch001, length = 100)
const chamf = chamfer(
extrude001,
length = 30,
tags = [
seg01,
getNextAdjacentEdge(yo),
getNextAdjacentEdge(seg02),
getOppositeEdge(seg01)
]
)

23
rust/kcl-lib/e2e/executor/inputs/e2e-can-sketch-on-chamfer.kcl Normal file
View File

@ -0,0 +1,23 @@
const sketch001 = startSketchOn('XZ')
|> startProfileAt([75.8, 317.2], %) // [$startCapTag, $EndCapTag]
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26
], %, $seg01)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
], %, $yo)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)], tag = $seg02)
|> close()
const extrude001 = extrude(sketch001, length = 100)
|> chamfer(
length = 30,
tags = [
seg01,
getNextAdjacentEdge(yo),
getNextAdjacentEdge(seg02),
getOppositeEdge(seg01)
],
)

29
rust/kcl-lib/e2e/executor/inputs/extrude-custom-plane.kcl Normal file
View File

@ -0,0 +1,29 @@
// create a sketch with name sketch000
const sketch000 = startSketchOn('XY')
|> startProfileAt([0.0, 0.0], %)
|> line(end = [1.0, 1.0], tag = $line000)
|> line(end = [0.0, -1.0], tag = $line001)
|> line(end = [-1.0, 0.0], tag = $line002)
// create an extrusion with name extrude000
const extrude000 = extrude(sketch000, length = 1.0)
// define a plane with name plane005
const plane005 = {
plane: {
origin: [0.0, 0.0, 1.0],
xAxis: [0.707107, 0.707107, 0.0],
yAxis: [-0.0, 0.0, 1.0],
zAxis: [0.707107, -0.707107, 0.0]
}
}
// create a sketch with name sketch001
const sketch001 = startSketchOn(plane005)
|> startProfileAt([0.100000, 0.250000], %)
|> line(end = [0.075545, 0.494260], tag = $line003)
|> line(end = [0.741390, -0.113317], tag = $line004)
|> line(end = [-0.816935, -0.380943], tag = $line005)
// create an extrusion with name extrude001
const extrude001 = extrude(sketch001, length = 1.0)

74
rust/kcl-lib/e2e/executor/inputs/extrude-inside-fn-with-tags.kcl Normal file
View File

@ -0,0 +1,74 @@
// A mounting bracket for the Focusrite Scarlett Solo audio interface
// This is a bracket that holds an audio device underneath a desk or shelf. The audio device has dimensions of 144mm wide, 80mm length and 45mm depth with fillets of 6mm. This mounting bracket is designed to be 3D printed with PLA material
// define constants in mm
const radius = 6.0
const width = 144.0
const length = 80.0
const depth = 45.0
const thk = 4
const holeDiam = 5
const tabLength = 25
const tabWidth = 12
const tabThk = 4
// define a rectangular shape func
fn rectShape = (pos, w, l) => {
const rr = startSketchOn('xy')
|> startProfileAt([pos[0] - (w / 2), pos[1] - (l / 2)], %)
|> line(endAbsolute = [pos[0] + w / 2, pos[1] - (l / 2)], tag = $edge01)
|> line(endAbsolute = [pos[0] + w / 2, pos[1] + l / 2], tag = $edge02)
|> line(endAbsolute = [pos[0] - (w / 2), pos[1] + l / 2], tag = $edge03)
|> close(tag = $edge04)
return rr
}
// define the bracket plane
const bracketPlane = {
plane: {
origin: { x: 0, y: length / 2 + thk, z: 0 },
xAxis: { x: 1, y: 0, z: 0 },
yAxis: { x: 0, y: 0, z: 1 },
zAxis: { x: 0, y: -1, z: 0 }
}
}
// build the bracket sketch around the body
fn bracketSketch = (w, d, t) => {
const s = startSketchOn(bracketPlane)
|> startProfileAt([-w / 2 - t, d + t], %)
|> line(endAbsolute = [-w / 2 - t, -t], tag = $edge1)
|> line(endAbsolute = [w / 2 + t, -t], tag = $edge2)
|> line(endAbsolute = [w / 2 + t, d + t], tag = $edge3)
|> line(endAbsolute = [w / 2, d + t], tag = $edge4)
|> line(endAbsolute = [w / 2, 0], tag = $edge5)
|> line(endAbsolute = [-w / 2, 0], tag = $edge6)
|> line(endAbsolute = [-w / 2, d + t], tag = $edge7)
|> close(tag = $edge8)
|> extrude(length = length + 2 * thk)
return s
}
// build the body of the bracket
const bs = bracketSketch(width, depth, thk)
const bracketBody = bs
|> fillet(
radius = radius,
tags = [
getPreviousAdjacentEdge(bs.sketch.tags.edge7),
getPreviousAdjacentEdge(bs.sketch.tags.edge2),
getPreviousAdjacentEdge(bs.sketch.tags.edge3),
getPreviousAdjacentEdge(bs.sketch.tags.edge6)
]
)
// sketch on the face
const retBack = startSketchOn(bs, bs.sketch.tags.edge4)
|> startProfileAt([length / 2 + thk, 0], %)
|> line(end = [0, thk])
|> line(end = [-thk, 0])
|> line(end = [0, -thk])
|> close()
|> extrude(length = width - 40)

81
rust/kcl-lib/e2e/executor/inputs/fillet-and-shell.kcl Normal file
View File

@ -0,0 +1,81 @@
const rpizWidth = 30
const rpizLength = 65
const caseThickness = 1
const border = 4
const screwHeight = 4
const caseWidth = rpizWidth + border * 2
const caseLength = rpizLength + border * 2
const caseHeight = 8
const widthBetweenScrews = 23
const lengthBetweenScrews = 29 * 2
const miniHdmiDistance = 12.4
const microUsb1Distance = 41.4
const microUsb2Distance = 54
const miniHdmiWidth = 11.2
const microUsbWidth = 7.4
const connectorPadding = 4
const miniHdmiHole = startSketchAt([
0,
border + miniHdmiDistance - (miniHdmiWidth / 2)
])
|> lineTo([
0,
border + miniHdmiDistance + miniHdmiWidth / 2
], %)
|> lineTo([
1,
border + miniHdmiDistance + miniHdmiWidth / 2
], %)
|> lineTo([
1,
border + miniHdmiDistance - (miniHdmiWidth / 2)
], %)
|> close()
const case = startSketchOn('XY')
|> startProfileAt([0, 0], %)
|> line(endAbsolute = [caseWidth, 0], $edge1)
|> line(endAbsolute = [caseWidth, caseLength], $edge2)
|> line(endAbsolute = [0, caseLength], $edge3)
|> close(tag = $edge4)
|> extrude(length = caseHeight)
|> fillet(
radius = 1,
tags = [
getNextAdjacentEdge(edge1),
getNextAdjacentEdge(edge2),
getNextAdjacentEdge(edge3),
getNextAdjacentEdge(edge4)
],
)
fn m25Screw = (x, y, height) => {
const screw = startSketchOn("XY")
|> startProfileAt([0, 0], %)
|> circle(center= [x, y], radius=2.5)
|> hole(circle(center= [x, y], radius = 1.25), %)
|> extrude(length = height)
return screw
}
m25Screw(border + rpizWidth / 2 - (widthBetweenScrews / 2), 0 + border + rpizLength / 2 - (lengthBetweenScrews / 2), screwHeight)
m25Screw(border + rpizWidth / 2 - (widthBetweenScrews / 2), 0 + border + rpizLength / 2 + lengthBetweenScrews / 2, screwHeight)
m25Screw(border + rpizWidth / 2 + widthBetweenScrews / 2, 0 + border + rpizLength / 2 + lengthBetweenScrews / 2, screwHeight)
m25Screw(border + rpizWidth / 2 + widthBetweenScrews / 2, 0 + border + rpizLength / 2 - (lengthBetweenScrews / 2), screwHeight)
shell(
faces = ['end'],
thickness = caseThickness
)

8
rust/kcl-lib/e2e/executor/inputs/fillet_duplicate_tags.kcl Normal file
View File

@ -0,0 +1,8 @@
const part001 = startSketchOn('XY')
|> startProfileAt([0,0], %)
|> line(end = [0, 10], tag = $thing)
|> line(end = [10, 0])
|> line(end = [0, -10], tag = $thing2)
|> close()
|> extrude(length = 10)
|> fillet(radius = 0.5, tags = [thing, thing])

157
rust/kcl-lib/e2e/executor/inputs/focusrite_scarlett_mounting_braket.kcl Normal file
View File

@ -0,0 +1,157 @@
// A mounting bracket for the Focusrite Scarlett Solo audio interface
// This is a bracket that holds an audio device underneath a desk or shelf. The audio device has dimensions of 144mm wide, 80mm length and 45mm depth with fillets of 6mm. This mounting bracket is designed to be 3D printed with PLA material
// define constants in mm
const radius = 6.0
const width = 144.0
const length = 80.0
const depth = 45.0
const thk = 4
const holeDiam = 5
const tabLength = 25
const tabWidth = 12
const tabThk = 4
// define a rectangular shape func
fn rectShape = (pos, w, l) => {
const rr = startSketchOn('xy')
|> startProfileAt([pos[0] - (w / 2), pos[1] - (l / 2)], %)
|> line(endAbsolute = [pos[0] + w / 2, pos[1] - (l / 2)], tag = $edge01)
|> line(endAbsolute = [pos[0] + w / 2, pos[1] + l / 2], tag = $edge02)
|> line(endAbsolute = [pos[0] - (w / 2), pos[1] + l / 2], tag = $edge03)
|> close(tag = $edge04)
return rr
}
// define the bracket plane
const bracketPlane = {
plane: {
origin: { x: 0, y: length / 2 + thk, z: 0 },
xAxis: { x: 1, y: 0, z: 0 },
yAxis: { x: 0, y: 0, z: 1 },
zAxis: { x: 0, y: -1, z: 0 }
}
}
// build the bracket sketch around the body
fn bracketSketch = (w, d, t) => {
const s = startSketchOn(bracketPlane)
|> startProfileAt([-w / 2 - t, d + t], %)
|> line(endAbsolute = [-w / 2 - t, -t], tag = $edge1)
|> line(endAbsolute = [w / 2 + t, -t], tag = $edge2)
|> line(endAbsolute = [w / 2 + t, d + t], tag = $edge3)
|> line(endAbsolute = [w / 2, d + t], tag = $edge4)
|> line(endAbsolute = [w / 2, 0], tag = $edge5)
|> line(endAbsolute = [-w / 2, 0], tag = $edge6)
|> line(endAbsolute = [-w / 2, d + t], tag = $edge7)
|> close(tag = $edge8)
return s
}
// build the body of the bracket
const bs = bracketSketch(width, depth, thk)
const bracketBody = bs
|> extrude(length = length + 2 * thk)
|> fillet(
radius = radius,
tags = [
getPreviousAdjacentEdge(bs.tags.edge7),
getPreviousAdjacentEdge(bs.tags.edge2),
getPreviousAdjacentEdge(bs.tags.edge3),
getPreviousAdjacentEdge(bs.tags.edge6)
]
)
// define the tab plane
const tabPlane = {
plane: {
origin: { x: 0, y: 0, z: depth + thk },
xAxis: { x: 1, y: 0, z: 0 },
yAxis: { x: 0, y: 1, z: 0 },
zAxis: { x: 0, y: 0, z: 1 }
}
}
// build the tabs of the mounting bracket (right side)
const tabsR = startSketchOn(tabPlane)
|> startProfileAt([width / 2 + thk, length / 2 + thk], %)
|> line(end = [tabWidth, -tabLength / 3], tag = $edge11)
|> line(end = [0, -tabLength / 3 * 2], tag = $edge12)
|> line(end = [-tabWidth, -tabLength / 3], tag = $edge13)
|> close(tag = $edge14)
|> hole(circle(
center = [
width / 2 + thk + tabWidth / 2,
length / 2 + thk - (tabLength / (3 / 2))
],
radius = holeDiam / 2
), %)
|> extrude(length = -tabThk)
|> fillet(
radius = holeDiam / 2,
tags = [
getNextAdjacentEdge(edge12),
getNextAdjacentEdge(edge13)
]
)
|> patternLinear3d(
axis = [0, -1, 0],
instances = 2,
distance = length + 2 * thk - (tabLength * 4 / 3)
)
// build the tabs of the mounting bracket (left side)
const tabsL = startSketchOn(tabPlane)
|> startProfileAt([-width / 2 - thk, length / 2 + thk], %)
|> line(end = [-tabWidth, -tabLength / 3], tag = $edge21)
|> line(end = [0, -tabLength / 3 * 2], tag = $edge22)
|> line(end = [tabWidth, -tabLength / 3], tag = $edge23)
|> close(tag = $edge24)
|> hole(circle(
center= [
-width / 2 - thk - (tabWidth / 2),
length / 2 + thk - (tabLength / (3 / 2))
],
radius= holeDiam / 2
), %)
|> extrude(length = -tabThk)
|> fillet(
radius = holeDiam / 2,
tags = [
getNextAdjacentEdge(edge21),
getNextAdjacentEdge(edge22)
]
)
|> patternLinear3d(
axis = [0, -1, 0],
instances = 2,
distance = length + 2 * thk - (tabLength * 4 / 3)
)
// define a plane for retention bumps
const retPlane = {
plane: {
origin: { x: -width / 2 + 20, y: 0, z: 0 },
xAxis: { x: 0, y: 1, z: 0 },
yAxis: { x: 0, y: 0, z: 1 },
zAxis: { x: 1, y: 0, z: 0 }
}
}
// build the retention bump in the front
const retFront = startSketchOn(retPlane)
|> startProfileAt([-length / 2 - thk, 0], %)
|> line(end = [0, thk])
|> line(end = [thk, -thk])
|> close()
|> extrude(length = width - 40)
// build the retention bump in the back
const retBack = startSketchOn(retPlane)
|> startProfileAt([length / 2 + thk, 0], %)
|> line(end = [0, thk])
|> line(end = [-thk, 0])
|> line(end = [0, -thk])
|> close()
|> extrude(length = width - 40)

13
rust/kcl-lib/e2e/executor/inputs/function_sketch.kcl Normal file
View File

@ -0,0 +1,13 @@
fn box = (h, l, w) => {
const myBox = startSketchOn('XY')
|> startProfileAt([0,0], %)
|> line(end = [0, l])
|> line(end = [w, 0])
|> line(end = [0, -l])
|> close()
|> extrude(length = h)
return myBox
}
const fnBox = box(3, 6, 10)

13
rust/kcl-lib/e2e/executor/inputs/function_sketch_with_position.kcl Normal file
View File

@ -0,0 +1,13 @@
fn box = (p, h, l, w) => {
const myBox = startSketchOn('XY')
|> startProfileAt(p, %)
|> line(end = [0, l])
|> line(end = [w, 0])
|> line(end = [0, -l])
|> close()
|> extrude(length = h)
return myBox
}
const thing = box([0,0], 3, 6, 10)

157
rust/kcl-lib/e2e/executor/inputs/global-tags.kcl Normal file
View File

@ -0,0 +1,157 @@
// A mounting bracket for the Focusrite Scarlett Solo audio interface
// This is a bracket that holds an audio device underneath a desk or shelf. The audio device has dimensions of 144mm wide, 80mm length and 45mm depth with fillets of 6mm. This mounting bracket is designed to be 3D printed with PLA material
// define constants in mm
const radius = 6.0
const width = 144.0
const length = 80.0
const depth = 45.0
const thk = 4
const holeDiam = 5
const tabLength = 25
const tabWidth = 12
const tabThk = 4
// define a rectangular shape func
fn rectShape = (pos, w, l) => {
const rr = startSketchOn('xy')
|> startProfileAt([pos[0] - (w / 2), pos[1] - (l / 2)], %)
|> line(endAbsolute = [pos[0] + w / 2, pos[1] - (l / 2)], tag = $edge01)
|> line(endAbsolute = [pos[0] + w / 2, pos[1] + l / 2], tag = $edge02)
|> line(endAbsolute = [pos[0] - (w / 2), pos[1] + l / 2], tag = $edge03)
|> close(tag = $edge04)
return rr
}
// define the bracket plane
const bracketPlane = {
plane: {
origin: { x: 0, y: length / 2 + thk, z: 0 },
xAxis: { x: 1, y: 0, z: 0 },
yAxis: { x: 0, y: 0, z: 1 },
zAxis: { x: 0, y: -1, z: 0 }
}
}
// build the bracket sketch around the body
fn bracketSketch = (w, d, t) => {
const s = startSketchOn(bracketPlane)
|> startProfileAt([-w / 2 - t, d + t], %)
|> line(endAbsolute = [-w / 2 - t, -t], tag = $edge1)
|> line(endAbsolute = [w / 2 + t, -t], tag = $edge2)
|> line(endAbsolute = [w / 2 + t, d + t], tag = $edge3)
|> line(endAbsolute = [w / 2, d + t], tag = $edge4)
|> line(endAbsolute = [w / 2, 0], tag = $edge5)
|> line(endAbsolute = [-w / 2, 0], tag = $edge6)
|> line(endAbsolute = [-w / 2, d + t], tag = $edge7)
|> close(tag = $edge8)
return s
}
// build the body of the bracket
const bs = bracketSketch(width, depth, thk)
const bracketBody = bs
|> extrude(length = length + 2 * thk)
|> fillet(
radius = radius,
tags = [
getPreviousAdjacentEdge(bs.tags.edge7),
getPreviousAdjacentEdge(bs.tags.edge2),
getPreviousAdjacentEdge(bs.tags.edge3),
getPreviousAdjacentEdge(bs.tags.edge6)
]
)
// define the tab plane
const tabPlane = {
plane: {
origin: { x: 0, y: 0, z: depth + thk },
xAxis: { x: 1, y: 0, z: 0 },
yAxis: { x: 0, y: 1, z: 0 },
zAxis: { x: 0, y: 0, z: 1 }
}
}
// build the tabs of the mounting bracket (right side)
const tabsR = startSketchOn(tabPlane)
|> startProfileAt([width / 2 + thk, length / 2 + thk], %)
|> line(end = [tabWidth, -tabLength / 3], tag = $edge11)
|> line(end = [0, -tabLength / 3 * 2], tag = $edge12)
|> line(end = [-tabWidth, -tabLength / 3], tag = $edge13)
|> close(tag = $edge14)
|> hole(circle(
center= [
width / 2 + thk + tabWidth / 2,
length / 2 + thk - (tabLength / (3 / 2))
],
radius= holeDiam / 2
), %)
|> extrude(length = -tabThk)
|> fillet(
radius = holeDiam / 2,
tags = [
getNextAdjacentEdge(edge12),
getNextAdjacentEdge(edge11)
]
)
|> patternLinear3d(
axis = [0, -1, 0],
instances = 2,
distance = length + 2 * thk - (tabLength * 4 / 3)
)
// build the tabs of the mounting bracket (left side)
const tabsL = startSketchOn(tabPlane)
|> startProfileAt([-width / 2 - thk, length / 2 + thk], %)
|> line(end = [-tabWidth, -tabLength / 3], tag = $edge21)
|> line(end = [0, -tabLength / 3 * 2], tag = $edge22)
|> line(end = [tabWidth, -tabLength / 3], tag = $edge23)
|> close(tag = $edge24)
|> hole(circle(
center= [
-width / 2 - thk - (tabWidth / 2),
length / 2 + thk - (tabLength / (3 / 2))
],
radius= holeDiam / 2
), %)
|> extrude(length = -tabThk)
|> fillet(
radius = holeDiam / 2,
tags = [
getNextAdjacentEdge(edge21),
getNextAdjacentEdge(edge22)
]
)
|> patternLinear3d(
axis = [0, -1, 0],
instances = 2,
distance = length + 2 * thk - (tabLength * 4 / 3)
)
// define a plane for retention bumps
const retPlane = {
plane: {
origin: { x: -width / 2 + 20, y: 0, z: 0 },
xAxis: { x: 0, y: 1, z: 0 },
yAxis: { x: 0, y: 0, z: 1 },
zAxis: { x: 1, y: 0, z: 0 }
}
}
// build the retention bump in the front
const retFront = startSketchOn(retPlane)
|> startProfileAt([-length / 2 - thk, 0], %)
|> line(end = [0, thk])
|> line(end = [thk, -thk])
|> close()
|> extrude(length = width - 40)
// build the retention bump in the back
const retBack = startSketchOn(retPlane)
|> startProfileAt([length / 2 + thk, 0], %)
|> line(end = [0, thk])
|> line(end = [-thk, 0])
|> line(end = [0, -thk])
|> close()
|> extrude(length = width - 40)

4
rust/kcl-lib/e2e/executor/inputs/helix_defaults.kcl Normal file
View File

@ -0,0 +1,4 @@
const part001 = startSketchOn('XY')
|> circle(center= [5, 5], radius= 10)
|> extrude(length = 10)
|> helixRevolutions({revolutions = 16, angleStart = 0}, %)

4
rust/kcl-lib/e2e/executor/inputs/helix_defaults_negative_extrude.kcl Normal file
View File

@ -0,0 +1,4 @@
const part001 = startSketchOn('XY')
|> circle(center = [5, 5], radius = 10)
|> extrude(length = -10)
|> helixRevolutions({revolutions = 16, angleStart = 0}, %)

4
rust/kcl-lib/e2e/executor/inputs/helix_with_length.kcl Normal file
View File

@ -0,0 +1,4 @@
const part001 = startSketchOn('XY')
|> circle(center= [5, 5], radius= 10)
|> extrude(length = 10)
|> helixRevolutions({revolutions = 16, angleStart = 0, length = 3}, %)

51
rust/kcl-lib/e2e/executor/inputs/i_shape.kcl Normal file
View File

@ -0,0 +1,51 @@
let d_wrist_circumference = [22.8, 10.7, 16.4, 18.5]
let width = d_wrist_circumference[0] + d_wrist_circumference[1] + d_wrist_circumference[2] + d_wrist_circumference[3]
let length = 120.0
let hand_thickness = 24.0
let corner_radius = 5.0
// At first I thought this was going to be symmetric,
// but I measured intentionally to not be symmetric,
// because your wrist isn't a perfect cylindrical surface
let brace_base = startSketchAt([corner_radius, 0])
|> line(end = [width - corner_radius, 0.0])
|> tangentialArcToRelative([corner_radius, corner_radius], %)
|> yLine(25.0 - corner_radius, %)
|> tangentialArcToRelative([-corner_radius, corner_radius], %)
|> xLine(-(d_wrist_circumference[0] - (corner_radius * 2)), %)
|> tangentialArcToRelative([-corner_radius, corner_radius], %)
|> yLine(length - 25.0 - 23.0 - (corner_radius * 2), %)
|> tangentialArcToRelative([corner_radius, corner_radius], %)
|> xLine(15.0 - (corner_radius * 2), %)
|> tangentialArcToRelative([corner_radius, corner_radius], %)
|> yLine(23.0 - corner_radius, %)
|> tangentialArcToRelative([-corner_radius, corner_radius], %)
|> xLine(-(hand_thickness + 15.0 + 15.0 - (corner_radius * 2)), %)
|> tangentialArcToRelative([-corner_radius, -corner_radius], %)
|> yLine(-(23.0 - corner_radius), %)
|> tangentialArcToRelative([corner_radius, -corner_radius], %)
|> xLine(15.0 - (corner_radius * 2), %)
|> tangentialArcToRelative([corner_radius, -corner_radius], %)
|> yLine(-(length - 25.0 - 23.0 - (corner_radius * 2)), %)
|> tangentialArcToRelative([-corner_radius, -corner_radius], %)
|> xLine(-(d_wrist_circumference[1] + d_wrist_circumference[2] + d_wrist_circumference[3] - hand_thickness - corner_radius), %)
|> tangentialArcToRelative([-corner_radius, -corner_radius], %)
|> yLine(-(25.0 - corner_radius), %)
|> tangentialArcToRelative([corner_radius, -corner_radius], %)
|> close()
let inner = startSketchAt([0, 0])
|> xLine(1.0, %)
|> tangentialArcToRelative([corner_radius, corner_radius], %)
|> yLine(25.0 - (corner_radius * 2), %)
|> tangentialArcToRelative([-corner_radius, corner_radius], %)
|> xLine(-1.0, %)
|> tangentialArcToRelative([-corner_radius, -corner_radius], %)
|> yLine(-(25.0 - (corner_radius * 2)), %)
|> tangentialArcToRelative([corner_radius, -corner_radius], %)
|> close()
let final = brace_base
|> hole(inner, %)
|> extrude(length = 3.0)

311
rust/kcl-lib/e2e/executor/inputs/kittycad_svg.kcl Normal file
View File

@ -0,0 +1,311 @@
const svg = startSketchOn('XY')
|> startProfileAt([0, 0], %)
|> line(endAbsolute = [2.52, -26.04]) // MoveAbsolute
|> line(endAbsolute = [2.52, -25.2]) // VerticalLineAbsolute
|> line(endAbsolute = [0.84, -25.2]) // HorizontalLineAbsolute
|> line(endAbsolute = [0.84, -24.36]) // VerticalLineAbsolute
|> line(endAbsolute = [0, -24.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [0, -6.72]) // VerticalLineAbsolute
|> line(endAbsolute = [0.84, -6.72]) // HorizontalLineAbsolute
|> line(endAbsolute = [0.84, -5.88]) // VerticalLineAbsolute
|> line(endAbsolute = [1.68, -5.88]) // HorizontalLineAbsolute
|> line(endAbsolute = [1.68, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [2.52, -5.04]) // HorizontalLineAbsolute
|> line(endAbsolute = [2.52, -4.2]) // VerticalLineAbsolute
|> line(endAbsolute = [3.36, -4.2]) // HorizontalLineAbsolute
|> line(endAbsolute = [3.36, -3.36]) // VerticalLineAbsolute
|> line(endAbsolute = [17.64, -3.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [17.64, -4.2]) // VerticalLineAbsolute
|> line(endAbsolute = [18.48, -4.2]) // HorizontalLineRelative
|> line(endAbsolute = [18.48, -5.04]) // VerticalLineHorizonal
|> line(endAbsolute = [19.32, -5.04]) // HorizontalLineRelative
|> line(endAbsolute = [19.32, -5.88]) // VerticalLineHorizonal
|> line(endAbsolute = [20.16, -5.88]) // HorizontalLineRelative
|> line(endAbsolute = [20.16, -6.72]) // VerticalLineAbsolute
|> line(endAbsolute = [21, -6.72]) // HorizontalLineAbsolute
|> line(endAbsolute = [21, -24.36]) // VerticalLineHorizonal
|> line(endAbsolute = [20.16, -24.36]) // HorizontalLineRelative
|> line(endAbsolute = [20.16, -25.2]) // VerticalLineHorizonal
|> line(endAbsolute = [18.48, -25.2]) // HorizontalLineRelative
|> line(endAbsolute = [18.48, -26.04]) // VerticalLineHorizonal
|> line(endAbsolute = [15.96, -26.04]) // HorizontalLineRelative
|> line(endAbsolute = [15.96, -26.88]) // VerticalLineHorizonal
|> line(endAbsolute = [16.8, -26.88]) // HorizontalLineRelative
|> line(endAbsolute = [16.8, -28.56]) // VerticalLineHorizonal
|> line(endAbsolute = [11.76, -28.56]) // HorizontalLineAbsolute
|> line(endAbsolute = [11.76, -26.88]) // VerticalLineAbsolute
|> line(endAbsolute = [12.6, -26.88]) // HorizontalLineAbsolute
|> line(endAbsolute = [12.6, -26.04]) // VerticalLineAbsolute
|> line(endAbsolute = [8.4, -26.04]) // HorizontalLineAbsolute
|> line(endAbsolute = [8.4, -26.88]) // VerticalLineHorizonal
|> line(endAbsolute = [9.24, -26.88]) // HorizontalLineRelative
|> line(endAbsolute = [9.24, -28.56]) // VerticalLineHorizonal
|> line(endAbsolute = [4.2, -28.56]) // HorizontalLineAbsolute
|> line(endAbsolute = [4.2, -26.88]) // VerticalLineHorizonal
|> line(endAbsolute = [5.04, -26.88]) // HorizontalLineRelative
|> line(endAbsolute = [5.04, -26.04]) // VerticalLineHorizonal
|> line(endAbsolute = [0.839996, -20.58]) // MoveRelative
|> line(endAbsolute = [0.839996, -24.36]) // VerticalLineHorizonal
|> line(endAbsolute = [2.52, -24.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [2.52, -25.2]) // VerticalLineHorizonal
|> line(endAbsolute = [18.48, -25.2]) // HorizontalLineRelative
|> line(endAbsolute = [18.48, -24.36]) // VerticalLineHorizonal
|> line(endAbsolute = [20.16, -24.36]) // HorizontalLineRelative
|> line(endAbsolute = [20.16, -20.58]) // VerticalLineAbsolute
// StopAbsolute
|> line(endAbsolute = [7.56, -24.36]) // MoveAbsolute
|> line(endAbsolute = [7.56, -22.68]) // VerticalLineHorizonal
|> line(endAbsolute = [13.44, -22.68]) // HorizontalLineRelative
|> line(endAbsolute = [13.44, -24.36]) // VerticalLineHorizonal
|> line(endAbsolute = [1.68, -22.68]) // MoveRelative
|> line(endAbsolute = [1.68, -21.84]) // VerticalLineHorizonal
|> line(endAbsolute = [5.88, -21.84]) // HorizontalLineRelative
|> line(endAbsolute = [5.88, -22.68]) // VerticalLineHorizonal
|> line(endAbsolute = [3.36, -24.36]) // MoveRelative
|> line(endAbsolute = [3.36, -23.52]) // VerticalLineHorizonal
|> line(endAbsolute = [5.88, -23.52]) // HorizontalLineRelative
|> line(endAbsolute = [5.88, -24.36]) // VerticalLineHorizonal
|> line(endAbsolute = [15.12, -22.68]) // MoveRelative
|> line(endAbsolute = [15.12, -21.84]) // VerticalLineHorizonal
|> line(endAbsolute = [15.959999999999999, -21.84]) // HorizontalLineRelative
|> line(endAbsolute = [15.959999999999999, -22.68]) // VerticalLineHorizonal
|> line(endAbsolute = [16.8, -22.68]) // MoveRelative
|> line(endAbsolute = [16.8, -21.84]) // VerticalLineHorizonal
|> line(endAbsolute = [17.64, -21.84]) // HorizontalLineRelative
|> line(endAbsolute = [17.64, -22.68]) // VerticalLineHorizonal
|> line(endAbsolute = [18.48, -22.68]) // MoveRelative
|> line(endAbsolute = [18.48, -21.84]) // VerticalLineHorizonal
|> line(endAbsolute = [19.32, -21.84]) // HorizontalLineRelative
|> line(endAbsolute = [19.32, -22.68]) // VerticalLineHorizonal
|> line(endAbsolute = [15.12, -24.36]) // MoveRelative
|> line(endAbsolute = [15.12, -23.52]) // VerticalLineHorizonal
|> line(endAbsolute = [17.64, -23.52]) // HorizontalLineRelative
|> line(endAbsolute = [17.64, -24.36]) // VerticalLineHorizonal
|> line(endAbsolute = [18.48, -5.88]) // MoveAbsolute
|> line(endAbsolute = [18.48, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [17.64, -5.04]) // HorizontalLineAbsolute
|> line(endAbsolute = [17.64, -4.2]) // VerticalLineAbsolute
|> line(endAbsolute = [3.36, -4.2]) // HorizontalLineAbsolute
|> line(endAbsolute = [3.36, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [2.52, -5.04]) // HorizontalLineAbsolute
|> line(endAbsolute = [2.52, -5.88]) // VerticalLineAbsolute
|> line(endAbsolute = [1.68, -5.88]) // HorizontalLineAbsolute
|> line(endAbsolute = [1.68, -6.72]) // VerticalLineAbsolute
|> line(endAbsolute = [0.839996, -6.72]) // HorizontalLineAbsolute
|> line(endAbsolute = [0.839996, -8.4]) // VerticalLineAbsolute
|> line(endAbsolute = [20.16, -8.4]) // HorizontalLineAbsolute
|> line(endAbsolute = [20.16, -6.72]) // VerticalLineAbsolute
|> line(endAbsolute = [19.32, -6.72]) // HorizontalLineAbsolute
|> line(endAbsolute = [19.32, -5.88]) // VerticalLineAbsolute
|> line(endAbsolute = [20.16, -7.56]) // MoveAbsolute
|> line(endAbsolute = [0.839996, -7.56]) // HorizontalLineAbsolute
|> line(endAbsolute = [0.839996, -19.32]) // VerticalLineAbsolute
|> line(endAbsolute = [20.16, -19.32]) // HorizontalLineAbsolute
|> line(endAbsolute = [3.36, -10.08]) // MoveAbsolute
|> line(endAbsolute = [3.36, -9.24001]) // VerticalLineAbsolute
|> line(endAbsolute = [17.64, -9.24001]) // HorizontalLineAbsolute
|> line(endAbsolute = [17.64, -10.08]) // VerticalLineAbsolute
|> line(endAbsolute = [18.48, -10.08]) // HorizontalLineRelative
|> line(endAbsolute = [18.48, -16.8]) // VerticalLineHorizonal
|> line(endAbsolute = [17.64, -16.8]) // HorizontalLineRelative
|> line(endAbsolute = [17.64, -17.64]) // VerticalLineHorizonal
|> line(endAbsolute = [3.36, -17.64]) // HorizontalLineAbsolute
|> line(endAbsolute = [3.36, -16.8]) // VerticalLineAbsolute
|> line(endAbsolute = [2.52, -16.8]) // HorizontalLineAbsolute
|> line(endAbsolute = [2.52, -10.080000000000002]) // VerticalLineHorizonal
|> line(endAbsolute = [13.44, -10.92]) // MoveRelative
|> line(endAbsolute = [13.44, -10.08]) // VerticalLineHorizonal
|> line(endAbsolute = [15.12, -10.08]) // HorizontalLineRelative
|> line(endAbsolute = [15.12, -13.44]) // VerticalLineHorizonal
|> line(endAbsolute = [14.28, -13.44]) // HorizontalLineRelative
|> line(endAbsolute = [9.24, -13.44]) // MoveRelative
|> line(endAbsolute = [11.76, -13.44]) // HorizontalLineRelative
|> line(endAbsolute = [11.76, -14.28]) // VerticalLineHorizonal
|> line(endAbsolute = [10.92, -14.28]) // HorizontalLineRelative here
|> line(endAbsolute = [10.92, -15.959999999999999]) // VerticalLineHorizonal
|> line(endAbsolute = [13.44, -15.959999999999999]) // HorizontalLineRelative
|> line(endAbsolute = [13.44, -15.12]) // VerticalLineHorizonal
|> line(endAbsolute = [14.28, -15.12]) // HorizontalLineRelative
|> line(endAbsolute = [14.28, -15.959999999999999]) // VerticalLineHorizonal
|> line(endAbsolute = [13.44, -15.959999999999999]) // HorizontalLineAbsolute
|> line(endAbsolute = [13.44, -16.8]) // VerticalLineAbsolute
|> line(endAbsolute = [7.56, -16.8]) // HorizontalLineAbsolute
|> line(endAbsolute = [7.56, -15.96]) // VerticalLineAbsolute
|> line(endAbsolute = [6.72, -15.96]) // HorizontalLineAbsolute
|> line(endAbsolute = [6.72, -15.120000000000001]) // VerticalLineHorizonal
|> line(endAbsolute = [7.56, -15.120000000000001]) // HorizontalLineRelative
|> line(endAbsolute = [7.56, -15.96]) // VerticalLineHorizonal
|> line(endAbsolute = [10.08, -15.96]) // HorizontalLineRelative
|> line(endAbsolute = [10.08, -14.28]) // VerticalLineAbsolute
|> line(endAbsolute = [9.24, -14.28]) // HorizontalLineAbsolute
|> line(endAbsolute = [7.56, -12.6]) // MoveAbsolute
|> line(endAbsolute = [7.56, -11.76]) // VerticalLineAbsolute
|> line(endAbsolute = [5.04, -11.76]) // HorizontalLineAbsolute
|> line(endAbsolute = [5.04, -12.6]) // VerticalLineAbsolute
|> line(endAbsolute = [4.2, -12.6]) // HorizontalLineAbsolute
|> line(endAbsolute = [4.2, -11.76]) // VerticalLineHorizonal
|> line(endAbsolute = [5.04, -11.76]) // HorizontalLineRelative
|> line(endAbsolute = [5.04, -10.92]) // VerticalLineHorizonal
|> line(endAbsolute = [7.5600000000000005, -10.92]) // HorizontalLineRelative
|> line(endAbsolute = [7.5600000000000005, -11.76]) // VerticalLineHorizonal
|> line(endAbsolute = [8.4, -11.76]) // HorizontalLineAbsolute
|> line(endAbsolute = [8.4, -12.6]) // VerticalLineHorizonal
|> line(endAbsolute = [3.36, -5.88]) // MoveAbsolute
|> line(endAbsolute = [3.36, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [4.2, -5.04]) // HorizontalLineAbsolute
|> line(endAbsolute = [4.2, -3.36]) // VerticalLineAbsolute
|> line(endAbsolute = [5.04, -3.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [5.04, -1.68]) // VerticalLineAbsolute
|> line(endAbsolute = [5.88, -1.68]) // HorizontalLineAbsolute
|> line(endAbsolute = [5.88, -0.83999599]) // VerticalLineAbsolute
|> line(endAbsolute = [6.72, -0.83999599]) // HorizontalLineAbsolute
|> line(endAbsolute = [6.72, -1.68]) // VerticalLineAbsolute
|> line(endAbsolute = [7.56, -1.68]) // HorizontalLineAbsolute
|> line(endAbsolute = [7.56, -3.36]) // VerticalLineAbsolute
|> line(endAbsolute = [8.4, -3.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [8.4, -5.04]) // VerticalLineHorizonal
|> line(endAbsolute = [9.24, -5.04]) // HorizontalLineRelative
|> line(endAbsolute = [9.24, -5.88]) // VerticalLineHorizonal
|> line(endAbsolute = [17.64, -5.04]) // MoveAbsolute
|> line(endAbsolute = [17.64, -5.88]) // VerticalLineAbsolute
|> line(endAbsolute = [11.76, -5.88]) // HorizontalLineAbsolute
|> line(endAbsolute = [11.76, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [12.6, -5.04]) // HorizontalLineAbsolute
|> line(endAbsolute = [12.6, -3.36]) // VerticalLineAbsolute
|> line(endAbsolute = [13.44, -3.36]) // HorizontalLineRelative
|> line(endAbsolute = [13.44, -1.68]) // VerticalLineAbsolute
|> line(endAbsolute = [14.28, -1.68]) // HorizontalLineRelative
|> line(endAbsolute = [14.28, -0.83999599]) // VerticalLineAbsolute
|> line(endAbsolute = [15.12, -0.83999599]) // HorizontalLineRelative
|> line(endAbsolute = [15.12, -1.68]) // VerticalLineAbsolute
|> line(endAbsolute = [15.959999999999999, -1.68]) // HorizontalLineRelative
|> line(endAbsolute = [15.959999999999999, -3.36]) // VerticalLineHorizonal
|> line(endAbsolute = [16.8, -3.36]) // HorizontalLineRelative
|> line(endAbsolute = [16.8, -5.04]) // VerticalLineHorizonal
|> line(endAbsolute = [13.44, -1.68]) // MoveAbsolute
|> line(endAbsolute = [13.44, -0]) // VerticalLineAbsolute
|> line(endAbsolute = [15.959999999999999, -0]) // HorizontalLineRelative
|> line(endAbsolute = [15.959999999999999, -1.68]) // VerticalLineHorizonal
|> line(endAbsolute = [16.8, -1.68]) // HorizontalLineRelative
|> line(endAbsolute = [16.8, -3.36]) // VerticalLineHorizonal
|> line(endAbsolute = [17.64, -3.36]) // HorizontalLineRelative
|> line(endAbsolute = [17.64, -4.62]) // VerticalLineAbsolute
|> line(endAbsolute = [16.8, -4.62]) // HorizontalLineAbsolute
|> line(endAbsolute = [16.8, -3.36]) // VerticalLineAbsolute
|> line(endAbsolute = [15.96, -3.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [15.96, -1.68]) // VerticalLineAbsolute
|> line(endAbsolute = [15.12, -1.68]) // HorizontalLineAbsolute
|> line(endAbsolute = [15.12, -0.83999999]) // VerticalLineAbsolute
|> line(endAbsolute = [14.28, -0.83999999]) // HorizontalLineAbsolute
|> line(endAbsolute = [14.28, -1.68]) // VerticalLineAbsolute
|> line(endAbsolute = [13.44, -1.68]) // HorizontalLineAbsolute
|> line(endAbsolute = [13.44, -3.36]) // VerticalLineAbsolute
|> line(endAbsolute = [12.6, -3.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [12.6, -4.62]) // VerticalLineAbsolute
|> line(endAbsolute = [11.76, -4.62]) // HorizontalLineAbsolute
|> line(endAbsolute = [11.76, -3.36]) // VerticalLineAbsolute
|> line(endAbsolute = [12.6, -3.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [12.6, -1.68]) // VerticalLineAbsolute
|> line(endAbsolute = [5.04, -1.68]) // MoveAbsolute
|> line(endAbsolute = [5.04, -0]) // VerticalLineAbsolute
|> line(endAbsolute = [7.56, -0]) // HorizontalLineAbsolute
|> line(endAbsolute = [7.56, -1.68]) // VerticalLineAbsolute
|> line(endAbsolute = [8.4, -1.68]) // HorizontalLineAbsolute
|> line(endAbsolute = [8.4, -3.36]) // VerticalLineAbsolute
|> line(endAbsolute = [9.24, -3.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [9.24, -4.62]) // VerticalLineAbsolute
|> line(endAbsolute = [8.4, -4.62]) // HorizontalLineAbsolute
|> line(endAbsolute = [8.4, -3.36]) // VerticalLineAbsolute
|> line(endAbsolute = [7.56, -3.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [7.56, -1.68]) // VerticalLineAbsolute
|> line(endAbsolute = [6.72, -1.68]) // HorizontalLineAbsolute
|> line(endAbsolute = [6.72, -0.83999999]) // VerticalLineAbsolute
|> line(endAbsolute = [5.88, -0.83999999]) // HorizontalLineAbsolute
|> line(endAbsolute = [5.88, -1.68]) // VerticalLineAbsolute
|> line(endAbsolute = [5.04, -1.68]) // HorizontalLineAbsolute
|> line(endAbsolute = [5.04, -3.36]) // VerticalLineAbsolute
|> line(endAbsolute = [4.2, -3.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [4.2, -4.62]) // VerticalLineAbsolute
|> line(endAbsolute = [3.36, -4.62]) // HorizontalLineAbsolute
|> line(endAbsolute = [3.36, -3.36]) // VerticalLineAbsolute
|> line(endAbsolute = [4.2, -3.36]) // HorizontalLineAbsolute
|> line(endAbsolute = [4.2, -1.68]) // VerticalLineAbsolute
|> line(endAbsolute = [13.44, -5.88]) // MoveAbsolute
|> line(endAbsolute = [13.44, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [14.28, -5.04]) // HorizontalLineRelative
|> line(endAbsolute = [14.28, -4.2]) // VerticalLineAbsolute
|> line(endAbsolute = [15.12, -4.2]) // HorizontalLineRelative
|> line(endAbsolute = [15.12, -5.04]) // VerticalLineHorizonal
|> line(endAbsolute = [15.959999999999999, -5.04]) // HorizontalLineRelative
|> line(endAbsolute = [15.959999999999999, -5.88]) // VerticalLineHorizonal
|> line(endAbsolute = [5.88, -5.04]) // MoveAbsolute
|> line(endAbsolute = [5.88, -4.2]) // VerticalLineAbsolute
|> line(endAbsolute = [6.72, -4.2]) // HorizontalLineAbsolute
|> line(endAbsolute = [6.72, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [7.56, -5.04]) // HorizontalLineAbsolute
|> line(endAbsolute = [7.56, -5.88]) // VerticalLineAbsolute
|> line(endAbsolute = [5.04, -5.88]) // HorizontalLineAbsolute
|> line(endAbsolute = [5.04, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [17.64, -5.88]) // MoveAbsolute
|> line(endAbsolute = [17.64, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [16.8, -5.04]) // HorizontalLineAbsolute
|> line(endAbsolute = [16.8, -4.2]) // VerticalLineAbsolute
|> line(endAbsolute = [17.64, -4.2]) // HorizontalLineRelative
|> line(endAbsolute = [17.64, -5.04]) // VerticalLineHorizonal
|> line(endAbsolute = [18.48, -5.04]) // HorizontalLineRelative
|> line(endAbsolute = [18.48, -5.88]) // VerticalLineHorizonal
|> line(endAbsolute = [3.36, -5.04]) // MoveAbsolute
|> line(endAbsolute = [3.36, -5.88]) // VerticalLineAbsolute
|> line(endAbsolute = [2.52, -5.88]) // HorizontalLineAbsolute
|> line(endAbsolute = [2.52, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [3.36, -5.04]) // HorizontalLineAbsolute
|> line(endAbsolute = [3.36, -4.2]) // VerticalLineAbsolute
|> line(endAbsolute = [4.2, -4.2]) // HorizontalLineAbsolute
|> line(endAbsolute = [4.2, -5.04]) // VerticalLineHorizonal
|> line(endAbsolute = [8.4, -4.2]) // MoveRelative
|> line(endAbsolute = [9.24, -4.2]) // HorizontalLineRelative
|> line(endAbsolute = [9.24, -5.04]) // VerticalLineHorizonal
|> line(endAbsolute = [10.08, -5.04]) // HorizontalLineRelative
|> line(endAbsolute = [10.08, -5.88]) // VerticalLineAbsolute
|> line(endAbsolute = [9.24, -5.88]) // HorizontalLineAbsolute
|> line(endAbsolute = [9.24, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [8.4, -5.04]) // HorizontalLineAbsolute
|> line(endAbsolute = [11.76, -4.2]) // MoveAbsolute
|> line(endAbsolute = [12.6, -4.2]) // HorizontalLineAbsolute
|> line(endAbsolute = [12.6, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [11.76, -5.04]) // HorizontalLineAbsolute
|> line(endAbsolute = [11.76, -5.88]) // VerticalLineAbsolute
|> line(endAbsolute = [10.92, -5.88]) // HorizontalLineAbsolute
|> line(endAbsolute = [10.92, -5.04]) // VerticalLineAbsolute
|> line(endAbsolute = [11.76, -5.04]) // HorizontalLineRelative
|> line(endAbsolute = [14.28, -10.92]) // MoveRelative
|> line(endAbsolute = [13.44, -10.92]) // HorizontalLineRelative
|> line(endAbsolute = [13.44, -13.44]) // VerticalLineHorizonal
|> line(endAbsolute = [14.28, -13.44]) // HorizontalLineRelative
|> close()
|> extrude(length = 1)

56
rust/kcl-lib/e2e/executor/inputs/lego.kcl Normal file
View File

@ -0,0 +1,56 @@
// Lego Brick
const lbumps = 10 // number of bumps long
const wbumps = 6 // number of bumps wide
const pitch = 8.0
const clearance = 0.1
const bumpDiam = 4.8
const bumpHeight = 1.8
const height = 3.2
const t = (pitch - (2 * clearance) - bumpDiam) / 2.0
const postDiam = pitch - t // works out to 6.5
const total_length = lbumps * pitch - (2.0 * clearance)
const total_width = wbumps * pitch - (2.0 * clearance)
const lSegments = total_length / (lbumps + 1)
const wSegments = total_width / (wbumps + 1)
// make the base
const s = startSketchOn('XY')
|> startProfileAt([-total_width / 2, -total_length / 2], %)
|> line(end = [total_width, 0])
|> line(end = [0, total_length])
|> line(end = [-total_width, 0])
|> close()
|> extrude(length = height)
const shellExtrude = startSketchOn(s, "start")
|> startProfileAt([
-(total_width / 2 - t),
-(total_length / 2 - t)
], %)
|> line(end = [total_width - (2 * t), 0])
|> line(end = [0, total_length - (2 * t)])
|> line(end = [-(total_width - (2 * t)), 0])
|> close()
|> extrude(length = -(height - t))
const peg = startSketchOn(s, "end")
|> circle( center= [
-(total_width / 2 - wSegments),
-(total_length / 2 - lSegments)
], radius= bumpDiam / 2)
|> patternLinear2d(
axis = [1, 0],
instances = 6,
distance = 7
)
|> patternLinear2d(
axis = [0, 1],
instances = 10,
distance = 7
)
|> extrude(length = bumpHeight)

21
rust/kcl-lib/e2e/executor/inputs/linear_pattern3d_a_pattern.kcl Normal file
View File

@ -0,0 +1,21 @@
exampleSketch = startSketchOn('XZ')
|> startProfileAt([0, 0], %)
|> line(end = [0, 2])
|> line(end = [3, 1])
|> line(end = [0, -4])
|> close()
|> extrude(length = 1)
pattn1 = patternLinear3d(
exampleSketch,
axis = [1, 0, 0],
instances = 7,
distance = 6
)
pattn2 = patternLinear3d(
pattn1,
axis = [0, 0, 1],
distance = 1,
instances = 7
)

121
rust/kcl-lib/e2e/executor/inputs/lsystem.kcl Normal file
View File

@ -0,0 +1,121 @@
// L-System KCL
// Zoo Corporation ⓒ 2024
// Comparators
fn cond = (bools) => {
return (a, b) => {
x = min(max(-1, a-b), 1) + 1
return bools[x]
}
}
fn Not = (b) => { return if b { false } else { true } }
fn And = (a, b) => { return if a { if b { true } else { false } } else { false }}
fn Or = (a, b) => { return if a { true } else { if b { true } else { false }}}
Eq = cond([false, true, false])
Lt = cond([true, false, false])
Gt = cond([false, false, true])
fn Lte = (a, b) => { return Not(Gt(a, b)) }
fn Gte = (a, b) => { return Not(Lt(a, b)) }
// L-system
// Note: it was most concise to encode productions directly in axioms.
// Change them as you need.
deg = pi()*2 / 360
fn setSketch = (state, q) => {
return {
depthMax: state.depthMax,
depth: state.depth + 1,
currentLength: state.currentLength,
factor: state.factor,
currentAngle: state.currentAngle,
angle: state.angle,
q
}
}
fn setDepth = (state, q) => {
return {
depthMax: state.depthMax,
depth: q,
currentLength: state.currentLength,
factor: state.factor,
currentAngle: state.currentAngle,
angle: state.angle,
q: state.q
}
}
fn setAngle = (state, q) => {
return {
depthMax: state.depthMax,
depth: state.depth,
currentLength: state.currentLength,
factor: state.factor,
currentAngle: q,
angle: state.angle,
q: state.q
}
}
fn setLength = (state, q) => {
return {
depthMax: state.depthMax,
depth: state.depth,
currentLength: q,
factor: state.factor,
currentAngle: state.currentAngle,
angle: state.angle,
q: state.q
}
}
fn Gt2 = (state) => { return setLength(state, state.currentLength * state.factor) }
fn Lt2 = (state) => { return setLength(state, state.currentLength / state.factor) }
fn Add = (state) => { return setAngle(state, rem(int(state.currentAngle - state.angle), divisor = 360)) }
fn Sub = (state) => { return setAngle(state, rem(int(state.currentAngle + state.angle), divisor = 360)) }
// Only necessary to get around recursion limitations...
fn F = (state, F) => {
return if Lt(state.depth, state.depthMax) {
stateNext = state |> setDepth(%, state.depth + 1)
// Produce
// Note:if you need [ and ], just save state to a variable.
stateNext
|> F(%, F) |> Sub(%) |> F(%, F)
|> Add(%) |> Add(%)
|> F(%, F) |> Sub(%) |> F(%, F)
|> setDepth(%, stateNext.depth - 1)
} else {
// Pass onto the next instruction
state |> setSketch(%, angledLine({ angle: state.currentAngle, length: state.currentLength }, state.q))
}
}
fn LSystem = (args, axioms) => {
return axioms({
depthMax: args.iterations,
depth: 0,
currentLength: 1.0,
factor: args.factor,
currentAngle: 0,
angle: args.angle,
q: startSketchAt([0, 0]),
})
}
LSystem({
iterations: 1,
factor: 1.36,
angle: 60,
}, (q) => {
result = q |> F(%, F) |> Add(%) |> Add(%) |> F(%, F) |> Add(%) |> Add(%) |> F(%, F)
return result.q
})

20
rust/kcl-lib/e2e/executor/inputs/math.kcl Normal file
View File

@ -0,0 +1,20 @@
const svg = startSketchOn('XY')
|> lineTo([0],%)
|> lineTo([0 + 1],%)
|> lineTo([0 + 1 + 2],%)
|> lineTo([0 + 1 + 2 + 3],%)
|> lineTo([0 + 1 + 2 + 3 + 4],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17],%)
|> lineTo([0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18],%)

17
rust/kcl-lib/e2e/executor/inputs/member_expression_sketch.kcl Normal file
View File

@ -0,0 +1,17 @@
fn square = (pos, scale) => {
sg = startSketchOn('XY')
|> startProfileAt(pos, %)
|> line(end = [0, scale])
|> line(end = [scale, 0])
|> line(end = [0, -scale])
|> close()
return sg
}
sq = square([0,0], 10)
cb = square([3,3], 4)
|> extrude(length = 10)
// pt1 = sq.paths[0]
// pt2 = cb.value[0]

1005
rust/kcl-lib/e2e/executor/inputs/mike_stress_test.kcl Normal file
View File

File diff suppressed because it is too large Load Diff

6
rust/kcl-lib/e2e/executor/inputs/neg_xz_plane.kcl Normal file
View File

@ -0,0 +1,6 @@
part001 = startSketchOn('-XZ')
|> startProfileAt([0, 0], %)
|> line(endAbsolute = [100, 100])
|> line(endAbsolute = [100, 0])
|> close()
|> extrude(length = 5 + 7)

19
rust/kcl-lib/e2e/executor/inputs/negative_args.kcl Normal file
View File

@ -0,0 +1,19 @@
const width = 5
const height = 10
const length = 12
fn box = (sk1, sk2, scale) => {
const boxSketch = startSketchOn('XY')
|> startProfileAt([sk1, sk2], %)
|> line(end = [0, scale])
|> line(end = [scale, 0])
|> line(end = [0, -scale])
|> close()
|> extrude(length = scale)
return boxSketch
}
box(0, 0, 5)
box(10, 23, 8)
let thing = box(-12, -15, 10)
box(-20, -5, 10)

3
rust/kcl-lib/e2e/executor/inputs/no_visuals/array_elem_push_fail.kcl Normal file
View File

@ -0,0 +1,3 @@
arr = [1, 2, 3]
pushedArr = push(arr, 4)
fail = arr[3]

2
rust/kcl-lib/e2e/executor/inputs/no_visuals/array_index_oob.kcl Normal file
View File

@ -0,0 +1,2 @@
let arr = []
let x = arr[0]

1
rust/kcl-lib/e2e/executor/inputs/no_visuals/comparisons_multiple.kcl Normal file
View File

@ -0,0 +1 @@
assert(3 == 3 == 3, "this should not compile")

1
rust/kcl-lib/e2e/executor/inputs/no_visuals/export_constant.kcl Normal file
View File

@ -0,0 +1 @@
export three = 3

5
rust/kcl-lib/e2e/executor/inputs/no_visuals/export_side_effect.kcl Normal file
View File

@ -0,0 +1,5 @@
export fn foo = () => { return 0 }
// This interacts with the engine.
part001 = startSketchOn('XY')
|> startProfileAt([0, 0], %)

3
rust/kcl-lib/e2e/executor/inputs/no_visuals/identity.kcl Normal file
View File

@ -0,0 +1,3 @@
export fn identity = (x) => {
return x
}

5
rust/kcl-lib/e2e/executor/inputs/no_visuals/if_else_no_expr.kcl Normal file
View File

@ -0,0 +1,5 @@
let x = if true {
let y = 1
} else {
let z = 1
}

1
rust/kcl-lib/e2e/executor/inputs/no_visuals/import_constant.kcl Normal file
View File

@ -0,0 +1 @@
import three from "export_constant.kcl"

3
rust/kcl-lib/e2e/executor/inputs/no_visuals/import_cycle1.kcl Normal file
View File

@ -0,0 +1,3 @@
import two from "import_cycle2.kcl"
export fn one = () => { return two() - 1 }

3
rust/kcl-lib/e2e/executor/inputs/no_visuals/import_cycle2.kcl Normal file
View File

@ -0,0 +1,3 @@
import three from "import_cycle3.kcl"
export fn two = () => { return three() - 1 }

3
rust/kcl-lib/e2e/executor/inputs/no_visuals/import_cycle3.kcl Normal file
View File

@ -0,0 +1,3 @@
import one from "import_cycle1.kcl"
export fn three = () => { return one() + one() + one() }

1
rust/kcl-lib/e2e/executor/inputs/no_visuals/import_from_other_directory.kcl Normal file
View File

@ -0,0 +1 @@
import cube from "../cube.kcl"

4
rust/kcl-lib/e2e/executor/inputs/no_visuals/import_in_function.kcl Normal file
View File

@ -0,0 +1,4 @@
fn foo = () => {
import identity from "identity.kcl"
return 1
}

6
rust/kcl-lib/e2e/executor/inputs/no_visuals/import_in_if.kcl Normal file
View File

@ -0,0 +1,6 @@
if true {
import identity from "identity.kcl"
1
} else {
2
}

1
rust/kcl-lib/e2e/executor/inputs/no_visuals/import_side_effect.kcl Normal file
View File

@ -0,0 +1 @@
import foo from "export_side_effect.kcl"

25
rust/kcl-lib/e2e/executor/inputs/no_visuals/import_simple.kcl Normal file
View File

@ -0,0 +1,25 @@
import identity from "identity.kcl"
answer = identity(42)
assertEqual(answer, 42, 0.0001, "identity")
import identity as id from "identity.kcl"
answer43 = id(43)
assertEqual(answer43, 43, 0.0001, "identity")
import increment, decrement from "numbers.kcl"
answer3 = increment(2)
assertEqual(answer3, 3, 0.0001, "increment")
answer5 = decrement(6)
assertEqual(answer5, 5, 0.0001, "decrement")
import increment as inc, decrement as dec from "numbers.kcl"
answer4 = inc(3)
assertEqual(answer4, 4, 0.0001, "inc")
answer6 = dec(7)
assertEqual(answer6, 6, 0.0001, "dec")

2
rust/kcl-lib/e2e/executor/inputs/no_visuals/invalid_index_fractional.kcl Normal file
View File

@ -0,0 +1,2 @@
let arr = [1, 2, 3]
let x = arr[1.2]

3
rust/kcl-lib/e2e/executor/inputs/no_visuals/invalid_index_negative.kcl Normal file
View File

@ -0,0 +1,3 @@
let arr = [1, 2, 3]
let i = -1
let x = arr[i]

2
rust/kcl-lib/e2e/executor/inputs/no_visuals/invalid_index_str.kcl Normal file
View File

@ -0,0 +1,2 @@
let arr = [1, 2, 3]
let x = arr["s"]

2
rust/kcl-lib/e2e/executor/inputs/no_visuals/invalid_member_object.kcl Normal file
View File

@ -0,0 +1,2 @@
let num = 999
let x = num[3]

2
rust/kcl-lib/e2e/executor/inputs/no_visuals/invalid_member_object_prop.kcl Normal file
View File

@ -0,0 +1,2 @@
let b = true
let x = b["property"]

2
rust/kcl-lib/e2e/executor/inputs/no_visuals/non_string_key_of_object.kcl Normal file
View File

@ -0,0 +1,2 @@
let obj = {key: 123}
let num = obj[3]

7
rust/kcl-lib/e2e/executor/inputs/no_visuals/numbers.kcl Normal file
View File

@ -0,0 +1,7 @@
export fn increment = (x) => {
return x + 1
}
export fn decrement = (x) => {
return x - 1
}

2
rust/kcl-lib/e2e/executor/inputs/no_visuals/object_prop_not_found.kcl Normal file
View File

@ -0,0 +1,2 @@
let obj = {}
let k = obj["age"]

7
rust/kcl-lib/e2e/executor/inputs/no_visuals/pipe_substitution_inside_function_called_from_pipeline.kcl Normal file
View File

@ -0,0 +1,7 @@
// Make sure pipe value doesn't leak into the function call.
fn f = (ignored) => {
return %
}
const answer = %
|> f(%)

39
rust/kcl-lib/e2e/executor/inputs/order-sketch-extrude-in-order.kcl Normal file
View File

@ -0,0 +1,39 @@
// define a plane with UID 94894440791888
const plane94894440791888 = {
plane: {
origin: [0.005000000000000001, 0.01, -0.005],
xAxis: [
0.9285064634886234,
0.37131623619207604,
0.0
],
yAxis: [-0.0, 0.0, 1.0],
zAxis: [
0.37131623619207604,
-0.9285064634886234,
0.0
]
}
}
// create a sketch with UID 94894440902176
const sketch94894440902176 = startSketchOn('-XZ')
|> startProfileAt([-0.005, -0.005], %)
|> line(end = [0.01, 0.0], tag = $line94894439494384)
|> line(end = [0.0, 0.01], tag = $line94894439429616)
|> line(end = [-0.01, 0.0], tag = $line94894439638160)
|> line(end = [0.0, -0.01], tag = $line94894439971808)
// create an extrusion with UID 94894439487136
const extrude94894439487136 = extrude(sketch94894440902176, length = 0.01)
// create a sketch with UID 94894439448464
const sketch94894439448464 = startSketchOn(plane94894440791888)
|> startProfileAt([
0.00074557205559017,
0.00306415853984399
], %)
|> line(end = [0.004999999999999999, 0.0], tag = $line94894440230336)
|> line(end = [0.0, -0.005], tag = $line94894439497168)
|> line(end = [-0.004999999999999999, 0.0], tag = $line94894439496768)
|> line(end = [0.0, 0.005], tag = $line94894440231952)

39
rust/kcl-lib/e2e/executor/inputs/order-sketch-extrude-out-of-order.kcl Normal file
View File

@ -0,0 +1,39 @@
// define a plane with UID 94894440791888
const plane94894440791888 = {
plane: {
origin: [0.005000000000000001, 0.01, -0.005],
xAxis: [
0.9285064634886234,
0.37131623619207604,
0.0
],
yAxis: [-0.0, 0.0, 1.0],
zAxis: [
0.37131623619207604,
-0.9285064634886234,
0.0
]
}
}
// create a sketch with UID 94894440902176
const sketch94894440902176 = startSketchOn('-XZ')
|> startProfileAt([-0.005, -0.005], %)
|> line(end = [0.01, 0.0], tag = $line94894439494384)
|> line(end = [0.0, 0.01], tag = $line94894439429616)
|> line(end = [-0.01, 0.0], tag = $line94894439638160)
|> line(end = [0.0, -0.01], tag = $line94894439971808)
// create a sketch with UID 94894439448464
const sketch94894439448464 = startSketchOn(plane94894440791888)
|> startProfileAt([
0.00074557205559017,
0.00306415853984399
], %)
|> line(end = [0.004999999999999999, 0.0], tag = $line94894440230336)
|> line(end = [0.0, -0.005], tag = $line94894439497168)
|> line(end = [-0.004999999999999999, 0.0], tag = $line94894439496768)
|> line(end = [0.0, 0.005], tag = $line94894440231952)
// create an extrusion with UID 94894439487136
const extrude94894439487136 = extrude(sketch94894440902176, length = 0.01)

18
rust/kcl-lib/e2e/executor/inputs/parametric.kcl Normal file
View File

@ -0,0 +1,18 @@
const sigmaAllow = 35000 // psi
const width = 9 // inch
const p = 150 // Force on shelf - lbs
const distance = 6 // inches
const FOS = 2
const leg1 = 5 // inches
const leg2 = 8 // inches
const thickness = sqrt(distance * p * FOS * 6 / sigmaAllow / width) // inches
const bracket = startSketchOn('XY')
|> startProfileAt([0, 0], %)
|> line(end = [0, leg1])
|> line(end = [leg2, 0])
|> line(end = [0, -thickness])
|> line(end = [-leg2 + thickness, 0])
|> line(end = [0, -leg1 + thickness])
|> close()
|> extrude(length = width)

26
rust/kcl-lib/e2e/executor/inputs/parametric_with_tan_arc.kcl Normal file
View File

@ -0,0 +1,26 @@
const sigmaAllow = 15000 // psi
const width = 11 // inch
const p = 150 // Force on shelf - lbs
const distance = 12 // inches
const FOS = 2
const thickness = sqrt(distance * p * FOS * 6 / ( sigmaAllow * width ))
const filletR = thickness * 2
const shelfMountL = 9
const wallMountL = 8
const bracket = startSketchAt([0, 0])
|> line(end = [0, wallMountL])
|> tangentialArc({
radius: filletR,
offset: 90
}, %)
|> line(end = [-shelfMountL, 0])
|> line(end = [0, -thickness])
|> line(end = [shelfMountL, 0])
|> tangentialArc({
radius: filletR - thickness,
offset: -90
}, %)
|> line(end = [0, -wallMountL])
|> close()
|> extrude(length = width)

26
rust/kcl-lib/e2e/executor/inputs/pattern_vase.kcl Normal file
View File

@ -0,0 +1,26 @@
// Parameters
const r = 50 // base radius
const h = 10 // layer height
const t = 0.005 // taper factor [0-1)
// Defines how to modify each layer of the vase.
// Each replica is shifted up the Z axis, and has a smoothly-varying radius
fn transform = (replicaId) => {
let scale = r * abs(1 - (t * replicaId)) * (5 + cos(replicaId / 8))
return {
translate: [0, 0, replicaId * 10],
scale: [scale, scale, 0],
}
}
// Each layer is just a pretty thin cylinder with a fillet.
fn layer = () => {
return startSketchOn("XY") // or some other plane idk
|> circle(center = [0, 0], radius = 1, tag = $tag1)
|> extrude(length = h)
// |> fillet(
// radius = h / 2.01,
// tags = [tag1, getOppositeEdge(tag1)]
// )
}
// The vase is 100 layers tall.
// The 100 layers are replica of each other, with a slight transformation applied to each.
let vase = layer() |> patternTransform(instances = 100, transform = transform)

38
rust/kcl-lib/e2e/executor/inputs/pentagon_fillet_sugar.kcl Normal file
View File

@ -0,0 +1,38 @@
let triangleHeight = 200
let plumbusLen = 100
let radius = 80
let circ = {angle_start: 0, angle_end: 360, radius: radius}
let triangleLen = 500
const p = startSketchOn('XY')
|> startProfileAt([0, 0], %)
|> angledLine({angle: 60, length:triangleLen}, %, $a)
|> angledLine({angle: 180, length: triangleLen}, %, $b)
|> angledLine({angle: 300, length: triangleLen}, %, $c)
|> extrude(length = triangleHeight)
fn circl = (x, face) => {
return startSketchOn(p, face)
|> startProfileAt([x + radius, triangleHeight/2], %)
|> arc(circ, %, $arc_tag)
|> close()
}
const c1 = circl(-200,c)
const plumbus1 =
c1
|> extrude(length = plumbusLen)
|> fillet(
radius = 5,
tags = [c1.tags.arc_tag, getOppositeEdge(c1.tags.arc_tag)]
)
const c2 = circl(200, a)
const plumbus0 =
c2
|> extrude(length = plumbusLen)
|> fillet(
radius = 5,
tags = [c2.tags.arc_tag, getOppositeEdge(c2.tags.arc_tag)]
, %)

22
rust/kcl-lib/e2e/executor/inputs/pipe_as_arg.kcl Normal file
View File

@ -0,0 +1,22 @@
fn cube = (length, center) => {
let l = length/2
let x = center[0]
let y = center[1]
let p0 = [-l + x, -l + y]
let p1 = [-l + x, l + y]
let p2 = [ l + x, l + y]
let p3 = [ l + x, -l + y]
return startSketchAt(p0)
|> line(endAbsolute = p1)
|> line(endAbsolute = p2)
|> line(endAbsolute = p3)
|> line(endAbsolute = p0)
|> close()
|> extrude(length = length)
}
fn double = (x) => { return x * 2}
fn width = () => { return 200 }
const myCube = cube(200 |> double(%), [0,0])

470
rust/kcl-lib/e2e/executor/inputs/pipes_on_pipes.kcl Normal file
View File

@ -0,0 +1,470 @@
const svg = startSketchOn('XY')
|> startProfileAt([0, 0], %)
|> line(endAbsolute = [22.687663, -2.7664351]) // MoveRelative
|> line(endAbsolute = [15.687664000000002, -5.7664351]) // MoveRelative
|> bezierCurve({ control1: [9.6876636, -13.766435], control2: [12.350729000000001, -9.156355099999999], to: [12.350729000000001, -9.156355099999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [3.6876636000000005, -32.766435], control2: [6.962245000000001, -20.186315], to: [4.8344949, -25.885455]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [5.0392261000000005, -58.571125], control2: [2.9675173000000004, -41.612785], to: [3.0190312000000006, -49.894795]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [10.687664000000002, -73.766435], control2: [6.693877800000001, -63.826655], to: [8.2887432, -68.804835]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [20.375163, -80.578935], control2: [16.045534000000004, -78.630635], to: [16.045534000000004, -78.630635]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [30.062663, -82.266435], control2: [24.812782, -81.936245], to: [24.812782, -81.936245]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [41.125163, -79.516435], control2: [35.794902, -82.039475], to: [35.794902, -82.039475]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [49.687663, -72.766435], control2: [45.867323, -76.907555], to: [45.867323, -76.907555]}, %) // CubicBezierRelative
|> line(endAbsolute = [50.687663, -69.766435]) // LineRelative
|> line(endAbsolute = [50.687663, -62.766435]) // VerticalLineHorizonal
|> line(endAbsolute = [48.687663, -57.891435]) // LineRelative
|> bezierCurve({ control1: [46.351725, -31.692225], control2: [46.191183, -48.997725], to: [46.295503000000004, -40.884555000000006]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [47.7736, -20.934404999999998], control2: [46.687663, -25.766435], to: [46.687663, -25.766435]}, %) // CubicBezierRelative
|> line(endAbsolute = [48.687663, -16.766434999999998]) // LineRelative
|> line(endAbsolute = [47.687663, -9.766435099999999]) // LineRelative
|> bezierCurve({ control1: [40.687663, -3.766435099999999], control2: [44.488820000000004, -6.310115099999999], to: [44.488820000000004, -6.310115099999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [22.687663, -2.766435099999999], control2: [34.632213, -2.2525750999999987], to: [28.903189, -2.550245099999999]}, %) // CubicBezierRelative
// StopRelative
|> line(endAbsolute = [116.68767, -9.766435099999999]) // MoveRelative
|> bezierCurve({ control1: [108.68767, -15.766434999999998], control2: [112.22719, -12.236704999999999], to: [112.22719, -12.236704999999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [102.37517, -28.953934999999998], control2: [105.79825, -20.100575], to: [103.93048, -23.991764999999997]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [101.68767, -47.766435], control2: [101.45837999999999, -35.371444999999994], to: [101.28287, -41.289805]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [110.31267, -61.203935], control2: [103.94304, -53.097335], to: [106.65406999999999, -56.725305]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [116.68767, -66.766435], control2: [113.42043, -64.74899500000001], to: [113.42043, -64.74899500000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [134.68767, -64.766435], control2: [123.4012, -67.124495], to: [128.03363, -66.429955]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [143.68767, -60.766435], control2: [139.37985, -63.042205], to: [139.37985, -63.042205]}, %) // CubicBezierRelative
|> line(endAbsolute = [148.68767, -55.766435]) // LineRelative
|> line(endAbsolute = [149.68767, -54.766435]) // LineRelative
|> bezierCurve({ control1: [149.75017, -46.078935], control2: [149.71427, -51.870655], to: [149.73387, -48.974805]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [150.68767, -36.766435], control2: [149.97673, -41.121905], to: [149.97673, -41.121905]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [158.68767, -30.766435], control2: [154.62517, -32.891435], to: [154.62517, -32.891435]}, %) // CubicBezierRelative
|> line(endAbsolute = [160.68767, -26.766435]) // LineRelative
|> line(endAbsolute = [160.68767, -20.766435]) // VerticalLineHorizonal
|> bezierCurve({ control1: [149.68767, -9.8289351], control2: [157.40521999999999, -16.321455], to: [154.13992, -13.098555000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [145.68767, -7.766435100000001], control2: [148.36767, -9.148315100000001], to: [147.04767, -8.4676851]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [116.68767, -9.7664351], control2: [135.27527, -6.278955100000001], to: [126.6914, -6.2357151]}, %) // CubicBezierRelative
// StopRelative
|> line(endAbsolute = [60.687663, -9.7664351]) // MoveRelative
|> line(endAbsolute = [54.687663, -13.766435000000001]) // MoveRelative
|> bezierCurve({ control1: [48.937663, -25.516435], control2: [50.481933, -19.450155000000002], to: [50.481933, -19.450155000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [47.687663, -41.766435], control2: [47.773086, -31.339325000000002], to: [47.261382, -35.869545]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [50.687663, -56.766435], control2: [48.8286, -49.471785000000004], to: [48.8286, -49.471785000000004]}, %) // CubicBezierRelative
|> line(endAbsolute = [54.687663, -62.766435]) // LineRelative
|> line(endAbsolute = [60.687663, -66.766435]) // LineRelative
|> bezierCurve({ control1: [69.562663, -67.203935], control2: [64.985029, -67.361225], to: [64.985029, -67.361225]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [74.17985, -67.199935], control2: [71.84817100000001, -67.201935], to: [71.84817100000001, -67.201935]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [86.687663, -63.766335], control2: [78.823333, -66.75328499999999], to: [82.418032, -65.599655]}, %) // CubicBezierRelative
|> line(endAbsolute = [86.687663, -61.766335]) // VerticalLineHorizonal
|> line(endAbsolute = [90.687663, -60.766335]) // LineRelative
|> line(endAbsolute = [95.687663, -56.766335]) // LineRelative
|> line(endAbsolute = [98.687663, -49.766335]) // LineRelative
|> bezierCurve({ control1: [97.562663, -37.578835], control2: [98.934927, -43.021825], to: [98.934927, -43.021825]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [95.687663, -32.766335], control2: [96.943913, -35.990714999999994], to: [96.325163, -34.402584999999995]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [86.687663, -27.766334999999998], control2: [90.389309, -28.854045], to: [90.389309, -28.854045]}, %) // CubicBezierRelative
|> line(endAbsolute = [84.687663, -23.766334999999998]) // LineRelative
|> line(endAbsolute = [82.687663, -22.766334999999998]) // LineRelative
|> line(endAbsolute = [79.687663, -17.766334999999998]) // LineRelative
|> line(endAbsolute = [77.687663, -17.766334999999998]) // HorizontalLineRelative
|> line(endAbsolute = [75.687663, -13.766334999999998]) // LineRelative
|> bezierCurve({ control1: [67.687663, -9.766335099999997], control2: [72.005138, -11.383034999999998], to: [72.005138, -11.383034999999998]}, %) // CubicBezierRelative
|> line(endAbsolute = [60.687663, -9.766335099999997]) // HorizontalLineRelative
// StopRelative
|> line(endAbsolute = [295.68767, -33.766435]) // MoveAbsolute
|> bezierCurve({ control1: [286.31267, -36.578935], control2: [292.56461, -34.710375], to: [289.43947000000003, -35.647445000000005]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [242.00408000000002, -50.172685], control2: [271.51088000000004, -41.004795], to: [256.74729, -45.555595000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [234.31267000000003, -52.578935], control2: [239.46591, -50.966755], to: [236.92775, -51.760815]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [227.28923000000003, -54.785975], control2: [231.99494, -53.307255], to: [229.67720000000003, -54.035585000000005]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [208.68767000000003, -59.766435], control2: [221.12295000000003, -56.635855], to: [214.94597000000005, -58.261215]}, %) // CubicBezierRelative
|> line(endAbsolute = [208.68767000000003, -57.766435]) // VerticalLineHorizonal
|> line(endAbsolute = [212.68767000000003, -55.766435]) // LineRelative
|> bezierCurve({ control1: [217.68767000000003, -48.766435], control2: [215.57281000000003, -52.830805], to: [215.57281000000003, -52.830805]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [218.68767000000003, -37.766435], control2: [218.84802000000002, -43.253935], to: [218.84802000000002, -43.253935]}, %) // CubicBezierRelative
|> line(endAbsolute = [215.68767000000003, -31.766435]) // LineRelative
|> bezierCurve({ control1: [208.68767000000003, -26.766435], control2: [212.58234000000002, -28.940575000000003], to: [212.58234000000002, -28.940575000000003]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [192.68767000000003, -22.766435], control2: [203.18777000000003, -24.627585], to: [198.58520000000001, -23.608945000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [174.68767000000003, -24.766435], control2: [186.30665000000002, -22.492965], to: [180.86041000000003, -23.137525]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [170.12517000000003, -25.953935], control2: [173.18205000000003, -25.158315], to: [171.67642000000004, -25.550185000000003]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [161.43767000000003, -31.016435], control2: [165.49678000000003, -27.618325000000002], to: [165.49678000000003, -27.618325000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [152.68767000000003, -41.766435], control2: [157.93412000000004, -34.519995], to: [155.07957000000002, -37.431115]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [152.68767000000003, -50.766435], control2: [151.93767000000003, -46.266435], to: [151.93767000000003, -46.266435]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [160.43767000000003, -61.578935], control2: [156.18761000000003, -57.582325], to: [156.18761000000003, -57.582325]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [164.68767000000003, -64.766435], control2: [162.54142000000002, -63.156755000000004], to: [162.54142000000002, -63.156755000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [180.68767000000003, -67.766435], control2: [172.62751000000003, -66.921865], to: [172.62751000000003, -66.921865]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [158.81267000000003, -75.266435], control2: [173.47790000000003, -70.856345], to: [166.33463000000003, -73.047575]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [138.52752000000004, -81.543785], control2: [148.62236000000001, -78.25548500000001], to: [148.62236000000001, -78.25548500000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [130.12517000000003, -82.828935], control2: [134.68767000000003, -82.766435], to: [134.68767000000003, -82.766435]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [125.68767000000003, -81.766435], control2: [128.66080000000002, -82.478315], to: [127.19642000000003, -82.127685]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [117.68767000000003, -75.766435], control2: [122.99559000000002, -79.800785], to: [120.32975000000002, -77.798805]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [107.68767000000003, -72.766435], control2: [113.16586000000002, -73.682455], to: [113.16586000000002, -73.682455]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [84.93766300000003, -73.953935], control2: [99.87842800000003, -72.226315], to: [92.61523300000002, -72.36835500000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [80.68766300000003, -75.766435], control2: [83.53516300000003, -74.552065], to: [82.13266300000002, -75.15018500000001]}, %) // CubicBezierRelative
|> line(endAbsolute = [75.68766300000003, -80.766435]) // LineRelative
|> line(endAbsolute = [76.68766300000003, -84.766435]) // LineRelative
|> line(endAbsolute = [81.68766300000003, -87.766435]) // LineRelative
|> bezierCurve({ control1: [93.93766300000003, -87.891435], control2: [85.76704300000003, -87.950845], to: [89.85495700000003, -87.974265]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [105.68767000000003, -87.766435], control2: [97.85393000000003, -87.821635], to: [101.77078000000003, -87.772355]}, %) // CubicBezierRelative
|> line(endAbsolute = [106.68767000000003, -88.766435]) // LineRelative
|> line(endAbsolute = [99.68766300000003, -90.766435]) // LineRelative
|> line(endAbsolute = [95.75016300000003, -93.266435]) // LineRelative
|> bezierCurve({ control1: [83.68766300000003, -97.766435], control2: [91.68766300000003, -95.766435], to: [91.68766300000003, -95.766435]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [68.68766300000003, -102.76643], control2: [78.56377900000003, -99.248045], to: [73.64162800000003, -100.78485]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [52.68766300000003, -101.76643], control2: [63.09091200000003, -102.95723], to: [58.18407400000003, -102.86573]}, %) // CubicBezierRelative
|> line(endAbsolute = [48.68766300000003, -106.76643]) // LineRelative
|> line(endAbsolute = [48.68766300000003, -114.76643]) // VerticalLineHorizonal
|> line(endAbsolute = [51.68766300000003, -121.76643]) // LineRelative
|> line(endAbsolute = [56.68766300000003, -123.76643]) // LineRelative
|> line(endAbsolute = [61.68766300000003, -123.76643]) // HorizontalLineRelative
|> line(endAbsolute = [64.68766300000003, -118.76643]) // LineRelative
|> line(endAbsolute = [69.68766300000003, -115.76643]) // LineRelative
|> line(endAbsolute = [69.68766300000003, -113.76643]) // VerticalLineHorizonal
|> line(endAbsolute = [75.68766300000003, -113.76643]) // HorizontalLineRelative
|> line(endAbsolute = [79.68766300000003, -110.76643]) // LineRelative
|> line(endAbsolute = [79.68766300000003, -108.76643]) // VerticalLineHorizonal
|> line(endAbsolute = [85.68766300000003, -109.76643]) // LineRelative
|> line(endAbsolute = [88.68766300000003, -106.76643]) // LineRelative
|> line(endAbsolute = [88.68766300000003, -102.76643]) // VerticalLineHorizonal
|> bezierCurve({ control1: [99.68766300000003, -101.76643], control2: [93.93766300000003, -102.01643], to: [93.93766300000003, -102.01643]}, %) // CubicBezierRelative
|> line(endAbsolute = [103.68767000000003, -105.76643]) // LineRelative
|> line(endAbsolute = [106.68767000000003, -106.76643]) // LineRelative
|> bezierCurve({ control1: [107.68767000000003, -102.76643], control2: [107.18267000000003, -104.78643], to: [107.18267000000003, -104.78643]}, %) // CubicBezierRelative
|> line(endAbsolute = [116.68767000000003, -102.76643]) // HorizontalLineRelative
|> line(endAbsolute = [113.68767000000003, -108.76643]) // LineRelative
|> bezierCurve({ control1: [101.68767000000003, -114.76643], control2: [109.73020000000002, -110.84932], to: [105.72846000000003, -112.85018]}, %) // CubicBezierRelative
|> line(endAbsolute = [97.68766300000003, -118.76643]) // LineRelative
|> line(endAbsolute = [97.68766300000003, -125.76643]) // VerticalLineHorizonal
|> line(endAbsolute = [101.68767000000003, -128.76643]) // LineRelative
|> bezierCurve({ control1: [115.75017000000003, -126.57893000000001], control2: [106.58566000000002, -128.61801000000003], to: [110.98125000000003, -127.69757000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [124.93767000000003, -122.01643000000001], control2: [120.74370000000002, -124.95192000000002], to: [120.74370000000002, -124.95192000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [134.68767000000003, -111.76643000000001], control2: [128.66063000000003, -118.78987000000001], to: [131.76465000000002, -115.73339000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [136.68767000000003, -96.76643500000002], control2: [137.05397000000002, -104.69775000000001], to: [137.05397000000002, -104.69775000000001]}, %) // CubicBezierRelative
|> line(endAbsolute = [135.68767000000003, -95.76643500000002]) // LineRelative
|> line(endAbsolute = [144.68767000000003, -91.76643500000002]) // LineRelative
|> line(endAbsolute = [144.68767000000003, -89.76643500000002]) // VerticalLineHorizonal
|> bezierCurve({ control1: [149.18767000000003, -88.95393500000002], control2: [146.91517000000002, -89.36425500000001], to: [146.91517000000002, -89.36425500000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [158.81267000000003, -86.20393500000002], control2: [154.52930000000003, -87.94347500000002], to: [154.52930000000003, -87.94347500000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [170.68767000000003, -83.76643500000002], control2: [162.68767000000003, -84.76643500000002], to: [162.68767000000003, -84.76643500000002]}, %) // CubicBezierRelative
|> line(endAbsolute = [169.68767000000003, -87.76643500000002]) // LineRelative
|> bezierCurve({ control1: [173.81267000000003, -124.20393000000001], control2: [169.31325000000004, -100.37193000000002], to: [170.34211000000002, -112.05696000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [175.68767000000003, -129.76643], control2: [174.43142000000003, -126.03956000000001], to: [175.05017000000004, -127.87518000000001]}, %) // CubicBezierRelative
|> line(endAbsolute = [177.68767000000003, -129.76643]) // HorizontalLineRelative
|> line(endAbsolute = [179.68767000000003, -133.76643]) // LineRelative
|> line(endAbsolute = [185.68767000000003, -138.76643]) // LineRelative
|> bezierCurve({ control1: [202.68767000000003, -139.76643], control2: [191.47452, -140.21315], to: [196.74116000000004, -140.04174]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [210.68767000000003, -135.76643], control2: [207.25921000000002, -138.23436], to: [207.25921000000002, -138.23436]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [215.35564000000002, -128.27815], control2: [213.71484000000004, -132.0027], to: [213.71484000000004, -132.0027]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [216.91033000000002, -104.88753000000001], control2: [217.63118000000003, -120.57069000000001], to: [217.01741, -112.86275]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [214.68767000000003, -85.76643500000002], control2: [216.67209000000003, -98.33796500000001], to: [216.17402, -92.15775500000001]}, %) // CubicBezierRelative
|> line(endAbsolute = [210.68767000000003, -78.76643500000002]) // LineRelative
|> line(endAbsolute = [207.68767000000003, -78.76643500000002]) // HorizontalLineRelative
|> line(endAbsolute = [207.68767000000003, -75.76643500000002]) // VerticalLineHorizonal
|> line(endAbsolute = [203.68767000000003, -74.76643500000002]) // LineRelative
|> line(endAbsolute = [204.68767000000003, -70.76643500000002]) // LineRelative
|> line(endAbsolute = [209.50017000000003, -70.01643500000002]) // LineRelative
|> bezierCurve({ control1: [226.68767000000003, -64.76643500000002], control2: [215.57464000000002, -68.78927500000002], to: [220.89892000000003, -66.95330500000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [247.31267000000003, -58.578935000000016], control2: [233.53624000000002, -62.60005500000001], to: [240.40800000000002, -60.55978500000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [277.21111, -48.92659500000001], control2: [257.37096, -55.63882500000002], to: [267.2794, -52.26503500000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [299.68767, -41.766435000000016], control2: [284.67443000000003, -46.437325000000016], to: [292.16675000000004, -44.07484500000001]}, %) // CubicBezierRelative
|> line(endAbsolute = [299.68767, -39.766435000000016]) // VerticalLineHorizonal
|> bezierCurve({ control1: [306.50017, -39.328935000000016], control2: [301.93580000000003, -39.62206500000001], to: [304.18392, -39.477685000000015]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [316.68767, -37.766435000000016], control2: [313.07319, -39.10529500000001], to: [313.07319, -39.10529500000001]}, %) // CubicBezierRelative
|> line(endAbsolute = [316.68767, -35.766435000000016]) // VerticalLineHorizonal
|> line(endAbsolute = [320.56267, -35.016435000000016]) // LineRelative
|> bezierCurve({ control1: [335.68767, -29.766435000000016], control2: [325.89187000000004, -33.71663500000002], to: [330.60815, -31.833685000000017]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [343.56267, -27.266435000000016], control2: [339.5858, -28.528935000000015], to: [339.5858, -28.528935000000015]}, %) // CubicBezierRelative
|> line(endAbsolute = [350.68767, -24.766435000000016]) // LineRelative
|> line(endAbsolute = [354.68767, -20.766435000000016]) // LineRelative
|> bezierCurve({ control1: [295.68767, -33.766435000000016], control2: [334.809, -20.766435000000016], to: [314.44364, -27.758665000000015]}, %) // CubicBezierRelative
// StopRelative
|> line(endAbsolute = [299.68767, -66.76643500000002]) // MoveRelative
|> bezierCurve({ control1: [285.00017, -76.64143500000002], control2: [293.75788, -69.23718500000001], to: [289.90768, -72.43500500000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [276.37517, -85.70393500000002], control2: [279.86247000000003, -81.42042500000002], to: [279.86247000000003, -81.42042500000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [273.68767, -88.76643500000002], control2: [275.48830000000004, -86.71456500000002], to: [274.60142, -87.72518500000001]}, %) // CubicBezierRelative
|> line(endAbsolute = [267.68767, -91.76643500000002]) // LineRelative
|> line(endAbsolute = [264.68767, -96.76643500000002]) // LineRelative
|> bezierCurve({ control1: [266.68767, -111.76643000000001], control2: [264.32138000000003, -104.69775000000001], to: [264.32138000000003, -104.69775000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [278.68767, -123.76643000000001], control2: [270.61411000000004, -116.17816000000002], to: [274.2035, -120.01380000000002]}, %) // CubicBezierRelative
|> line(endAbsolute = [282.93767, -126.01643000000001]) // LineRelative
|> bezierCurve({ control1: [303.68767, -126.76643000000001], control2: [289.896, -127.11512000000002], to: [296.66137000000003, -126.99871000000002]}, %) // CubicBezierRelative
|> line(endAbsolute = [305.68767, -125.76643000000001]) // LineRelative
|> line(endAbsolute = [310.68767, -124.76643000000001]) // LineRelative
|> line(endAbsolute = [317.68767, -122.76643000000001]) // LineRelative
|> bezierCurve({ control1: [324.37517, -113.14143000000001], control2: [322.56495, -117.43458000000001], to: [322.56495, -117.43458000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [327.68767, -96.76643500000002], control2: [326.02173000000005, -107.65292000000001], to: [327.05405, -102.46899000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [323.37517, -79.39143500000002], control2: [327.04242000000005, -90.45732500000001], to: [325.54155000000003, -85.36362500000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [320.68767, -73.76643500000002], control2: [322.48830000000004, -77.53518500000001], to: [321.60142, -75.67893500000001]}, %) // CubicBezierRelative
|> line(endAbsolute = [315.68767, -68.76643500000002]) // LineRelative
|> bezierCurve({ control1: [305.43767, -66.32893500000002], control2: [310.76687000000004, -66.51488500000002], to: [310.76687000000004, -66.51488500000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [299.68767, -66.76643500000002], control2: [302.59142, -66.54550500000002], to: [302.59142, -66.54550500000002]}, %) // CubicBezierRelative
// StopRelative
|> line(endAbsolute = [240.68767000000003, -68.76643500000002]) // MoveRelative
|> bezierCurve({ control1: [222.68767000000003, -80.76643500000002], control2: [233.66999, -72.11131500000002], to: [228.65800000000002, -75.79116500000002]}, %) // CubicBezierRelative
|> line(endAbsolute = [219.68767000000003, -86.76643500000002]) // LineRelative
|> bezierCurve({ control1: [222.55095000000003, -116.67268000000001], control2: [219.05386000000001, -97.26953500000002], to: [220.04332000000002, -106.46619000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [227.68767000000003, -130.76643], control2: [223.91824000000003, -121.59681000000002], to: [225.39892000000003, -126.18894000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [236.43377000000004, -136.4969], control2: [232.25590000000003, -134.74853000000002], to: [232.25590000000003, -134.74853000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [249.75017000000003, -138.07893], control2: [241.08415000000005, -137.88476], to: [244.90570000000002, -138.13253]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [254.34783000000002, -138.06723000000002], control2: [251.26740000000004, -138.07493000000002], to: [252.78463000000002, -138.07093]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [265.68767, -135.76644000000002], control2: [259.20097000000004, -137.88174000000004], to: [259.20097000000004, -137.88174000000004]}, %) // CubicBezierRelative
|> line(endAbsolute = [265.68767, -132.76644000000002]) // VerticalLineHorizonal
|> line(endAbsolute = [267.68767, -132.76644000000002]) // HorizontalLineRelative
|> bezierCurve({ control1: [268.56267, -122.32894000000002], control2: [268.96128000000004, -128.41242000000003], to: [268.96128000000004, -128.41242000000003]}, %) // CubicBezierRelative
|> line(endAbsolute = [267.68767, -115.76644000000002]) // LineRelative
|> line(endAbsolute = [262.68767, -110.76644000000002]) // LineRelative
|> line(endAbsolute = [259.68767, -104.76644000000002]) // LineRelative
|> line(endAbsolute = [259.68767, -96.76644500000002]) // VerticalLineHorizonal
|> line(endAbsolute = [263.68767, -91.76644500000002]) // LineRelative
|> line(endAbsolute = [263.68767, -88.76644500000002]) // VerticalLineHorizonal
|> line(endAbsolute = [265.68767, -88.76644500000002]) // HorizontalLineRelative
|> bezierCurve({ control1: [265.68767, -74.76644500000002], control2: [265.77327, -84.10056500000002], to: [265.76887000000005, -79.43241500000002]}, %) // CubicBezierRelative
|> line(endAbsolute = [263.68767, -71.76644500000002]) // LineRelative
|> line(endAbsolute = [257.68767, -68.76644500000002]) // LineRelative
|> bezierCurve({ control1: [240.68767000000003, -68.76644500000002], control2: [251.63750000000002, -68.30105500000002], to: [246.62747000000002, -68.01396500000001]}, %) // CubicBezierRelative
// StopRelative
|> line(endAbsolute = [348.06267, -71.45394500000002]) // MoveRelative
|> bezierCurve({ control1: [336.68767, -78.76644500000002], control2: [342.24112, -73.65657500000002], to: [342.24112, -73.65657500000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [331.68767, -85.76644500000002], control2: [333.86052, -82.22373500000002], to: [333.86052, -82.22373500000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [330.68767, -113.76644000000002], control2: [329.44062, -94.75465500000001], to: [330.36224000000004, -104.56387000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [333.68767, -125.76644000000002], control2: [331.54987, -120.49367000000002], to: [331.54987, -120.49367000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [339.68767, -134.76644000000002], control2: [336.35378000000003, -130.85268000000002], to: [336.35378000000003, -130.85268000000002]}, %) // CubicBezierRelative
|> line(endAbsolute = [344.68767, -136.76644000000002]) // LineRelative
|> bezierCurve({ control1: [354.50017, -136.89144000000002], control2: [347.95588000000004, -136.90388000000002], to: [351.22938000000005, -136.93595000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [359.7072, -136.83674000000002], control2: [357.07765, -136.86434000000003], to: [357.07765, -136.86434000000003]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [363.68767, -136.76644000000002], control2: [361.02076, -136.81354000000002], to: [362.33431, -136.79034000000001]}, %) // CubicBezierRelative
|> line(endAbsolute = [364.68767, -133.76644000000002]) // LineRelative
|> line(endAbsolute = [369.68767, -132.76644000000002]) // LineRelative
|> line(endAbsolute = [374.68767, -127.76644000000002]) // LineRelative
|> line(endAbsolute = [375.68767, -125.76644000000002]) // LineRelative
|> line(endAbsolute = [378.68767, -124.76644000000002]) // LineRelative
|> line(endAbsolute = [381.68767, -119.76644000000002]) // LineRelative
|> bezierCurve({ control1: [383.68767, -90.76644500000002], control2: [383.35291, -110.03795000000002], to: [384.23553000000004, -100.62782000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [376.68767, -74.76644500000002], control2: [381.89678000000004, -84.77624500000002], to: [379.89992, -80.12019500000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [361.68767, -69.76644500000002], control2: [371.66314, -72.44743500000001], to: [367.11478000000005, -70.85187500000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [348.06267, -71.45394500000002], control2: [353.98599, -69.38331500000002], to: [353.98599, -69.38331500000002]}, %) // CubicBezierRelative
// StopRelative
|> line(endAbsolute = [420.68767, -75.76644500000002]) // MoveRelative
|> line(endAbsolute = [414.68767, -78.76644500000002]) // MoveRelative
|> line(endAbsolute = [411.68767, -81.76644500000002]) // MoveRelative
|> bezierCurve({ control1: [394.68767, -89.76644500000002], control2: [406.10302, -84.70574500000002], to: [400.49226000000004, -87.27876500000002]}, %) // CubicBezierRelative
|> line(endAbsolute = [390.68767, -93.76644500000002]) // LineRelative
|> bezierCurve({ control1: [387.00017, -105.95394000000002], control2: [388.81932, -97.84915500000002], to: [387.7277, -101.52261000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [386.68767, -123.76644000000002], control2: [386.61176, -111.93554000000002], to: [386.45034000000004, -117.77373000000001]}, %) // CubicBezierRelative
|> line(endAbsolute = [389.68767, -129.76644000000002]) // LineRelative
|> bezierCurve({ control1: [401.68767, -140.76644000000002], control2: [393.59112000000005, -133.6699], to: [397.39354000000003, -137.31580000000002]}, %) // CubicBezierRelative
|> line(endAbsolute = [406.68767, -142.76644000000002]) // LineRelative
|> bezierCurve({ control1: [419.18767, -141.64144000000002], control2: [414.16723, -143.08983], to: [414.16723, -143.08983]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [431.68767, -133.76644000000002], control2: [424.08865000000003, -139.59937000000002], to: [427.61672000000004, -137.15890000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [438.81267, -125.32894000000002], control2: [436.54426, -129.29261000000002], to: [436.54426, -129.29261000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [443.68767, -106.76644000000002], control2: [441.36597, -119.11592000000002], to: [442.65924, -113.42420000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [442.68767, -87.76644500000002], control2: [443.82181, -100.36380000000001], to: [443.70527000000004, -94.09420500000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [438.68767, -79.76644500000002], control2: [441.01966000000004, -83.40792500000002], to: [441.01966000000004, -83.40792500000002]}, %) // CubicBezierRelative
|> line(endAbsolute = [434.68767, -76.76644500000002]) // LineRelative
|> bezierCurve({ control1: [420.68767, -75.76644500000002], control2: [428.38627, -75.54725500000002], to: [428.38627, -75.54725500000002]}, %) // CubicBezierRelative
|> line(endAbsolute = [119.83194, -25.193075]) // MoveRelative
|> bezierCurve({ control1: [126.83194, -26.193075], control2: [122.14194, -25.523075], to: [124.45194000000001, -25.853075]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [129.83194, -32.193075], control2: [127.82194, -28.173075], to: [128.81194, -30.153075]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [130.83194, -33.193075], control2: [130.16194000000002, -32.523075], to: [130.49194, -32.853075]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [131.83194, -41.193075], control2: [131.16194000000002, -35.833075], to: [131.49194, -38.473075]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [133.83194, -38.193075], control2: [132.49194, -40.203075], to: [133.15194, -39.213075]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [135.26944, -32.068075], control2: [134.30631, -36.171825], to: [134.78069, -34.150575]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [136.83194, -26.193075], control2: [135.78506000000002, -30.129325], to: [136.30069, -28.190575]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [139.83194, -25.193075], control2: [137.82194, -25.863075000000002], to: [138.81194, -25.533075]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [137.39444, -44.318075], control2: [139.51153, -31.793465], to: [139.18359, -37.939365]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [133.83194, -52.193075], control2: [135.83194, -48.193075], to: [135.83194, -48.193075]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [129.83194, -51.193075], control2: [132.51194, -51.863075], to: [131.19194000000002, -51.533075000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [124.83194, -41.193075], control2: [126.83194, -46.193075], to: [126.83194, -46.193075]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [120.83194, -51.193075], control2: [123.51194000000001, -44.493075], to: [122.19194, -47.793075]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [117.83194, -51.193075], control2: [119.84194000000001, -51.193075], to: [118.85194, -51.193075]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [116.83194, -50.193075], control2: [117.50194, -50.863075], to: [117.17194, -50.533075000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [118.83194, -26.193075], control2: [116.5899, -41.883314999999996], to: [116.78264, -34.269515]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [119.83194, -25.193075], control2: [119.16194, -25.863075000000002], to: [119.49194, -25.533075]}, %) // CubicBezierRelative
|> line(endAbsolute = [65.254392, -26.686845]) // MoveRelative
|> bezierCurve({ control1: [69.254392, -26.686845], control2: [66.57439199999999, -26.686845], to: [67.894392, -26.686845]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [70.254392, -32.686845000000005], control2: [69.584392, -28.666845000000002], to: [69.91439199999999, -30.646845000000003]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [69.254392, -35.686845000000005], control2: [69.924392, -33.67684500000001], to: [69.594392, -34.666845]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [69.254392, -44.686845000000005], control2: [69.21439199999999, -38.686575000000005], to: [69.210922, -41.687155000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [72.629392, -39.374345000000005], control2: [70.36814199999999, -42.93371500000001], to: [71.481892, -41.180595000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [78.254392, -30.686845000000005], control2: [74.483601, -36.465155], to: [76.34075899999999, -33.557295]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [81.254392, -30.686845000000005], control2: [79.24439199999999, -30.686845000000005], to: [80.234392, -30.686845000000005]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [80.004392, -42.811845000000005], control2: [81.254392, -38.686845000000005], to: [81.254392, -38.686845000000005]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [74.254392, -52.686845000000005], control2: [78.254392, -46.686845000000005], to: [78.254392, -46.686845000000005]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [73.254392, -53.686845000000005], control2: [73.924392, -53.016845], to: [73.594392, -53.346845]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [67.254392, -53.686845000000005], control2: [71.27439199999999, -53.686845000000005], to: [69.294392, -53.686845000000005]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [61.254391999999996, -48.686845000000005], control2: [65.27439199999999, -52.03684500000001], to: [63.294391999999995, -50.38684500000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [60.254391999999996, -46.686845000000005], control2: [60.924392, -48.02684500000001], to: [60.594392, -47.366845000000005]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [61.254391999999996, -28.686845000000005], control2: [60.10475399999999, -40.47687500000001], to: [60.373141, -34.855605000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [65.254392, -26.686845000000005], control2: [62.574391999999996, -28.026845000000005], to: [63.894391999999996, -27.366845000000005]}, %) // CubicBezierRelative
|> line(endAbsolute = [185.48371, -31.108985]) // MoveRelative
|> bezierCurve({ control1: [197.48371, -31.108985], control2: [189.48289, -31.028185], to: [193.48463, -31.022985000000002]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [198.48371, -36.108985000000004], control2: [197.81371000000001, -32.758985], to: [198.14371, -34.408985]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [197.48371, -38.108985000000004], control2: [198.15371, -36.768985], to: [197.82371, -37.428985000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [189.48371, -38.108985000000004], control2: [194.84371000000002, -38.108985000000004], to: [192.20371, -38.108985000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [188.48371, -42.108985000000004], control2: [189.15371, -39.428985000000004], to: [188.82371, -40.748985000000005]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [196.48371, -43.108985000000004], control2: [191.12371, -42.438985], to: [193.76371, -42.768985]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [196.48371, -47.108985000000004], control2: [196.48371, -44.428985000000004], to: [196.48371, -45.748985000000005]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [191.54621, -48.983985000000004], control2: [194.85433, -47.727735], to: [193.22496, -48.346485]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [186.48371, -51.108985000000004], control2: [189.87558, -49.685235000000006], to: [188.20496, -50.38648500000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [185.48371, -53.108985000000004], control2: [186.15371, -51.768985], to: [185.82371, -52.428985000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [195.48371, -52.108985000000004], control2: [188.78371, -52.778985000000006], to: [192.08371, -52.44898500000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [193.48371, -56.108985000000004], control2: [194.82371, -53.428985000000004], to: [194.16371, -54.748985000000005]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [188.48371, -58.108985000000004], control2: [191.83371, -56.768985], to: [190.18371, -57.428985000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [183.48371, -58.108985000000004], control2: [186.83371, -58.108985000000004], to: [185.18371, -58.108985000000004]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [179.48371, -55.108985000000004], control2: [182.16371, -57.118985], to: [180.84371000000002, -56.12898500000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [180.79621, -38.046485000000004], control2: [178.95086, -49.019255], to: [179.50181, -44.025395]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [182.48371, -33.108985000000004], control2: [181.35308, -36.41710500000001], to: [181.90996, -34.787735000000005]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [185.48371, -31.108985000000004], control2: [183.47371, -32.44898500000001], to: [184.46371, -31.788985000000004]}, %) // CubicBezierRelative
|> line(endAbsolute = [248.52117, -92.100105]) // MoveRelative
|> bezierCurve({ control1: [252.52117, -92.100105], control2: [249.84117, -92.100105], to: [251.16117, -92.100105]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [253.52117, -99.100105], control2: [252.85117000000002, -94.410105], to: [253.18117, -96.720105]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [248.89617, -100.8501], control2: [251.99492, -99.677605], to: [250.46867, -100.2551]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [237.52117, -107.1001], control2: [243.22058, -103.02548], to: [243.22058, -103.02548]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [236.52117, -109.1001], control2: [237.19117, -107.7601], to: [236.86117000000002, -108.42009999999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [252.52117, -108.1001], control2: [241.80117, -108.7701], to: [247.08117000000001, -108.4401]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [253.52117, -112.1001], control2: [252.85117000000002, -109.42009999999999], to: [253.18117, -110.7401]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [248.52117, -117.1001], control2: [251.87117, -113.7501], to: [250.22117, -115.4001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [234.52117, -118.1001], control2: [242.52117, -118.1001], to: [242.52117, -118.1001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [231.52117, -112.1001], control2: [233.53117, -116.1201], to: [232.54117000000002, -114.1401]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [231.52117, -104.1001], control2: [231.52117, -109.4601], to: [231.52117, -106.8201]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [236.52117, -99.100105], control2: [233.17117000000002, -102.45009999999999], to: [234.82117000000002, -100.8001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [236.52117, -97.100105], control2: [236.52117, -98.440105], to: [236.52117, -97.780105]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [248.52117, -92.100105], control2: [240.49514000000002, -95.372295], to: [244.49777, -93.709465]}, %) // CubicBezierRelative
|> line(endAbsolute = [299.09756, -85.781585]) // MoveRelative
|> bezierCurve({ control1: [305.09756, -85.781585], control2: [301.07756, -85.781585], to: [303.05755999999997, -85.781585]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [307.09756, -86.781585], control2: [305.75756, -86.111585], to: [306.41756, -86.441585]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [308.09756, -97.781585], control2: [307.48978999999997, -90.442425], to: [307.81822999999997, -94.110415]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [309.09756, -102.78158], control2: [308.42755999999997, -99.43158500000001], to: [308.75756, -101.08158]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [307.09756, -104.78158], control2: [308.43755999999996, -103.44158], to: [307.77756, -104.10158]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [306.09756, -108.78158], control2: [306.76756, -106.10158], to: [306.43755999999996, -107.42158]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [301.09756, -113.78158], control2: [304.43089, -110.44825], to: [302.76423, -112.11491000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [301.09756, -105.78158], control2: [301.09756, -111.14158], to: [301.09756, -108.50158]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [298.09756, -106.78158], control2: [300.10756, -106.11158], to: [299.11755999999997, -106.44158]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [294.09756, -105.78158], control2: [296.77756, -106.45158], to: [295.45756, -106.12158000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [293.09756, -111.78158], control2: [293.76756, -107.76158000000001], to: [293.43755999999996, -109.74158]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [290.09756, -114.78158], control2: [292.10756, -112.77158], to: [291.11755999999997, -113.76158000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [290.09756, -100.78158], control2: [290.09756, -110.16158], to: [290.09756, -105.54158000000001]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [292.09756, -100.78158], control2: [290.75756, -100.78158], to: [291.41756, -100.78158]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [293.34756, -95.531585], control2: [292.51006, -99.049085], to: [292.92256, -97.316585]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [295.09756, -89.781585], control2: [293.92506, -93.63408500000001], to: [294.50255999999996, -91.736585]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [299.09756, -85.781585], control2: [296.41756, -88.46158500000001], to: [297.73756, -87.141585]}, %) // CubicBezierRelative
|> line(endAbsolute = [419.93938, -96.155625]) // MoveRelative
|> bezierCurve({ control1: [424.75188, -96.218125], control2: [422.32157, -96.186525], to: [422.32157, -96.186525]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [425.75188, -102.21812], control2: [425.08188, -98.198125], to: [425.41188000000005, -100.17812]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [417.75188, -104.21812], control2: [423.11188000000004, -102.87812], to: [420.47188000000006, -103.53811999999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [415.75188, -107.21812], control2: [416.76188, -105.70312], to: [416.76188, -105.70312]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [422.75188, -108.21812], control2: [418.06188000000003, -107.54812], to: [420.37188000000003, -107.87812]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [423.75188, -112.21812], control2: [423.08188, -109.53811999999999], to: [423.41188000000005, -110.85812]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [413.75188, -117.21812], control2: [418.80188000000004, -114.69312], to: [418.80188000000004, -114.69312]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [422.75188, -117.21812], control2: [416.72188000000006, -117.21812], to: [419.69188, -117.21812]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [421.75188, -120.21812], control2: [422.42188000000004, -118.20812], to: [422.09188, -119.19812]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [418.75188, -122.21812], control2: [420.76188, -120.87812], to: [419.77188, -121.53811999999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [411.75188, -123.21812], control2: [416.44188, -122.54812], to: [414.13188, -122.87812]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [407.75188, -121.21812], control2: [410.43188000000004, -122.55812], to: [409.11188000000004, -121.89812]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [409.18938, -103.59312], control2: [407.53385000000003, -114.968], to: [407.63543000000004, -109.67378]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [411.75188, -97.218125], control2: [410.75188, -99.218125], to: [410.75188, -99.218125]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [419.93938, -96.155625], control2: [414.75188, -96.218125], to: [414.75188, -96.218125]}, %) // CubicBezierRelative
|> line(endAbsolute = [198.29461, -92.109945]) // MoveRelative
|> bezierCurve({ control1: [202.29461, -92.109945], control2: [199.61461, -92.109945], to: [200.93461, -92.109945]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [205.29461, -97.109945], control2: [203.28461000000001, -93.759945], to: [204.27461, -95.409945]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [205.29461, -104.10994], control2: [205.29461, -99.419945], to: [205.29461, -101.72994]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [203.29461, -103.10994], control2: [204.63461, -103.77994], to: [203.97461, -103.44994]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [203.29461, -101.10994], control2: [203.29461, -102.44994], to: [203.29461, -101.78994]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [195.29461, -105.10994], control2: [200.58634, -102.35660999999999], to: [197.91966, -103.69645]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [194.29461, -108.10994], control2: [194.96461, -106.09993999999999], to: [194.63461, -107.08994]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [201.29461, -110.10994], control2: [196.60461, -108.76993999999999], to: [198.91461, -109.42993999999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [203.29461, -112.10994], control2: [201.95461, -110.76993999999999], to: [202.61461, -111.42993999999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [203.29461, -117.10994], control2: [203.29461, -113.75994], to: [203.29461, -115.40993999999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [195.29461, -120.10994], control2: [200.65652, -118.18306], to: [197.98453, -119.17430999999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [190.29461, -120.10994], control2: [193.64461, -120.10994], to: [191.99461, -120.10994]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [188.29461, -117.10994], control2: [189.63461, -119.11994], to: [188.97461, -118.12993999999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [194.29461, -114.10994], control2: [190.27461, -116.11994], to: [192.25461, -115.12993999999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [188.29461, -110.10994], control2: [192.31461000000002, -112.78994], to: [190.33461, -111.46994]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [186.29461, -107.10994], control2: [187.63461, -109.11994], to: [186.97461, -108.12993999999999]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [187.29461, -101.10994], control2: [186.62461000000002, -105.12993999999999], to: [186.95461, -103.14994]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [191.29461, -96.109945], control2: [188.61461, -99.45994499999999], to: [189.93461, -97.809945]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [198.29461, -92.109945], control2: [193.60461, -94.789945], to: [195.91461, -93.469945]}, %) // CubicBezierRelative
|> line(endAbsolute = [0, -0]) // MoveRelative
|> bezierCurve({ control1: [3, -1], control2: [0.99, -0.33], to: [1.98, -0.66]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [3, -4], control2: [3, -1.99], to: [3, -2.98]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [8, -4], control2: [4.65, -4], to: [6.3, -4]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [13, -6], control2: [10.475, -4.99], to: [10.475, -4.99]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [13, -10], control2: [13, -7.32], to: [13, -8.64]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [7, -12], control2: [11.02, -10.66], to: [9.04, -11.32]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [3, -12], control2: [5.68, -12], to: [4.36, -12] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [0, -19], control2: [2.01, -14.31], to: [1.02, -16.62] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [-2, -18], control2: [-0.66, -18.67], to: [-1.32, -18.34] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [-3, -8], control2: [-2.383986, -14.672121], to: [-2.7150643, -11.337819] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [-4, -5], control2: [-3.33, -7.01], to: [-3.66, -6.02] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [-1, -5], control2: [-3.01, -5], to: [-2.02, -5]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [0, -0], control2: [-0.6699999999999999, -3.35], to: [-0.33999999999999997, -1.7000000000000002]}, %) // CubicBezierRelative
|> line(endAbsolute = [0, -0]) // MoveRelative
|> bezierCurve({ control1: [7, -0], control2: [2.31, -0], to: [4.62, -0]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [17, -5], control2: [12.3125, -2.3125], to: [12.3125, -2.3125]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [19, -8], control2: [17.99, -6.485], to: [17.99, -6.485]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [17, -14], control2: [18.333333, -10], to: [17.666667, -12]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [15, -14], control2: [16.34, -14], to: [15.68, -14]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [14, -9], control2: [14.67, -12.35], to: [14.34, -10.7] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [6, -8], control2: [11.36, -8.67], to: [8.72, -8.34] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [6, -6], control2: [6, -7.34], to: [6, -6.68] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [1, -5], control2: [4.35, -5.67], to: [2.7, -5.34] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [0, -0], control2: [0.67, -3.35], to: [0.34, -1.7] }, %) // CubicBezierAbsolute
|> line(endAbsolute = [-19.467588, -31.053017]) // MoveRelative
|> bezierCurve({ control1: [-12.467588, -32.053017], control2: [-17.157588, -31.383017], to: [-14.847587999999998, -31.713017]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [-10.467588, -34.053017], control2: [-11.807587999999999, -32.713016999999994], to: [-11.147587999999999, -33.373017]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [-10.467588, -39.053017], control2: [-10.467588, -35.703016999999996], to: [-10.467588, -37.353016999999994]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [-14.467588, -37.053017], control2: [-11.787588, -38.393017], to: [-13.107588, -37.733017]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [-14.467588, -40.053017], control2: [-14.467588, -38.043017], to: [-14.467588, -39.033016999999994]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [-26.467588, -40.053017], control2: [-18.427588, -40.053017], to: [-22.387588, -40.053017]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [-24.467588, -38.053017], control2: [-25.807588, -39.393017], to: [-25.147588, -38.733017]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [-17.467588, -36.053017], control2: [-22.157588, -37.393017], to: [-19.847588, -36.733017]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [-21.467588, -34.053017], control2: [-18.787588, -35.393017], to: [-20.107588, -34.733017]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [-21.467588, -32.053017], control2: [-21.467588, -33.393017], to: [-21.467588, -32.733017]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [-19.467588, -31.053016999999997], control2: [-20.807588, -31.723017], to: [-20.147588, -31.393016999999997]}, %) // CubicBezierRelative
|> line(endAbsolute = [0, -0]) // MoveRelative
|> bezierCurve({ control1: [16, -3], control2: [5.4494016, -0.77848594], to: [10.65681, -1.7240142]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [18, -4], control2: [16.66, -3.33], to: [17.32, -3.66]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [18, -6], control2: [18, -4.66], to: [18, -5.32]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [14, -8], control2: [16.02, -6.99], to: [16.02, -6.99] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [7, -7], control2: [11.69, -7.67], to: [9.38, -7.34] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [1, -3], control2: [5.02, -5.68], to: [3.04, -4.36] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [1, -8], control2: [1, -4.65], to: [1, -6.3] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [-3, -7], control2: [-0.32, -7.67], to: [-1.64, -7.34] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [-4, -3], control2: [-3.33, -5.68], to: [-3.66, -4.36] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [0, -0], control2: [-2.68, -2.01], to: [-1.36, -1.02] }, %) // CubicBezierAbsolute
|> line(endAbsolute = [0, -0]) // MoveAbsolute
|> bezierCurve({ control1: [7, -0], control2: [2.31, -0], to: [4.62, -0] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [7, -4], control2: [7, -1.32], to: [7, -2.64] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [9, -5], control2: [7.66, -4.33], to: [8.32, -4.66] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [5, -7], control2: [7.02, -5.99], to: [7.02, -5.99] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [8, -8], control2: [5.99, -7.33], to: [6.98, -7.66] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [5, -12], control2: [7.01, -9.32], to: [6.02, -10.64] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [6, -18], control2: [5.33, -13.98], to: [5.66, -15.96] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [2, -21], control2: [4.68, -18.99], to: [3.36, -19.98] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [0, -21], control2: [1.34, -21], to: [0.68, -21] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [2, -3], control2: [-0.18556857, -14.319532], to: [0.34378347, -9.6248661] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [0, -3], control2: [1.34, -3], to: [0.68, -3] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [0, -0], control2: [0, -2.01], to: [0, -1.02] }, %) // CubicBezierAbsolute
|> line(endAbsolute = [0, -0]) // MoveRelative
|> bezierCurve({ control1: [1, -4], control2: [0.33, -1.32], to: [0.66, -2.64]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [9, -4], control2: [3.64, -4], to: [6.28, -4]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [12, -1], control2: [9.99, -3.01], to: [10.98, -2.02]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [12, -3], control2: [12, -1.6600000000000001], to: [12, -2.3200000000000003]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [15, -4], control2: [12.99, -3.33], to: [13.98, -3.66]}, %) // CubicBezierRelative
|> bezierCurve({ control1: [12, -6], control2: [14.01, -4.66], to: [13.02, -5.32] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [2, -7], control2: [8.6740937, -6.4007116], to: [5.3398344, -6.7397532] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [9, -11], control2: [5.465, -8.98], to: [5.465, -8.98] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [9, -12], control2: [9, -11.33], to: [9, -11.66] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [1, -11], control2: [6.36, -11.67], to: [3.72, -11.34] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [-2, -9], control2: [0.01, -10.34], to: [-0.98, -9.68] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [-2, -4], control2: [-2, -7.35], to: [-2, -5.7] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [-4, -3], control2: [-2.66, -3.67], to: [-3.32, -3.34] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [0, -2], control2: [-2.68, -2.67], to: [-1.36, -2.34] }, %) // CubicBezierAbsolute
|> bezierCurve({ control1: [0, -0], control2: [0, -1.34], to: [0, -0.68] }, %) // CubicBezierAbsolute
|> close()

58
rust/kcl-lib/e2e/executor/inputs/poop_chute.kcl Normal file
View File

@ -0,0 +1,58 @@
wall_thickness = 0.125
back_walls_width = 2
front_walls_width = 2.5
height = 5.5
filletRadius = 0.050
back_length = 7
exit_height = 1
front_length = 6
Fx = 0.5
Fy = 0.5
sketch001 = startSketchOn('-YZ')
|> startProfileAt([back_walls_width / 2, 0], %)
|> xLine(wall_thickness / 2, %)
|> angledLineToX({ angle: 45, to: back_walls_width }, %, $seg01)
|> yLineTo(height, %)
|> xLine(-wall_thickness, %)
|> yLineTo(segEndY(seg01), %)
|> angledLineToX({
angle: 45,
to: back_walls_width / 2 + wall_thickness / 2
}, %)
|> xLine(-wall_thickness, %)
|> angledLineToX({ angle: 180 - 45, to: wall_thickness }, %)
|> yLineTo(height, %)
|> xLineTo(0, %)
|> yLineTo(segEndY(seg01), %)
|> angledLineToY({ angle: 180 - 45, to: 0 }, %)
|> close()
part001 = revolve({
angle: 90,
axis: {
custom: {
axis: [1.0, 0.0],
origin: [0.0, height + .0000001]
}
}
}, sketch001)
sketch002 = startSketchOn('-YZ')
|> startProfileAt([back_walls_width / 2, 0], %)
|> xLine(wall_thickness / 2, %)
|> angledLineToX({ angle: 45, to: back_walls_width }, %, $seg02)
|> yLineTo(height, %)
|> xLine(-wall_thickness, %)
|> yLineTo(segEndY(seg01), %)
|> angledLineToX({
angle: 45,
to: back_walls_width / 2 + wall_thickness / 2
}, %)
|> xLine(-wall_thickness, %)
|> angledLineToX({ angle: 180 - 45, to: wall_thickness }, %)
|> yLineTo(height, %)
|> xLineTo(0, %)
|> yLineTo(segEndY(seg02), %)
|> angledLineToY({ angle: 180 - 45, to: 0 }, %)
|> close()
|> extrude(length = back_length - height)

2654
rust/kcl-lib/e2e/executor/inputs/riddle.kcl Normal file
View File

File diff suppressed because it is too large Load Diff

17
rust/kcl-lib/e2e/executor/inputs/riddle_small.kcl Normal file
View File

@ -0,0 +1,17 @@
const ANSWER = 41803
fn t = (s) => {
return (ANSWER * s + 12345) % 214748
}
let xs = 205804
let ys = 71816
let ox = 35 - (t(xs) % 70)
let oy = 35 - (t(ys) % 70)
const r = startSketchOn('XZ')
|> startProfileAt([ox, oy], %)
|> line(end = [1, 0])
|> line(end = [0, -1])
|> line(end = [-1, 0])
|> close()
|> extrude(length = 1)

69
rust/kcl-lib/e2e/executor/inputs/router-template-slate.kcl Normal file
View File

@ -0,0 +1,69 @@
const routerDiameter = 12.7
const mmInInch = 25.4
const templateDiameter = mmInInch * 11 / 16
const templateGap = ((templateDiameter - routerDiameter) / 2) -0.5
const slateWidthHalf = 41.5 / 2
const minClampingDistance = 50 + 30
const templateThickness = 10
const radius = 10
const depth = 30
const length001 = slateWidthHalf - radius
const length002 = depth + minClampingDistance
const sketch001 = startSketchOn('XZ')
|> startProfileAt([0, depth - templateGap], %)
|> xLine(length001, %, $seg01)
|> arc({
angleEnd: 0,
angleStart: 90,
radius: radius - templateGap
}, %)
|> yLineTo(-templateGap * 2 - (templateDiameter / 2), %, $seg05)
|> xLineTo(slateWidthHalf + templateThickness, %, $seg04)
|> yLine(-length002, %, $seg03)
|> xLineTo(0, %, $seg02)
|> xLine(-segLen(seg02, %), %)
|> yLine(segLen(seg03, %), %)
|> xLine(segLen(seg04, %), %)
|> yLine(segLen(seg05, %), %)
|> arc({
angleEnd: 90,
angleStart: 180,
radius: radius - templateGap
}, %)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
const extrude001 = extrude(sketch001, length = 5)
const sketch002 = startSketchOn(extrude001, 'START')
|> startProfileAt([
-slateWidthHalf,
-templateGap * 2 - (templateDiameter / 2)
], %)
|> xLine(-7, %, $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001, %) + 90,
minClampingDistance
], %, $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA001, %),
-segLen(rectangleSegmentA001, %)
], %, $rectangleSegmentC001)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
const extrude002 = extrude(sketch002, length = 7.5)
const sketch003 = startSketchOn(extrude001, 'START')
|> startProfileAt([
slateWidthHalf,
-templateGap * 2 - (templateDiameter / 2)
], %)
|> xLine(7, %, $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002, %) - 90,
minClampingDistance
], %)
|> angledLine([
segAng(rectangleSegmentA002, %),
-segLen(rectangleSegmentA002, %)
], %)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
const extrude003 = extrude(sketch003, length = 7.5)

18
rust/kcl-lib/e2e/executor/inputs/scoped-tags.kcl Normal file
View File

@ -0,0 +1,18 @@
fn rect = (origin) => {
return startSketchOn('XZ')
|> startProfileAt(origin, %)
|> angledLine([0, 191.26], %, $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
196.99
], %, $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
], %, $rectangleSegmentC001)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
}
rect([0, 0])
rect([20, 0])

1869
rust/kcl-lib/e2e/executor/inputs/server-rack-heavy.kcl Normal file
View File

File diff suppressed because it is too large Load Diff

1316
rust/kcl-lib/e2e/executor/inputs/server-rack-lite.kcl Normal file
View File

File diff suppressed because it is too large Load Diff

49
rust/kcl-lib/e2e/executor/inputs/sketch-on-chamfer-two-times-different-order.kcl Normal file
View File

@ -0,0 +1,49 @@
const sketch001 = startSketchOn('XZ')
|> startProfileAt([75.8, 317.2], %) // [$startCapTag, $EndCapTag]
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26
], %, $seg01)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
], %)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
const extrude001 = extrude(sketch001, length = 100)
|> fillet( radius = 20, tags = [seg01] )
|> chamfer(
length = 50,
tags = [getOppositeEdge(seg01)],
tag = $seg03
)
|> chamfer(length = 50, tags = [seg02], tag = $seg04)
const sketch003 = startSketchOn(extrude001, seg04)
|> startProfileAt([-69.1, 277.34], %)
|> angledLine([0, 41.48], %, $rectangleSegmentA003)
|> angledLine([
segAng(rectangleSegmentA003) - 90,
104.8
], %, $rectangleSegmentB002)
|> angledLine([
segAng(rectangleSegmentA003),
-segLen(rectangleSegmentA003)
], %, $rectangleSegmentC002)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
const sketch002 = startSketchOn(extrude001, seg03)
|> startProfileAt([159.25, 278.35], %)
|> angledLine([0, 40.82], %, $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002) - 90,
132.27
], %, $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA002),
-segLen(rectangleSegmentA002)
], %, $rectangleSegmentC001)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
const extrude002 = extrude(sketch002, length = 50)

49
rust/kcl-lib/e2e/executor/inputs/sketch-on-chamfer-two-times.kcl Normal file
View File

@ -0,0 +1,49 @@
const sketch001 = startSketchOn('XZ')
|> startProfileAt([75.8, 317.2], %) // [$startCapTag, $EndCapTag]
|> angledLine([0, 268.43], %, $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
217.26
], %, $seg01)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
], %)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)], tag = $seg02)
|> close()
const extrude001 = extrude(sketch001, length = 100)
|> fillet(radius = 20, tags = [seg01])
|> chamfer(length = 50, tags = [seg02], tag = $seg04)
|> chamfer(
length = 50,
tags = [getOppositeEdge(seg01)],
tag = $seg03
)
const sketch003 = startSketchOn(extrude001, seg04)
|> startProfileAt([-69.1, 277.34], %)
|> angledLine([0, 41.48], %, $rectangleSegmentA003)
|> angledLine([
segAng(rectangleSegmentA003) - 90,
104.8
], %, $rectangleSegmentB002)
|> angledLine([
segAng(rectangleSegmentA003),
-segLen(rectangleSegmentA003)
], %, $rectangleSegmentC002)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
const sketch002 = startSketchOn(extrude001, seg03)
|> startProfileAt([159.25, 278.35], %)
|> angledLine([0, 40.82], %, $rectangleSegmentA002)
|> angledLine([
segAng(rectangleSegmentA002) - 90,
132.27
], %, $rectangleSegmentB001)
|> angledLine([
segAng(rectangleSegmentA002),
-segLen(rectangleSegmentA002)
], %, $rectangleSegmentC001)
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
const extrude002 = extrude(sketch002, length = 50)

15
rust/kcl-lib/e2e/executor/inputs/sketch_on_face.kcl Normal file
View File

@ -0,0 +1,15 @@
part001 = startSketchOn('XY')
|> startProfileAt([11.19, 28.35], %)
|> line(end = [28.67, -13.25], tag = $here)
|> line(end = [-4.12, -22.81])
|> line(end = [-33.24, 14.55])
|> close()
|> extrude(length = 5)
part002 = startSketchOn(part001, here)
|> startProfileAt([0, 0], %)
|> line(end = [0, 10])
|> line(end = [10, 0])
|> line(end = [0, -10])
|> close()
|> extrude(length = 5)

55
rust/kcl-lib/e2e/executor/inputs/sketch_on_face_after_fillets_referencing_face.kcl Normal file
View File

@ -0,0 +1,55 @@
// Shelf Bracket
// This is a shelf bracket made out of 6061-T6 aluminum sheet metal. The required thickness is calculated based on a point load of 300 lbs applied to the end of the shelf. There are two brackets holding up the shelf, so the moment experienced is divided by 2. The shelf is 1 foot long from the wall.
// Define our bracket feet lengths
shelfMountL = 8 // The length of the bracket holding up the shelf is 6 inches
wallMountL = 6 // the length of the bracket
// Define constants required to calculate the thickness needed to support 300 lbs
sigmaAllow = 35000 // psi
width = 6 // inch
p = 300 // Force on shelf - lbs
L = 12 // inches
M = L * p / 2 // Moment experienced at fixed end of bracket
FOS = 2 // Factor of safety of 2 to be conservative
// Calculate the thickness off the bending stress and factor of safety
thickness = sqrt(6 * M * FOS / (width * sigmaAllow))
// 0.25 inch fillet radius
filletR = 0.25
// Sketch the bracket and extrude with fillets
bracket = startSketchOn('XY')
|> startProfileAt([0, 0], %)
|> line(end = [0, wallMountL], tag = $outerEdge)
|> line(end = [-shelfMountL, 0], tag = $seg01)
|> line(end = [0, -thickness])
|> line(end = [shelfMountL - thickness, 0], tag = $innerEdge)
|> line(end = [0, -wallMountL + thickness])
|> close()
|> extrude(length = width)
|> fillet(
radius = filletR,
tags = [
getNextAdjacentEdge(innerEdge)
]
)
|> fillet(
radius = filletR + thickness,
tags = [
getNextAdjacentEdge(outerEdge)
]
)
sketch001 = startSketchOn(bracket, seg01)
|> startProfileAt([4.28, 3.83], %)
|> line(end = [2.17, -0.03])
|> line(end = [-0.07, -1.8])
|> line(end = [-2.07, 0.05])
|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|> close()
|> extrude(length = 10)

16
rust/kcl-lib/e2e/executor/inputs/sketch_on_face_circle_tagged.kcl Normal file
View File

@ -0,0 +1,16 @@
fn cube = (pos, scale) => {
const sg = startSketchOn('XY')
|> startProfileAt(pos, %)
|> line(end = [0, scale])
|> line(end = [scale, 0])
|> line(end = [0, -scale])
return sg
}
const part001 = cube([0,0], 20)
|> close()
|> extrude(length = 20)
const part002 = startSketchOn(part001, "end")
|> circle(center: [0, 0], radius: 5, tag =$myCircle)
|> extrude(length = 5)

20
rust/kcl-lib/e2e/executor/inputs/sketch_on_face_end.kcl Normal file
View File

@ -0,0 +1,20 @@
fn cube = (pos, scale) => {
const sg = startSketchOn('XY')
|> startProfileAt(pos, %)
|> line(end = [0, scale])
|> line(end = [scale, 0])
|> line(end = [0, -scale])
return sg
}
const part001 = cube([0,0], 20)
|> close()
|> extrude(length = 20)
const part002 = startSketchOn(part001, "END")
|> startProfileAt([0, 0], %)
|> line(end = [0, 10])
|> line(end = [10, 0])
|> line(end = [0, -10])
|> close()
|> extrude(length = 5)

20
rust/kcl-lib/e2e/executor/inputs/sketch_on_face_end_negative_extrude.kcl Normal file
View File

@ -0,0 +1,20 @@
fn cube = (pos, scale) => {
const sg = startSketchOn('XY')
|> startProfileAt(pos, %)
|> line(end = [0, scale])
|> line(end = [scale, 0])
|> line(end = [0, -scale])
return sg
}
const part001 = cube([0,0], 20)
|> close()
|> extrude(length = 20)
const part002 = startSketchOn(part001, "END")
|> startProfileAt([0, 0], %)
|> line(end = [0, 10])
|> line(end = [10, 0])
|> line(end = [0, -10])
|> close()
|> extrude(length = -5)

20
rust/kcl-lib/e2e/executor/inputs/sketch_on_face_start.kcl Normal file
View File

@ -0,0 +1,20 @@
fn cube = (pos, scale) => {
const sg = startSketchOn('XY')
|> startProfileAt(pos, %)
|> line(end = [0, scale])
|> line(end = [scale, 0])
|> line(end = [0, -scale])
return sg
}
const part001 = cube([0,0], 20)
|> close()
|> extrude(length = 20)
const part002 = startSketchOn(part001, "start")
|> startProfileAt([0, 0], %)
|> line(end = [0, 10])
|> line(end = [10, 0])
|> line(end = [0, -10])
|> close()
|> extrude(length = 5)

81
rust/kcl-lib/e2e/executor/inputs/slow_lego.kcl.tmpl Normal file
View File

@ -0,0 +1,81 @@
// 2x8 Lego Brick
// A standard Lego brick with 2 bumps wide and 8 bumps long.
// Define constants
const lbumps = 10 // number of bumps long
const wbumps = {{N}} // number of bumps wide
const pitch = 8.0
const clearance = 0.1
const bumpDiam = 4.8
const bumpHeight = 1.8
const height = 9.6
const t = (pitch - (2 * clearance) - bumpDiam) / 2.0
const totalLength = lbumps * pitch - (2.0 * clearance)
const totalWidth = wbumps * pitch - (2.0 * clearance)
// Create the plane for the pegs. This is a hack so that the pegs can be patterned along the face of the lego base.
const pegFace = {
plane: {
origin: { x: 0, y: 0, z: height },
xAxis: { x: 1, y: 0, z: 0 },
yAxis: { x: 0, y: 1, z: 0 },
zAxis: { x: 0, y: 0, z: 1 }
}
}
// Create the plane for the tubes underneath the lego. This is a hack so that the tubes can be patterned underneath the lego.
const tubeFace = {
plane: {
origin: { x: 0, y: 0, z: height - t },
xAxis: { x: 1, y: 0, z: 0 },
yAxis: { x: 0, y: 1, z: 0 },
zAxis: { x: 0, y: 0, z: 1 }
}
}
// Make the base
const s = startSketchOn('XY')
|> startProfileAt([-totalWidth / 2, -totalLength / 2], %)
|> line([totalWidth, 0], %)
|> line([0, totalLength], %)
|> line([-totalWidth, 0], %)
|> close(%)
|> extrude(height, %)
// Sketch and extrude a rectangular shape to create the shell underneath the lego. This is a hack until we have a shell function.
const shellExtrude = startSketchOn(s, "start")
|> startProfileAt([
-(totalWidth / 2 - t),
-(totalLength / 2 - t)
], %)
|> line([totalWidth - (2 * t), 0], %)
|> line([0, totalLength - (2 * t)], %)
|> line([-(totalWidth - (2 * t)), 0], %)
|> close(%)
|> extrude(-(height - t), %)
fn tr = (i) => {
let j = i + 1
let x = (j/wbumps) * pitch
let y = (j % wbumps) * pitch
return {
translate: [x, y, 0],
}
}
// Create the pegs on the top of the base
const totalBumps = (wbumps * lbumps)-1
const peg = startSketchOn(s, 'end')
|> circle( center = [
-(pitch*(wbumps-1)/2),
-(pitch*(lbumps-1)/2)
], radius = bumpDiam / 2)
|> patternLinear2d(
axis = [1, 0],
instances = wbumps,
distance = pitch
)
|> patternLinear2d(
axis = [0, 1],
instances = lbumps,
distance = pitch
)
|> extrude(bumpHeight, %)
// |> patternTransform(instances = int(totalBumps-1), transform = tr)

25
rust/kcl-lib/e2e/executor/inputs/tan_arc_x_line.kcl Normal file
View File

@ -0,0 +1,25 @@
let startX = 0
let startY = 0
let angleOffset = 135
let r = 1
let angleStart = 110
startSketchOn('XY')
|> startProfileAt([startX, startY], %)
|> angledLine({
angle: angleStart,
length: .000001,
}, %)
|> tangentialArc({
offset: angleOffset,
radius: r,
}, %, $arc1)
|> tangentialArc({
offset: angleOffset,
radius: 0.5*r,
}, %, $arc2)
|> tangentialArc({
offset: -angleOffset,
radius: 0.5*r,
}, %, $arc3)
|> xLineTo(1, %)

5
rust/kcl-lib/e2e/executor/inputs/tangential_arc.kcl Normal file
View File

@ -0,0 +1,5 @@
const boxSketch = startSketchAt([0, 0])
|> line(end = [0, 10])
|> tangentialArc({radius: 5, offset: 90}, %)
|> line(end = [5, -15])
|> extrude(length = 10)

14
rust/kcl-lib/e2e/executor/inputs/test-circle-extrude.kcl Normal file
View File

@ -0,0 +1,14 @@
sketch002 = startSketchOn('XZ')
|> startProfileAt([-108.83, -57.48], %)
|> angledLine([0, 105.13], %, $rectangleSegmentA001)
|> angledLine([
segAng(rectangleSegmentA001) - 90,
77.9
], %)
|> angledLine([
segAng(rectangleSegmentA001),
-segLen(rectangleSegmentA001)
], %)
|> close()
sketch001 = startSketchOn('XZ')
|> circle(center = [318.33, 168.1], radius = 182.8)

6
rust/kcl-lib/e2e/executor/inputs/xz_plane.kcl Normal file
View File

@ -0,0 +1,6 @@
part001 = startSketchOn('XZ')
|> startProfileAt([0, 0], %)
|> line(endAbsolute = [100, 100])
|> line(endAbsolute = [100, 0])
|> close()
|> extrude(length = 5 + 7)