@jscad/modeling 2.7.0 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
   "main": "src/index.js",
@@ -60,5 +60,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "fbc9b90f0ae02bea4e6e7b974c65e751c3858269"
+  "gitHead": "92fb9c75eb070fca5f5ee8c2bab6614b1f54514e"
 }

package/src/colors/hslToRgb.js

@@ -5,7 +5,7 @@ const hueToColorComponent = require('./hueToColorComponent')
 /**
  * Converts HSL color values to RGB color values.
  *
- * @see http://en.wikipedia.org/wiki/HSL_color_space.
+ * @see http://en.wikipedia.org/wiki/HSL_color_space
  * @param {...Number|Array} values - HSL or HSLA color values
  * @return {Array} RGB or RGBA color values
  * @alias module:modeling/colors.hslToRgb

package/src/colors/hueToColorComponent.js

@@ -3,6 +3,7 @@
  * @param  {Number} p
  * @param  {Number} q
  * @param  {Number} t
+ * @return {Number} color component
  * @alias module:modeling/colors.hueToColorComponent
  */
 const hueToColorComponent = (p, q, t) => {

package/src/curves/bezier/create.js

@@ -7,14 +7,6 @@
  * @property {Array} permutations - A pre-calculation of the bezier algorithm's co-efficients
  * @property {Array} tangentPermutations - A pre-calculation of the bezier algorithm's tangent co-efficients
  *
- * @example
- * const b = bezier.create([0,10]) // a linear progression from 0 to 10
- * const b = bezier.create([0, 0, 10, 10]) // a symmetrical cubic easing curve that starts slowly and ends slowly from 0 to 10
- * const b = bezier.create([0,0,0], [0,5,10], [10,0,-5], [10,10,10]]) // a cubic 3 dimensional easing curve that can generate position arrays for modelling
- * Usage:
- * let position = bezier.valueAt(t,b) // where 0 < t < 1
- * let tangent = bezier.tangentAt(t,b) // where 0 < t < 1
- *
  */
 
 /**
@@ -25,6 +17,9 @@
  * const b = bezier.create([0,10]) // a linear progression from 0 to 10
  * const b = bezier.create([0, 0, 10, 10]) // a symmetrical cubic easing curve that starts slowly and ends slowly from 0 to 10
  * const b = bezier.create([0,0,0], [0,5,10], [10,0,-5], [10,10,10]]) // a cubic 3 dimensional easing curve that can generate position arrays for modelling
+ * // Usage
+ * let position = bezier.valueAt(t,b) // where 0 < t < 1
+ * let tangent = bezier.tangentAt(t,b) // where 0 < t < 1
  *
  * @param {Array} points An array with at least 2 elements of either all numbers, or all arrays of numbers that are the same size.
  * @returns {bezier} a new bezier data object

package/src/curves/bezier/tangentAt.js

@@ -4,12 +4,12 @@
  * See the example called extrudeAlongPath.js
  *
  * @example
- * const b = bezier.create([0,0,0], [0,5,10], [10,0,-5], [10,10,10]]) // a cubic 3 dimensional easing curve that can generate position arrays for modelling
+ * const b = bezier.create([[0,0,0], [0,5,10], [10,0,-5], [10,10,10]]) // a cubic 3 dimensional easing curve that can generate position arrays for modelling
  * let tangent = bezier.tangentAt(t, b)
  *
  * @param {number} t : the position of which to calculate the bezier's tangent value; 0 < t < 1
  * @param {Object} bezier : an array with at least 2 elements of either all numbers, or all arrays of numbers that are the same size.
- * @returns {array | number} the tangent at the requested position.
+ * @return {array | number} the tangent at the requested position.
  * @alias module:modeling/curves/bezier.tangentAt
  */
 const tangentAt = (t, bezier) => {

package/src/curves/bezier/tangentAt.test.js

@@ -20,7 +20,7 @@ test('quadratic bezier (3 control points)', (t) => {
   t.is(bezier.tangentAt(1, OneDCurve), 20)
 })
 
-test('quadratic bezier (3 control points, non symetric)', (t) => {
+test('quadratic bezier (3 control points, non symmetric)', (t) => {
   const OneDCurve = bezier.create([0, 0, 20])
   t.is(bezier.tangentAt(0, OneDCurve), 0)
   t.is(bezier.tangentAt(0.5, OneDCurve), 20)

package/src/curves/bezier/valueAt.test.js

@@ -20,7 +20,7 @@ test('quadratic bezier (3 control points)', (t) => {
   t.is(bezier.valueAt(1, OneDCurve), 20)
 })
 
-test('quadratic bezier (3 control points, non symetric)', (t) => {
+test('quadratic bezier (3 control points, non symmetric)', (t) => {
   const OneDCurve = bezier.create([0, 0, 20])
   t.is(bezier.valueAt(0, OneDCurve), 0)
   t.is(bezier.valueAt(0.5, OneDCurve), 5)

package/src/curves/index.js

@@ -1,5 +1,5 @@
 /**
- * Curves are n-dimensional mathematical constructs that define a path from point 0 to point 1
+ * Curves are n-dimensional mathematical constructs that define a path from point 0 to point 1.
  * @module modeling/curves
  * @example
  * const { bezier } = require('@jscad/modeling').curves

package/src/geometries/geom2/index.js

@@ -2,6 +2,16 @@
  * Represents a 2D geometry consisting of a list of sides.
  * @see {@link geom2} for data structure information.
  * @module modeling/geometries/geom2
+ *
+ * @example
+ * colorize([0.5,0,1,1], square()) // purple square
+ *
+ * @example
+ * {
+ *   "sides": [[[-1,1],[-1,-1]],[[-1,-1],[1,-1]],[[1,-1],[1,1]],[[1,1],[-1,1]]],
+ *   "transforms": [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
+ *   "color": [0.5,0,1,1]
+ * }
  */
 module.exports = {
   clone: require('./clone'),

package/src/geometries/geom2/isA.js

@@ -1,6 +1,6 @@
 /**
- * Determin if the given object is a 2D geometry.
- * @param {Object} object - the object to interogate
+ * Determine if the given object is a 2D geometry.
+ * @param {Object} object - the object to interrogate
  * @returns {Boolean} true, if the object matches a geom2 based object
  * @alias module:modeling/geometries/geom2.isA
  */

package/src/geometries/geom2/toCompactBinary.js

@@ -4,11 +4,11 @@
  * @returns {TypedArray} compact binary representation
  * @alias module:modeling/geometries/geom2.toCompactBinary
  */
-const toCompactBinary = (geom) => {
-  const sides = geom.sides
-  const transforms = geom.transforms
+const toCompactBinary = (geometry) => {
+  const sides = geometry.sides
+  const transforms = geometry.transforms
   let color = [-1, -1, -1, -1]
-  if (geom.color) color = geom.color
+  if (geometry.color) color = geometry.color
 
   // FIXME why Float32Array?
   const compacted = new Float32Array(1 + 16 + 4 + (sides.length * 4)) // type + transforms + color + sides data

package/src/geometries/geom2/toOutlines.js

@@ -7,21 +7,16 @@ const toSides = require('./toSides')
  * This allows the edges to be traversed in order.
  */
 const toEdges = (sides) => {
-  const uniquevertices = []
+  const vertices = {}
   const getUniqueVertex = (vertex) => {
-    const i = uniquevertices.findIndex((v) => vec2.equals(v, vertex))
-    if (i < 0) {
-      uniquevertices.push(vertex)
-      return vertex
+    const key = vertex.toString()
+    if (!vertices[key]) {
+      vertices[key] = vertex
     }
-    return uniquevertices[i]
+    return vertices[key]
   }
 
-  const edges = []
-  sides.forEach((side) => {
-    edges.push([getUniqueVertex(side[0]), getUniqueVertex(side[1])])
-  })
-  return edges
+  return sides.map((side) => side.map(getUniqueVertex))
 }
 
 /**

package/src/geometries/geom2/toString.js

@@ -5,7 +5,7 @@ const toSides = require('./toSides')
 /**
  * Create a string representing the contents of the given geometry.
  * @param {geom2} geometry - the geometry
- * @returns {String} a representive string
+ * @returns {String} a representative string
  * @alias module:modeling/geometries/geom2.toString
  *
  * @example

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

@@ -11,7 +11,7 @@ test('transform: adjusts the transforms of geom2', (t) => {
   const rotation = 90 * 0.017453292519943295
   const rotate90 = mat4.fromZRotation(mat4.create(), rotation)
 
-  // continue with typical user scenario, several itterations of transforms and access
+  // continue with typical user scenario, several iterations of transforms and access
 
   // expect lazy transform, i.e. only the transforms change
   const expected = {

package/src/geometries/geom3/create.js

@@ -4,7 +4,7 @@ const mat4 = require('../../maths/mat4')
  * Represents a 3D geometry consisting of a list of polygons.
  * @typedef {Object} geom3
  * @property {Array} polygons - list of polygons, each polygon containing three or more points
- * @property {mat4} transforms - transforms to apply to the sides, see transform()
+ * @property {mat4} transforms - transforms to apply to the polygons, see transform()
  */
 
 /**

package/src/geometries/geom3/fromCompactBinary.js

@@ -33,7 +33,7 @@ const fromCompactBinary = (data) => {
     created.polygons.push(poly3.create(vertices))
   }
 
-  // transfer known properities, i.e. color
+  // transfer known properties, i.e. color
   if (data[17] >= 0) {
     created.color = [data[17], data[18], data[19], data[20]]
   }

package/src/geometries/geom3/index.js

@@ -2,6 +2,23 @@
  * Represents a 3D geometry consisting of a list of polygons.
  * @see {@link geom3} for data structure information.
  * @module modeling/geometries/geom3
+ *
+ * @example
+ * colorize([0,0.5,1,0.6], cube()) // transparent ice cube
+ *
+ * @example
+ * {
+ *   "polygons": [
+ *     {"vertices": [[-1,-1,-1], [-1,-1,1], [-1,1,1], [-1,1,-1]]},
+ *     {"vertices": [[1,-1,-1], [1,1,-1], [1,1,1], [1,-1,1]]},
+ *     {"vertices": [[-1,-1,-1], [1,-1,-1], [1,-1,1], [-1,-1,1]]},
+ *     {"vertices": [[-1,1,-1], [-1,1,1], [1,1,1], [1,1,-1]]},
+ *     {"vertices": [[-1,-1,-1], [-1,1,-1], [1,1,-1], [1,-1,-1]]},
+ *     {"vertices": [[-1,-1,1], [1,-1,1], [1,1,1], [-1,1,1]]}
+ *   ],
+ *   "transforms": [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
+ *   "color": [0,0.5,1,0.6]
+ * }
  */
 module.exports = {
   clone: require('./clone'),

package/src/geometries/geom3/invert.js

@@ -5,8 +5,8 @@ const toPolygons = require('./toPolygons')
 
 /**
  * Invert the given geometry, transposing solid and empty space.
- * @params {geom3} geometry - the geometry to invert
- * @returns {geom3} a new geometry
+ * @param {geom3} geometry - the geometry to invert
+ * @return {geom3} a new geometry
  * @alias module:modeling/geometries/geom3.invert
  */
 const invert = (geometry) => {

package/src/geometries/geom3/isA.js

@@ -1,6 +1,6 @@
 /**
- * Determin if the given object is a 3D geometry.
- * @param {object} object - the object to interogate
+ * Determine if the given object is a 3D geometry.
+ * @param {object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a geom3
  * @alias module:modeling/geometries/geom3.isA
  */

package/src/geometries/geom3/toCompactBinary.js

@@ -6,14 +6,14 @@ const poly3 = require('../poly3')
  * @return {TypedArray} compact binary representation
  * @alias module:modeling/geometries/geom3.toCompactBinary
  */
-const toCompactBinary = (geom) => {
-  const polygons = geom.polygons
-  const transforms = geom.transforms
+const toCompactBinary = (geometry) => {
+  const polygons = geometry.polygons
+  const transforms = geometry.transforms
 
   const numberOfPolygons = polygons.length
   const numberOfVertices = polygons.reduce((count, polygon) => count + polygon.vertices.length, 0)
   let color = [-1, -1, -1, -1]
-  if (geom.color) color = geom.color
+  if (geometry.color) color = geometry.color
 
   // FIXME why Float32Array?
   const compacted = new Float32Array(1 + 16 + 4 + 1 + numberOfPolygons + (numberOfVertices * 3))

package/src/geometries/geom3/toPoints.js

@@ -5,6 +5,7 @@ const toPolygons = require('./toPolygons')
 /**
  * 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
  * @return {Array} list of points, where each sub-array represents a polygon
  * @alias module:modeling/geometries/geom3.toPoints
  */

package/src/geometries/geom3/toString.js

@@ -5,7 +5,7 @@ const toPolygons = require('./toPolygons')
 /**
  * Create a string representing the contents of the given geometry.
  * @param {geom3} geometry - the geometry
- * @returns {String} a representive string
+ * @returns {String} a representative string
  * @alias module:modeling/geometries/geom3.toString
  *
  * @example

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

@@ -11,7 +11,7 @@ test('transform: Adjusts the transforms of a populated geom3', (t) => {
   const rotation = 90 * 0.017453292519943295
   const rotate90 = mat4.fromZRotation(mat4.create(), rotation)
 
-  // continue with typical user scenario, several itterations of transforms and access
+  // continue with typical user scenario, several iterations of transforms and access
 
   // expect lazy transform, i.e. only the transforms change
   const expected = {

package/src/geometries/index.js

@@ -1,6 +1,13 @@
 /**
  * Geometries are objects that represent the contents of primitives or the results of operations.
- * Note: Geometries are consider immutable, so never change the contents directly.
+ * Note: Geometries are considered immutable, so never change the contents directly.
+ *
+ * @see {@link geom2} - 2D geometry consisting of sides
+ * @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
+ *
  * @module modeling/geometries
  * @example
  * const { geom2, geom3, path2, poly2, poly3 } = require('@jscad/modeling').geometries

package/src/geometries/path2/eachPoint.js

@@ -1,14 +1,14 @@
 const toPoints = require('./toPoints')
 
 /**
- * Calls a function for each point in the geometry.
+ * Calls a function for each point in the path.
  * @param {Object} options - options
  * @param {Function} thunk - the function to call
- * @param {path2} geometry - the geometry to traverse
+ * @param {path2} path - the path to traverse
  * @alias module:modeling/geometries/path2.eachPoint
  *
  * @example
- * eachPoint({}, accumulate, geometry)
+ * eachPoint({}, accumulate, path)
  */
 const eachPoint = (options, thunk, path) => {
   toPoints(path).forEach(thunk)

package/src/geometries/path2/index.js

@@ -2,6 +2,17 @@
  * Represents a 2D geometry consisting of a list of ordered points.
  * @see {@link path2} for data structure information.
  * @module modeling/geometries/path2
+ *
+ * @example
+ * colorize([0,0,0,1], path2.fromPoints({ closed: true }, [[0,0], [4,0], [4,3]]))
+ *
+ * @example
+ * {
+ *   "points": [[0,0], [4,0], [4,3]],
+ *   "isClosed": true,
+ *   "transforms": [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
+ *   "color": [0,0,0,1]
+ * }
  */
 module.exports = {
   appendArc: require('./appendArc'),

package/src/geometries/path2/isA.js

@@ -1,6 +1,6 @@
 /**
- * Determin if the given object is a path2 geometry.
- * @param {Object} object - the object to interogate
+ * Determine if the given object is a path2 geometry.
+ * @param {Object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a path2
  * @alias module:modeling/geometries/path2.isA
  */

package/src/geometries/path2/reverse.js

@@ -3,17 +3,17 @@ const clone = require('./clone')
 /**
  * Reverses the path so that the points are in the opposite order.
  * This swaps the left (interior) and right (exterior) edges.
- * @param {path2} geometry - the geometry to reverse
+ * @param {path2} geometry - the path to reverse
  * @returns {path2} a new path
  * @alias module:modeling/geometries/path2.reverse
  *
  * @example
  * let newpath = reverse(mypath)
  */
-const reverse = (path) => {
+const reverse = (geometry) => {
   // NOTE: this only updates the order of the points
-  const cloned = clone(path)
-  cloned.points = path.points.slice().reverse()
+  const cloned = clone(geometry)
+  cloned.points = geometry.points.slice().reverse()
   return cloned
 }
 

package/src/geometries/path2/toCompactBinary.js

@@ -1,14 +1,14 @@
 /**
  * Produce a compact binary representation from the given path.
- * @param {path2} geometry - the path
+ * @param {path2} geometry - the path geometry
  * @returns {TypedArray} compact binary representation
  * @alias module:modeling/geometries/path2.toCompactBinary
  */
-const toCompactBinary = (geom) => {
-  const points = geom.points
-  const transforms = geom.transforms
+const toCompactBinary = (geometry) => {
+  const points = geometry.points
+  const transforms = geometry.transforms
   let color = [-1, -1, -1, -1]
-  if (geom.color) color = geom.color
+  if (geometry.color) color = geometry.color
 
   // FIXME why Float32Array?
   const compacted = new Float32Array(1 + 16 + 1 + 4 + (points.length * 2)) // type + transforms + isClosed + color + points data
@@ -32,7 +32,7 @@ const toCompactBinary = (geom) => {
   compacted[15] = transforms[14]
   compacted[16] = transforms[15]
 
-  compacted[17] = geom.isClosed ? 1 : 0
+  compacted[17] = geometry.isClosed ? 1 : 0
 
   compacted[18] = color[0]
   compacted[19] = color[1]

package/src/geometries/path2/toString.js

@@ -5,7 +5,7 @@ const toPoints = require('./toPoints')
 /**
  * Create a string representing the contents of the given path.
  * @param {path2} geometry - the path
- * @returns {String} a representive string
+ * @returns {String} a representative string
  * @alias module:modeling/geometries/path2.toString
  *
  * @example

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

@@ -11,7 +11,7 @@ test('transform: adjusts the transforms of path', (t) => {
   const rotation = 90 * 0.017453292519943295
   const rotate90 = mat4.fromZRotation(mat4.create(), rotation)
 
-  // continue with typical user scenario, several itterations of transforms and access
+  // continue with typical user scenario, several iterations of transforms and access
 
   // expect lazy transform, i.e. only the transforms change
   const expected = {

package/src/geometries/poly2/arePointsInside.test.js

@@ -12,7 +12,7 @@ test('poly2: arePointsInside() should return proper values', (t) => {
   t.is(obs, 0)
 
   polygon = create([[0, 0], [5, 0], [5, 5], [0, 5]])
-  // points overlaping points
+  // points overlapping points
   obs = arePointsInside([[0, 0]], polygon)
   t.is(obs, 0)
   obs = arePointsInside([[5, 0]], polygon)

package/src/geometries/poly2/index.js

@@ -2,6 +2,12 @@
  * Represents a 2D polygon consisting of a list of ordered vertices.
  * @see {@link poly2} for data structure information.
  * @module modeling/geometries/poly2
+ *
+ * @example
+ * poly2.create([[0,0], [4,0], [4,3]])
+ *
+ * @example
+ * {"vertices": [[0,0], [4,0], [4,3]]}
  */
 module.exports = {
   arePointsInside: require('./arePointsInside'),

package/src/geometries/poly3/index.js

@@ -1,7 +1,13 @@
 /**
- * Represents a convex 3D polygon consisting of a list of vertices.
+ * Represents a convex 3D polygon consisting of a list of ordered vertices.
  * @see {@link poly3} for data structure information.
  * @module modeling/geometries/poly3
+ *
+ * @example
+ * poly3.create([[0,0,0], [4,0,0], [4,3,12]])
+ *
+ * @example
+ * {"vertices": [[0,0,0], [4,0,0], [4,3,12]]}
  */
 module.exports = {
   clone: require('./clone'),

package/src/geometries/poly3/isA.js

@@ -1,6 +1,6 @@
 /**
- * Determin if the given object is a polygon.
- * @param {Object} object - the object to interogate
+ * Determine if the given object is a polygon.
+ * @param {Object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a poly3
  * @alias module:modeling/geometries/poly3.isA
  */

package/src/geometries/poly3/isConvex.js

@@ -3,11 +3,11 @@ const vec3 = require('../../maths/vec3')
 
 /**
  * Check whether the given polygon is convex.
- * @param {poly3} polygon - the polygon to interogate
+ * @param {poly3} polygon - the polygon to interrogate
  * @returns {Boolean} true if convex
  * @alias module:modeling/geometries/poly3.isConvex
  */
-const isConvex = (poly3) => areVerticesConvex(poly3.vertices)
+const isConvex = (polygon) => areVerticesConvex(polygon.vertices)
 
 const areVerticesConvex = (vertices) => {
   const numvertices = vertices.length

package/src/geometries/poly3/measureArea.js

@@ -7,15 +7,15 @@ const plane = require('./plane')
  * @return {Number} area of the polygon
  * @alias module:modeling/geometries/poly3.measureArea
  */
-const measureArea = (poly3) => {
-  const n = poly3.vertices.length
+const measureArea = (polygon) => {
+  const n = polygon.vertices.length
   if (n < 3) {
     return 0 // degenerate polygon
   }
-  const vertices = poly3.vertices
+  const vertices = polygon.vertices
 
   // calculate a normal vector
-  const normal = plane(poly3)
+  const normal = plane(polygon)
 
   // determine direction of projection
   const ax = Math.abs(normal[0])

package/src/geometries/poly3/measureBoundingBox.js

@@ -5,8 +5,8 @@ const vec3 = require('../../maths/vec3')
  * @returns {Array} an array of two vectors (3D);  minimum and maximum coordinates
  * @alias module:modeling/geometries/poly3.measureBoundingBox
  */
-const measureBoundingBox = (poly3) => {
-  const vertices = poly3.vertices
+const measureBoundingBox = (polygon) => {
+  const vertices = polygon.vertices
   const numvertices = vertices.length
   const min = numvertices === 0 ? vec3.create() : vec3.clone(vertices[0])
   const max = vec3.clone(min)

package/src/geometries/poly3/measureBoundingSphere.js

@@ -7,8 +7,8 @@ const measureBoundingBox = require('./measureBoundingBox')
  * @returns {Array} the computed bounding sphere; center point (3D) and radius
  * @alias module:modeling/geometries/poly3.measureBoundingSphere
  */
-const measureBoundingSphere = (poly3) => {
-  const box = measureBoundingBox(poly3)
+const measureBoundingSphere = (polygon) => {
+  const box = measureBoundingBox(polygon)
   const center = box[0]
   vec3.add(center, box[0], box[1])
   vec3.scale(center, center, 0.5)

package/src/geometries/poly3/measureSignedVolume.js

@@ -2,17 +2,17 @@ const vec3 = require('../../maths/vec3')
 
 /**
  * Measure the signed volume of the given polygon, which must be convex.
- * The volume is that formed by the tetrahedon connected to the axis [0,0,0],
+ * The volume is that formed by the tetrahedron connected to the axis [0,0,0],
  * and will be positive or negative based on the rotation of the vertices.
  * @see http://chenlab.ece.cornell.edu/Publication/Cha/icip01_Cha.pdf
  * @param {poly3} polygon - the polygon to measure
  * @return {Number} volume of the polygon
  * @alias module:modeling/geometries/poly3.measureSignedVolume
  */
-const measureSignedVolume = (poly3) => {
+const measureSignedVolume = (polygon) => {
   let signedVolume = 0
-  const vertices = poly3.vertices
-  // calculate based on triangluar polygons
+  const vertices = polygon.vertices
+  // calculate based on triangular polygons
   const cross = vec3.create()
   for (let i = 0; i < vertices.length - 2; i++) {
     vec3.cross(cross, vertices[i + 1], vertices[i + 2])

package/src/geometries/poly3/toPoints.js

@@ -1,10 +1,10 @@
 /**
- * Return the given geometry as a list of points.
+ * Return the given polygon as a list of points.
  * NOTE: The returned array should not be modified as the points are shared with the geometry.
  * @param {poly3} polygon - the polygon
  * @return {Array} list of points (3D)
  * @alias module:modeling/geometries/poly3.toPoints
  */
-const toPoints = (geometry) => geometry.vertices
+const toPoints = (polygon) => polygon.vertices
 
 module.exports = toPoints

package/src/geometries/poly3/toString.js

@@ -5,9 +5,9 @@ const vec3 = require('../../maths/vec3/')
  * @return {String} the string representation
  * @alias module:modeling/geometries/poly3.toString
  */
-const toString = (poly3) => {
+const toString = (polygon) => {
   let result = 'poly3: vertices: ['
-  poly3.vertices.forEach((vertex) => {
+  polygon.vertices.forEach((vertex) => {
     result += `${vec3.toString(vertex)}, `
   })
   result += ']'

package/src/geometries/poly3/transform.js

@@ -10,8 +10,8 @@ const create = require('./create')
  * @returns {poly3} a new polygon
  * @alias module:modeling/geometries/poly3.transform
  */
-const transform = (matrix, poly3) => {
-  const vertices = poly3.vertices.map((vertex) => vec3.transform(vec3.create(), vertex, matrix))
+const transform = (matrix, polygon) => {
+  const vertices = polygon.vertices.map((vertex) => vec3.transform(vec3.create(), vertex, matrix))
   if (mat4.isMirroring(matrix)) {
     // reverse the order to preserve the orientation
     vertices.reverse()

package/src/maths/index.js

@@ -1,6 +1,6 @@
 /**
  * Maths are computational units for fundamental Euclidean geometry. All maths operate upon array data structures.
- * Note: Maths data structues are consider immutable, so never change the contents directly.
+ * Note: Maths data structures are considered immutable, so never change the contents directly.
  * @see Most computations are based upon the glMatrix library (glmatrix.net)
  * @module modeling/maths
  * @example