@duet3d/objectmodel 3.7.0-alpha.5 → 3.7.0-alpha.7

package/dist/src/move/DriverId.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriverId = void 0;
+exports.isDriverId = isDriverId;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+function isDriverId(value) {
+    return (value instanceof Object) && value.board !== undefined && value.driver !== undefined;
+}
+class DriverId extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.board = null;
+        this.driver = 0;
+    }
+    equals(value) {
+        if (isDriverId(value)) {
+            if (!this.board && !value.board) {
+                return this.driver === value.driver;
+            }
+            return (value.board === this.board) && (value.driver === this.driver);
+        }
+        return false;
+    }
+    update(jsonElement) {
+        if (isDriverId(jsonElement)) {
+            this.board = jsonElement.board;
+            this.driver = jsonElement.driver;
+            return this;
+        }
+        if (typeof jsonElement === "string") {
+            const matches = /(\d+)\.(\d+)/.exec(jsonElement);
+            if (matches !== null) {
+                this.board = Number(matches[1]);
+                this.driver = Number(matches[2]);
+            }
+            else {
+                this.board = null;
+                this.driver = Number(jsonElement);
+            }
+            return this;
+        }
+        return null;
+    }
+    toString() {
+        return (this.board === null) ? this.driver.toString() : `${this.board}.${this.driver}`;
+    }
+}
+exports.DriverId = DriverId;
+exports.default = DriverId;

package/dist/src/move/Extruder.d.ts

@@ -0,0 +1,39 @@
+import ModelObject from "../ModelObject";
+import DriverId from "./DriverId";
+import Microstepping from "./Microstepping";
+export declare class ExtruderNonlinear extends ModelObject {
+    a: number;
+    b: number;
+    upperLimit: number;
+}
+export declare class ExtruderPressureAdvance extends ModelObject {
+    d: number | null;
+    k0: number;
+    k1: number;
+}
+export declare class Extruder extends ModelObject {
+    constructor();
+    acceleration: number;
+    current: number;
+    driver: DriverId | null;
+    filament: string;
+    filamentDiameter: number;
+    factor: number;
+    jerk: number;
+    readonly microstepping: Microstepping;
+    readonly nonlinear: ExtruderNonlinear;
+    percentCurrent: number;
+    percentStstCurrent: number | null;
+    phaseStep: boolean | null;
+    position: number;
+    readonly pressAdv: ExtruderPressureAdvance;
+    /**
+     * @deprecated use pressAdv instead
+     */
+    pressureAdvance: number;
+    printingJerk: number;
+    rawPosition: number;
+    speed: number;
+    stepsPerMm: number;
+}
+export default Extruder;

package/dist/src/move/Extruder.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Extruder = exports.ExtruderPressureAdvance = exports.ExtruderNonlinear = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+const DriverId_1 = __importDefault(require("./DriverId"));
+const Microstepping_1 = __importDefault(require("./Microstepping"));
+class ExtruderNonlinear extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.a = 0;
+        this.b = 0;
+        this.upperLimit = 0.2;
+    }
+}
+exports.ExtruderNonlinear = ExtruderNonlinear;
+class ExtruderPressureAdvance extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.d = null;
+        this.k0 = 0;
+        this.k1 = 0;
+    }
+}
+exports.ExtruderPressureAdvance = ExtruderPressureAdvance;
+class Extruder extends ModelObject_1.default {
+    constructor() {
+        super();
+        this.acceleration = 500;
+        this.current = 0;
+        this.driver = null;
+        this.filament = "";
+        this.filamentDiameter = 1.75;
+        this.factor = 1;
+        this.jerk = 15;
+        this.microstepping = new Microstepping_1.default();
+        this.nonlinear = new ExtruderNonlinear();
+        this.percentCurrent = 100;
+        this.percentStstCurrent = null;
+        this.phaseStep = null;
+        this.position = 0;
+        this.pressAdv = new ExtruderPressureAdvance();
+        /**
+         * @deprecated use pressAdv instead
+         */
+        this.pressureAdvance = 0;
+        this.printingJerk = 15;
+        this.rawPosition = 0;
+        this.speed = 100;
+        this.stepsPerMm = 420;
+        ModelObject_1.default.wrapModelProperty(this, "driver", DriverId_1.default);
+    }
+}
+exports.Extruder = Extruder;
+exports.default = Extruder;

