@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/geometries/geom3/toCompactBinary.d.ts

@@ -1,5 +1,3 @@
-import Geom3 from './type'
+import type { Geom3 } from './type.d.ts'
 
-export default toCompactBinary
-
-declare function toCompactBinary(geom: Geom3): Float32Array
+export function toCompactBinary(geom: Geom3): Float32Array

package/src/geometries/geom3/toCompactBinary.js

@@ -1,12 +1,12 @@
-const poly3 = require('../poly3')
+import * as poly3 from '../poly3/index.js'
 
 /**
  * Return the given geometry in compact binary representation.
- * @param {geom3} geometry - the geometry
+ * @param {Geom3} geometry - the geometry
  * @return {TypedArray} compact binary representation
  * @alias module:modeling/geometries/geom3.toCompactBinary
  */
-const toCompactBinary = (geometry) => {
+export const toCompactBinary = (geometry) => {
   const polygons = geometry.polygons
   const transforms = geometry.transforms
 
@@ -48,21 +48,19 @@ const toCompactBinary = (geometry) => {
   let ci = 22
   let vi = ci + numberOfPolygons
   polygons.forEach((polygon) => {
-    const points = poly3.toPoints(polygon)
+    const vertices = poly3.toVertices(polygon)
     // record the number of vertices per polygon
-    compacted[ci] = points.length
+    compacted[ci] = vertices.length
     ci++
     // convert the vertices
-    for (let i = 0; i < points.length; i++) {
-      const point = points[i]
-      compacted[vi + 0] = point[0]
-      compacted[vi + 1] = point[1]
-      compacted[vi + 2] = point[2]
+    for (let i = 0; i < vertices.length; i++) {
+      const vertex = vertices[i]
+      compacted[vi + 0] = vertex[0]
+      compacted[vi + 1] = vertex[1]
+      compacted[vi + 2] = vertex[2]
       vi += 3
     }
   })
   // TODO: how about custom properties or fields ?
   return compacted
 }
-
-module.exports = toCompactBinary

package/src/geometries/geom3/toPoints.d.ts

@@ -1,6 +1,4 @@
-import Geom3 from './type'
-import Vec3 from '../../maths/vec3/type'
+import type { Geom3 } from './type.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
 
-export default toPoints
-
-declare function toPoints(geometry: Geom3): Array<Array<Vec3>>
+export function toPoints(geometry: Geom3): Array<Array<Vec3>>

package/src/geometries/geom3/toPoints.js

@@ -1,18 +1,15 @@
-const poly3 = require('../poly3')
+import * as poly3 from '../poly3/index.js'
 
-const toPolygons = require('./toPolygons')
+import { toPolygons } from './toPolygons.js'
 
 /**
  * Return the given geometry as a list of points, after applying transforms.
  * The returned array should not be modified as the points are shared with the geometry.
- * @param {geom3} geometry - the geometry
+ * @param {Geom3} geometry - the geometry
  * @return {Array} list of points, where each sub-array represents a polygon
  * @alias module:modeling/geometries/geom3.toPoints
  */
-const toPoints = (geometry) => {
+export const toPoints = (geometry) => {
   const polygons = toPolygons(geometry)
-  const listofpoints = polygons.map((polygon) => poly3.toPoints(polygon))
-  return listofpoints
+  return polygons.map((polygon) => poly3.toVertices(polygon))
 }
-
-module.exports = toPoints

package/src/geometries/geom3/toPoints.test.js

@@ -1,19 +1,19 @@
-const test = require('ava')
+import test from 'ava'
 
-const { toPoints, fromPoints, toString } = require('./index')
+import { toPoints, fromPoints, toString } from './index.js'
 
-const { comparePolygonsAsPoints } = require('../../../test/helpers/')
+import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
-test('toPoints: Creates an array of points from a populated geom3', (t) => {
-  const points = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
-  const geometry = fromPoints(points)
+test('toPoints: Creates an array of vertices from a populated geom3', (t) => {
+  const vertices = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
+  const geometry = fromPoints(vertices)
 
   toString(geometry)
 
   const expected = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
-  const pointarray = toPoints(geometry)
-  t.deepEqual(pointarray, expected)
-  t.true(comparePolygonsAsPoints(pointarray, expected))
+  const vertexList = toPoints(geometry)
+  t.deepEqual(vertexList, expected)
+  t.true(comparePolygonsAsPoints(vertexList, expected))
 
   toString(geometry)
 })

package/src/geometries/geom3/toPolygons.d.ts

@@ -1,6 +1,4 @@
-import Geom3 from './type'
-import Poly3 from '../poly3/type'
+import type { Geom3 } from './type.d.ts'
+import type { Poly3 } from '../poly3/type.d.ts'
 
-export default toPolygons
-
-declare function toPolygons(geometry: Geom3): Array<Poly3>
+export function toPolygons(geometry: Geom3): Array<Poly3>

package/src/geometries/geom3/toPolygons.js

@@ -1,15 +1,13 @@
-const applyTransforms = require('./applyTransforms')
+import { applyTransforms } from './applyTransforms.js'
 
 /**
  * Produces an array of polygons from the given geometry, after applying transforms.
  * The returned array should not be modified as the polygons are shared with the geometry.
- * @param {geom3} geometry - the geometry
+ * @param {Geom3} geometry - the geometry
  * @returns {Array} an array of polygons
  * @alias module:modeling/geometries/geom3.toPolygons
  *
  * @example
- * let sharedpolygons = toPolygons(geometry)
+ * let sharedPolygons = toPolygons(geometry)
  */
-const toPolygons = (geometry) => applyTransforms(geometry).polygons
-
-module.exports = toPolygons
+export const toPolygons = (geometry) => applyTransforms(geometry).polygons

package/src/geometries/geom3/toString.d.ts

@@ -1,5 +1,3 @@
-import Geom3 from './type'
+import type { Geom3 } from './type.d.ts'
 
-export default toString
-
-declare function toString(geometry: Geom3): string
+export function toString(geometry: Geom3): string

package/src/geometries/geom3/toString.js

@@ -1,17 +1,17 @@
-const poly3 = require('../poly3')
+import * as poly3 from '../poly3/index.js'
 
-const toPolygons = require('./toPolygons')
+import { toPolygons } from './toPolygons.js'
 
 /**
  * Create a string representing the contents of the given geometry.
- * @param {geom3} geometry - the geometry
- * @returns {String} a representative string
+ * @param {Geom3} geometry - the geometry
+ * @returns {string} a representative string
  * @alias module:modeling/geometries/geom3.toString
  *
  * @example
  * console.out(toString(geometry))
  */
-const toString = (geometry) => {
+export const toString = (geometry) => {
   const polygons = toPolygons(geometry)
   let result = 'geom3 (' + polygons.length + ' polygons):\n'
   polygons.forEach((polygon) => {
@@ -19,5 +19,3 @@ const toString = (geometry) => {
   })
   return result
 }
-
-module.exports = toString

package/src/geometries/geom3/toString.test.js

@@ -0,0 +1,17 @@
+import test from 'ava'
+
+import { create, fromPoints, toString } from './index.js'
+
+test('toString: serialize empty geom3 into a string', (t) => {
+  const geometry = create()
+  const result = toString(geometry)
+  const expected = 'geom3 (0 polygons):\n'
+  t.is(result, expected)
+})
+
+test('toString: serialize geom3 into a string', (t) => {
+  const geometry = fromPoints([[[0, 0, 3], [0, 1, 3], [2, 0, 3]]])
+  const result = toString(geometry)
+  const expected = 'geom3 (1 polygons):\n  poly3: [[0.0000000, 0.0000000, 3.0000000], [0.0000000, 1.0000000, 3.0000000], [2.0000000, 0.0000000, 3.0000000]]\n'
+  t.is(result, expected)
+})

package/src/geometries/geom3/transform.d.ts

@@ -1,6 +1,4 @@
-import Geom3 from './type'
-import Mat4 from '../../maths/mat4/type'
+import type { Geom3 } from './type.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
 
-export default transform
-
-declare function transform(matrix: Mat4, geometry: Geom3): Geom3
+export function transform(matrix: Mat4, geometry: Geom3): Geom3

package/src/geometries/geom3/transform.js

@@ -1,20 +1,18 @@
-const mat4 = require('../../maths/mat4')
+import * as mat4 from '../../maths/mat4/index.js'
 
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the polygons, as this function only adjusts the transforms.
  * See applyTransforms() for the actual application of the transforms to the polygons.
- * @param {mat4} matrix - the matrix to transform with
- * @param {geom3} geometry - the geometry to transform
- * @returns {geom3} a new geometry
+ * @param {Mat4} matrix - the matrix to transform with
+ * @param {Geom3} geometry - the geometry to transform
+ * @returns {Geom3} a new geometry
  * @alias module:modeling/geometries/geom3.transform
  *
  * @example
- * let newgeometry = transform(fromXRotation(degToRad(90)), geometry)
+ * let newGeometry = transform(fromXRotation(TAU / 4), geometry)
  */
-const transform = (matrix, geometry) => {
+export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
   return Object.assign({}, geometry, { transforms })
 }
-
-module.exports = transform

package/src/geometries/geom3/transform.test.js

@@ -1,13 +1,13 @@
-const test = require('ava')
+import test from 'ava'
 
-const mat4 = require('../../maths/mat4')
+import { mat4 } from '../../maths/index.js'
 
-const { transform, fromPoints, toPolygons } = require('./index')
+import { transform, fromPoints, toPolygons } from './index.js'
 
-const { comparePolygons, compareVectors } = require('../../../test/helpers/')
+import { comparePolygons, compareVectors } from '../../../test/helpers/index.js'
 
 test('transform: Adjusts the transforms of a populated geom3', (t) => {
-  const points = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
+  const vertices = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
   const rotation = 90 * 0.017453292519943295
   const rotate90 = mat4.fromZRotation(mat4.create(), rotation)
 
@@ -20,7 +20,7 @@ test('transform: Adjusts the transforms of a populated geom3', (t) => {
     ],
     transforms: [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
-  const geometry = fromPoints(points)
+  const geometry = fromPoints(vertices)
   let another = transform(rotate90, geometry)
   t.not(geometry, another)
   t.true(comparePolygons(another.polygons[0], expected.polygons[0]))

package/src/geometries/geom3/type.d.ts

@@ -1,10 +1,8 @@
-import Poly3 from '../poly3/type'
-import Mat4 from '../../maths/mat4/type'
-import { Color } from '../types'
+import type { Poly3 } from '../poly3/type.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
+import type { Color } from '../types.d.ts'
 
-export default Geom3
-
-declare interface Geom3 {
+export interface Geom3 {
   polygons: Array<Poly3>
   transforms: Mat4
   color?: Color

package/src/geometries/geom3/validate.d.ts

@@ -1,3 +1 @@
-export default validate
-
-declare function validate(object: any): void
+export function validate(object: any): void

package/src/geometries/geom3/validate.js

@@ -1,5 +1,6 @@
-const poly3 = require('../poly3')
-const isA = require('./isA')
+import * as poly3 from '../poly3/index.js'
+
+import { isA } from './isA.js'
 
 /**
  * Determine if the given object is a valid 3D geometry.
@@ -7,11 +8,11 @@ const isA = require('./isA')
  *
  * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
  *
- * @param {Object} object - the object to interrogate
+ * @param {object} object - the object to interrogate
  * @throws {Error} error if the geometry is not valid
  * @alias module:modeling/geometries/geom3.validate
  */
-const validate = (object) => {
+export const validate = (object) => {
   if (!isA(object)) {
     throw new Error('invalid geom3 structure')
   }
@@ -58,5 +59,3 @@ const validateManifold = (object) => {
     throw new Error(`non-manifold edges ${nonManifold.length}\n${nonManifold.join('\n')}`)
   }
 }
-
-module.exports = validate

package/src/geometries/geom3/validate.test.js

@@ -0,0 +1,26 @@
+import test from 'ava'
+
+import * as vec3 from '../../maths/vec3/index.js'
+import { fromPoints, validate } from './index.js'
+
+// tetrahedron
+const a = vec3.fromValues(-1, -1, 1)
+const b = vec3.fromValues(-1, 1, -1)
+const c = vec3.fromValues(1, -1, -1)
+const d = vec3.fromValues(1, 1, 1)
+
+test('validate: allow valid geom3', (t) => {
+  // simplest valid geometry
+  const geometry = fromPoints([[a, b, c], [d, b, a], [d, a, c], [c, b, d]])
+  t.notThrows(() => validate(geometry))
+})
+
+test('validate: throw exception for nan', (t) => {
+  const geometry = fromPoints([[a, b, c], [d, b, a], [d, a, c], [c, b, [1, 1, NaN]]])
+  t.throws(() => validate(geometry))
+})
+
+test('validate: throw exception for infinity', (t) => {
+  const geometry = fromPoints([[a, b, c], [d, b, a], [d, a, c], [c, b, [1, 1, Infinity]]])
+  t.throws(() => validate(geometry))
+})

package/src/geometries/index.d.ts

@@ -1,7 +1,6 @@
-export * as geom2 from './geom2'
-export * as geom3 from './geom3'
-export * as path2 from './path2'
-export * as poly2 from './poly2'
-export * as poly3 from './poly3'
-
-export as namespace geometries
+export * as geom2 from './geom2/index.js'
+export * as geom3 from './geom3/index.js'
+export * as path2 from './path2/index.js'
+export * as poly2 from './poly2/index.js'
+export * as poly3 from './poly3/index.js'
+export * as slice from './slice/index.js'

package/src/geometries/index.js

@@ -2,20 +2,21 @@
  * Geometries are objects that represent the contents of primitives or the results of operations.
  * Note: Geometries are considered immutable, so never change the contents directly.
  *
- * @see {@link geom2} - 2D geometry consisting of sides
+ * @see {@link geom2} - 2D geometry consisting of 2D outlines
  * @see {@link geom3} - 3D geometry consisting of polygons
  * @see {@link path2} - 2D geometry consisting of ordered points
  * @see {@link poly2} - 2D polygon consisting of ordered vertices
  * @see {@link poly3} - 3D polygon consisting of ordered vertices
+ * @see {@link slice} - 3D geometry consisting of 3D outlines
  *
  * @module modeling/geometries
  * @example
- * const { geom2, geom3, path2, poly2, poly3 } = require('@jscad/modeling').geometries
+ * import { geometries } from '@jscad/modeling'
+ * const { geom2, geom3, path2, poly2, poly3 } = geometries
  */
-module.exports = {
-  geom2: require('./geom2'),
-  geom3: require('./geom3'),
-  path2: require('./path2'),
-  poly2: require('./poly2'),
-  poly3: require('./poly3')
-}
+export * as geom2 from './geom2/index.js'
+export * as geom3 from './geom3/index.js'
+export * as path2 from './path2/index.js'
+export * as poly2 from './poly2/index.js'
+export * as poly3 from './poly3/index.js'
+export * as slice from './slice/index.js'

package/src/geometries/path2/appendArc.d.ts

@@ -1,15 +1,13 @@
-import Path2 from './type'
-import Vec2 from '../../maths/vec2/type'
-
-export default appendArc
+import type { Path2 } from './type.d.ts'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
 
 export interface AppendArcOptions {
   endpoint: Vec2
   radius?: Vec2
-  xaxisrotation?: number
+  xaxisRotation?: number
   clockwise?: boolean
   large?: boolean
   segments?: number
 }
 
-declare function appendArc(options: AppendArcOptions, geometry: Path2): Path2
+export function appendArc(options: AppendArcOptions, geometry: Path2): Path2

package/src/geometries/path2/appendArc.js

@@ -1,38 +1,38 @@
-const { TAU } = require('../../maths/constants')
-const vec2 = require('../../maths/vec2')
+import { TAU } from '../../maths/constants.js'
+import * as vec2 from '../../maths/vec2/index.js'
 
-const fromPoints = require('./fromPoints')
-const toPoints = require('./toPoints')
+import { fromPoints } from './fromPoints.js'
+import { toPoints } from './toPoints.js'
 
 /**
  * Append a series of points to the given geometry that represent an arc.
  * This implementation follows the SVG specifications.
  * @see http://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands
- * @param {Object} options - options for construction
- * @param {vec2} options.endpoint - end point of arc (REQUIRED)
- * @param {vec2} [options.radius=[0,0]] - radius of arc (X and Y)
- * @param {Number} [options.xaxisrotation=0] - rotation (RADIANS) of the X axis of the arc with respect to the X axis of the coordinate system
- * @param {Boolean} [options.clockwise=false] - draw an arc clockwise with respect to the center point
- * @param {Boolean} [options.large=false] - draw an arc longer than TAU / 2 radians
- * @param {Number} [options.segments=16] - number of segments per full rotation
- * @param {path2} geometry - the path of which to append the arc
- * @returns {path2} a new path with the appended points
+ * @param {object} options - options for construction
+ * @param {Vec2} options.endpoint - end point of arc (REQUIRED)
+ * @param {Vec2} [options.radius=[0,0]] - radius of arc (X and Y)
+ * @param {number} [options.xaxisRotation=0] - rotation (RADIANS) of the X axis of the arc with respect to the X axis of the coordinate system
+ * @param {boolean} [options.clockwise=false] - draw an arc clockwise with respect to the center point
+ * @param {boolean} [options.large=false] - draw an arc longer than TAU / 2 radians
+ * @param {number} [options.segments=16] - number of segments per full rotation
+ * @param {Path2} geometry - the path of which to append the arc
+ * @returns {Path2} a new path with the appended points
  * @alias module:modeling/geometries/path2.appendArc
  *
  * @example
- * let p1 = path2.fromPoints({}, [[27.5,-22.96875]]);
- * p1 = path2.appendPoints([[27.5,-3.28125]], p1);
- * p1 = path2.appendArc({endpoint: [12.5, -22.96875], radius: [15, -19.6875]}, p1);
+ * let myShape = fromPoints({}, [[27.5,-22.96875]]);
+ * myShape = appendPoints([[27.5,-3.28125]], myShape);
+ * myShape = appendArc({endpoint: [12.5, -22.96875], radius: [15, -19.6875]}, myShape);
  */
-const appendArc = (options, geometry) => {
+export const appendArc = (options, geometry) => {
   const defaults = {
     radius: [0, 0], // X and Y radius
-    xaxisrotation: 0,
+    xaxisRotation: 0,
     clockwise: false,
     large: false,
     segments: 16
   }
-  let { endpoint, radius, xaxisrotation, clockwise, large, segments } = Object.assign({}, defaults, options)
+  let { endpoint, radius, xaxisRotation, clockwise, large, segments } = Object.assign({}, defaults, options)
 
   // validate the given options
   if (!Array.isArray(endpoint)) throw new Error('endpoint must be an array of X and Y values')
@@ -56,59 +56,59 @@ const appendArc = (options, geometry) => {
     throw new Error('the given path must contain one or more points (as the starting point for the arc)')
   }
 
-  let xradius = radius[0]
-  let yradius = radius[1]
+  let xRadius = radius[0]
+  let yRadius = radius[1]
   const startpoint = points[points.length - 1]
 
   // round to precision in order to have determinate calculations
-  xradius = Math.round(xradius * decimals) / decimals
-  yradius = Math.round(yradius * decimals) / decimals
+  xRadius = Math.round(xRadius * decimals) / decimals
+  yRadius = Math.round(yRadius * decimals) / decimals
   endpoint = vec2.fromValues(Math.round(endpoint[0] * decimals) / decimals, Math.round(endpoint[1] * decimals) / decimals)
 
   const sweepFlag = !clockwise
-  let newpoints = []
-  if ((xradius === 0) || (yradius === 0)) {
+  let newPoints = []
+  if ((xRadius === 0) || (yRadius === 0)) {
     // http://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes:
     // If rx = 0 or ry = 0, then treat this as a straight line from (x1, y1) to (x2, y2) and stop
-    newpoints.push(endpoint)
+    newPoints.push(endpoint)
   } else {
-    xradius = Math.abs(xradius)
-    yradius = Math.abs(yradius)
+    xRadius = Math.abs(xRadius)
+    yRadius = Math.abs(yRadius)
 
     // see http://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes :
-    const phi = xaxisrotation
-    const cosphi = Math.cos(phi)
-    const sinphi = Math.sin(phi)
-    const minushalfdistance = vec2.subtract(vec2.create(), startpoint, endpoint)
-    vec2.scale(minushalfdistance, minushalfdistance, 0.5)
+    const phi = xaxisRotation
+    const cosPhi = Math.cos(phi)
+    const sinPhi = Math.sin(phi)
+    const minusHalfDistance = vec2.subtract(vec2.create(), startpoint, endpoint)
+    vec2.scale(minusHalfDistance, minusHalfDistance, 0.5)
     // F.6.5.1:
     // round to precision in order to have determinate calculations
-    const x = Math.round((cosphi * minushalfdistance[0] + sinphi * minushalfdistance[1]) * decimals) / decimals
-    const y = Math.round((-sinphi * minushalfdistance[0] + cosphi * minushalfdistance[1]) * decimals) / decimals
+    const x = Math.round((cosPhi * minusHalfDistance[0] + sinPhi * minusHalfDistance[1]) * decimals) / decimals
+    const y = Math.round((-sinPhi * minusHalfDistance[0] + cosPhi * minusHalfDistance[1]) * decimals) / decimals
     const startTranslated = vec2.fromValues(x, y)
     // F.6.6.2:
-    const biglambda = (startTranslated[0] * startTranslated[0]) / (xradius * xradius) + (startTranslated[1] * startTranslated[1]) / (yradius * yradius)
-    if (biglambda > 1.0) {
+    const bigLambda = (startTranslated[0] * startTranslated[0]) / (xRadius * xRadius) + (startTranslated[1] * startTranslated[1]) / (yRadius * yRadius)
+    if (bigLambda > 1.0) {
       // F.6.6.3:
-      const sqrtbiglambda = Math.sqrt(biglambda)
-      xradius *= sqrtbiglambda
-      yradius *= sqrtbiglambda
+      const sqrtBigLambda = Math.sqrt(bigLambda)
+      xRadius *= sqrtBigLambda
+      yRadius *= sqrtBigLambda
       // round to precision in order to have determinate calculations
-      xradius = Math.round(xradius * decimals) / decimals
-      yradius = Math.round(yradius * decimals) / decimals
+      xRadius = Math.round(xRadius * decimals) / decimals
+      yRadius = Math.round(yRadius * decimals) / decimals
     }
     // F.6.5.2:
-    let multiplier1 = Math.sqrt((xradius * xradius * yradius * yradius - xradius * xradius * startTranslated[1] * startTranslated[1] - yradius * yradius * startTranslated[0] * startTranslated[0]) / (xradius * xradius * startTranslated[1] * startTranslated[1] + yradius * yradius * startTranslated[0] * startTranslated[0]))
+    let multiplier1 = Math.sqrt((xRadius * xRadius * yRadius * yRadius - xRadius * xRadius * startTranslated[1] * startTranslated[1] - yRadius * yRadius * startTranslated[0] * startTranslated[0]) / (xRadius * xRadius * startTranslated[1] * startTranslated[1] + yRadius * yRadius * startTranslated[0] * startTranslated[0]))
     if (sweepFlag === large) multiplier1 = -multiplier1
-    const centerTranslated = vec2.fromValues(xradius * startTranslated[1] / yradius, -yradius * startTranslated[0] / xradius)
+    const centerTranslated = vec2.fromValues(xRadius * startTranslated[1] / yRadius, -yRadius * startTranslated[0] / xRadius)
     vec2.scale(centerTranslated, centerTranslated, multiplier1)
     // F.6.5.3:
-    let center = vec2.fromValues(cosphi * centerTranslated[0] - sinphi * centerTranslated[1], sinphi * centerTranslated[0] + cosphi * centerTranslated[1])
+    let center = vec2.fromValues(cosPhi * centerTranslated[0] - sinPhi * centerTranslated[1], sinPhi * centerTranslated[0] + cosPhi * centerTranslated[1])
     center = vec2.add(center, center, vec2.scale(vec2.create(), vec2.add(vec2.create(), startpoint, endpoint), 0.5))
 
     // F.6.5.5:
-    const vector1 = vec2.fromValues((startTranslated[0] - centerTranslated[0]) / xradius, (startTranslated[1] - centerTranslated[1]) / yradius)
-    const vector2 = vec2.fromValues((-startTranslated[0] - centerTranslated[0]) / xradius, (-startTranslated[1] - centerTranslated[1]) / yradius)
+    const vector1 = vec2.fromValues((startTranslated[0] - centerTranslated[0]) / xRadius, (startTranslated[1] - centerTranslated[1]) / yRadius)
+    const vector2 = vec2.fromValues((-startTranslated[0] - centerTranslated[0]) / xRadius, (-startTranslated[1] - centerTranslated[1]) / yRadius)
     const theta1 = vec2.angleRadians(vector1)
     const theta2 = vec2.angleRadians(vector2)
     let deltatheta = theta2 - theta1
@@ -120,23 +120,21 @@ const appendArc = (options, geometry) => {
     }
 
     // Ok, we have the center point and angle range (from theta1, deltatheta radians) so we can create the ellipse
-    let numsteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1
-    if (numsteps < 1) numsteps = 1
-    for (let step = 1; step < numsteps; step++) {
-      const theta = theta1 + step / numsteps * deltatheta
-      const costheta = Math.cos(theta)
-      const sintheta = Math.sin(theta)
+    let numSteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1
+    if (numSteps < 1) numSteps = 1
+    for (let step = 1; step < numSteps; step++) {
+      const theta = theta1 + step / numSteps * deltatheta
+      const cosTheta = Math.cos(theta)
+      const sinTheta = Math.sin(theta)
       // F.6.3.1:
-      const point = vec2.fromValues(cosphi * xradius * costheta - sinphi * yradius * sintheta, sinphi * xradius * costheta + cosphi * yradius * sintheta)
+      const point = vec2.fromValues(cosPhi * xRadius * cosTheta - sinPhi * yRadius * sinTheta, sinPhi * xRadius * cosTheta + cosPhi * yRadius * sinTheta)
       vec2.add(point, point, center)
-      newpoints.push(point)
+      newPoints.push(point)
     }
     // ensure end point is precisely what user gave as parameter
-    if (numsteps) newpoints.push(options.endpoint)
+    if (numSteps) newPoints.push(options.endpoint)
   }
-  newpoints = points.concat(newpoints)
-  const result = fromPoints({}, newpoints)
+  newPoints = points.concat(newPoints)
+  const result = fromPoints({}, newPoints)
   return result
 }
-
-module.exports = appendArc