@duet3d/monacotokens 3.5.0 → 3.5.3

package/README.md

@@ -1,6 +1,18 @@
 # MonacoTokens
 
-TypeScript library that holds syntax highlighting files for the Monaco editor 
+TypeScript library that holds syntax highlighting files for the Monaco editor
+
+Currently exported Monaco languages:
+
+- `gcodeFDMLanguage` (RRF G-code to be used in FFF mode)
+- `gcodeCNCLanguage` (RRF G-code to be used in CNC and Laser mode)
+
+After importing the languages, you need to register them as following:
+
+```
+monaco.languages.setMonarchTokensProvider("gcode-fdm", gcodeFDMLanguage);
+monaco.languages.setMonarchTokensProvider("gcode-cnc", gcodeCNCLanguage);
+```
 
 ## Bug reports
 

package/dist/index.js

@@ -14,5 +14,4 @@ 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);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// Export functionality for G-code highlighting
 __exportStar(require("./monaco-gcode"), exports);

package/dist/monaco-gcode.d.ts

@@ -1,5 +1,3 @@
-/**
- * Set the options for the Monaco G-code language tokenizer
- * @param cncMode If true, comments in parentheses are allowed
- */
-export declare function setMonacoGCodeOptions(fdmMode: boolean): void;
+import * as monaco from "monaco-editor/esm/vs/editor/editor.api";
+export declare const gcodeFDMLanguage: monaco.languages.IMonarchLanguage;
+export declare const gcodeCNCLanguage: monaco.languages.IMonarchLanguage;

package/dist/monaco-gcode.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setMonacoGCodeOptions = void 0;
-const monaco = require("monaco-editor/esm/vs/editor/editor.api");
+exports.gcodeCNCLanguage = exports.gcodeFDMLanguage = void 0;
 /**
- * Set the options for the Monaco G-code language tokenizer
+ * Generate a Monarch language for RRF-style G-code
  * @param cncMode If true, comments in parentheses are allowed
  */
-function setMonacoGCodeOptions(fdmMode) {
-    monaco.languages.setMonarchTokensProvider("gcode", {
+function generateMonarchLanguage(fdmMode) {
+    return {
         consts: ["true", "false", "iterations", "line", "null", "pi", "result", "input"],
         functions: ["abs", "acos", "asin", "atan", "atan2", "cos", "degrees", "exists", "fileexists", "fileread", "floor", "isnan", "max",
             "min", "mod", "radians", "random", "sin", "sqrt", "tan", "vector"],
@@ -134,9 +133,7 @@ function setMonacoGCodeOptions(fdmMode) {
                 [/\n/, "", "@popall"]
             ]
         }
-    });
+    };
 }
-exports.setMonacoGCodeOptions = setMonacoGCodeOptions;
-// Register default gcode language in FDM mode
-monaco.languages.register({ id: "gcode" });
-setMonacoGCodeOptions(true);
+exports.gcodeFDMLanguage = generateMonarchLanguage(true);
+exports.gcodeCNCLanguage = generateMonarchLanguage(false);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duet3d/monacotokens",
-  "version": "3.5.0",
+  "version": "3.5.3",
   "description": "TypeScript library that holds syntax highlighting files for the Monaco editor",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/analysis.d.ts

@@ -1,22 +0,0 @@
-/**
- * Result of a frequency analysis
- */
-export interface FrequencyAnalysisResult {
-    /**
-     * Determined frequencies (in Hz)
-     */
-    frequencies: number[];
-    /**
-     * Amplitudes of each axis
-     */
-    amplitudes: number[][];
-}
-/**
- * Analyze the given accelerometer data by computing the ringing frequencies from the samples at a given sampling rate.
- * This effectively performs an FFT on the given data set
- * @param samples Accelerometer samples of each axis
- * @param samplingRate Sampling rate in Hz
- * @param wideBand Perform wide-band analysis (more frequencies)
- * @returns Frequency vs. amplitude per axis
- */
-export declare function analyzeAccelerometerData(samples: number[][], samplingRate: number, wideBand?: boolean): FrequencyAnalysisResult;