package/dist/src/move/InputShaping.d.ts

@@ -0,0 +1,19 @@
+import ModelObject from "../ModelObject";
+export declare enum InputShapingType {
+    none = "none",
+    mzv = "mzv",
+    zvd = "zvd",
+    zvdd = "zvdd",
+    zvddd = "zvddd",
+    ei2 = "ei2",
+    ei3 = "ei3",
+    custom = "custom"
+}
+export declare class InputShaping extends ModelObject {
+    amplitudes: Array<number>;
+    damping: number;
+    delays: Array<number>;
+    frequency: number;
+    type: InputShapingType;
+}
+export default InputShaping;

package/dist/src/move/InputShaping.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputShaping = exports.InputShapingType = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+var InputShapingType;
+(function (InputShapingType) {
+    InputShapingType["none"] = "none";
+    InputShapingType["mzv"] = "mzv";
+    InputShapingType["zvd"] = "zvd";
+    InputShapingType["zvdd"] = "zvdd";
+    InputShapingType["zvddd"] = "zvddd";
+    InputShapingType["ei2"] = "ei2";
+    InputShapingType["ei3"] = "ei3";
+    InputShapingType["custom"] = "custom";
+})(InputShapingType || (exports.InputShapingType = InputShapingType = {}));
+class InputShaping extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.amplitudes = [];
+        this.damping = 0.1;
+        this.delays = [];
+        this.frequency = 40;
+        this.type = InputShapingType.none;
+    }
+}
+exports.InputShaping = InputShaping;
+exports.default = InputShaping;

package/dist/src/move/KeepoutZone.d.ts

@@ -0,0 +1,10 @@
+import { ModelCollection } from "../ModelCollection";
+import { ModelObject } from "../ModelObject";
+export declare class KeepoutZoneCoordinates extends ModelObject {
+    max: number;
+    min: number;
+}
+export default class KeepoutZone extends ModelObject {
+    active: boolean;
+    readonly coords: ModelCollection<KeepoutZoneCoordinates | null>;
+}

package/dist/src/move/KeepoutZone.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeepoutZoneCoordinates = void 0;
+const ModelCollection_1 = require("../ModelCollection");
+const ModelObject_1 = require("../ModelObject");
+class KeepoutZoneCoordinates extends ModelObject_1.ModelObject {
+    constructor() {
+        super(...arguments);
+        this.max = 0;
+        this.min = 0;
+    }
+}
+exports.KeepoutZoneCoordinates = KeepoutZoneCoordinates;
+class KeepoutZone extends ModelObject_1.ModelObject {
+    constructor() {
+        super(...arguments);
+        this.active = true;
+        this.coords = new ModelCollection_1.ModelCollection(KeepoutZoneCoordinates);
+    }
+}
+exports.default = KeepoutZone;

package/dist/src/move/Microstepping.d.ts

@@ -0,0 +1,6 @@
+import ModelObject from "../ModelObject";
+export declare class Microstepping extends ModelObject {
+    interpolated: boolean;
+    value: number;
+}
+export default Microstepping;

package/dist/src/move/Microstepping.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Microstepping = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+class Microstepping extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.interpolated = false;
+        this.value = 16;
+    }
+}
+exports.Microstepping = Microstepping;
+exports.default = Microstepping;

package/dist/src/move/MotionSystem.d.ts

@@ -0,0 +1,20 @@
+import ModelObject from "../ModelObject";
+import ModelCollection from "../ModelCollection";
+import RestorePoint from "../state/RestorePoint";
+import { CurrentMove, MoveRotation } from ".";
+export declare class MotionSystem extends ModelObject {
+    readonly currentMove: CurrentMove;
+    currentObject: number | null;
+    currentTool: number;
+    nextTool: number;
+    previousTool: number;
+    printingAcceleration: number;
+    readonly restorePoints: ModelCollection<RestorePoint>;
+    readonly rotation: MoveRotation;
+    speedFactor: number;
+    travelAcceleration: number;
+    userPosition: Array<number>;
+    virtualEPos: number;
+    workplaceNumber: number;
+}
+export default MotionSystem;

