@design-core/core 0.0.7 → 50.1.0

package/core/entities/insert.js

@@ -153,13 +153,13 @@ export class Insert extends Entity {
   /**
    * Draw the entity
    * @param {Object} renderer
-   * @return {Array} block items for the canvas to render recursively
+   * @return {Array} block entities for the canvas to render recursively
    */
   draw(renderer) {
     // blocks are associated with an insert point.
-    // Apply the insert location and rotation so block items draw correctly.
+    // Apply the insert location and rotation so block entities draw correctly.
     renderer.applyTransform({ x: this.points[0].x, y: this.points[0].y, rotation: Utils.degrees2radians(this.getRotation()) });
-    return this.block.items;
+    return this.block.entities;
   }
 
   /**
@@ -204,9 +204,9 @@ export class Insert extends Entity {
 
     for (let snap = 0; snap < blockSnaps.length; snap++) {
       const sp = blockSnaps[snap];
-      // offset the item snap point by the block insert location
+      // offset the entity snap point by the block insert location
       const rotatedPoint = sp.snapPoint.add(this.points[0]);
-      // rotate the snap point to match the item positions
+      // rotate the snap point to match the entity positions
       const adjustedPoint = rotatedPoint.rotate(this.points[0], Utils.degrees2radians(this.getRotation()));
       snaps.push(new SnapPoint(adjustedPoint, sp.type));
     }

package/core/entities/point.js

@@ -298,16 +298,16 @@ export class Point {
    * Find the closest point on a arc between start and end points
    * @param {Point} startPoint
    * @param {Point} endPoint
-   * @param {Point} centerPoint
+   * @param {Point} centrePoint
    * @param {number} direction - CCW if > 0
    * @return {Point} the closest point on the arc or null
    */
-  closestPointOnArc(startPoint, endPoint, centerPoint, direction = 0) {
-    const length = this.distance(centerPoint);
-    const radius = centerPoint.distance(startPoint);
+  closestPointOnArc(startPoint, endPoint, centrePoint, direction = 0) {
+    const length = this.distance(centrePoint);
+    const radius = centrePoint.distance(startPoint);
 
-    const Cx = centerPoint.x + radius * (this.x - centerPoint.x) / length;
-    const Cy = centerPoint.y + radius * (this.y - centerPoint.y) / length;
+    const Cx = centrePoint.x + radius * (this.x - centrePoint.x) / length;
+    const Cy = centrePoint.y + radius * (this.y - centrePoint.y) / length;
     const closest = new Point(Cx, Cy);
 
     // circle
@@ -315,7 +315,7 @@ export class Point {
       return closest;
     }
 
-    if (closest.isOnArc(startPoint, endPoint, centerPoint, direction)) {
+    if (closest.isOnArc(startPoint, endPoint, centrePoint, direction)) {
       return closest;
     }
 
@@ -327,15 +327,15 @@ export class Point {
    * Determine if point is on arc segment
    * @param {Point} startPoint
    * @param {Point} endPoint
-   * @param {Point} centerPoint
+   * @param {Point} centrePoint
    * @param {number} direction - CCW if > 0
    * @return {Point} true or false
    */
-  isOnArc(startPoint, endPoint, centerPoint, direction = 0) {
+  isOnArc(startPoint, endPoint, centrePoint, direction = 0) {
     // direction: ccw arc > 0, clockwise arc <= 0
-    const snapAngle = centerPoint.angle(this);
-    const startAngle = centerPoint.angle(startPoint);
-    const endAngle = centerPoint.angle(endPoint);
+    const snapAngle = centrePoint.angle(this);
+    const startAngle = centrePoint.angle(startPoint);
+    const endAngle = centrePoint.angle(endPoint);
 
     if (direction > 0) {
       // Counter Clockwise Arc
@@ -438,7 +438,7 @@ export class Point {
   }
 
   /**
-   * Returns apothem; the distance from arc center to cord midpoint
+   * Returns apothem; the distance from arc centre to cord midpoint
    * @param {Point} nextPoint
    * @return {number} apothem
    */
@@ -465,12 +465,12 @@ export class Point {
 
     let a = this.apothem(nextPoint);
 
-    // check if the center point is inverted. i.e. at 180 it goes inside the arc
+    // check if the centre point is inverted. i.e. at 180 it goes inside the arc
     if (Math.abs(this.bulgeAngle()) > Math.PI) {
       a = -a;
     }
 
-    // get the direction from the midpoint to the center point
+    // get the direction from the midpoint to the centre point
     const direction = this.angle(nextPoint) + (Math.PI / 2) * Math.sign(this.bulge);
     // centre point is the apothem distance from the mid point in the given direction
     const centre = midp.project(direction, a);
@@ -486,12 +486,12 @@ export class Point {
    * @return {number} - the partial bulge value
    */
   partialBulge(nextPoint, splitPoint, afterSplit = false) {
-    const center = this.bulgeCentrePoint(nextPoint);
+    const centre = this.bulgeCentrePoint(nextPoint);
     const direction = this.bulge > 0 ? 1 : -1;
 
-    const startAngle = center.angle(this);
-    const endAngle = center.angle(nextPoint);
-    const splitAngle = center.angle(splitPoint);
+    const startAngle = centre.angle(this);
+    const endAngle = centre.angle(nextPoint);
+    const splitAngle = centre.angle(splitPoint);
 
     let includedAngle;
     if (afterSplit) {

package/core/entities/polyline.js

@@ -1,12 +1,12 @@
 import { DXFFile } from '../lib/dxf/dxfFile.js';
-import { BasePolyline } from './basePolyline.js';
+import { PolylineBase } from './polylineBase.js';
 import { Point } from './point.js';
 
 /**
  * Polyline Entity Class
- * @extends BasePolyline
+ * @extends PolylineBase
  */
-export class Polyline extends BasePolyline {
+export class Polyline extends PolylineBase {
   static type = 'Polyline';
 
   /**

package/core/entities/{basePolyline.js → polylineBase.js}

@@ -20,8 +20,8 @@ import { RubberBand } from '../lib/auxiliary/rubberBand.js';
  * Base Polyline Entity Class
  * @extends Entity
  */
-export class BasePolyline extends Entity {
-  static type = 'BasePolyline';
+export class PolylineBase extends Entity {
+  static type = 'PolylineBase';
 
   /**
    * Create a Base Polyline
@@ -233,7 +233,7 @@ export class BasePolyline extends Entity {
   /**
    * Set entity points from a polyline point representation
    * @param {Array} points
-   * @return {BasePolyline}
+   * @return {PolylineBase}
    */
   fromPolylinePoints(points) {
     const pts = points.map((p) => new Point(p.x, p.y, p.bulge));
@@ -311,10 +311,10 @@ export class BasePolyline extends Entity {
       let closestPoint;
       let candidateSegment;
       if (A.bulge !== 0) {
-        const center = A.bulgeCentrePoint(B);
+        const centre = A.bulgeCentrePoint(B);
         const direction = A.bulge > 0 ? 1 : -1;
-        closestPoint = P.closestPointOnArc(A, B, center, direction);
-        candidateSegment = new Arc({ points: [center, A, B], direction });
+        closestPoint = P.closestPointOnArc(A, B, centre, direction);
+        candidateSegment = new Arc({ points: [centre, A, B], direction });
       } else {
         closestPoint = P.closestPointOnLine(A, B);
         candidateSegment = new Line({ points: [A, B] });
@@ -420,9 +420,9 @@ export class BasePolyline extends Entity {
    */
   isPointOnSegment(point, A, B) {
     if (A.bulge !== 0) {
-      const center = A.bulgeCentrePoint(B);
+      const centre = A.bulgeCentrePoint(B);
       const direction = A.bulge > 0 ? 1 : -1;
-      return point.isOnArc(A, B, center, direction);
+      return point.isOnArc(A, B, centre, direction);
     }
     return point.isOnLine(A, B);
   }
@@ -438,9 +438,9 @@ export class BasePolyline extends Entity {
     const B = this.points[segmentIndex % this.points.length];
 
     if (A.bulge !== 0) {
-      const center = A.bulgeCentrePoint(B);
+      const centre = A.bulgeCentrePoint(B);
       const direction = A.bulge > 0 ? 1 : -1;
-      const closest = point.closestPointOnArc(A, B, center, direction);
+      const closest = point.closestPointOnArc(A, B, centre, direction);
 
       if (closest) {
         return closest;
@@ -464,10 +464,10 @@ export class BasePolyline extends Entity {
     const B = this.points[segmentIndex % this.points.length];
 
     if (A.bulge !== 0) {
-      const center = A.bulgeCentrePoint(B);
+      const centre = A.bulgeCentrePoint(B);
       const direction = A.bulge > 0 ? 1 : -1;
-      const startAngle = center.angle(A);
-      const pointAngle = center.angle(point);
+      const startAngle = centre.angle(A);
+      const pointAngle = centre.angle(point);
       return ((pointAngle - startAngle) * direction + 4 * Math.PI) % (2 * Math.PI);
     }
 
@@ -490,8 +490,8 @@ export class BasePolyline extends Entity {
       let boundingBox = BoundingBox.lineBoundingBox(this.points[i], nextPoint);
 
       if (this.points[i].bulge !== 0) {
-        const centerPoint = this.points[i].bulgeCentrePoint(nextPoint);
-        boundingBox = BoundingBox.arcBoundingBox(centerPoint, this.points[i], nextPoint, this.points[i].bulge);
+        const centrePoint = this.points[i].bulgeCentrePoint(nextPoint);
+        boundingBox = BoundingBox.arcBoundingBox(centrePoint, this.points[i], nextPoint, this.points[i].bulge);
       }
 
       xmin = Math.min(xmin, boundingBox.xMin);
@@ -519,9 +519,9 @@ export class BasePolyline extends Entity {
     // get the angle at the end of the previous segment
     let lastSegAngle;
     if (lastSegIsArc) {
-      const centerPoint = this.points.at(-2).bulgeCentrePoint(this.points.at(-1));
-      // angle is perpendicular to the center-to-end point ray, in the direction of the bulge
-      lastSegAngle = centerPoint.angle(this.points.at(-1)) + (Math.PI / 2) * Math.sign(lastSegBulge);
+      const centrePoint = this.points.at(-2).bulgeCentrePoint(this.points.at(-1));
+      // angle is perpendicular to the centre-to-end point ray, in the direction of the bulge
+      lastSegAngle = centrePoint.angle(this.points.at(-1)) + (Math.PI / 2) * Math.sign(lastSegBulge);
     } else {
       // line segment angle is the angle from point 0 to point 1
       lastSegAngle = this.points.at(-2).angle(this.points.at(-1));

package/core/entities/text.js

@@ -83,7 +83,7 @@ export class Text extends Entity {
       type: Property.Type.LIST,
       value: hAlign > 2 ? 1 : hAlign,
       dxfCode: 72,
-      options: () => [{ display: 'Left', value: 0 }, { display: 'Center', value: 1 }, { display: 'Right', value: 2 }],
+      options: () => [{ display: 'Left', value: 0 }, { display: 'Centre', value: 1 }, { display: 'Right', value: 2 }],
     });
     // DXF Groupcode 73 - Vertical Alignment (0=Baseline; 1=Bottom; 2=Middle; 3=Top)
     this.properties.add(Property.Names.VERTICALALIGNMENT, {
@@ -354,13 +354,13 @@ export class Text extends Entity {
       case 0:
         return 'left';
       case 1:
-        return 'center';
+        return 'centre';
       case 2:
         return 'right';
       case 3:
         return (this.getProperty(Property.Names.VERTICALALIGNMENT) === 0 ? 'aligned' : 'left');
       case 4:
-        return (this.getProperty(Property.Names.VERTICALALIGNMENT) === 0 ? 'center' : 'left');
+        return (this.getProperty(Property.Names.VERTICALALIGNMENT) === 0 ? 'centre' : 'left');
       case 5:
         return (this.getProperty(Property.Names.VERTICALALIGNMENT) === 0 ? 'fit' : 'left');
       default:
@@ -539,7 +539,7 @@ export class Text extends Entity {
       case 0: // left
         offsetX = 0;
         break;
-      case 1: // center
+      case 1: // centre
         offsetX = -rect.width / 2;
         break;
       case 2: // right

package/core/lib/boundingBox.js

@@ -55,9 +55,9 @@ export class BoundingBox {
   }
 
   /**
-   * return bounding box center point
+   * return bounding box centre point
    */
-  get centerPoint() {
+  get centrePoint() {
     return new Point(this.xMin + this.xLength / 2, this.yMin + this.yLength / 2);
   }
 
@@ -136,16 +136,16 @@ export class BoundingBox {
 
   /**
    * Calculate the boundingbox for an arc
-   * @param {Point} centerPoint
+   * @param {Point} centrePoint
    * @param {Point} startPoint
    * @param {Point} endPoint
    * @param {number} direction - ccw > 0, cw < 0
    * @return {BoundingBox}
    */
-  static arcBoundingBox(centerPoint, startPoint, endPoint, direction = 1) {
-    const startAngle = centerPoint.angle(startPoint);
-    const endAngle = centerPoint.angle(endPoint);
-    const radius = centerPoint.distance(startPoint);
+  static arcBoundingBox(centrePoint, startPoint, endPoint, direction = 1) {
+    const startAngle = centrePoint.angle(startPoint);
+    const endAngle = centrePoint.angle(endPoint);
+    const radius = centrePoint.distance(startPoint);
 
     const cross0 = this.crossesAxis(startAngle, endAngle, 0, direction);
     const cross90 = this.crossesAxis(startAngle, endAngle, Math.PI * 0.5, direction);
@@ -154,10 +154,10 @@ export class BoundingBox {
 
     // if the arc crosses the axis the min or max is where the arc intersects the axis
     // otherwise max/min is the arc endpoint
-    const xmin = cross180 ? centerPoint.x - radius : Math.min(startPoint.x, endPoint.x);
-    const xmax = cross0 ? centerPoint.x + radius : Math.max(startPoint.x, endPoint.x);
-    const ymin = cross270 ? centerPoint.y - radius : Math.min(startPoint.y, endPoint.y);
-    const ymax = cross90 ? centerPoint.y + radius : Math.max(startPoint.y, endPoint.y);
+    const xmin = cross180 ? centrePoint.x - radius : Math.min(startPoint.x, endPoint.x);
+    const xmax = cross0 ? centrePoint.x + radius : Math.max(startPoint.x, endPoint.x);
+    const ymin = cross270 ? centrePoint.y - radius : Math.min(startPoint.y, endPoint.y);
+    const ymax = cross90 ? centrePoint.y + radius : Math.max(startPoint.y, endPoint.y);
 
     const topLeft = new Point(xmin, ymax);
     const bottomRight = new Point(xmax, ymin);

package/core/lib/canvas.js

@@ -189,7 +189,9 @@ export class Canvas {
    */
   wheel(delta) {
     if (DesignCore.Mouse.buttonTwoDown) return;
-    const scale = Math.pow(1 + Math.abs(delta), delta > 0 ? 1 : -1);
+    // Clamp to [-1, 1] so that high-resolution mice and track pads don't produce runaway jumps.
+    const clampedDelta = Math.max(-1, Math.min(1, delta));
+    const scale = Math.pow(1.2, clampedDelta);
     if (scale < 1 && this.getScale() > this.minScaleFactor || scale > 1 && this.getScale() < this.maxScaleFactor) {
       this.zoom(scale);
     }
@@ -386,8 +388,8 @@ export class Canvas {
     this.#paintEntities(DesignCore.Scene.previewEntities, renderer);
 
     // Paint the selected scene items: single pass — renderer handles glow + entity internally.
-    const selectedItems = DesignCore.Scene.selectionManager.selectedItems;
-    this.#paintEntities(selectedItems, renderer, { colour: selectionHaloColour, lineWidthDelta: selectionLineWidthDelta });
+    const selectedEntities = DesignCore.Scene.selectionManager.selectedEntities;
+    this.#paintEntities(selectedEntities, renderer, { colour: selectionHaloColour, lineWidthDelta: selectionLineWidthDelta });
 
     // Paint the auxiliary scene items
     // auxiliary items include things like the selection window, snap points etc
@@ -403,7 +405,7 @@ export class Canvas {
 
   /**
    * Recursively paint a single entity and any children it returns.
-   * Container entities (Insert, BaseDimension) return an array of child items from draw().
+   * Container entities (Insert, DimensionBase) return an array of child items from draw().
    * Leaf entities return undefined. Renderer state is saved/restored around each entity.
    * @param {Object} entity - entity to paint
    * @param {Object} renderer - renderer instance

package/core/lib/clipboard.js

@@ -69,7 +69,7 @@ export class Clipboard {
       return;
     }
 
-    // copy the item to avoid mutation of originals
+    // copy the entity to avoid mutation of originals
     this.#Entities = entities.map((entity) => Utils.cloneObject(entity));
     // set basepoint to bottom left of selection bounding box
     const bbox = BoundingBox.fromEntities(entities);
@@ -152,7 +152,7 @@ export class Clipboard {
     const clipboardData = { basePoint: undefined, Entities: undefined };
     const jsonEntities = [];
 
-    // convert each entity to a simple object - this allows non-enumberable properties (like points) to be copied
+    // convert each entity to a simple object - this allows non-enumerable properties (like points) to be copied
     for (const ent of this.#Entities) {
       const jsonEntity = this.#simplify(ent);
       jsonEntities.push(jsonEntity);

package/core/lib/dxf/dxf.js

@@ -311,14 +311,14 @@ export class DXF {
               DesignCore.HandleManager.checkHandle(itemHandle);
             }
 
-            if (block.hasOwnProperty('items') === false) {
-              block.items = [];
+            if (block.hasOwnProperty('entities') === false) {
+              block.entities = [];
             }
 
             // add the child to the block items
             // TODO: create a block instance and add the items.
             // check block is valid before adding to scene
-            block.items.push(item);
+            block.entities.push(item);
           }
         });
       }
@@ -347,7 +347,7 @@ export class DXF {
         entity.points = this.parsePoints(entity.points);
       }
 
-      this.addItem(entity);
+      this.addEntity(entity);
     });
 
     // ensure all layers, ltypes, styles, dimstyles exist
@@ -378,18 +378,18 @@ export class DXF {
   }
 
   /**
-   * Add Item
-   * @param {Object} item
+   * Add Entity
+   * @param {Object} entity
    */
-  addItem(item) {
-    if (item.hasOwnProperty('0') === false) {
+  addEntity(entity) {
+    if (entity.hasOwnProperty('0') === false) {
       return;
     }
 
-    const command = item[0];
+    const command = entity[0];
     if (DesignCore.CommandManager.isCommand(command)) {
-      const entity = DesignCore.CommandManager.createNew(command, item);
-      DesignCore.Scene.entities.add(entity);
+      const newEntity = DesignCore.CommandManager.createNew(command, entity);
+      DesignCore.Scene.entities.add(newEntity);
     } else {
       Logging.instance.warn(`${Strings.Message.UNKNOWNCOMMAND} ${command}`);
       this.unsupportedElements = true;

package/core/lib/dxf/dxfIterator.js

@@ -23,11 +23,11 @@ Example DXF Entity Pairs:
  value: 100.0       - y position
  */
 
-/** DXF Interator Class */
+/** DXF Iterator Class */
 export class DxfIterator {
   static _instance;
 
-  /** Create DXFInterator */
+  /** Create DXFIterator */
   constructor() {
     this.currentIndex = 0;
     this.lines = [];

package/core/lib/entityManager.js

@@ -92,26 +92,26 @@ export class EntityManager {
   }
 
   /**
-   * Find items in scene
+   * Find entities  in scene
    * @param {string} type - entity type or "ANY"
    * @param {string} prop - object of entity parameters
    * @param {any} value - value of the property
-   * @return {number} - index of items
+   * @return {number} - index of entities
    */
   find(type, prop, value) {
-    const filteredItems = [];
+    const filteredEntities = [];
 
-    this.#entities.forEach((item, index) => {
-      if (type.toUpperCase() === 'ANY' || item.type.toUpperCase() === type.toUpperCase()) {
-        const inStore = item.properties?.has(prop);
-        const propValue = inStore ? item.getProperty(prop) : (Object.prototype.hasOwnProperty.call(item, prop) ? item[prop] : undefined);
+    this.#entities.forEach((entity, index) => {
+      if (type.toUpperCase() === 'ANY' || entity.type.toUpperCase() === type.toUpperCase()) {
+        const inStore = entity.properties?.has(prop);
+        const propValue = inStore ? entity.getProperty(prop) : (Object.prototype.hasOwnProperty.call(entity, prop) ? entity[prop] : undefined);
         if (propValue !== undefined && propValue === value) {
-          filteredItems.push(index);
+          filteredEntities.push(index);
         }
       }
     });
 
-    return filteredItems;
+    return filteredEntities;
   }
 
   /** Get index of entity
@@ -124,16 +124,16 @@ export class EntityManager {
 
 
   /**
-   * Find closest item to point
+   * Find closest entity to point
    * @param  {Point} point
-   * @return {number} - return index of closest item or undefined
+   * @return {number} - return index of closest entity or undefined
    */
   findClosest(point) {
     let delta = 1.65 / DesignCore.Core.canvas.getScale(); // find a more suitable starting value
-    let closestItemIndex;
+    let closestEntityIndex;
 
     for (let i = 0; i < this.#entities.length; i++) {
-      // check the items layer is selectable - i.e. on, thawed, etc...
+      // check the entities  layer is selectable - i.e. on, thawed, etc...
       const layer = DesignCore.LayerManager.getItemByName(this.#entities[i].getProperty(Property.Names.LAYER));
 
       if (!layer?.isSelectable) {
@@ -144,11 +144,11 @@ export class EntityManager {
 
       if (distance < delta) {
         delta = distance;
-        closestItemIndex = i;
+        closestEntityIndex = i;
       }
     }
 
-    return closestItemIndex;
+    return closestEntityIndex;
   }
 
   /**
@@ -157,14 +157,14 @@ export class EntityManager {
    * @param {object} data
    */
   update(index, data) {
-    const item = this.get(index);
+    const entity = this.get(index);
 
-    if (!item) {
-      throw Error('Item not found in scene');
+    if (!entity) {
+      throw Error('Entity not found in scene');
     }
 
     for (const property of Object.keys(data)) {
-      item.setProperty(property, data[property]);
+      entity.setProperty(property, data[property]);
     }
   }
 

package/core/lib/inputManager.js

@@ -392,7 +392,7 @@ export class InputManager {
     }
 
     if (Input.getType(selection) === Input.Type.SINGLESELECTION) {
-      DesignCore.Scene.selectionManager.addToSelectionSet(selection.selectedItemIndex);
+      DesignCore.Scene.selectionManager.addToSelectionSet(selection.selectedEntityIndex);
     }
   }
 

package/core/lib/matrix.js

@@ -37,7 +37,7 @@ export class Matrix {
   };
 
   /**
-   * Apply tranlation to matrix
+   * Apply translation to matrix
    * @param {number} x - translation in x
    * @param {number} y - translation in y
    */

package/core/lib/patterns.js

@@ -462,7 +462,7 @@ export class Patterns {
 60, 0, 0, 4.7625, 2.749630645, -6.35, 3.175` },
 
     'HOUND': {
-      description: 'Houndstooth check', pattern:
+      description: 'Hounds tooth check', pattern:
                 `0, 0, 0, 6.35, 1.5875, 25.4, -12.7
 90, 0, 0, 6.35, 1.5875, 25.4, -12.7` },
 

package/core/lib/polylineUtils.js

@@ -16,12 +16,12 @@ export class PolylineUtils {
    */
   static isPointOnSegment(point, A, B) {
     if (A.bulge !== 0 && A.bulge !== undefined) {
-      const center = A.bulgeCentrePoint(B);
-      const radius = center.distance(A);
+      const centre = A.bulgeCentrePoint(B);
+      const radius = centre.distance(A);
       // Point must lie on the circle before checking the angular range.
-      if (Utils.round(center.distance(point)) !== Utils.round(radius)) return false;
+      if (Utils.round(centre.distance(point)) !== Utils.round(radius)) return false;
       const direction = A.bulge > 0 ? 1 : -1;
-      return point.isOnArc(A, B, center, direction);
+      return point.isOnArc(A, B, centre, direction);
     }
     return point.isOnLine(A, B);
   }
@@ -38,9 +38,9 @@ export class PolylineUtils {
     const B = points[segmentIndex % points.length];
 
     if (A.bulge !== 0 && A.bulge !== undefined) {
-      const center = A.bulgeCentrePoint(B);
+      const centre = A.bulgeCentrePoint(B);
       const direction = A.bulge > 0 ? 1 : -1;
-      const closest = point.closestPointOnArc(A, B, center, direction);
+      const closest = point.closestPointOnArc(A, B, centre, direction);
       if (closest) return closest;
       // Point not on arc — return the nearer endpoint
       return point.distance(A) < point.distance(B) ? A : B;
@@ -63,10 +63,10 @@ export class PolylineUtils {
     const B = points[segmentIndex % points.length];
 
     if (A.bulge !== 0 && A.bulge !== undefined) {
-      const center = A.bulgeCentrePoint(B);
+      const centre = A.bulgeCentrePoint(B);
       const direction = A.bulge > 0 ? 1 : -1;
-      const startAngle = center.angle(A);
-      const pointAngle = center.angle(point);
+      const startAngle = centre.angle(A);
+      const pointAngle = centre.angle(point);
       return ((pointAngle - startAngle) * direction + 4 * Math.PI) % (2 * Math.PI);
     }
 

package/core/lib/renderers/cairoRenderer.js

@@ -159,14 +159,14 @@ export class CairoRenderer extends RendererBase {
       if (!p.bulge) {
         this.#cr.lineTo(next.x, next.y);
       } else {
-        const center = p.bulgeCentrePoint(next);
+        const centre = p.bulgeCentrePoint(next);
         const radius = p.bulgeRadius(next);
-        const startAngle = center.angle(p);
-        const endAngle = center.angle(next);
+        const startAngle = centre.angle(p);
+        const endAngle = centre.angle(next);
         if (p.bulge > 0) {
-          this.#cr.arc(center.x, center.y, radius, startAngle, endAngle);
+          this.#cr.arc(centre.x, centre.y, radius, startAngle, endAngle);
         } else {
-          this.#cr.arcNegative(center.x, center.y, radius, startAngle, endAngle);
+          this.#cr.arcNegative(centre.x, centre.y, radius, startAngle, endAngle);
         }
       }
     }

package/core/lib/renderers/canvasRenderer.js

@@ -141,12 +141,12 @@ export class CanvasRenderer extends RendererBase {
       if (!p.bulge) {
         this.#ctx.lineTo(next.x, next.y);
       } else {
-        const center = p.bulgeCentrePoint(next);
+        const centre = p.bulgeCentrePoint(next);
         const radius = p.bulgeRadius(next);
-        const startAngle = center.angle(p);
-        const endAngle = center.angle(next);
+        const startAngle = centre.angle(p);
+        const endAngle = centre.angle(next);
         // Canvas arc: CCW = false (default), CW = true (anticlockwise flag inverted)
-        this.#ctx.arc(center.x, center.y, radius, startAngle, endAngle, p.bulge < 0);
+        this.#ctx.arc(centre.x, centre.y, radius, startAngle, endAngle, p.bulge < 0);
       }
     }
   }