package/dist/analysis.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzeAccelerometerData = void 0;
-const fft_1 = require("./fft");
-/**
- * Analyze the given accelerometer data by computing the ringing frequencies from the samples at a given sampling rate.
- * This effectively performs an FFT on the given data set
- * @param samples Accelerometer samples of each axis
- * @param samplingRate Sampling rate in Hz
- * @param wideBand Perform wide-band analysis (more frequencies)
- * @returns Frequency vs. amplitude per axis
- */
-function analyzeAccelerometerData(samples, samplingRate, wideBand = false) {
-    if (samples.length < 1) {
-        throw new Error("Too few samples to perform frequency analysis");
-    }
-    // Determine number of axes, frequency resolution, and number of frequencies to compute
-    const numSamples = samples[0].length, freqResolution = samplingRate / numSamples;
-    const numFreqs = Math.floor(Math.min(numSamples / 2, (wideBand ? (samplingRate / 2) : 200) / freqResolution));
-    // Prepare result
-    const result = {
-        frequencies: new Array(numFreqs),
-        amplitudes: new Array(samples.length)
-    };
-    for (let i = 0; i < numFreqs; i++) {
-        result.frequencies[i] = i * freqResolution + freqResolution / 2;
-    }
-    for (let axis = 0; axis < samples.length; axis++) {
-        // Perform FFT on the samples per axis
-        const real = samples[axis].slice(), imag = new Array(numSamples);
-        imag.fill(0);
-        (0, fft_1.transform)(real, imag);
-        // Compute amplitudes
-        const amplitudes = new Array(numFreqs);
-        for (let k = 1; k <= numFreqs; k++) {
-            amplitudes[k - 1] = Math.sqrt(real[k] * real[k] + imag[k] * imag[k]) / numSamples;
-        }
-        result.amplitudes[axis] = amplitudes;
-    }
-    return result;
-}
-exports.analyzeAccelerometerData = analyzeAccelerometerData;

package/dist/fft.d.ts

@@ -1,7 +0,0 @@
-export declare function transform(real: Array<number> | Float64Array, imag: Array<number> | Float64Array): void;
-export declare function inverseTransform(real: Array<number> | Float64Array, imag: Array<number> | Float64Array): void;
-export declare function transformRadix2(real: Array<number> | Float64Array, imag: Array<number> | Float64Array): void;
-export declare function transformBluestein(real: Array<number> | Float64Array, imag: Array<number> | Float64Array): void;
-export declare function convolveReal(xvec: Array<number> | Float64Array, yvec: Array<number> | Float64Array, outvec: Array<number> | Float64Array): void;
-export declare function convolveComplex(xreal: Array<number> | Float64Array, ximag: Array<number> | Float64Array, yreal: Array<number> | Float64Array, yimag: Array<number> | Float64Array, outreal: Array<number> | Float64Array, outimag: Array<number> | Float64Array): void;
-export declare function newArrayOfZeros(n: number): Array<number>;

package/dist/fft.js