package/dist/src/move/MotionSystem.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MotionSystem = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+const ModelCollection_1 = __importDefault(require("../ModelCollection"));
+const RestorePoint_1 = __importDefault(require("../state/RestorePoint"));
+const _1 = require(".");
+class MotionSystem extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.currentMove = new _1.CurrentMove();
+        this.currentObject = null;
+        this.currentTool = -1;
+        this.nextTool = -1;
+        this.previousTool = -1;
+        this.printingAcceleration = 10000;
+        this.restorePoints = new ModelCollection_1.default(RestorePoint_1.default);
+        this.rotation = new _1.MoveRotation();
+        this.speedFactor = 1;
+        this.travelAcceleration = 10000;
+        this.userPosition = [];
+        this.virtualEPos = 0;
+        this.workplaceNumber = 0;
+    }
+}
+exports.MotionSystem = MotionSystem;
+exports.default = MotionSystem;

package/dist/src/move/MoveCalibration.d.ts

@@ -0,0 +1,11 @@
+import ModelObject from "../ModelObject";
+export declare class MoveDeviations extends ModelObject {
+    deviation: number;
+    mean: number;
+}
+export declare class MoveCalibration extends ModelObject {
+    readonly final: MoveDeviations;
+    readonly initial: MoveDeviations;
+    numFactors: number;
+}
+export default MoveCalibration;

package/dist/src/move/MoveCalibration.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveCalibration = exports.MoveDeviations = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+class MoveDeviations extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.deviation = 0;
+        this.mean = 0;
+    }
+}
+exports.MoveDeviations = MoveDeviations;
+class MoveCalibration extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.final = new MoveDeviations();
+        this.initial = new MoveDeviations();
+        this.numFactors = 0;
+    }
+}
+exports.MoveCalibration = MoveCalibration;
+exports.default = MoveCalibration;

package/dist/src/move/MoveCompensation.d.ts

@@ -0,0 +1,30 @@
+import ModelObject from "../ModelObject";
+import { MoveDeviations } from "./MoveCalibration";
+export declare class ProbeGrid extends ModelObject {
+    axes: Array<string>;
+    maxs: Array<number>;
+    mins: Array<number>;
+    radius: number;
+    spacings: Array<number>;
+}
+export declare class Skew extends ModelObject {
+    compensateXY: boolean;
+    tanXY: number;
+    tanXZ: number;
+    tanYZ: number;
+}
+export declare enum MoveCompensationType {
+    none = "none",
+    mesh = "mesh"
+}
+export declare class MoveCompensation extends ModelObject {
+    constructor();
+    fadeHeight: number | null;
+    file: string | null;
+    liveGrid: ProbeGrid | null;
+    meshDeviation: MoveDeviations | null;
+    readonly probeGrid: ProbeGrid;
+    readonly skew: Skew;
+    type: MoveCompensationType;
+}
+export default MoveCompensation;

package/dist/src/move/MoveCompensation.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveCompensation = exports.MoveCompensationType = exports.Skew = exports.ProbeGrid = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+const MoveCalibration_1 = require("./MoveCalibration");
+class ProbeGrid extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.axes = ['X', 'Y'];
+        this.maxs = [-1, -1];
+        this.mins = [0, 0];
+        this.radius = 0;
+        this.spacings = [0, 0];
+    }
+}
+exports.ProbeGrid = ProbeGrid;
+class Skew extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.compensateXY = true;
+        this.tanXY = 0;
+        this.tanXZ = 0;
+        this.tanYZ = 0;
+    }
+}
+exports.Skew = Skew;
+var MoveCompensationType;
+(function (MoveCompensationType) {
+    MoveCompensationType["none"] = "none";
+    MoveCompensationType["mesh"] = "mesh";
+})(MoveCompensationType || (exports.MoveCompensationType = MoveCompensationType = {}));
+class MoveCompensation extends ModelObject_1.default {
+    constructor() {
+        super();
+        this.fadeHeight = null;
+        this.file = null;
+        this.liveGrid = null;
+        this.meshDeviation = null;
+        this.probeGrid = new ProbeGrid();
+        this.skew = new Skew();
+        this.type = MoveCompensationType.none;
+        ModelObject_1.default.wrapModelProperty(this, "liveGrid", ProbeGrid);
+        ModelObject_1.default.wrapModelProperty(this, "meshDeviation", MoveCalibration_1.MoveDeviations);
+    }
+}
+exports.MoveCompensation = MoveCompensation;
+exports.default = MoveCompensation;

