flo-mat 3.0.15 → 4.0.2

package/src/cp-node/fs/get-boundary-bezier-parts-to-next.ts

@@ -19,8 +19,8 @@ function getBoundaryBezierPartsToNext(
     const cpThis = cpNode; 
     const cpNext = cpNode.next;
 
-    const posThis = cpThis.cp.pointOnShape;
-    const posNext = cpNext.cp.pointOnShape;
+    const posThis = cpThis.pointOnShape;
+    const posNext = cpNext.pointOnShape;
 
     const curveThis = posThis.curve;
     const curveNext = posNext.curve;

package/src/cp-node/fs/get-cp-node-ordering.ts

@@ -6,14 +6,14 @@ import { CpNode } from '../cp-node.js';
  * @param cpNode 
  */
 function getCpNodeOrdering(cpNode: CpNode) {
-    const cp = cpNode.cp;
-    const pos = cp.pointOnShape;
+    // const cp = cpNode.cp;
+    const pos = cpNode.pointOnShape;
 
     return {
         'idx': pos.curve.idx,
         't': pos.t,
-        'order': cp.order,
-        'order2': cp.order2
+        'order': pos.order,
+        'order2': pos.order2
     };
 }
 

package/src/cp-node/fs/get-edge-direction.ts

@@ -12,13 +12,13 @@ import { isPosSharpCorner } from '../../point-on-shape/is-pos-sharp-corner.js';
  * @param cpNode 
  */
 function getEdgeDirection(cpNode: CpNode) {
-    const circleCenter = cpNode.cp.circle.center;
+    const circleCenter = cpNode.pointOnShape.circle.center;
 
     const cp1 = cpNode;
     const cp2 = cpNode.nextOnCircle;
 
-    const pos1 = cp1.cp.pointOnShape;
-    const pos2 = cp2.cp.pointOnShape;
+    const pos1 = cp1.pointOnShape;
+    const pos2 = cp2.pointOnShape;
 
     const p1 = pos1.p;
     const p2 = pos2.p;

package/src/cp-node/fs/get-hole-closers.ts

@@ -1,4 +1,4 @@
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
 import { getAllOnLoop } from "./get-all-on-loop.js";
 
 

package/src/cp-node/fs/get-implied-boundary-bezier-between.ts

@@ -16,8 +16,8 @@ function getImpliedBoundaryBezierBetween(
         cpNodeA: CpNode,
         cpNodeB: CpNode): number[][] | undefined {
 
-    const posA = cpNodeA.cp.pointOnShape;
-    const posB = cpNodeB.cp.pointOnShape;
+    const posA = cpNodeA.pointOnShape;
+    const posB = cpNodeB.pointOnShape;
 
     let { curve: curveA, p: pA, t: tA } = posA;
     let { curve: curveB, p: pB, t: tB } = posB;

package/src/cp-node/fs/get-mat-curve-between.ts

@@ -1,10 +1,12 @@
+import type { CpNode } from '../cp-node.js';
 import { 
     fromTo, dot, cross, rotate90Degrees, interpolate, translate,
     lineLineIntersection
 } from 'flo-vector2d';
-import { CpNode } from '../cp-node.js';
 import { getEdgeDirection } from './get-edge-direction.js';
 
+const { abs } = Math;
+
 
 /** @internal */
 const TOLERANCE_ADD_2PRONG = 0.01;
@@ -22,10 +24,10 @@ function getMatCurveBetween(
         cpNodeFrom: CpNode, 
         cpNodeTo: CpNode): number[][] {
 
-    const fromCc = cpNodeFrom.cp.circle.center;
+    const fromCc = cpNodeFrom.pointOnShape.circle.center;
     const fromL = getEdgeDirection(cpNodeFrom);
 
-    const toCc = cpNodeTo.cp.circle.center;
+    const toCc = cpNodeTo.pointOnShape.circle.center;
     const toL = getEdgeDirection(cpNodeTo.prevOnCircle);
 
     const mid = lineLineIntersection(fromL, toL);
@@ -50,11 +52,11 @@ function getMatCurveBetween(
     const w1 = fromTo(fromL[0], fromL[1]); // This is a unit vector
     const w2 = fromTo(toL[0],  toL[1]);  // This is a unit vector
 
-    const d1 = Math.abs(cross(c, w1)) / (3*3); 
-    const d2 = Math.abs(cross(c, w2)) / (3*3); 
+    const d1 = abs(cross(c, w1)) / (3*3); 
+    const d2 = abs(cross(c, w2)) / (3*3); 
 
     if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
-        // TODO - not within tolerance - must add additional 2-prong
+        // FUTURE - not within tolerance - must add additional 2-prong
         return [fromCc, toCc];
     } 
 

package/src/cp-node/fs/get-salience.ts

@@ -1,6 +1,6 @@
+import type { CpNode } from "../cp-node.js";
 import { distanceBetween } from "flo-vector2d";
 import { totalLength } from "flo-bezier3";
-import { CpNode } from "../cp-node.js";
 import { getBoundaryBeziersBetween } from "./get-boundary-beziers-between.js";
 import { sum } from '../../utils/sum.js';
 
@@ -12,8 +12,8 @@ import { sum } from '../../utils/sum.js';
 function getSalience(cpNode: CpNode) {
     const cpNode1 = cpNode;
     const cpNode2 = cpNode.nextOnCircle;
-    const bp1 = cpNode1.cp.pointOnShape.p;
-    const bp2 = cpNode2.cp.pointOnShape.p;
+    const bp1 = cpNode1.pointOnShape.p;
+    const bp2 = cpNode2.pointOnShape.p;
 
     const d = distanceBetween(bp1, bp2);
 
@@ -21,7 +21,7 @@ function getSalience(cpNode: CpNode) {
 
     const s = sum(pss.map(ps => totalLength(ps)));
 
-    return hasHoleCloser ? Number.POSITIVE_INFINITY : s/d;
+    return hasHoleCloser ? Infinity : s/d;
 }
 
 

package/src/cp-node/fs/insert-cp-node.ts

@@ -1,6 +1,7 @@
-import { LlRbTree } from "flo-ll-rb-tree";
-import { compareCps, ContactPoint } from "../../contact-point/contact-point.js";
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
+import type { PointOnShape } from "../../point-on-shape/point-on-shape.js";
+import type { Mutable } from "../../utils/mutable.js";
+import { RbTree } from "flo-ll-rb-tree";
 import { isOrderCorrect } from "./is-order-correct.js";
 
 
@@ -8,22 +9,21 @@ function insertCpNode(
         insertIfOrderWrong: boolean,
         isHoleClosing: boolean,
         isIntersection: boolean,
-        cpTree: LlRbTree<CpNode>,
-        cp: ContactPoint, 
+        cpTree: RbTree<CpNode>,
+        pos: PointOnShape,
         _prev: CpNode | undefined,
         lastInsertId: { id: number }): CpNode | undefined {
 
     if (_prev !== undefined &&
-        !isOrderCorrect(cpTree, cp, _prev.next)) {
+        !isOrderCorrect(cpTree, pos, _prev.next)) {
 
-        // console.log(compareCps(cp,_prev!.next.cp))
         if (!insertIfOrderWrong) {
             return undefined;
         }
     }
 
-    const cpNode: CpNode = {
-        cp,
+    const cpNode: Mutable<CpNode> = {
+        pointOnShape: pos,
         isHoleClosing,
         isIntersection,
         id: lastInsertId.id,
@@ -37,14 +37,14 @@ function insertCpNode(
     const prev = _prev === undefined ? cpNode : _prev;
     const next = _prev === undefined ? cpNode : prev.next;
 
-    next.prev = cpNode;
-    prev.next = cpNode;
+    (next as Mutable<CpNode>).prev = cpNode;
+    (prev as Mutable<CpNode>).next = cpNode;
     cpNode.prev = prev;
     cpNode.next = next;
 
     cpTree.insert(cpNode);
 
-    return cpNode;
+    return cpNode as CpNode;
 }
 
 

package/src/cp-node/fs/is-one-prong.ts

@@ -1,4 +1,5 @@
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
+import { getRealProngCount } from "./get-real-prong-count.js";
 
 
 /**
@@ -9,20 +10,8 @@ import { CpNode } from "../cp-node.js";
  * Note, however, that two `CpNode`s are stored for each such point to
  * preserve symmetry - see `isTerminating` for more details.
  */
-// TODO2 - remove - or replace with `getRealProngCount === 1`
 function isOneProng(cpNode: CpNode) {
-    const cp1 = cpNode;
-
-    if (cp1.cp.circle.radius === 0) {
-        return true;
-    }
-
-    const cp2 = cp1.nextOnCircle;
-
-    const p1 = cp1.cp.pointOnShape.p;
-    const p2 = cp2.cp.pointOnShape.p;
-
-    return (p1[0] === p2[0] && p1[1] === p2[1]);
+    return getRealProngCount(cpNode) === 1 && !cpNode.isHoleClosing;
 }
 
 

package/src/cp-node/fs/is-order-correct.ts

@@ -1,20 +1,18 @@
 import type { CpNode } from "../cp-node.js";
-import { LlRbTree } from "flo-ll-rb-tree";
-import { compareCps, ContactPoint } from "../../contact-point/contact-point.js";
+import { RbTree } from "flo-ll-rb-tree";
+import { PointOnShape } from "../../point-on-shape/point-on-shape.js";
+import { comparePoss } from "../../point-on-shape/compare-poss.js";
 
 
 function isOrderCorrect(
-        cpTree: LlRbTree<CpNode>,
-        cp: ContactPoint,
+        cpTree: RbTree<CpNode>,
+        pos: PointOnShape,
         next: CpNode): boolean {
 
-    // TODO2
-    const c = compareCps(cp,next.cp);
+    const c = comparePoss(pos, next.pointOnShape);
     if (c < 0) { return true; }
     if (c === 0) {
-        // TODO2
-        // console.log('c === 0');
-        return true;
+        return false;
     }
 
     const minNode = cpTree.getMinNode();
@@ -26,7 +24,7 @@ function isOrderCorrect(
     const max = cpTree.getMaxNode()!.datum;
 
     // larger than all -> crossing zero on loop
-    return (compareCps(max.cp,cp) < 0 && min === next);
+    return (comparePoss(max.pointOnShape!, pos) < 0 && min === next);
 }
 
 

package/src/cp-node/fs/is-sharp.ts

@@ -9,7 +9,7 @@ import { CpNode } from "../cp-node.js";
  * terminating and one not. See `isTerminating` for more details.
  */
 function isSharp(cpNode: CpNode) {
-    return cpNode.cp.circle.radius === 0;
+    return cpNode.pointOnShape.circle.radius === 0;
 }
 
 

package/src/cp-node/fs/remove-cp-node.ts

@@ -1,22 +1,20 @@
-// import { Loop } from 'flo-boolean';
-// import { LlRbTree } from 'flo-ll-rb-tree';
 import type { CpNode } from "../cp-node.js";
 import type { MatMeta } from '../../mat/mat-meta.js';
+import type { Mutable } from "../../utils/mutable.js";
 
 
 function removeCpNode(
         cpNode: CpNode,
         meta: MatMeta): void {
-        // cpTrees: Map<Loop, LlRbTree<CpNode>>): void {
 
     const { cpTrees } = meta;
 
     const prev = cpNode.prev;
     const next = cpNode.next;
-    prev.next = next;
-    next.prev = prev;
+    (prev as Mutable<CpNode>).next = next;
+    (next as Mutable<CpNode>).prev = prev;
 
-    const cpTree = cpTrees.get(cpNode.cp.pointOnShape.curve.loop)!;
+    const cpTree = cpTrees.get(cpNode.pointOnShape.curve.loop)!;
     cpTree.remove(cpNode, false); 
 }
 

package/src/cp-node/fs/traverse-cp.ts

@@ -27,7 +27,7 @@ function traverseCp(
         const next = cpNode.next.prevOnCircle;
         cpNode = cpNode === next
                 ? cpNode = cpNode.next.next // Terminal vertex
-                : cpNode = next         // Take last exit
+                : cpNode = next             // Take last exit
     
     } while (cpNode !== cpStart); 
     

package/src/cp-node/fs/traverse-vertices.ts

@@ -1,5 +1,4 @@
-import { CpNode } from '../cp-node.js';
-import { CpNodeFs } from '../cp-node-fs.js';
+import type { CpNode } from '../cp-node.js';
 import { getAllOnCircle } from './get-all-on-circle.js';
 import { isTerminating } from './is-terminating.js';
 import { getVertexForwardChildren } from './get-vertex-forward-children.js';

package/src/cp-node/stringification/cp-node-stringifyable.ts

@@ -1,5 +1,5 @@
-// import type { Loop } from "flo-boolean";
 import type { Circle } from "../../geometry/circle";
+import type { PointOnShape } from "../../point-on-shape/point-on-shape";
 import type { CpNode } from "../cp-node";
 import type { LoopStringifyable } from "./loop-stringifyable";
 
@@ -18,23 +18,14 @@ type Edge =
 
 
 /** @internal */
-type PointOnShapeSimplified = {
+type PointOnShapeSimplified = Omit<PointOnShape, 'curve'> & {
     readonly loopIdx: number;
     readonly curveIdx: number;
-    readonly p: number[];
-    readonly t: number;
-    readonly isSource?: boolean;
 }
+
 /** @internal */
-type ContactPointSimplified = {
-    readonly circle: Circle;
+type CpNodeSimplified = Omit<CpNode, 'pointOnShape'> & {
     readonly pointOnShape: PointOnShapeSimplified;
-    readonly order: number;
-    readonly order2: number;
-}
-/** @internal */
-type CpNodeSimplified = Omit<CpNode, 'cp'> & {
-    readonly cp: ContactPointSimplified;
 }
 
 /** @internal */
@@ -48,8 +39,8 @@ type CpNodeWithAnyEdges = PartialBy<
 
 
 interface CpNodeStringifyable {
-    cpNodes: CpNodeWithAnyEdges[];
-    loops: LoopStringifyable[];
+    readonly cpNodes: CpNodeWithAnyEdges[];
+    readonly loops: LoopStringifyable[];
 }
 
 
@@ -62,7 +53,7 @@ const EDGES: Edge[] = [
 
 export { EDGES }
 export type {
-    PointOnShapeSimplified, ContactPointSimplified,
+    PointOnShapeSimplified,
     CpNodeSimplified, CpNodeSimplifiedEdgeless,
     CpNodeStringifyable, CpNodeWithAnyEdges,
 }

package/src/cp-node/stringification/from-stringifyable.ts

@@ -1,4 +1,4 @@
-import type { ContactPoint } from "../../contact-point/contact-point";
+import type { PointOnShape } from "../../point-on-shape/point-on-shape.js";
 import type { CpNode } from "../cp-node";
 import type { CpNodeStringifyable } from "./cp-node-stringifyable";
 import { EDGES } from "./cp-node-stringifyable";
@@ -16,22 +16,22 @@ function fromStringifyable(
     // Edges still hold number ids at this point.
     //--------------------------------------------------------------------------
     const cpNodes: CpNode[] = _cpNodes.map(cpNode_ => {
-        const { id, cp, isHoleClosing, isIntersection } = cpNode_;
-        const { circle, pointOnShape, order, order2 } = cp;
+        const { id, pointOnShape, isHoleClosing, isIntersection } = cpNode_;
+        const { circle, order, order2 } = pointOnShape;
         const { curveIdx, loopIdx, p, t, isSource } = pointOnShape;
 
         const curve = loops[loopIdx].curves[curveIdx];
 
-        const cp_: ContactPoint = {
+        const pointOnShape_: PointOnShape = {
             circle,
-            pointOnShape: { curve, p, t, isSource },
+            curve, p, t, isSource,
             order, order2
         };
 
         return {
             ...cpNode_,
             id, isHoleClosing, isIntersection,
-            cp: cp_
+            pointOnShape: pointOnShape_
         } as CpNode;
     });
 

package/src/cp-node/stringification/to-stringifyable.ts

@@ -23,12 +23,11 @@ function toStringifyable(
     do {
         const {
             id, isHoleClosing, isIntersection,
-            cp,
+            pointOnShape,
             prev, next, nextOnCircle, prevOnCircle, holeCloserTwin,
         } = cpNode
 
-        const { pointOnShape, circle, order, order2 } = cp;
-        const { curve, p, t, isSource } = pointOnShape;
+        const { curve, p, t, isSource, circle, order, order2 } = pointOnShape;
         const { idx: curveIdx, loop, ps, prev: prevCurve, next: nextCurve } = curve;
 
         if (!loopSet.has(loop)) {
@@ -36,16 +35,13 @@ function toStringifyable(
         }
 
         const posSimplified: PointOnShapeSimplified = {
-            curveIdx, loopIdx: loop.idx!, p, t, isSource
+            curveIdx, loopIdx: loop.idx!, p, t, isSource,
+            circle, order, order2
         };
 
         cpNodes_.push({
             id, isHoleClosing, isIntersection,
-            cp: {
-                circle,
-                pointOnShape: posSimplified,
-                order, order2
-            },
+            pointOnShape: posSimplified,
             prev: prev.id,
             next: next.id,
             prevOnCircle: prevOnCircle.id,

package/src/debug/debug-elem-types.ts

@@ -6,7 +6,7 @@ type DebugElemKey = keyof typeof emptyDebugElems;
 
 
 const emptyDebugElems = {
-    oneProng: [] as CpNode[][],
+    oneProng: [] as CpNode[],
     // oneProngAtDullCorner: [] as PointOnShape[],
     twoProng: [] as CpNode[],
     threeProng: [] as CpNode[],
@@ -22,8 +22,7 @@ const emptyDebugElems = {
     cull: [] as number[][],
     cpNode: [] as CpNode[],
     branch: [] as CpNode[][],
-    holeCloser: [] as CpNode[],
-    speed: [] as CpNode[]
+    holeCloser: [] as CpNode[]
 } as const;
 
 

package/src/{mat → debug}/elem-type-two-prong.ts

@@ -5,4 +5,4 @@ type ElemType_TwoProng =
     | 'twoProng_holeClosing';
 
 
-export { ElemType_TwoProng }
+export type { ElemType_TwoProng }

package/src/debug/functions/check-ordering.ts

@@ -1,15 +1,13 @@
 import type { Loop } from "flo-boolean";
-import type { LlRbTree } from "flo-ll-rb-tree";
 import type { MatMeta } from "../../mat/mat-meta.js";
-import { compareCps } from "../../contact-point/contact-point.js";
 import { CpNode } from "../../cp-node/cp-node.js";
 import { getAllOnLoop } from "../../cp-node/fs/get-all-on-loop.js";
 import { getProngCount } from "../../cp-node/fs/get-prong-count.js";
 import { isOrderCorrect } from "../../cp-node/fs/is-order-correct.js";
+import { comparePoss } from "../../point-on-shape/compare-poss.js";
 
 
 function checkOrdering(
-        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
         meta: MatMeta,
         cpStart: CpNode) {
 
@@ -21,22 +19,20 @@ function checkOrdering(
     for (const cpNodeA of cpNodes) {
         const cpNodeB = cpNodeA.next;
 
-        const cpA = cpNodeA.cp;
-        const posA = cpA.pointOnShape;
+        const posA = cpNodeA.pointOnShape;
         const idxA = posA.curve.idx;
         const pA = posA.p;
         const loopA = posA.curve.loop;
         const cpTreeA = cpTrees.get(loopA)!;
 
-        const cpB = cpNodeB.cp;
-        const posB = cpB.pointOnShape;
+        const posB = cpNodeB.pointOnShape;
         const idxB = posB.curve.idx;
         const pB = posB.p;
         // const loopB = posB.curve.loop;
         // const cpTreeB = cpTrees.get(loopB)!;
         
         const orderCorrect = isOrderCorrect(
-            cpTreeA, cpA, cpNodeB
+            cpTreeA, posA, cpNodeB
         )
         if (!orderCorrect) {
             const A: Order = {
@@ -44,20 +40,20 @@ function checkOrdering(
                 p: pA,
                 cpNode: cpNodeA,
                 curveIdx: idxA,
-                t: cpA.pointOnShape.t,
-                order: cpA.order,
-                order2: cpA.order2
+                t: posA.t,
+                order: posA.order,
+                order2: posA.order2
             }
             const B: Order = {
                 prongCount: getProngCount(cpNodeB),
                 p: pB,
                 cpNode: cpNodeB,
                 curveIdx: idxB,
-                t: cpB.pointOnShape.t,
-                order: cpB.order,
-                order2: cpB.order2
+                t: posB.t,
+                order: posB.order,
+                order2: posB.order2
             }
-            const loopA = A.cpNode.cp.pointOnShape.curve.loop;
+            const loopA = A.cpNode.pointOnShape.curve.loop;
             let wrongs = wrongsPerLoop.get(loopA);
             if (wrongs === undefined) {
                 wrongs = [];
@@ -68,12 +64,12 @@ function checkOrdering(
     }
 
     for (const [loop,wrongs] of wrongsPerLoop) {
-        let maxOrder = Number.NEGATIVE_INFINITY;
+        let maxOrder = -Infinity;
         let max: Order | undefined = undefined;
         for (const wrong of wrongs) {
             const A = wrong[0];
             const B = wrong[1];
-            const c = compareCps(A.cpNode.cp,B.cpNode.cp);
+            const c = comparePoss(A.cpNode.pointOnShape, B.cpNode.pointOnShape);
             if (c > maxOrder) { 
                 
             }

package/src/debug/functions/cmp-cp-on-delta.ts

@@ -1,5 +1,5 @@
-import { CpNode } from '../../cp-node/cp-node.js';
-import { ContactPoint, compareCps } from '../../contact-point/contact-point.js';
+import type { CpNode } from '../../cp-node/cp-node.js';
+import { PointOnShape } from '../../point-on-shape/point-on-shape.js';
 
 
 /**
@@ -17,7 +17,7 @@ import { ContactPoint, compareCps } from '../../contact-point/contact-point.js';
  */
 function cmpCpOnδ(
         δ: CpNode[], 
-        cp: ContactPoint) {
+        cp: PointOnShape) {
 
     if (δ[0] === undefined) { 
         return 1;

package/src/debug/functions/draw-elem/draw-branch.ts

@@ -1,6 +1,4 @@
-import { drawFs } from 'flo-draw';
-import { CpNode } from '../../../cp-node/cp-node.js';
-import { CpNodeFs } from '../../../cp-node/cp-node-fs.js';
+import type { CpNode } from '../../../cp-node/cp-node.js';
 import { getMatCurveToNext } from '../../../cp-node/fs/get-mat-curve-to-next.js';
 import { isTerminating } from '../../../cp-node/fs/is-terminating.js';
 import { drawBeziersAsSinglePath } from '../draw/draw-beziers-as-single-path.js';

package/src/debug/functions/draw-elem/draw-cp-node.ts

@@ -1,8 +1,7 @@
-
+import type { CpNode } from '../../../cp-node/cp-node.js';
 import { drawFs } from 'flo-draw';
 import { scaleCircle } from '../../../geometry/circle.js';
-import { CpNode } from '../../../cp-node/cp-node.js';
-import { CpNodeFs } from '../../../cp-node/cp-node-fs.js';
+import { getAllOnCircle } from '../../../cp-node/fs/get-all-on-circle.js';
 
 
 /** @internal */
@@ -14,13 +13,13 @@ function drawCpNode(
         scaleFactor = 1) {
 
     const circle = scaleCircle(
-        cpNode.cp.circle,
+        cpNode.pointOnShape.circle,
         1
     );
     const { center: c, radius: r } = circle;
     
-    const poss = CpNodeFs.getAllOnCircle(cpNode)
-        .map(cpNode => cpNode.cp.pointOnShape)
+    const poss = getAllOnCircle(cpNode)
+        .map(cpNode => cpNode.pointOnShape)
 
     const { dot, circle: drawCircle, crossHair } = drawFs;
 

package/src/debug/functions/draw-elem/draw-elem.ts

@@ -18,7 +18,6 @@ import { drawCull } from './draw-cull.js';
 import { drawBranch } from './draw-branch.js';
 import { oneProngAtDullCorner } from './draw-one-prong-at-dull-corner.js';
 import { drawCpNode } from './draw-cp-node.js';
-import { drawSpeed } from './draw-speed.js';
 
 
 type DrawElemFunction<T extends DebugElemKey> = (
@@ -37,8 +36,6 @@ type DrawElemFunctions = { [T in DebugElemKey]: DrawElemFunction<T> }
 /** @internal */
 const drawElemFs: DrawElemFunctions = {
     oneProng: drawOneProng,
-    // oneProngAtDullCorner,
-    // csf,
     twoProng: drawTwoProng(false, true),
     threeProng: drawThreeProng,
     boundingHull,
@@ -54,8 +51,7 @@ const drawElemFs: DrawElemFunctions = {
     cull: drawCull,
     cpNode: drawCpNode,
     branch: drawBranch,
-    holeCloser: drawTwoProng(false, false),
-    speed: drawSpeed
+    holeCloser: drawTwoProng(false, false)
 }