@@ -1,203 +0,0 @@
-"use strict";
-/*
- * Free FFT and convolution (TypeScript)
- *
- * Copyright (c) 2022 Project Nayuki. (MIT License)
- * https://www.nayuki.io/page/free-small-fft-in-multiple-languages
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of
- * this software and associated documentation files (the "Software"), to deal in
- * the Software without restriction, including without limitation the rights to
- * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
- * the Software, and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- * - The above copyright notice and this permission notice shall be included in
- *   all copies or substantial portions of the Software.
- * - The Software is provided "as is", without warranty of any kind, express or
- *   implied, including but not limited to the warranties of merchantability,
- *   fitness for a particular purpose and noninfringement. In no event shall the
- *   authors or copyright holders be liable for any claim, damages or other
- *   liability, whether in an action of contract, tort or otherwise, arising from,
- *   out of or in connection with the Software or the use or other dealings in the
- *   Software.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.newArrayOfZeros = exports.convolveComplex = exports.convolveReal = exports.transformBluestein = exports.transformRadix2 = exports.inverseTransform = exports.transform = void 0;
-/*
- * Computes the discrete Fourier transform (DFT) of the given complex vector, storing the result back into the vector.
- * The vector can have any length. This is a wrapper function.
- */
-function transform(real, imag) {
-    const n = real.length;
-    if (n != imag.length)
-        throw new RangeError("Mismatched lengths");
-    if (n == 0)
-        return;
-    else if ((n & (n - 1)) == 0) // Is power of 2
-        transformRadix2(real, imag);
-    else // More complicated algorithm for arbitrary sizes
-        transformBluestein(real, imag);
-}
-exports.transform = transform;
-/*
- * Computes the inverse discrete Fourier transform (IDFT) of the given complex vector, storing the result back into the vector.
- * The vector can have any length. This is a wrapper function. This transform does not perform scaling, so the inverse is not a true inverse.
- */
-function inverseTransform(real, imag) {
-    transform(imag, real);
-}
-exports.inverseTransform = inverseTransform;
-/*
- * Computes the discrete Fourier transform (DFT) of the given complex vector, storing the result back into the vector.
- * The vector's length must be a power of 2. Uses the Cooley-Tukey decimation-in-time radix-2 algorithm.
- */
-function transformRadix2(real, imag) {
-    // Length variables
-    const n = real.length;
-    if (n != imag.length)
-        throw new RangeError("Mismatched lengths");
-    if (n == 1) // Trivial transform
-        return;
-    let levels = -1;
-    for (let i = 0; i < 32; i++) {
-        if (1 << i == n)
-            levels = i; // Equal to log2(n)
-    }
-    if (levels == -1)
-        throw new RangeError("Length is not a power of 2");
-    // Trigonometric tables
-    let cosTable = new Array(n / 2);
-    let sinTable = new Array(n / 2);
-    for (let i = 0; i < n / 2; i++) {
-        cosTable[i] = Math.cos(2 * Math.PI * i / n);
-        sinTable[i] = Math.sin(2 * Math.PI * i / n);
-    }
-    // Bit-reversed addressing permutation
-    for (let i = 0; i < n; i++) {
-        const j = reverseBits(i, levels);
-        if (j > i) {
-            let temp = real[i];
-            real[i] = real[j];
-            real[j] = temp;
-            temp = imag[i];
-            imag[i] = imag[j];
-            imag[j] = temp;
-        }
-    }
-    // Cooley-Tukey decimation-in-time radix-2 FFT
-    for (let size = 2; size <= n; size *= 2) {
-        const halfsize = size / 2;
-        const tablestep = n / size;
-        for (let i = 0; i < n; i += size) {
-            for (let j = i, k = 0; j < i + halfsize; j++, k += tablestep) {
-                const l = j + halfsize;
-                const tpre = real[l] * cosTable[k] + imag[l] * sinTable[k];
-                const tpim = -real[l] * sinTable[k] + imag[l] * cosTable[k];
-                real[l] = real[j] - tpre;
-                imag[l] = imag[j] - tpim;
-                real[j] += tpre;
-                imag[j] += tpim;
-            }
-        }
-    }
-    // Returns the integer whose value is the reverse of the lowest 'width' bits of the integer 'val'.
-    function reverseBits(val, width) {
-        let result = 0;
-        for (let i = 0; i < width; i++) {
-            result = (result << 1) | (val & 1);
-            val >>>= 1;
-        }
-        return result;
-    }
-}
-exports.transformRadix2 = transformRadix2;
-/*
- * Computes the discrete Fourier transform (DFT) of the given complex vector, storing the result back into the vector.
- * The vector can have any length. This requires the convolution function, which in turn requires the radix-2 FFT function.
- * Uses Bluestein's chirp z-transform algorithm.
- */
-function transformBluestein(real, imag) {
-    // Find a power-of-2 convolution length m such that m >= n * 2 + 1
-    const n = real.length;
-    if (n != imag.length)
-        throw new RangeError("Mismatched lengths");
-    let m = 1;
-    while (m < n * 2 + 1)
-        m *= 2;
-    // Trigonometric tables
-    let cosTable = new Array(n);
-    let sinTable = new Array(n);
-    for (let i = 0; i < n; i++) {
-        const j = i * i % (n * 2); // This is more accurate than j = i * i
-        cosTable[i] = Math.cos(Math.PI * j / n);
-        sinTable[i] = Math.sin(Math.PI * j / n);
-    }
-    // Temporary vectors and preprocessing
-    let areal = newArrayOfZeros(m);
-    let aimag = newArrayOfZeros(m);
-    for (let i = 0; i < n; i++) {
-        areal[i] = real[i] * cosTable[i] + imag[i] * sinTable[i];
-        aimag[i] = -real[i] * sinTable[i] + imag[i] * cosTable[i];
-    }
-    let breal = newArrayOfZeros(m);
-    let bimag = newArrayOfZeros(m);
-    breal[0] = cosTable[0];
-    bimag[0] = sinTable[0];
-    for (let i = 1; i < n; i++) {
-        breal[i] = breal[m - i] = cosTable[i];
-        bimag[i] = bimag[m - i] = sinTable[i];
-    }
-    // Convolution
-    let creal = new Array(m);
-    let cimag = new Array(m);
-    convolveComplex(areal, aimag, breal, bimag, creal, cimag);
-    // Postprocessing
-    for (let i = 0; i < n; i++) {
-        real[i] = creal[i] * cosTable[i] + cimag[i] * sinTable[i];
-        imag[i] = -creal[i] * sinTable[i] + cimag[i] * cosTable[i];
-    }
-}
-exports.transformBluestein = transformBluestein;
-/*
- * Computes the circular convolution of the given real vectors. Each vector's length must be the same.
- */
-function convolveReal(xvec, yvec, outvec) {
-    const n = xvec.length;
-    if (n != yvec.length || n != outvec.length)
-        throw new RangeError("Mismatched lengths");
-    convolveComplex(xvec, newArrayOfZeros(n), yvec, newArrayOfZeros(n), outvec, newArrayOfZeros(n));
-}
-exports.convolveReal = convolveReal;
-/*
- * Computes the circular convolution of the given complex vectors. Each vector's length must be the same.
- */
-function convolveComplex(xreal, ximag, yreal, yimag, outreal, outimag) {
-    const n = xreal.length;
-    if (n != ximag.length || n != yreal.length || n != yimag.length
-        || n != outreal.length || n != outimag.length)
-        throw new RangeError("Mismatched lengths");
-    xreal = xreal.slice();
-    ximag = ximag.slice();
-    yreal = yreal.slice();
-    yimag = yimag.slice();
-    transform(xreal, ximag);
-    transform(yreal, yimag);
-    for (let i = 0; i < n; i++) {
-        const temp = xreal[i] * yreal[i] - ximag[i] * yimag[i];
-        ximag[i] = ximag[i] * yreal[i] + xreal[i] * yimag[i];
-        xreal[i] = temp;
-    }
-    inverseTransform(xreal, ximag);
-    for (let i = 0; i < n; i++) { // Scaling (because this FFT implementation omits it)
-        outreal[i] = xreal[i] / n;
-        outimag[i] = ximag[i] / n;
-    }
-}
-exports.convolveComplex = convolveComplex;
-function newArrayOfZeros(n) {
-    let result = [];
-    for (let i = 0; i < n; i++)
-        result.push(0);
-    return result;
-}
-exports.newArrayOfZeros = newArrayOfZeros;