package/dist/src/move/index.d.ts

@@ -0,0 +1,80 @@
+import ModelObject from "../ModelObject";
+import ModelCollection from "../ModelCollection";
+import Axis from "./Axis";
+import Extruder from "./Extruder";
+import InputShaping from "./InputShaping";
+import KeepoutZone from "./KeepoutZone";
+import MotionSystem from "./MotionSystem";
+import MoveCalibration from "./MoveCalibration";
+import MoveCompensation from "./MoveCompensation";
+import Kinematics from "./kinematics";
+export declare class CurrentMove extends ModelObject {
+    acceleration: number;
+    deceleration: number;
+    extrusionRate: number;
+    laserPwm: number | null;
+    requestedSpeed: number;
+    topSpeed: number;
+}
+export declare class MotorsIdleControl extends ModelObject {
+    factor: number;
+    timeout: number;
+}
+export declare class MoveQueueItem extends ModelObject {
+    gracePeriod: number;
+    length: number;
+}
+export declare class MoveRotation extends ModelObject {
+    angle: number;
+    centre: Array<number>;
+}
+export declare class Move extends ModelObject {
+    accelerationTime: number | null;
+    readonly axes: ModelCollection<Axis>;
+    backlashFactor: number;
+    readonly calibration: MoveCalibration;
+    readonly compensation: MoveCompensation;
+    readonly currentMove: CurrentMove;
+    readonly extruders: ModelCollection<Extruder>;
+    readonly idle: MotorsIdleControl;
+    readonly keepout: ModelCollection<KeepoutZone | null>;
+    kinematics: Kinematics;
+    limitAxes: boolean;
+    noMovesBeforeHoming: boolean;
+    readonly motionSystems: ModelCollection<MotionSystem>;
+    /**
+     * @deprecated use motionSystems[].printingAcceleration instead
+     */
+    printingAcceleration: number;
+    readonly queue: ModelCollection<MoveQueueItem>;
+    /**
+     * @deprecated use motionSystems[].rotation instead
+     */
+    readonly rotation: MoveRotation;
+    readonly shaping: InputShaping;
+    speedFactor: number;
+    /**
+     * @deprecated use motionSystems[].travelAcceleration instead
+     */
+    travelAcceleration: number;
+    usingSCurve: boolean;
+    /**
+     * @deprecated use motionSystems[].virtualEPos instead
+     */
+    virtualEPos: number;
+    /**
+     * @deprecated use motionSystems[].workplaceNumber instead
+     */
+    workplaceNumber: number;
+}
+export default Move;
+export * from "./kinematics";
+export * from "./Axis";
+export * from "./DriverId";
+export * from "./Extruder";
+export * from "./InputShaping";
+export * from "./KeepoutZone";
+export * from "./Microstepping";
+export * from "./MoveCalibration";
+export * from "./MotionSystem";
+export * from "./MoveCompensation";

