atriusmaps-node-sdk 3.3.632 → 3.3.633

package/dist/cjs/src/extModules/log.js

@@ -9,10 +9,10 @@ const nodeColorsOb = {
   blue: '\x1b[34m',
   magenta: '\x1b[35m',
   cyan: '\x1b[36m',
-  white: '\x1b[37m'
+  white: '\x1b[37m',
 };
 
-function clog (name, options = { }) {
+function clog(name, options = {}) {
   let prefix = name + ': ';
   let style = null;
 
@@ -22,34 +22,29 @@ function clog (name, options = { }) {
       style = `color: ${options.color}`;
     } else {
       const cstring = nodeColorsOb[options.color];
-      if (cstring)
-        prefix = cstring + prefix;
+      if (cstring) prefix = cstring + prefix;
     }
 
-  const trunc = (str, len) => str && str.length > len ? str.substring(0, len) + '...' : str;
-  const checkPassesFilter = (args, filter) => typeof filter === 'string'
-    ? args[0].includes(filter)
-    : filter.test(args[0]);
+  const trunc = (str, len) => (str && str.length > len ? str.substring(0, len) + '...' : str);
+  const checkPassesFilter = (args, filter) =>
+    typeof filter === 'string' ? args[0].includes(filter) : filter.test(args[0]);
 
-  function logGen (cmethod) {
+  function logGen(cmethod) {
     return function () {
       const isEnabled = options.enabled === undefined ? true : !!options.enabled;
       if (isEnabled || cmethod === console.error) {
         let args = Array.from(arguments);
-        if (style)
-          args.unshift(style);
+        if (style) args.unshift(style);
         args.unshift(prefix);
         if (options.truncateObjects && cmethod !== console.error)
           args = args.map(arg => {
-            if (typeof arg === 'object')
-              return trunc(JSON.stringify(arg), parseInt(options.truncateObjects) || 100)
-            return arg
+            if (typeof arg === 'object') return trunc(JSON.stringify(arg), parseInt(options.truncateObjects) || 100);
+            return arg;
           });
         const passesFilter = !options.logFilter || checkPassesFilter(args, options.logFilter);
-        if (passesFilter || cmethod === console.error)
-          cmethod.apply(console, args);
+        if (passesFilter || cmethod === console.error) cmethod.apply(console, args);
       }
-    }
+    };
   }
 
   const log = logGen(options.trace ? console.trace : console.log);
@@ -58,15 +53,18 @@ function clog (name, options = { }) {
   log.detailed = logGen(console.debug);
   log.error = logGen(console.error);
 
-  log.setEnabled = e => { options.enabled = e; };
+  log.setEnabled = e => {
+    options.enabled = e;
+  };
 
-  return log
+  return log;
 }
 
-function initLog (name, options) {
+function initLog(name, options) {
   const log = clog(name, options);
-  log.sublog = (sublogName, sublogOptions) => initLog(name + '.' + sublogName, Object.assign(Object.create(options), sublogOptions));
-  return log
+  log.sublog = (sublogName, sublogOptions) =>
+    initLog(name + '.' + sublogName, Object.assign(Object.create(options), sublogOptions));
+  return log;
 }
 
 exports.initLog = initLog;

package/dist/cjs/src/historyManager.js

@@ -9,7 +9,7 @@ const initHistoryManager = ({ bus }) => {
     const layersToHide = [];
     const current = stepStack.pop();
 
-    if (!current) return
+    if (!current) return;
 
     layersToHide.push(current.viewId);
     for (let i = stepStack.length - 1; i >= 0; --i) {
@@ -17,7 +17,7 @@ const initHistoryManager = ({ bus }) => {
         const same = stepStack.pop();
         layersToHide.push(same.viewId);
       } else {
-        break
+        break;
       }
     }
     bus.send('layers/hideMultiple', layersToHide);

package/dist/cjs/src/utils/bounds.js

@@ -2,24 +2,24 @@
 
 var R = require('ramda');
 
-function findBoundsOfWaypoints (waypoints) {
+function findBoundsOfWaypoints(waypoints) {
   const latitudes = waypoints.map(R.path(['position', 'lat'])).filter(R.identity);
   const longitudes = waypoints.map(R.path(['position', 'lng'])).filter(R.identity);
-  return findBounds(latitudes, longitudes)
+  return findBounds(latitudes, longitudes);
 }
 
-function findBoundsOfCoordinates (coordinates) {
+function findBoundsOfCoordinates(coordinates) {
   const latitudes = coordinates.map(R.prop(0)).filter(R.identity);
   const longitudes = coordinates.map(R.prop(1)).filter(R.identity);
-  return findBounds(latitudes, longitudes)
+  return findBounds(latitudes, longitudes);
 }
 
-function findBounds (latitudes, longitudes) {
+function findBounds(latitudes, longitudes) {
   const n = Math.max(...latitudes);
   const s = Math.min(...latitudes);
   const e = Math.max(...longitudes);
   const w = Math.min(...longitudes);
-  return { n, s, e, w }
+  return { n, s, e, w };
 }
 
 exports.findBoundsOfCoordinates = findBoundsOfCoordinates;

package/dist/cjs/src/utils/buildStructureLookup.js

@@ -21,7 +21,7 @@ function _interopNamespaceDefault(e) {
 
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
-const buildStructuresLookup = (structures) => {
+const buildStructuresLookup = structures => {
   const floors = R__namespace.mergeAll(structures.map(R__namespace.prop('levels')));
   const floorIdToFloor = floorId => floors[floorId];
   const floorIdToOrdinal = R__namespace.pipe(floorIdToFloor, R__namespace.prop('ordinal'));
@@ -31,8 +31,8 @@ const buildStructuresLookup = (structures) => {
     floorIdToOrdinal,
     floorIdToFloor,
     floorIdToStructureId,
-    floorIdToStructure
-  }
+    floorIdToStructure,
+  };
 };
 
 exports.buildStructuresLookup = buildStructuresLookup;

package/dist/cjs/src/utils/configUtils.js

@@ -17,47 +17,43 @@
  * @param  {string} lang language code
  * @param  {any} def default value to return if no value is found through localized checks
  */
-function getLocalized (config, name, lang, def) {
+function getLocalized(config, name, lang, def) {
   let key = name;
-  if (lang)
-    key += '-' + lang;
+  if (lang) key += '-' + lang;
 
   const value = config[key];
 
-  if (value)
-    return value
+  if (value) return value;
 
   if (lang) {
-    if (lang.indexOf('-') > 0) // we have sublocales, so strip last one and try again
-      return getLocalized(config, name, lang.substring(0, lang.indexOf('-')), def)
-    else // no sublanguage, so next is try the name on its own
-      return getLocalized(config, name, null, def)
+    if (lang.indexOf('-') > 0)
+      // we have sublocales, so strip last one and try again
+      return getLocalized(config, name, lang.substring(0, lang.indexOf('-')), def);
+    // no sublanguage, so next is try the name on its own
+    else return getLocalized(config, name, null, def);
   }
 
   // we are here means we just checked the name (no lang arg) and there was no value found, so
   // we simply return the def
-  return def
+  return def;
 }
 
 // A debug property is considered "true" if:
 //  The key is defined as a property within the debug object AND
 //  the value of that key is not "no" or "false" or false (boolean) or undefined or null
 // Any other value will be considered true - even 0 and ""
-function debugIsTrue (app, key) {
-  if (!app.config.debug)
-    return false
+function debugIsTrue(app, key) {
+  if (!app.config.debug) return false;
 
   let value = app.config.debug[key];
 
-  if (value === undefined || value === null || value === false)
-    return false
+  if (value === undefined || value === null || value === false) return false;
 
-  if (value === true)
-    return true
+  if (value === true) return true;
 
   value = value.toLowerCase ? value.toLowerCase() : value; // lower case it if possible
 
-  return value !== 'no' && value !== 'false'
+  return value !== 'no' && value !== 'false';
 }
 
 // import this global to access to the "window" or "global" variables from

package/dist/cjs/src/utils/dom.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const $ = (expr, container) => typeof expr === 'string' ? (container || document).querySelector(expr) : expr || null;
+const $ = (expr, container) => (typeof expr === 'string' ? (container || document).querySelector(expr) : expr || null);
 const $$ = (expr, container) => Array.prototype.slice.call((document).querySelectorAll(expr));
 
 // adds an element (default: div) defined in eConf to parent element (default: body) - returns element
@@ -8,43 +8,37 @@ const $$ = (expr, container) => Array.prototype.slice.call((document).querySelec
 // const newDiv = ad() = creates a new div, adds to end of page and returns it
 // const newDiv = ad({klass: "foo"}) = same as above with class of "foo"
 // const newImg = ad({tag: "img", src: "test.png"}, "#top") = image at end of top
-function ad (eConf, parent) {
+function ad(eConf, parent) {
   const c = eConf || {};
   parent = parent ? (typeof parent === 'string' ? document.querySelector(parent) : parent) : document.body;
 
   let tag = 'div';
 
-  if (c.tag)
-    tag = c.tag;
+  if (c.tag) tag = c.tag;
 
   const node = document.createElement(tag);
 
   for (const cc in c) {
-    if (c[cc] != null) // null or undefined
+    if (c[cc] != null)
       if (cc === 'klass')
+        // null or undefined
         node.setAttribute('class', c.klass);
-      else if (cc === 'tag')
-        ; // already swallowed this
-      else if (cc === 'styles')
-        setStyles(node, c.styles);
-      else if (cc === 'text')
-        node.textContent = c.text;
-      else if (cc === 'html')
-        node.innerHTML = c.html;
-      else
-        node.setAttribute(cc, c[cc]);
+      else if (cc === 'tag'); // already swallowed this
+      else if (cc === 'styles') setStyles(node, c.styles);
+      else if (cc === 'text') node.textContent = c.text;
+      else if (cc === 'html') node.innerHTML = c.html;
+      else node.setAttribute(cc, c[cc]);
   }
 
   parent.appendChild(node);
 
-  return node
+  return node;
 }
 
 const del = element => element?.parentNode?.removeChild(element);
 
 const setStyles = (node, styles) => {
-  for (const style in styles)
-    node.style[style] = styles[style];
+  for (const style in styles) node.style[style] = styles[style];
 };
 
 exports.$ = $;

package/dist/cjs/src/utils/funcs.js

@@ -5,14 +5,13 @@ require('zousan');
 
 // Ensures only a single asynchronous function wrapped in this function runs at a time.
 let lastFn = null;
-const singleFile = fn => function () {
-  if (lastFn)
-    lastFn = lastFn.then(() => fn.apply(null, arguments));
-  else
-    lastFn = fn.apply(null, arguments);
+const singleFile = fn =>
+  function () {
+    if (lastFn) lastFn = lastFn.then(() => fn.apply(null, arguments));
+    else lastFn = fn.apply(null, arguments);
 
-  return lastFn
-};
+    return lastFn;
+  };
 
 /**
  * returns a copy of an object with any (top-level) properties that do not
@@ -22,14 +21,12 @@ const singleFile = fn => function () {
  * @param  {object} ob The object to filter (top level properties only)
  * @returns (object) The newly created object with filtered properties
  */
-function filterOb (fn, ob) {
-  const ret = { };
-  Object.keys(ob)
-    .forEach(key => {
-      if (fn(key, ob[key]))
-        ret[key] = ob[key];
-    });
-  return ret
+function filterOb(fn, ob) {
+  const ret = {};
+  Object.keys(ob).forEach(key => {
+    if (fn(key, ob[key])) ret[key] = ob[key];
+  });
+  return ret;
 }
 
 exports.filterOb = filterOb;

package/dist/cjs/src/utils/geodesy.js

@@ -8,7 +8,7 @@
 */
 
 // degrees to radians
-const toRadians = d => d * Math.PI / 180;
+const toRadians = d => (d * Math.PI) / 180;
 
 /**
  * Haversine formula for finding distance between two lat/lng points.
@@ -19,22 +19,20 @@ const toRadians = d => d * Math.PI / 180;
  * @param {float} lng2 longitude of point 2
  * @returns number (in meters) between p1 and p2
  */
-function distance (lat1, lng1, lat2, lng2) {
+function distance(lat1, lng1, lat2, lng2) {
   const R = 6371000; // approx. earth radius (meters)
   const φ1 = toRadians(lat1);
   const φ2 = toRadians(lat2);
   const Δφ = toRadians(lat2 - lat1);
   const Δλ = toRadians(lng2 - lng1);
 
-  const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +
-    Math.cos(φ1) * Math.cos(φ2) *
-    Math.sin(Δλ / 2) * Math.sin(Δλ / 2);
+  const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) + Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ / 2) * Math.sin(Δλ / 2);
   const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
 
-  return R * c
+  return R * c;
 }
 
-function bearingToDirection (deg, T) {
+function bearingToDirection(deg, T) {
   const names = [
     T('wayfinder:north'), // 0
     T('wayfinder:northeast'), // 45
@@ -43,13 +41,13 @@ function bearingToDirection (deg, T) {
     T('wayfinder:south'), // 180 / -180
     T('wayfinder:southwest'), // -135
     T('wayfinder:west'), // -90
-    T('wayfinder:northwest') // -45
+    T('wayfinder:northwest'), // -45
   ];
   // normalize -180..180
   const d = ((deg + 180) % 360) - 180;
 
   const index = Math.round(d / 45);
-  return names[(index + 8) % 8]
+  return names[(index + 8) % 8];
 }
 
 exports.bearingToDirection = bearingToDirection;

package/dist/cjs/src/utils/geom.js

@@ -37,17 +37,22 @@ const pointInPolygon = (point, vs) => {
     const yi = vs[i][1];
     const xj = vs[j][0];
     const yj = vs[j][1];
-    const intersect = ((yi > y) !== (yj > y)) &&
-          (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
+    const intersect = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
     if (intersect) {
       inside = !inside;
     }
   }
 
-  return inside
+  return inside;
 };
 
-const bounds2Coords = ({ n, s, e, w }) => [[n, e], [n, w], [s, w], [s, e], [n, e]];
+const bounds2Coords = ({ n, s, e, w }) => [
+  [n, e],
+  [n, w],
+  [s, w],
+  [s, e],
+  [n, e],
+];
 const NULL_STRUCTURE_AND_FLOOR = { structure: null, floor: null };
 
 /**
@@ -63,15 +68,18 @@ const NULL_STRUCTURE_AND_FLOOR = { structure: null, floor: null };
  * @param  {boolean} preciseFlag if false, we provide a fuzzy reading, allowing for the map center to be "close enough" to a building/floor
  * @returns {structure: object, floor: object} structure/building and floor that contains the point passed (or {structure:null,floor:null})
  */
-function getStructureAndFloorAtPoint (structures, lat, lng, ord, mapviewBBox, preciseFlag = false) { // Step 1 of logic flow
-  if (!R__namespace.length(structures)) return NULL_STRUCTURE_AND_FLOOR
+function getStructureAndFloorAtPoint(structures, lat, lng, ord, mapviewBBox, preciseFlag = false) {
+  // Step 1 of logic flow
+  if (!R__namespace.length(structures)) return NULL_STRUCTURE_AND_FLOOR;
 
   structures = structures.filter(s => s.shouldDisplay == null || s.shouldDisplay === true);
 
-  const floorsToConsider = structures
-    .map(structure => ({ structure, floor: ordToFloor(structure, ord) })); // array of {structure,floor} obs
+  const floorsToConsider = structures.map(structure => ({
+    structure,
+    floor: ordToFloor(structure, ord),
+  })); // array of {structure,floor} obs
 
-  return getStructureAndFloorWithinFloorsAtPoint(structures, floorsToConsider, lat, lng, mapviewBBox, preciseFlag)
+  return getStructureAndFloorWithinFloorsAtPoint(structures, floorsToConsider, lat, lng, mapviewBBox, preciseFlag);
 }
 
 /**
@@ -84,7 +92,7 @@ function getStructureAndFloorAtPoint (structures, lat, lng, ord, mapviewBBox, pr
  * @param  {boolean} preciseFlag if false, we provide a fuzzy reading, allowing for the map center to be "close enough" to a building/floor
  * @returns {structure: object, floor: object} structure/building and floor that contains the point passed (or {structure:null,floor:null})
  */
-function getStructureAndFloorWithinFloorsAtPoint (structures, floorsToConsider, lat, lng, mapviewBBox, preciseFlag) {
+function getStructureAndFloorWithinFloorsAtPoint(structures, floorsToConsider, lat, lng, mapviewBBox, preciseFlag) {
   // Step 2 - Select floors whose bounding box contains map center
   const pointWithinFloorsBBox = floorsToConsider
     .filter(ftc => ftc.floor) // ignore structures with no floor on this ord
@@ -96,20 +104,19 @@ function getStructureAndFloorWithinFloorsAtPoint (structures, floorsToConsider,
   //
   if (preciseFlag) {
     // not within any floor's bounding box? return nulls
-    if (pointWithinFloorsBBox.length === 0)
-      return NULL_STRUCTURE_AND_FLOOR
+    if (pointWithinFloorsBBox.length === 0) return NULL_STRUCTURE_AND_FLOOR;
 
     // Step 3 (precise) - We need to determine which of the floors found above are we ACTUALLY in:
-    const floorsWithinBoundsPolygon = pointWithinFloorsBBox
-      .filter(ftc => pointInPolygon([lat, lng], ftc.floor.boundsPolygon));
+    const floorsWithinBoundsPolygon = pointWithinFloorsBBox.filter(ftc =>
+      pointInPolygon([lat, lng], ftc.floor.boundsPolygon),
+    );
 
     // We should never be in MORE than one floor's bounding polygon, so return 1st one
     // and in unlikely case we ARE in multiple, user will get first one...
-    if (floorsWithinBoundsPolygon.length >= 1)
-      return R__namespace.head(floorsWithinBoundsPolygon)
+    if (floorsWithinBoundsPolygon.length >= 1) return R__namespace.head(floorsWithinBoundsPolygon);
 
     // precise yet not within any floor polygon, "so you get nothing. you lose. good day sir!"
-    return NULL_STRUCTURE_AND_FLOOR
+    return NULL_STRUCTURE_AND_FLOOR;
   }
 
   //
@@ -124,32 +131,38 @@ function getStructureAndFloorWithinFloorsAtPoint (structures, floorsToConsider,
       // .map(structure => ({ structure, floor: structure.levels[structure.defaultLevelId] }))
       .map(structure => ({ structure, floor: null }));
 
-    if (floorsWithinBuildingBoundingBox.length >= 1)
-      return floorsWithinBuildingBoundingBox[0]
+    if (floorsWithinBuildingBoundingBox.length >= 1) return floorsWithinBuildingBoundingBox[0];
 
-    return NULL_STRUCTURE_AND_FLOOR // user does not seem to be near ANYTHING!
+    return NULL_STRUCTURE_AND_FLOOR; // user does not seem to be near ANYTHING!
   }
 
   // Step 4 - If we are only in the bounding box of a single floor, return it
-  if (pointWithinFloorsBBox.length === 1)
-    return pointWithinFloorsBBox[0]
+  if (pointWithinFloorsBBox.length === 1) return pointWithinFloorsBBox[0];
 
   // Step 5 - Ok, so from here, we are NOT precise, and the map center is within MULTIPLE bounding boxes
   // so how do we determine WHICH item to select...?
 
-  const floorsContainingPoint = pointWithinFloorsBBox.filter(ftc => pointInPolygon([lat, lng], ftc.floor.boundsPolygon));
+  const floorsContainingPoint = pointWithinFloorsBBox.filter(ftc =>
+    pointInPolygon([lat, lng], ftc.floor.boundsPolygon),
+  );
 
   // We will score the building/floor's "prominence" and pick the highest scoring building/floor
-  const prominenceScores = pointWithinFloorsBBox.map(ftc => prominence(ftc, mapviewBBox, floorsContainingPoint.some(fcp => fcp.floor.id === ftc.floor.id)));
+  const prominenceScores = pointWithinFloorsBBox.map(ftc =>
+    prominence(
+      ftc,
+      mapviewBBox,
+      floorsContainingPoint.some(fcp => fcp.floor.id === ftc.floor.id),
+    ),
+  );
   const bestScore = Math.max.apply(null, prominenceScores);
 
-  return pointWithinFloorsBBox[prominenceScores.indexOf(bestScore)]
+  return pointWithinFloorsBBox[prominenceScores.indexOf(bestScore)];
 }
 
 // Returns a prominenceScore from 0 to 100
 // This is calculated by a % of screen taken by the
 // floor polygon
-function prominence ({ structure, floor }, mapviewBBox, pointWithinFloorPoly) {
+function prominence({ structure, floor }, mapviewBBox, pointWithinFloorPoly) {
   // Take the polygon of the floor...
   const floorPolygon = coords2Poly(floor.boundsPolygon);
 
@@ -163,7 +176,7 @@ function prominence ({ structure, floor }, mapviewBBox, pointWithinFloorPoly) {
   const viewableMapArea = area.area(mapviewBBoxPoly);
 
   // now the prominence is simply the ratio of viewable floor to viewable map (with 20% bonus if center within floor)
-  return floorArea * (pointWithinFloorPoly ? 150 : 100) / viewableMapArea
+  return (floorArea * (pointWithinFloorPoly ? 150 : 100)) / viewableMapArea;
 }
 
 const latLngSwap = point => [point[1], point[0]];
@@ -172,26 +185,25 @@ const coords2Poly = coords => helpers.polygon([coords.map(latLngSwap)]);
 /**
  * given a building and ord, return the floor (or undefined if doesn't exist)
  */
-const ordToFloor = (building, ord) =>
-  Object.values(building.levels).find(floor => floor.ordinal === ord);
+const ordToFloor = (building, ord) => Object.values(building.levels).find(floor => floor.ordinal === ord);
 
 /**
  * Return the floor based on its ID (pass in buildings array and floorId)
  */
 const getFloor = (structures, selectedLevelId) =>
-  structures.reduce((fmatch, building) =>
-    Object.values(building.levels).find(floor => floor.id === selectedLevelId) || fmatch, undefined);
+  structures.reduce(
+    (fmatch, building) => Object.values(building.levels).find(floor => floor.id === selectedLevelId) || fmatch,
+    undefined,
+  );
 
 // pass in the structures array and a floorId and this will return the structure
 // that contains the floorId.
 const getStructureForFloorId = (structures, floorId) =>
-  structures.reduce((sMatch, structure) =>
-    buildContainsFloorWithId(structure, floorId) ? structure : sMatch, null);
+  structures.reduce((sMatch, structure) => (buildContainsFloorWithId(structure, floorId) ? structure : sMatch), null);
 
 // returns true if the building specified contains the floorId specified
 const buildContainsFloorWithId = (building, floorId) =>
-  Object.values(building.levels).reduce((fmatch, floor) =>
-    floor.id === floorId ? true : fmatch, false);
+  Object.values(building.levels).reduce((fmatch, floor) => (floor.id === floorId ? true : fmatch), false);
 
 /**
  * Calculate the points for a bezier cubic curve
@@ -206,7 +218,7 @@ const buildContainsFloorWithId = (building, floorId) =>
  * @param {number} toY - Destination point y
  * @return {Object[]} Array of points of the curve
  */
-function bezierCurveTo (fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY) {
+function bezierCurveTo(fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY) {
   const n = 20; // controls smoothness of line
   let dt = 0;
   let dt2 = 0;
@@ -219,7 +231,7 @@ function bezierCurveTo (fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY) {
   for (let i = 1, j = 0; i <= n; ++i) {
     j = i / n;
 
-    dt = (1 - j);
+    dt = 1 - j;
     dt2 = dt * dt;
     dt3 = dt2 * dt;
 
@@ -227,12 +239,12 @@ function bezierCurveTo (fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY) {
     t3 = t2 * j;
 
     path.push({
-      x: (dt3 * fromX) + (3 * dt2 * j * cpX) + (3 * dt * t2 * cpX2) + (t3 * toX),
-      y: (dt3 * fromY) + (3 * dt2 * j * cpY) + (3 * dt * t2 * cpY2) + (t3 * toY)
+      x: dt3 * fromX + 3 * dt2 * j * cpX + 3 * dt * t2 * cpX2 + t3 * toX,
+      y: dt3 * fromY + 3 * dt2 * j * cpY + 3 * dt * t2 * cpY2 + t3 * toY,
     });
   }
 
-  return path
+  return path;
 }
 
 exports.bezierCurveTo = bezierCurveTo;