package/dist/shapers.d.ts

@@ -1,41 +0,0 @@
-/**
- * Supported input shaper types
- * TODO: Replace this with enum from @duet3d/objectmodel
- */
-export declare enum InputShaperType {
-    ei2 = "ei2",
-    ei3 = "ei3",
-    mzv = "mzv",
-    zvd = "zvd",
-    zvdd = "zvdd",
-    zvddd = "zvddd"
-}
-/**
- * Computed factors of an input shaper
- */
-export interface InputShaperFactors {
-    /**
-     * Input shaper amplitudes (coefficients)
-     */
-    amplitudes: number[];
-    /**
-     * Input shaper durations (in s)
-     */
-    durations: number[];
-}
-/***
- * Compute input shaper amplitudes and durations like RepRapFirmware does
- * @param type Input shaper type
- * @param frequency Target frequency (in Hz)
- * @param dampingFactor Optional damping factor (zeta)
- * @returns Input shaper factors
- */
-export declare function getInputShaperFactors(type: InputShaperType, frequency: number, dampingFactor?: number): InputShaperFactors;
-/**
- * Compute the damping for the given frequencies with the given input shaper amplitudes and durations
- * @param frequencies Frequencies to compute the damping for
- * @param amplitudes Input shaper amplitudes (coefficients)
- * @param durations Input shaper durations (in s)
- * @returns Damping factor (0..1) per frequency
- */
-export declare function getInputShaperDamping(frequencies: number[], amplitudes: number[], durations: number[]): number[];