package/dist/src/move/index.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Move = exports.MoveRotation = exports.MoveQueueItem = exports.MotorsIdleControl = exports.CurrentMove = void 0;
+const ModelObject_1 = __importDefault(require("../ModelObject"));
+const ModelCollection_1 = __importDefault(require("../ModelCollection"));
+const Axis_1 = __importDefault(require("./Axis"));
+const Extruder_1 = __importDefault(require("./Extruder"));
+const InputShaping_1 = __importDefault(require("./InputShaping"));
+const KeepoutZone_1 = __importDefault(require("./KeepoutZone"));
+const MotionSystem_1 = __importDefault(require("./MotionSystem"));
+const MoveCalibration_1 = __importDefault(require("./MoveCalibration"));
+const MoveCompensation_1 = __importDefault(require("./MoveCompensation"));
+const kinematics_1 = require("./kinematics");
+class CurrentMove extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.acceleration = 0;
+        this.deceleration = 0;
+        this.extrusionRate = 0;
+        this.laserPwm = null;
+        this.requestedSpeed = 0;
+        this.topSpeed = 0;
+    }
+}
+exports.CurrentMove = CurrentMove;
+class MotorsIdleControl extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.factor = 0.3;
+        this.timeout = 30;
+    }
+}
+exports.MotorsIdleControl = MotorsIdleControl;
+class MoveQueueItem extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.gracePeriod = 0;
+        this.length = 0;
+    }
+}
+exports.MoveQueueItem = MoveQueueItem;
+class MoveRotation extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.angle = 0;
+        this.centre = [0, 0];
+    }
+}
+exports.MoveRotation = MoveRotation;
+class Move extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.accelerationTime = null;
+        this.axes = new ModelCollection_1.default(Axis_1.default);
+        this.backlashFactor = 10;
+        this.calibration = new MoveCalibration_1.default();
+        this.compensation = new MoveCompensation_1.default();
+        this.currentMove = new CurrentMove();
+        this.extruders = new ModelCollection_1.default(Extruder_1.default);
+        this.idle = new MotorsIdleControl();
+        this.keepout = new ModelCollection_1.default(KeepoutZone_1.default);
+        this.kinematics = new kinematics_1.CoreKinematics(kinematics_1.KinematicsName.cartesian);
+        this.limitAxes = true;
+        this.noMovesBeforeHoming = true;
+        this.motionSystems = new ModelCollection_1.default(MotionSystem_1.default);
+        /**
+         * @deprecated use motionSystems[].printingAcceleration instead
+         */
+        this.printingAcceleration = 10000;
+        this.queue = new ModelCollection_1.default(MoveQueueItem);
+        /**
+         * @deprecated use motionSystems[].rotation instead
+         */
+        this.rotation = new MoveRotation();
+        this.shaping = new InputShaping_1.default();
+        this.speedFactor = 1;
+        /**
+         * @deprecated use motionSystems[].travelAcceleration instead
+         */
+        this.travelAcceleration = 10000;
+        this.usingSCurve = false;
+        /**
+         * @deprecated use motionSystems[].virtualEPos instead
+         */
+        this.virtualEPos = 0;
+        /**
+         * @deprecated use motionSystems[].workplaceNumber instead
+         */
+        this.workplaceNumber = 0;
+    }
+}
+exports.Move = Move;
+exports.default = Move;
+__exportStar(require("./kinematics"), exports);
+__exportStar(require("./Axis"), exports);
+__exportStar(require("./DriverId"), exports);
+__exportStar(require("./Extruder"), exports);
+__exportStar(require("./InputShaping"), exports);
+__exportStar(require("./KeepoutZone"), exports);
+__exportStar(require("./Microstepping"), exports);
+__exportStar(require("./MoveCalibration"), exports);
+__exportStar(require("./MotionSystem"), exports);
+__exportStar(require("./MoveCompensation"), exports);

package/dist/src/move/kinematics/CoreKinematics.d.ts

@@ -0,0 +1,9 @@
+import { IModelObject } from "../../ModelObject";
+import { KinematicsName, ZLeadscrewKinematics } from "./KinematicsBase";
+export declare class CoreKinematics extends ZLeadscrewKinematics {
+    constructor(name: KinematicsName);
+    forwardMatrix: Array<Array<number>>;
+    inverseMatrix: Array<Array<number>>;
+    update(jsonElement: any): IModelObject | null;
+}
+export default CoreKinematics;

package/dist/src/move/kinematics/CoreKinematics.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreKinematics = void 0;
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class CoreKinematics extends KinematicsBase_1.ZLeadscrewKinematics {
+    constructor(name) {
+        super(name);
+        this.forwardMatrix = [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]
+        ];
+        this.inverseMatrix = [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]
+        ];
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.CoreKinematics = CoreKinematics;
+exports.default = CoreKinematics;