ableton-js 3.1.8 → 3.2.0

package/index.js

@@ -1,184 +1,101 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPackageVersion = exports.Ableton = exports.TimeoutError = void 0;
-var os_1 = __importDefault(require("os"));
-var path_1 = __importDefault(require("path"));
-var dgram_1 = __importDefault(require("dgram"));
-var events_1 = require("events");
-var uuid_1 = require("uuid");
-var semver_1 = __importDefault(require("semver"));
-var zlib_1 = require("zlib");
-var lru_cache_1 = __importDefault(require("lru-cache"));
-var fs_1 = require("fs");
-var promises_1 = require("fs/promises");
-var song_1 = require("./ns/song");
-var internal_1 = require("./ns/internal");
-var application_1 = require("./ns/application");
-var midi_1 = require("./ns/midi");
-var package_version_1 = require("./util/package-version");
-var cache_1 = require("./util/cache");
-var SERVER_PORT_FILE = "ableton-js-server.port";
-var CLIENT_PORT_FILE = "ableton-js-client.port";
-var TimeoutError = /** @class */ (function (_super) {
-    __extends(TimeoutError, _super);
-    function TimeoutError(message, payload) {
-        var _this = _super.call(this, message) || this;
-        _this.message = message;
-        _this.payload = payload;
-        return _this;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const dgram_1 = __importDefault(require("dgram"));
+const events_1 = require("events");
+const uuid_1 = require("uuid");
+const semver_1 = __importDefault(require("semver"));
+const zlib_1 = require("zlib");
+const lru_cache_1 = __importDefault(require("lru-cache"));
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const song_1 = require("./ns/song");
+const internal_1 = require("./ns/internal");
+const application_1 = require("./ns/application");
+const midi_1 = require("./ns/midi");
+const package_version_1 = require("./util/package-version");
+const cache_1 = require("./util/cache");
+const SERVER_PORT_FILE = "ableton-js-server.port";
+const CLIENT_PORT_FILE = "ableton-js-client.port";
+class TimeoutError extends Error {
+    message;
+    payload;
+    constructor(message, payload) {
+        super(message);
+        this.message = message;
+        this.payload = payload;
     }
-    return TimeoutError;
-}(Error));
+}
 exports.TimeoutError = TimeoutError;
-var Ableton = /** @class */ (function (_super) {
-    __extends(Ableton, _super);
-    function Ableton(options) {
-        var _a, _b, _c, _d;
-        var _this = _super.call(this) || this;
-        _this.options = options;
-        _this.msgMap = new Map();
-        _this.eventListeners = new Map();
-        _this._isConnected = false;
-        _this.buffer = [];
-        _this.latency = 0;
-        _this.song = new song_1.Song(_this);
-        _this.application = new application_1.Application(_this);
-        _this.internal = new internal_1.Internal(_this);
-        _this.midi = new midi_1.Midi(_this);
-        _this.clientState = "closed";
-        _this.cancelDisconnectEvent = false;
-        _this.logger = options === null || options === void 0 ? void 0 : options.logger;
-        _this.cache = new lru_cache_1.default(__assign({ max: 500, ttl: 1000 * 60 * 10 }, options === null || options === void 0 ? void 0 : options.cacheOptions));
-        _this.clientPortFile = path_1.default.join(os_1.default.tmpdir(), (_b = (_a = _this.options) === null || _a === void 0 ? void 0 : _a.clientPortFile) !== null && _b !== void 0 ? _b : CLIENT_PORT_FILE);
-        _this.serverPortFile = path_1.default.join(os_1.default.tmpdir(), (_d = (_c = _this.options) === null || _c === void 0 ? void 0 : _c.serverPortFile) !== null && _d !== void 0 ? _d : SERVER_PORT_FILE);
-        return _this;
+class Ableton extends events_1.EventEmitter {
+    options;
+    client;
+    msgMap = new Map();
+    eventListeners = new Map();
+    heartbeatInterval;
+    _isConnected = false;
+    buffer = [];
+    latency = 0;
+    serverPort;
+    cache;
+    song = new song_1.Song(this);
+    application = new application_1.Application(this);
+    internal = new internal_1.Internal(this);
+    midi = new midi_1.Midi(this);
+    clientPortFile;
+    serverPortFile;
+    logger;
+    clientState = "closed";
+    cancelDisconnectEvent = false;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.logger = options?.logger;
+        this.cache = new lru_cache_1.default({
+            max: 500,
+            ttl: 1000 * 60 * 10,
+            ...options?.cacheOptions,
+        });
+        this.clientPortFile = path_1.default.join(os_1.default.tmpdir(), this.options?.clientPortFile ?? CLIENT_PORT_FILE);
+        this.serverPortFile = path_1.default.join(os_1.default.tmpdir(), this.options?.serverPortFile ?? SERVER_PORT_FILE);
     }
-    Ableton.prototype.handleConnect = function (type) {
-        var _a;
+    handleConnect(type) {
         if (!this._isConnected) {
             this._isConnected = true;
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info("Live connected", { type: type });
+            this.logger?.info("Live connected", { type });
             this.emit("connect", type);
         }
-    };
-    Ableton.prototype.handleDisconnect = function (type) {
-        var _a;
+    }
+    handleDisconnect(type) {
         if (this._isConnected) {
             this._isConnected = false;
             this.eventListeners.clear();
-            this.msgMap.forEach(function (msg) { return msg.clearTimeout(); });
+            this.msgMap.forEach((msg) => msg.clearTimeout());
             this.msgMap.clear();
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info("Live disconnected", { type: type });
+            this.logger?.info("Live disconnected", { type });
             this.emit("disconnect", type);
         }
-    };
+    }
     /**
      * If connected, returns immediately. Otherwise,
      * it waits for a connection event before returning.
      */
-    Ableton.prototype.waitForConnection = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                if (this._isConnected) {
-                    return [2 /*return*/];
-                }
-                else {
-                    return [2 /*return*/, Promise.race([
-                            new Promise(function (res) { return _this.once("connect", res); }),
-                            this.internal.get("ping").catch(function () { return new Promise(function () { }); }),
-                        ])];
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
+    async waitForConnection() {
+        if (this._isConnected) {
+            return;
+        }
+        else {
+            return Promise.race([
+                new Promise((res) => this.once("connect", res)),
+                this.internal.get("ping").catch(() => new Promise(() => { })),
+            ]);
+        }
+    }
     /**
      * Starts the server and waits for a connection with Live to be established.
      *
@@ -186,230 +103,142 @@ var Ableton = /** @class */ (function (_super) {
      * If set, the function will throw an error if it can't establish a connection
      * in the given time. Should be higher than 2000ms to avoid false positives.
      */
-    Ableton.prototype.start = function (timeoutMs) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        return __awaiter(this, void 0, void 0, function () {
-            var clientPort, port, error_1, connection, timeout, heartbeat;
-            var _this = this;
-            return __generator(this, function (_j) {
-                switch (_j.label) {
-                    case 0:
-                        if (this.clientState !== "closed") {
-                            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.warn("Tried calling start, but client is already " + this.clientState);
-                            return [2 /*return*/];
-                        }
-                        this.clientState = "starting";
-                        this.client = dgram_1.default.createSocket({ type: "udp4" });
-                        this.client.addListener("message", this.handleIncoming.bind(this));
-                        this.client.addListener("listening", function () { return __awaiter(_this, void 0, void 0, function () {
-                            var port;
-                            var _a, _b;
-                            return __generator(this, function (_c) {
-                                switch (_c.label) {
-                                    case 0:
-                                        port = (_a = this.client) === null || _a === void 0 ? void 0 : _a.address().port;
-                                        (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info("Client is bound and listening", { port: port });
-                                        // Write used port to a file so Live can read from it
-                                        return [4 /*yield*/, promises_1.writeFile(this.clientPortFile, String(port))];
-                                    case 1:
-                                        // Write used port to a file so Live can read from it
-                                        _c.sent();
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); });
-                        _j.label = 1;
-                    case 1:
-                        _j.trys.push([1, 3, , 4]);
-                        // Try binding to the port that was used last for better start performance
-                        (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info("Checking if a stored port exists", {
-                            file: this.clientPortFile,
-                        });
-                        return [4 /*yield*/, promises_1.readFile(this.clientPortFile)];
-                    case 2:
-                        clientPort = _j.sent();
-                        port = Number(clientPort.toString());
-                        (_c = this.logger) === null || _c === void 0 ? void 0 : _c.info("Trying to bind to the most recent port", { port: port });
-                        this.client.bind(port, "127.0.0.1");
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_1 = _j.sent();
-                        (_d = this.logger) === null || _d === void 0 ? void 0 : _d.info("Couldn't bind to last port, binding to any free port instead", { error: error_1 });
-                        this.client.bind(undefined, "127.0.0.1");
-                        return [3 /*break*/, 4];
-                    case 4: 
-                    // Wait for the server port file to exist
-                    return [4 /*yield*/, new Promise(function (res) { return __awaiter(_this, void 0, void 0, function () {
-                            var serverPort, e_1;
-                            var _this = this;
-                            var _a;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        _b.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, promises_1.readFile(this.serverPortFile)];
-                                    case 1:
-                                        serverPort = _b.sent();
-                                        this.serverPort = Number(serverPort.toString());
-                                        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info("Server port:", { port: this.serverPort });
-                                        res();
-                                        return [3 /*break*/, 3];
-                                    case 2:
-                                        e_1 = _b.sent();
-                                        return [3 /*break*/, 3];
-                                    case 3:
-                                        // Set up a watcher in case the server port changes
-                                        fs_1.watchFile(this.serverPortFile, function (curr) { return __awaiter(_this, void 0, void 0, function () {
-                                            var serverPort, newPort;
-                                            var _a;
-                                            return __generator(this, function (_b) {
-                                                switch (_b.label) {
-                                                    case 0:
-                                                        if (!curr.isFile()) return [3 /*break*/, 2];
-                                                        return [4 /*yield*/, promises_1.readFile(this.serverPortFile)];
-                                                    case 1:
-                                                        serverPort = _b.sent();
-                                                        newPort = Number(serverPort.toString());
-                                                        if (!isNaN(newPort) && newPort !== this.serverPort) {
-                                                            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info("Server port changed:", { port: newPort });
-                                                            this.serverPort = Number(serverPort.toString());
-                                                        }
-                                                        res();
-                                                        _b.label = 2;
-                                                    case 2: return [2 /*return*/];
-                                                }
-                                            });
-                                        }); });
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                    case 5:
-                        // Wait for the server port file to exist
-                        _j.sent();
-                        (_e = this.logger) === null || _e === void 0 ? void 0 : _e.info("Checking connection...");
-                        connection = this.waitForConnection();
-                        if (!timeoutMs) return [3 /*break*/, 7];
-                        timeout = new Promise(function (_, rej) {
-                            return setTimeout(function () { return rej("Connection timed out."); }, timeoutMs);
-                        });
-                        return [4 /*yield*/, Promise.race([connection, timeout])];
-                    case 6:
-                        _j.sent();
-                        return [3 /*break*/, 9];
-                    case 7: return [4 /*yield*/, connection];
-                    case 8:
-                        _j.sent();
-                        _j.label = 9;
-                    case 9:
-                        (_f = this.logger) === null || _f === void 0 ? void 0 : _f.info("Got connection!");
-                        this.clientState = "started";
-                        this.handleConnect("start");
-                        heartbeat = function () { return __awaiter(_this, void 0, void 0, function () {
-                            var e_2;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        _a.trys.push([0, 2, 3, 4]);
-                                        return [4 /*yield*/, this.internal.get("ping")];
-                                    case 1:
-                                        _a.sent();
-                                        this.handleConnect("heartbeat");
-                                        return [3 /*break*/, 4];
-                                    case 2:
-                                        e_2 = _a.sent();
-                                        if (!this.cancelDisconnectEvent) {
-                                            this.handleDisconnect("heartbeat");
-                                        }
-                                        return [3 /*break*/, 4];
-                                    case 3:
-                                        this.cancelDisconnectEvent = false;
-                                        return [7 /*endfinally*/];
-                                    case 4: return [2 /*return*/];
-                                }
-                            });
-                        }); };
-                        this.heartbeatInterval = setInterval(heartbeat, (_h = (_g = this.options) === null || _g === void 0 ? void 0 : _g.heartbeatInterval) !== null && _h !== void 0 ? _h : 2000);
-                        heartbeat();
-                        this.internal
-                            .get("version")
-                            .then(function (v) {
-                            var _a;
-                            var jsVersion = package_version_1.getPackageVersion();
-                            if (semver_1.default.lt(v, jsVersion)) {
-                                (_a = _this.logger) === null || _a === void 0 ? void 0 : _a.warn("The installed version of your AbletonJS plugin (" + v + ") is lower than the JS library (" + jsVersion + ").", "Please update your AbletonJS plugin to the latest version: https://git.io/JvaOu");
-                            }
-                        })
-                            .catch(function () { });
-                        return [2 /*return*/];
-                }
-            });
+    async start(timeoutMs) {
+        if (this.clientState !== "closed") {
+            this.logger?.warn("Tried calling start, but client is already " + this.clientState);
+            return;
+        }
+        this.clientState = "starting";
+        this.client = dgram_1.default.createSocket({ type: "udp4" });
+        this.client.addListener("message", this.handleIncoming.bind(this));
+        this.client.addListener("listening", async () => {
+            const port = this.client?.address().port;
+            this.logger?.info("Client is bound and listening", { port });
+            // Write used port to a file so Live can read from it
+            await (0, promises_1.writeFile)(this.clientPortFile, String(port));
         });
-    };
-    /** Closes the client */
-    Ableton.prototype.close = function () {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var closePromise;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info("Closing the client");
-                        fs_1.unwatchFile(this.serverPortFile);
-                        if (this.heartbeatInterval) {
-                            clearInterval(this.heartbeatInterval);
-                        }
-                        if (!this.client) return [3 /*break*/, 2];
-                        closePromise = new Promise(function (res) { var _a; return (_a = _this.client) === null || _a === void 0 ? void 0 : _a.once("close", res); });
-                        this.client.close();
-                        return [4 /*yield*/, closePromise];
-                    case 1:
-                        _c.sent();
-                        _c.label = 2;
-                    case 2:
-                        this.clientState = "closed";
-                        this._isConnected = false;
-                        (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info("Client closed");
-                        return [2 /*return*/];
+        try {
+            // Try binding to the port that was used last for better start performance
+            this.logger?.info("Checking if a stored port exists", {
+                file: this.clientPortFile,
+            });
+            const clientPort = await (0, promises_1.readFile)(this.clientPortFile);
+            const port = Number(clientPort.toString());
+            this.logger?.info("Trying to bind to the most recent port", { port });
+            this.client.bind(port, "127.0.0.1");
+        }
+        catch (error) {
+            this.logger?.info("Couldn't bind to last port, binding to any free port instead", { error });
+            this.client.bind(undefined, "127.0.0.1");
+        }
+        // Wait for the server port file to exist
+        await new Promise(async (res) => {
+            try {
+                const serverPort = await (0, promises_1.readFile)(this.serverPortFile);
+                this.serverPort = Number(serverPort.toString());
+                this.logger?.info("Server port:", { port: this.serverPort });
+                res();
+            }
+            catch (e) { }
+            // Set up a watcher in case the server port changes
+            (0, fs_1.watchFile)(this.serverPortFile, async (curr) => {
+                if (curr.isFile()) {
+                    const serverPort = await (0, promises_1.readFile)(this.serverPortFile);
+                    const newPort = Number(serverPort.toString());
+                    if (!isNaN(newPort) && newPort !== this.serverPort) {
+                        this.logger?.info("Server port changed:", { port: newPort });
+                        this.serverPort = Number(serverPort.toString());
+                    }
+                    res();
                 }
             });
         });
-    };
+        this.logger?.info("Checking connection...");
+        const connection = this.waitForConnection();
+        if (timeoutMs) {
+            const timeout = new Promise((_, rej) => setTimeout(() => rej("Connection timed out."), timeoutMs));
+            await Promise.race([connection, timeout]);
+        }
+        else {
+            await connection;
+        }
+        this.logger?.info("Got connection!");
+        this.clientState = "started";
+        this.handleConnect("start");
+        const heartbeat = async () => {
+            try {
+                await this.internal.get("ping");
+                this.handleConnect("heartbeat");
+            }
+            catch (e) {
+                if (!this.cancelDisconnectEvent) {
+                    this.handleDisconnect("heartbeat");
+                }
+            }
+            finally {
+                this.cancelDisconnectEvent = false;
+            }
+        };
+        this.heartbeatInterval = setInterval(heartbeat, this.options?.heartbeatInterval ?? 2000);
+        heartbeat();
+        this.internal
+            .get("version")
+            .then((v) => {
+            const jsVersion = (0, package_version_1.getPackageVersion)();
+            if (semver_1.default.lt(v, jsVersion)) {
+                this.logger?.warn(`The installed version of your AbletonJS plugin (${v}) is lower than the JS library (${jsVersion}).`, "Please update your AbletonJS plugin to the latest version: https://git.io/JvaOu");
+            }
+        })
+            .catch(() => { });
+    }
+    /** Closes the client */
+    async close() {
+        this.logger?.info("Closing the client");
+        (0, fs_1.unwatchFile)(this.serverPortFile);
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        if (this.client) {
+            const closePromise = new Promise((res) => this.client?.once("close", res));
+            this.client.close();
+            await closePromise;
+        }
+        this.clientState = "closed";
+        this._isConnected = false;
+        this.logger?.info("Client closed");
+    }
     /**
      * Returns the latency between the last command and its response.
      * This is a rough measurement, so don't rely too much on it.
      */
-    Ableton.prototype.getPing = function () {
+    getPing() {
         return this.latency;
-    };
-    Ableton.prototype.setPing = function (latency) {
+    }
+    setPing(latency) {
         this.latency = latency;
         this.emit("ping", this.latency);
-    };
-    Ableton.prototype.handleIncoming = function (msg, info) {
-        var _a;
+    }
+    handleIncoming(msg, info) {
         try {
-            var index = msg[0];
-            var message = msg.slice(1);
+            const index = msg[0];
+            const message = msg.slice(1);
             this.buffer[index] = message;
             // 0xFF signals that the end of the buffer has been reached
             if (index === 255) {
-                this.handleUncompressedMessage(zlib_1.unzipSync(Buffer.concat(this.buffer.filter(function (b) { return b; }))).toString());
+                this.handleUncompressedMessage((0, zlib_1.unzipSync)(Buffer.concat(this.buffer.filter((b) => b))).toString());
                 this.buffer = [];
             }
         }
         catch (e) {
             this.buffer = [];
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.warn("Couldn't handle message:", { error: e });
+            this.logger?.warn("Couldn't handle message:", { error: e });
             this.emit("error", e);
         }
-    };
-    Ableton.prototype.handleUncompressedMessage = function (msg) {
-        var _a, _b, _c, _d;
+    }
+    handleUncompressedMessage(msg) {
         this.emit("raw_message", msg);
-        var data = JSON.parse(msg);
-        var functionCallback = this.msgMap.get(data.uuid);
+        const data = JSON.parse(msg);
+        const functionCallback = this.msgMap.get(data.uuid);
         this.emit("message", data);
         if (data.event === "result" && functionCallback) {
             this.msgMap.delete(data.uuid);
@@ -426,215 +255,174 @@ var Ableton = /** @class */ (function (_super) {
             // If some heartbeat ping from the old connection is still pending,
             // cancel it to prevent a double disconnect/connect event.
             this.cancelDisconnectEvent = true;
-            if (((_a = data.data) === null || _a === void 0 ? void 0 : _a.port) && ((_b = data.data) === null || _b === void 0 ? void 0 : _b.port) !== this.serverPort) {
-                (_c = this.logger) === null || _c === void 0 ? void 0 : _c.info("Got new server port via connect:", {
+            if (data.data?.port && data.data?.port !== this.serverPort) {
+                this.logger?.info("Got new server port via connect:", {
                     port: data.data.port,
                 });
                 this.serverPort = data.data.port;
             }
             return this.handleConnect(this.clientState === "starting" ? "start" : "realtime");
         }
-        var eventCallback = this.eventListeners.get(data.event);
+        const eventCallback = this.eventListeners.get(data.event);
         if (eventCallback) {
-            return eventCallback.forEach(function (cb) { return cb(data.data); });
+            return eventCallback.forEach((cb) => cb(data.data));
         }
         if (data.uuid) {
-            (_d = this.logger) === null || _d === void 0 ? void 0 : _d.warn("Message could not be assigned to any request:", {
-                msg: msg,
+            this.logger?.warn("Message could not be assigned to any request:", {
+                msg,
             });
         }
-    };
+    }
     /**
      * Sends a raw command to Ableton. Usually, you won't need this.
      * A good starting point in general is the `song` prop.
      */
-    Ableton.prototype.sendCommand = function (command, timeout) {
-        if (timeout === void 0) { timeout = 2000; }
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, new Promise(function (res, rej) {
-                        var msgId = uuid_1.v4();
-                        var payload = __assign({ uuid: msgId }, command);
-                        var msg = JSON.stringify(payload);
-                        var timeoutId = setTimeout(function () {
-                            var arg = JSON.stringify(command.args);
-                            var cls = command.nsid
-                                ? command.ns + "(" + command.nsid + ")"
-                                : command.ns;
-                            rej(new TimeoutError([
-                                "The command " + cls + "." + command.name + "(" + arg + ") timed out after " + timeout + " ms.",
-                                "Please make sure that Ableton is running and that you have the latest",
-                                "version of AbletonJS' MIDI script installed and renamed to \"AbletonJS\".",
-                            ].join(" "), payload));
-                        }, timeout);
-                        var currentTimestamp = Date.now();
-                        _this.msgMap.set(msgId, {
-                            res: function (result) {
-                                _this.setPing(Date.now() - currentTimestamp);
-                                clearTimeout(timeoutId);
-                                res(result);
-                            },
-                            rej: rej,
-                            clearTimeout: function () {
-                                clearTimeout(timeoutId);
-                            },
-                        });
-                        _this.sendRaw(msg);
-                    })];
-            });
-        });
-    };
-    Ableton.prototype.sendCachedCommand = function (command, timeout) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var args, cacheKey, cached, result;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        args = (_b = (_a = command.args) === null || _a === void 0 ? void 0 : _a.prop) !== null && _b !== void 0 ? _b : JSON.stringify(command.args);
-                        cacheKey = [command.ns, command.nsid, args].filter(Boolean).join("/");
-                        cached = this.cache.get(cacheKey);
-                        return [4 /*yield*/, this.sendCommand(__assign(__assign({}, command), { etag: cached === null || cached === void 0 ? void 0 : cached.etag, cache: true }), timeout)];
-                    case 1:
-                        result = _c.sent();
-                        if (cache_1.isCached(result)) {
-                            if (!cached) {
-                                throw new Error("Tried to get an object that isn't cached.");
-                            }
-                            else {
-                                return [2 /*return*/, cached.data];
-                            }
-                        }
-                        else {
-                            if (result.etag) {
-                                this.cache.set(cacheKey, result);
-                            }
-                            return [2 /*return*/, result.data];
-                        }
-                        return [2 /*return*/];
-                }
+    async sendCommand(command) {
+        return new Promise((res, rej) => {
+            const msgId = (0, uuid_1.v4)();
+            const payload = {
+                uuid: msgId,
+                ...command,
+            };
+            const msg = JSON.stringify(payload);
+            const timeout = this.options?.commandTimeoutMs ?? 2000;
+            const timeoutId = setTimeout(() => {
+                const arg = JSON.stringify(command.args);
+                const cls = command.nsid
+                    ? `${command.ns}(${command.nsid})`
+                    : command.ns;
+                rej(new TimeoutError([
+                    `The command ${cls}.${command.name}(${arg}) timed out after ${timeout} ms.`,
+                    `Please make sure that Ableton is running and that you have the latest`,
+                    `version of AbletonJS' MIDI script installed and renamed to "AbletonJS".`,
+                ].join(" "), payload));
+            }, timeout);
+            const currentTimestamp = Date.now();
+            this.msgMap.set(msgId, {
+                res: (result) => {
+                    this.setPing(Date.now() - currentTimestamp);
+                    clearTimeout(timeoutId);
+                    res(result);
+                },
+                rej,
+                clearTimeout: () => {
+                    clearTimeout(timeoutId);
+                },
             });
+            this.sendRaw(msg);
         });
-    };
-    Ableton.prototype.getProp = function (ns, nsid, prop, cache) {
-        return __awaiter(this, void 0, void 0, function () {
-            var params;
-            return __generator(this, function (_a) {
-                params = { ns: ns, nsid: nsid, name: "get_prop", args: { prop: prop } };
-                if (cache) {
-                    return [2 /*return*/, this.sendCachedCommand(params)];
-                }
-                else {
-                    return [2 /*return*/, this.sendCommand(params)];
-                }
-                return [2 /*return*/];
-            });
+    }
+    async sendCachedCommand(command) {
+        const args = command.args?.prop ?? JSON.stringify(command.args);
+        const cacheKey = [command.ns, command.nsid, args].filter(Boolean).join("/");
+        const cached = this.cache.get(cacheKey);
+        const result = await this.sendCommand({
+            ...command,
+            etag: cached?.etag,
+            cache: true,
         });
-    };
-    Ableton.prototype.setProp = function (ns, nsid, prop, value) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.sendCommand({
-                        ns: ns,
-                        nsid: nsid,
-                        name: "set_prop",
-                        args: { prop: prop, value: value },
-                    })];
-            });
+        if ((0, cache_1.isCached)(result)) {
+            if (!cached) {
+                throw new Error("Tried to get an object that isn't cached.");
+            }
+            else {
+                return cached.data;
+            }
+        }
+        else {
+            if (result.etag) {
+                this.cache.set(cacheKey, result);
+            }
+            return result.data;
+        }
+    }
+    async getProp(ns, nsid, prop, cache) {
+        const params = { ns, nsid, name: "get_prop", args: { prop } };
+        if (cache) {
+            return this.sendCachedCommand(params);
+        }
+        else {
+            return this.sendCommand(params);
+        }
+    }
+    async setProp(ns, nsid, prop, value) {
+        return this.sendCommand({
+            ns,
+            nsid,
+            name: "set_prop",
+            args: { prop, value },
         });
-    };
-    Ableton.prototype.addPropListener = function (ns, nsid, prop, listener) {
-        return __awaiter(this, void 0, void 0, function () {
-            var eventId, result;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        eventId = uuid_1.v4();
-                        return [4 /*yield*/, this.sendCommand({
-                                ns: ns,
-                                nsid: nsid,
-                                name: "add_listener",
-                                args: { prop: prop, nsid: nsid, eventId: eventId },
-                            })];
-                    case 1:
-                        result = _a.sent();
-                        if (!this.eventListeners.has(result)) {
-                            this.eventListeners.set(result, [listener]);
-                        }
-                        else {
-                            this.eventListeners.set(result, __spreadArray(__spreadArray([], __read(this.eventListeners.get(result))), [
-                                listener,
-                            ]));
-                        }
-                        return [2 /*return*/, function () { return _this.removePropListener(ns, nsid, prop, result, listener); }];
-                }
-            });
+    }
+    async addPropListener(ns, nsid, prop, listener) {
+        const eventId = (0, uuid_1.v4)();
+        const result = await this.sendCommand({
+            ns,
+            nsid,
+            name: "add_listener",
+            args: { prop, nsid, eventId },
         });
-    };
-    Ableton.prototype.removePropListener = function (ns, nsid, prop, eventId, listener) {
-        return __awaiter(this, void 0, void 0, function () {
-            var listeners;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        listeners = this.eventListeners.get(eventId);
-                        if (!listeners) {
-                            return [2 /*return*/, false];
-                        }
-                        if (listeners.length > 1) {
-                            this.eventListeners.set(eventId, listeners.filter(function (l) { return l !== listener; }));
-                            return [2 /*return*/, true];
-                        }
-                        if (!(listeners.length === 1)) return [3 /*break*/, 2];
-                        this.eventListeners.delete(eventId);
-                        return [4 /*yield*/, this.sendCommand({
-                                ns: ns,
-                                nsid: nsid,
-                                name: "remove_listener",
-                                args: { prop: prop, nsid: nsid },
-                            })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, true];
-                    case 2: return [2 /*return*/];
-                }
+        if (!this.eventListeners.has(result)) {
+            this.eventListeners.set(result, [listener]);
+        }
+        else {
+            this.eventListeners.set(result, [
+                ...this.eventListeners.get(result),
+                listener,
+            ]);
+        }
+        return () => this.removePropListener(ns, nsid, prop, result, listener);
+    }
+    async removePropListener(ns, nsid, prop, eventId, listener) {
+        const listeners = this.eventListeners.get(eventId);
+        if (!listeners) {
+            return false;
+        }
+        if (listeners.length > 1) {
+            this.eventListeners.set(eventId, listeners.filter((l) => l !== listener));
+            return true;
+        }
+        if (listeners.length === 1) {
+            this.eventListeners.delete(eventId);
+            await this.sendCommand({
+                ns,
+                nsid,
+                name: "remove_listener",
+                args: { prop, nsid },
             });
-        });
-    };
+            return true;
+        }
+    }
     /**
      * Removes all event listeners that were attached to properties.
      * This is useful for clearing all listeners when Live
      * disconnects, for example.
      */
-    Ableton.prototype.removeAllPropListeners = function () {
+    removeAllPropListeners() {
         this.eventListeners.clear();
-    };
-    Ableton.prototype.sendRaw = function (msg) {
+    }
+    sendRaw(msg) {
         if (!this.client || !this.serverPort) {
             throw new Error("The client hasn't been started yet. Please call start() first.");
         }
-        var buffer = zlib_1.deflateSync(Buffer.from(msg));
+        const buffer = (0, zlib_1.deflateSync)(Buffer.from(msg));
         // Based on this thread, 7500 bytes seems like a safe value
         // https://stackoverflow.com/questions/22819214/udp-message-too-long
-        var byteLimit = 7500;
-        var chunks = Math.ceil(buffer.byteLength / byteLimit);
+        const byteLimit = 7500;
+        const chunks = Math.ceil(buffer.byteLength / byteLimit);
         // Split the message into chunks if it becomes too large
-        for (var i = 0; i < chunks; i++) {
-            var chunk = Buffer.concat([
+        for (let i = 0; i < chunks; i++) {
+            const chunk = Buffer.concat([
                 // Add a counter to the message, the last message is always 255
                 Buffer.alloc(1, i + 1 === chunks ? 255 : i),
                 buffer.slice(i * byteLimit, i * byteLimit + byteLimit),
             ]);
             this.client.send(chunk, 0, chunk.length, this.serverPort, "127.0.0.1");
         }
-    };
-    Ableton.prototype.isConnected = function () {
+    }
+    isConnected() {
         return this._isConnected;
-    };
-    return Ableton;
-}(events_1.EventEmitter));
+    }
+}
 exports.Ableton = Ableton;
 var package_version_2 = require("./util/package-version");
 Object.defineProperty(exports, "getPackageVersion", { enumerable: true, get: function () { return package_version_2.getPackageVersion; } });