package/dist/shapers.js

@@ -1,153 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getInputShaperDamping = exports.getInputShaperFactors = exports.InputShaperType = void 0;
-/**
- * Supported input shaper types
- * TODO: Replace this with enum from @duet3d/objectmodel
- */
-var InputShaperType;
-(function (InputShaperType) {
-    InputShaperType["ei2"] = "ei2";
-    InputShaperType["ei3"] = "ei3";
-    InputShaperType["mzv"] = "mzv";
-    InputShaperType["zvd"] = "zvd";
-    InputShaperType["zvdd"] = "zvdd";
-    InputShaperType["zvddd"] = "zvddd";
-})(InputShaperType || (exports.InputShaperType = InputShaperType = {}));
-/***
- * Compute input shaper amplitudes and durations like RepRapFirmware does
- * @param type Input shaper type
- * @param frequency Target frequency (in Hz)
- * @param dampingFactor Optional damping factor (zeta)
- * @returns Input shaper factors
- */
-function getInputShaperFactors(type, frequency, dampingFactor = 0.1) {
-    const result = {
-        amplitudes: [],
-        durations: []
-    };
-    const sqrtOneMinusZetaSquared = Math.sqrt(1 - Math.pow(dampingFactor, 2));
-    const dampedFrequency = frequency * sqrtOneMinusZetaSquared;
-    const dampedPeriod = 1 / dampedFrequency;
-    const k = Math.exp(-dampingFactor * Math.PI / sqrtOneMinusZetaSquared);
-    switch (type) {
-        case InputShaperType.mzv:
-            {
-                // Klipper gives amplitude steps of [a3 = k^2 * (1 - 1/sqrt(2)), a2 = k * (sqrt(2) - 1), a1 = 1 - 1/sqrt(2)] all divided by (a1 + a2 + a3)
-                // Rearrange to: a3 = k^2 * (1 - sqrt(2)/2), a2 = k * (sqrt(2) - 1), a1 = (1 - sqrt(2)/2)
-                const kMzv = Math.exp(-dampingFactor * 0.75 * Math.PI / sqrtOneMinusZetaSquared);
-                const a1 = 1.0 - 0.5 * Math.sqrt(2);
-                const a2 = (Math.sqrt(2) - 1) * kMzv;
-                const a3 = a1 * kMzv * kMzv;
-                const sum = (a1 + a2 + a3);
-                result.amplitudes.push(a3 / sum);
-                result.amplitudes.push((a2 + a3) / sum);
-            }
-            result.durations.push(0.375 * dampedPeriod);
-            result.durations.push(0.375 * dampedPeriod);
-            break;
-        case InputShaperType.zvd:
-            {
-                const j = Math.pow(1 + k, 2);
-                result.amplitudes.push(1 / j);
-                result.amplitudes.push(1 / j + 2 * k / j);
-            }
-            result.durations.push(0.5 * dampedPeriod);
-            result.durations.push(0.5 * dampedPeriod);
-            break;
-        case InputShaperType.zvdd:
-            {
-                const j = Math.pow(1 + k, 3);
-                result.amplitudes.push(1 / j);
-                result.amplitudes.push(result.amplitudes[0] + 3 * k / j);
-                result.amplitudes.push(result.amplitudes[1] + 3 * Math.pow(k, 2) / j);
-            }
-            result.durations.push(0.5 * dampedPeriod);
-            result.durations.push(0.5 * dampedPeriod);
-            result.durations.push(0.5 * dampedPeriod);
-            break;
-        case InputShaperType.zvddd:
-            {
-                const j = Math.pow(1 + k, 4);
-                result.amplitudes.push(1 / j);
-                result.amplitudes.push(result.amplitudes[0] + 4 * k / j);
-                result.amplitudes.push(result.amplitudes[1] + 6 * Math.pow(k, 2) / j);
-                result.amplitudes.push(result.amplitudes[2] + 4 * Math.pow(k, 3) / j);
-            }
-            result.durations.push(0.5 * dampedPeriod);
-            result.durations.push(0.5 * dampedPeriod);
-            result.durations.push(0.5 * dampedPeriod);
-            result.durations.push(0.5 * dampedPeriod);
-            break;
-        case InputShaperType.ei2: // see http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.465.1337&rep=rep1&type=pdf. United States patent #4,916,635.
-            {
-                const zetaSquared = Math.pow(dampingFactor, 2), zetaCubed = zetaSquared * dampingFactor;
-                result.amplitudes.push((0.16054) + (0.76699) * dampingFactor + (2.26560) * zetaSquared + (-1.22750) * zetaCubed);
-                result.amplitudes.push((0.16054 + 0.33911) + (0.76699 + 0.45081) * dampingFactor + (2.26560 - 2.58080) * zetaSquared + (-1.22750 + 1.73650) * zetaCubed);
-                result.amplitudes.push((0.16054 + 0.33911 + 0.34089) + (0.76699 + 0.45081 - 0.61533) * dampingFactor + (2.26560 - 2.58080 - 0.68765) * zetaSquared + (-1.22750 + 1.73650 + 0.42261) * zetaCubed);
-                result.durations.push(((0.49890) + (0.16270) * dampingFactor + (-0.54262) * zetaSquared + (6.16180) * zetaCubed) * dampedPeriod);
-                result.durations.push(((0.99748 - 0.49890) + (0.18382 - 0.16270) * dampingFactor + (-1.58270 + 0.54262) * zetaSquared + (8.17120 - 6.16180) * zetaCubed) * dampedPeriod);
-                result.durations.push(((1.49920 - 0.99748) + (-0.09297 - 0.18382) * dampingFactor + (-0.28338 + 1.58270) * zetaSquared + (1.85710 - 8.17120) * zetaCubed) * dampedPeriod);
-            }
-            break;
-        case InputShaperType.ei3: // see http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.465.1337&rep=rep1&type=pdf. United States patent #4,916,635
-            {
-                const zetaSquared = Math.pow(dampingFactor, 2);
-                const zetaCubed = zetaSquared * dampingFactor;
-                result.amplitudes.push((0.11275) + 0.76632 * dampingFactor + (3.29160) * zetaSquared + (-1.44380) * zetaCubed);
-                result.amplitudes.push((0.11275 + 0.23698) + (0.76632 + 0.61164) * dampingFactor + (3.29160 - 2.57850) * zetaSquared + (-1.44380 + 4.85220) * zetaCubed);
-                result.amplitudes.push((0.11275 + 0.23698 + 0.30008) + (0.76632 + 0.61164 - 0.19062) * dampingFactor + (3.29160 - 2.57850 - 2.14560) * zetaSquared + (-1.44380 + 4.85220 + 0.13744) * zetaCubed);
-                result.amplitudes.push((0.11275 + 0.23698 + 0.30008 + 0.23775) + (0.76632 + 0.61164 - 0.19062 - 0.73297) * dampingFactor + (3.29160 - 2.57850 - 2.14560 + 0.46885) * zetaSquared + (-1.44380 + 4.85220 + 0.13744 - 2.08650) * zetaCubed);
-                result.durations.push(((0.49974) + (0.23834) * dampingFactor + (0.44559) * zetaSquared + (12.4720) * zetaCubed) * dampedPeriod);
-                result.durations.push(((0.99849 - 0.49974) + (0.29808 - 0.23834) * dampingFactor + (-2.36460 - 0.44559) * zetaSquared + (23.3990 - 12.4720) * zetaCubed) * dampedPeriod);
-                result.durations.push(((1.49870 - 0.99849) + (0.10306 - 0.29808) * dampingFactor + (-2.01390 + 2.36460) * zetaSquared + (17.0320 - 23.3990) * zetaCubed) * dampedPeriod);
-                result.durations.push(((1.99960 - 1.49870) + (-0.28231 - 0.10306) * dampingFactor + (0.61536 + 2.01390) * zetaSquared + (5.40450 - 17.0320) * zetaCubed) * dampedPeriod);
-            }
-            break;
-        default:
-            // Other shaper types are not supported
-            return result;
-    }
-    return result;
-}
-exports.getInputShaperFactors = getInputShaperFactors;
-/**
- * Compute the damping for the given frequencies with the given input shaper amplitudes and durations
- * @param frequencies Frequencies to compute the damping for
- * @param amplitudes Input shaper amplitudes (coefficients)
- * @param durations Input shaper durations (in s)
- * @returns Damping factor (0..1) per frequency
- */
-function getInputShaperDamping(frequencies, amplitudes, durations) {
-    // Perform input check
-    if (amplitudes.length < 1) {
-        throw new Error("Insufficient number of amplitudes");
-    }
-    if (amplitudes.length !== durations.length) {
-        throw new Error("Number of amplitudes must match the number of durations");
-    }
-    // Compute step sizes
-    const stepSizes = [amplitudes[0]];
-    for (let i = 1; i < amplitudes.length; i++) {
-        stepSizes[i] = amplitudes[i] - amplitudes[i - 1];
-    }
-    stepSizes.push(1 - amplitudes[amplitudes.length - 1]);
-    // Compute the accumulated times in seconds
-    const accTimes = [0];
-    for (let duration of durations) {
-        accTimes.push(duration + accTimes[accTimes.length - 1]);
-    }
-    // Calculate the actual damping per frequency
-    const result = new Array(frequencies.length);
-    for (let i = 0; i < frequencies.length; i++) {
-        const frequency = frequencies[i];
-        let totalSine = 0, totalCosine = 0;
-        for (let k = 0; k < stepSizes.length; k++) {
-            totalSine += stepSizes[k] * Math.sin(2 * Math.PI * frequency * accTimes[k]);
-            totalCosine += stepSizes[k] * Math.cos(2 * Math.PI * frequency * accTimes[k]);
-        }
-        result[i] = Math.sqrt(totalSine * totalSine + totalCosine * totalCosine);
-    }
-    return result;
-}
-exports.getInputShaperDamping = getInputShaperDamping;