@gibme/tablo.tv 20.0.3 → 22.0.0

package/dist/tablo.js

@@ -18,15 +18,6 @@
 // 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.
-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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -42,19 +33,14 @@ const memory_1 = __importDefault(require("@gibme/cache/memory"));
  * Note: this implementation is currently incomplete and is unlikely to have all endpoints implemented.
  */
 class Tablo extends tablo_api_1.default {
-    constructor() {
-        super(...arguments);
-        this.cache = new memory_1.default({ stdTTL: 10 * 60 * 1000 });
-        this.session_channels = new Map();
-    }
+    cache = new memory_1.default({ stdTTL: 10 * 60 * 1000 });
+    session_channels = new Map();
     /**
      * Attempts to discover the Tablo devices on the network from which this API is made.
      * @param timeout
      */
-    static discover() {
-        return __awaiter(this, arguments, void 0, function* (timeout = 2000) {
-            return lighthouse_1.default.listAvailableDevices(timeout);
-        });
+    static async discover(timeout = 2000) {
+        return lighthouse_1.default.listAvailableDevices(timeout);
     }
     /**
      * Returns the currently available airings
@@ -69,124 +55,134 @@ class Tablo extends tablo_api_1.default {
      * @param force_refresh if set to true, will force a refresh of the cache.
      * @param progress_callback
      */
-    airings() {
-        return __awaiter(this, arguments, void 0, function* (all = false, timeout = this.timeout, force_refresh = false, progress_callback) {
-            var _a, _b;
-            const progress = (total, received) => {
-                if (progress_callback) {
-                    progress_callback(total, received);
-                }
-            };
-            const { now, start } = this.currentHour;
-            try {
-                const result = !force_refresh ? (_a = yield this.cache.get('airings')) !== null && _a !== void 0 ? _a : [] : [];
-                if (result.length === 0) {
-                    let airings = (_b = yield this.get('/guide/airings', undefined, timeout)) !== null && _b !== void 0 ? _b : [];
-                    const total = airings.length;
+    async airings(all = false, timeout = this.timeout, force_refresh = false, progress_callback) {
+        const progress = (total, received) => {
+            if (progress_callback) {
+                progress_callback(total, received);
+            }
+        };
+        const { now } = this.currentHour;
+        try {
+            const result = !force_refresh ? await this.cache.get('airings') ?? [] : [];
+            if (result.length === 0) {
+                let airings = await this.get('/guide/airings', undefined, timeout) ?? [];
+                const total = airings.length;
+                progress(total, result.length);
+                while (airings.length > 0) {
+                    const batch = airings.slice(0, 50);
+                    airings = airings.slice(50);
+                    const data = await this.batch(batch, timeout);
+                    result.push(...Object.entries(data)
+                        .map(([, response]) => {
+                        return {
+                            show_title: response.airing_details.show_title,
+                            start_time: new Date(response.airing_details.datetime),
+                            end_time: new Date(this.calculate_endtime(response.airing_details.datetime, response.airing_details.duration)),
+                            duration: response.airing_details.duration,
+                            episode: {
+                                ...response.episode,
+                                orig_air_date: response.episode.orig_air_date
+                                    ? new Date(response.episode.orig_air_date)
+                                    : new Date(0)
+                            },
+                            channel: {
+                                ...response.airing_details.channel.channel
+                            }
+                        };
+                    }));
                     progress(total, result.length);
-                    while (airings.length > 0) {
-                        const batch = airings.slice(0, 50);
-                        airings = airings.slice(50);
-                        const data = yield this.batch(batch, timeout);
-                        result.push(...Object.entries(data)
-                            .map(([, response]) => {
-                            return {
-                                show_title: response.airing_details.show_title,
-                                start_time: new Date(response.airing_details.datetime),
-                                end_time: new Date(this.calculate_endtime(response.airing_details.datetime, response.airing_details.duration)),
-                                duration: response.airing_details.duration,
-                                episode: Object.assign(Object.assign({}, response.episode), { orig_air_date: new Date(response.episode.orig_air_date) }),
-                                channel: Object.assign({}, response.airing_details.channel.channel)
-                            };
-                        }));
-                        progress(total, result.length);
-                    }
-                    yield this.cache.set('airings', result);
-                }
-                else {
-                    progress(result.length, result.length);
                 }
-                return result.filter(airing => {
-                    if (all) {
-                        return true;
-                    }
-                    const start_time = new Date(airing.start_time).getTime();
-                    const end_time = new Date(airing.end_time).getTime();
-                    return start_time >= start && start_time < now && end_time > now;
-                }).sort((a, b) => {
-                    return (a.channel.major + (a.channel.minor * 0.1)) - (b.channel.major + (b.channel.minor * 0.1));
-                });
+                await this.cache.set('airings', result);
             }
-            catch (_c) {
-                return [];
+            else {
+                progress(result.length, result.length);
             }
-        });
+            return result.filter(airing => {
+                if (all) {
+                    return true;
+                }
+                const start_time = new Date(airing.start_time).getTime();
+                const end_time = new Date(airing.end_time).getTime();
+                return start_time < now && end_time > now;
+            }).sort((a, b) => {
+                return (a.channel.major * 1000 + a.channel.minor) - (b.channel.major * 1000 + b.channel.minor);
+            });
+        }
+        catch {
+            return [];
+        }
     }
     /**
      * Retrieves account subscription information from the device
      * @param timeout
      */
-    accountSubscription() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            try {
-                const response = yield this.get('/account/subscription', undefined, timeout);
-                if (response) {
-                    return Object.assign(Object.assign({}, response), { subscriptions: response.subscriptions.map(subscription => {
-                            return Object.assign(Object.assign({}, subscription), { expires: subscription.expires ? new Date(subscription.expires) : null });
-                        }) });
-                }
-            }
-            catch (_a) {
-            }
-        });
+    async accountSubscription(timeout = this.timeout) {
+        try {
+            const response = await this.get('/account/subscription', undefined, timeout);
+            if (response) {
+                return {
+                    ...response,
+                    subscriptions: response.subscriptions.map(subscription => {
+                        return {
+                            ...subscription,
+                            expires: subscription.expires ? new Date(subscription.expires) : null
+                        };
+                    })
+                };
+            }
+        }
+        catch {
+        }
     }
     /**
      * Retrieves the capabilities of the device.
      * @param timeout
      */
-    capabilities() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            var _a;
+    async capabilities(timeout = this.timeout) {
+        try {
+            const response = await this.get('/server/capabilities', undefined, timeout);
+            return response?.capabilities ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    async channel(channel_id, timeout = this.timeout) {
+        if (channel_id.startsWith('/')) {
             try {
-                const response = yield this.get('/server/capabilities', undefined, timeout);
-                return (_a = response === null || response === void 0 ? void 0 : response.capabilities) !== null && _a !== void 0 ? _a : [];
+                return (await this.get(channel_id, undefined, timeout))?.channel;
             }
-            catch (_b) {
-                return [];
+            catch {
+                return undefined;
             }
-        });
-    }
-    channel(channel_id_1) {
-        return __awaiter(this, arguments, void 0, function* (channel_id, timeout = this.timeout) {
-            const channels = yield this.channels(timeout);
-            return channels.find(elem => elem.channel_identifier === channel_id);
-        });
+        }
+        const channels = await this.channels(timeout);
+        return channels.find(elem => elem.channel_identifier === channel_id);
     }
     /**
      * Returns a list of the available channels on the device.
      * @param timeout
      */
-    channels() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            var _a;
-            try {
-                const channels = (_a = yield this.get('/guide/channels')) !== null && _a !== void 0 ? _a : [];
-                if (channels.length === 0) {
-                    return [];
-                }
-                const channel_data = yield this.batch(channels, timeout);
-                return Object.entries(channel_data)
-                    .map(([, response]) => {
-                    return Object.assign({}, response.channel);
-                })
-                    .sort((a, b) => {
-                    return (a.major + (a.minor * 0.1)) - (b.major + (b.minor * 0.1));
-                });
-            }
-            catch (_b) {
+    async channels(timeout = this.timeout) {
+        try {
+            const channels = await this.get('/guide/channels') ?? [];
+            if (channels.length === 0) {
                 return [];
             }
-        });
+            const channel_data = await this.batch(channels, timeout);
+            return Object.entries(channel_data)
+                .map(([, response]) => {
+                return {
+                    ...response.channel
+                };
+            })
+                .sort((a, b) => {
+                return (a.major * 1000 + a.minor) - (b.major * 1000 + b.minor);
+            });
+        }
+        catch {
+            return [];
+        }
     }
     /**
      * Retrieves information regarding the latest (or a specified) channel scan.
@@ -194,231 +190,225 @@ class Tablo extends tablo_api_1.default {
      * @param scan_idx if not specified, will pull the latest channel scan information
      * @param timeout
      */
-    channelScanInfo(scan_idx_1) {
-        return __awaiter(this, arguments, void 0, function* (scan_idx, timeout = this.timeout) {
-            try {
-                if (!scan_idx) {
-                    const response = yield this.get('/channels/info', undefined, timeout);
-                    if (response === null || response === void 0 ? void 0 : response.committed_scan) {
-                        const [, , , scan_idx] = response.committed_scan.split('/');
-                        return this.channelScanInfo(scan_idx, timeout);
-                    }
-                }
-                else {
-                    const response = yield this.get(`/channels/scans/${scan_idx}`);
-                    if (response) {
-                        return Object.assign(Object.assign({}, response), { datetime: new Date(response.datetime) });
-                    }
+    async channelScanInfo(scan_idx, timeout = this.timeout) {
+        try {
+            if (!scan_idx) {
+                const response = await this.get('/channels/info', undefined, timeout);
+                if (response?.committed_scan) {
+                    const [, , , scan_idx] = response.committed_scan.split('/');
+                    return this.channelScanInfo(scan_idx, timeout);
                 }
             }
-            catch (_a) {
+            else {
+                const response = await this.get(`/channels/scans/${scan_idx}`);
+                if (response) {
+                    return {
+                        ...response,
+                        datetime: new Date(response.datetime)
+                    };
+                }
             }
-        });
+        }
+        catch {
+        }
     }
     /**
      * Deletes/stops an existing watch (streaming) session
      * @param tokenOrPlayerSession
      * @param timeout
      */
-    deleteSession(tokenOrPlayerSession_1) {
-        return __awaiter(this, arguments, void 0, function* (tokenOrPlayerSession, timeout = this.timeout) {
-            const token = typeof tokenOrPlayerSession === 'string' ? tokenOrPlayerSession : tokenOrPlayerSession.token;
-            try {
-                const success = yield this.delete(`/player/sessions/${token}`, { lh: undefined }, timeout);
-                if (success) {
-                    this.session_channels.delete(token);
-                }
-                return success;
-            }
-            catch (_a) {
-                return false;
-            }
-        });
+    async deleteSession(tokenOrPlayerSession, timeout = this.timeout) {
+        const token = typeof tokenOrPlayerSession === 'string' ? tokenOrPlayerSession : tokenOrPlayerSession.token;
+        try {
+            const success = await this.delete(`/player/sessions/${token}`, { lh: undefined }, timeout);
+            if (success) {
+                this.session_channels.delete(token);
+            }
+            return success;
+        }
+        catch {
+            return false;
+        }
     }
     /**
      * Retrieves device subscription information.
      * @param timeout
      */
-    deviceSubscription() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            try {
-                const response = yield this.get('/server/subscription', undefined, timeout);
-                if (response) {
-                    return Object.assign(Object.assign({}, response), { expires: response.expires ? new Date(response.expires) : null });
-                }
-            }
-            catch (_a) {
-            }
-        });
+    async deviceSubscription(timeout = this.timeout) {
+        try {
+            const response = await this.get('/server/subscription', undefined, timeout);
+            if (response) {
+                return {
+                    ...response,
+                    expires: response.expires ? new Date(response.expires) : null
+                };
+            }
+        }
+        catch {
+        }
     }
     /**
      * Retrieves the guide status from the device
      * @param timeout
      */
-    guideStatus() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            try {
-                const response = yield this.get('/server/guide/status', undefined, timeout);
-                if (response) {
-                    return Object.assign(Object.assign({}, response), { last_update: new Date(response.last_update), limit: new Date(response.limit) });
-                }
-            }
-            catch (_a) {
-            }
-        });
+    async guideStatus(timeout = this.timeout) {
+        try {
+            const response = await this.get('/server/guide/status', undefined, timeout);
+            if (response) {
+                return {
+                    ...response,
+                    last_update: new Date(response.last_update),
+                    limit: new Date(response.limit)
+                };
+            }
+        }
+        catch {
+        }
     }
     /**
      * Retrieves a list of the hard drives connected to the device.
      * @param timeout
      */
-    hardDrives() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            var _a;
-            try {
-                return ((_a = yield this.get('/server/harddrives', undefined, timeout)) !== null && _a !== void 0 ? _a : []);
-            }
-            catch (_b) {
-                return [];
-            }
-        });
+    async hardDrives(timeout = this.timeout) {
+        try {
+            return (await this.get('/server/harddrives', undefined, timeout) ?? []);
+        }
+        catch {
+            return [];
+        }
     }
     /**
      * Retrieves device information
      * @param timeout
      */
-    info() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            try {
-                return yield this.get('/server/info', undefined, timeout);
-            }
-            catch (_a) {
-            }
-        });
+    async info(timeout = this.timeout) {
+        try {
+            return await this.get('/server/info', undefined, timeout);
+        }
+        catch {
+        }
     }
     /**
      * Sends a watch (streaming) session keepalive request so that the session does not time out and stop
      * @param tokenOrPlayerSession
      * @param timeout
      */
-    keepaliveSession(tokenOrPlayerSession_1) {
-        return __awaiter(this, arguments, void 0, function* (tokenOrPlayerSession, timeout = this.timeout) {
-            const token = typeof tokenOrPlayerSession === 'string' ? tokenOrPlayerSession : tokenOrPlayerSession.token;
-            try {
-                const channel = this.session_channels.get(token);
-                const response = yield this.post(`/player/sessions/${token}/keepalive`, { lh: undefined }, undefined, timeout);
-                if (response) {
-                    return Object.assign(Object.assign({}, response), { channel });
-                }
-            }
-            catch (_a) {
-            }
-        });
+    async keepaliveSession(tokenOrPlayerSession, timeout = this.timeout) {
+        const token = typeof tokenOrPlayerSession === 'string' ? tokenOrPlayerSession : tokenOrPlayerSession.token;
+        try {
+            const channel = this.session_channels.get(token);
+            const response = await this.post(`/player/sessions/${token}/keepalive`, { lh: undefined }, undefined, timeout);
+            if (response) {
+                return {
+                    ...response,
+                    channel
+                };
+            }
+        }
+        catch {
+        }
     }
     /**
      * Retrieves device location information
      * @param timeout
      */
-    location() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            try {
-                return yield this.get('/server/location', undefined, timeout);
-            }
-            catch (_a) {
-            }
-        });
+    async location(timeout = this.timeout) {
+        try {
+            return await this.get('/server/location', undefined, timeout);
+        }
+        catch {
+        }
     }
     /**
      * Attempts to retrieve an existing watch (streaming) session
      * @param tokenOrPlayerSession
      * @param timeout
      */
-    session(tokenOrPlayerSession_1) {
-        return __awaiter(this, arguments, void 0, function* (tokenOrPlayerSession, timeout = this.timeout) {
-            const token = typeof tokenOrPlayerSession === 'string' ? tokenOrPlayerSession : tokenOrPlayerSession.token;
-            try {
-                const channel = this.session_channels.get(token);
-                const response = yield this.get(`/player/sessions/${token}`, { lh: undefined }, timeout);
-                if (response) {
-                    return Object.assign(Object.assign({}, response), { channel });
-                }
-            }
-            catch (_a) {
-            }
-        });
+    async session(tokenOrPlayerSession, timeout = this.timeout) {
+        const token = typeof tokenOrPlayerSession === 'string' ? tokenOrPlayerSession : tokenOrPlayerSession.token;
+        try {
+            const channel = this.session_channels.get(token);
+            const response = await this.get(`/player/sessions/${token}`, { lh: undefined }, timeout);
+            if (response) {
+                return {
+                    ...response,
+                    channel
+                };
+            }
+        }
+        catch {
+        }
     }
     /**
      * Retrieves the settings of the device.
      * @param timeout
      */
-    settings() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            try {
-                return yield this.get('/settings/info', undefined, timeout);
-            }
-            catch (_a) {
-            }
-        });
+    async settings(timeout = this.timeout) {
+        try {
+            return await this.get('/settings/info', undefined, timeout);
+        }
+        catch {
+        }
     }
     /**
      * Retrieves the list of supported storage types.
      * @param timeout
      */
-    storage() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            var _a;
-            try {
-                const response = yield this.get('/storage/info', undefined, timeout);
-                return (_a = response === null || response === void 0 ? void 0 : response.supported_kinds) !== null && _a !== void 0 ? _a : [];
-            }
-            catch (_b) {
-                return [];
-            }
-        });
+    async storage(timeout = this.timeout) {
+        try {
+            const response = await this.get('/storage/info', undefined, timeout);
+            return response?.supported_kinds ?? [];
+        }
+        catch {
+            return [];
+        }
     }
     /**
      * Retrieves tuner information of the device.
      * @param timeout
      */
-    tuners() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            var _a;
-            try {
-                // todo: resolve the channel property with actual information
-                return ((_a = yield this.get('/server/tuners', undefined, timeout)) !== null && _a !== void 0 ? _a : []);
-            }
-            catch (_b) {
-                return [];
-            }
-        });
+    async tuners(timeout = this.timeout) {
+        try {
+            const tuners = await this.get('/server/tuners', undefined, timeout) ?? [];
+            return Promise.all(tuners.map(async (tuner) => ({
+                ...tuner,
+                channel: tuner.channel
+                    ? await this.channel(tuner.channel, timeout) ?? null
+                    : null
+            })));
+        }
+        catch {
+            return [];
+        }
     }
     /**
      * Retrieves device update information.
      * @param timeout
      */
-    updateInfo() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            try {
-                const response = yield this.get('/server/update/info', undefined, timeout);
-                if (response) {
-                    return Object.assign(Object.assign({}, response), { last_checked: new Date(response.last_checked), last_update: response.last_update ? new Date(response.last_update) : null });
-                }
-            }
-            catch (_a) {
-            }
-        });
+    async updateInfo(timeout = this.timeout) {
+        try {
+            const response = await this.get('/server/update/info', undefined, timeout);
+            if (response) {
+                return {
+                    ...response,
+                    last_checked: new Date(response.last_checked),
+                    last_update: response.last_update ? new Date(response.last_update) : null
+                };
+            }
+        }
+        catch {
+        }
     }
     /**
      * Retrieves device update progress information.
      * @param timeout
      */
-    updateProgress() {
-        return __awaiter(this, arguments, void 0, function* (timeout = this.timeout) {
-            try {
-                return yield this.get('/server/update/progress', undefined, timeout);
-            }
-            catch (_a) {
-            }
-        });
+    async updateProgress(timeout = this.timeout) {
+        try {
+            return await this.get('/server/update/progress', undefined, timeout);
+        }
+        catch {
+        }
     }
     /**
      * Initiates a channel watch (streaming) session on the device which must be managed via
@@ -427,37 +417,37 @@ class Tablo extends tablo_api_1.default {
      * @param device_info
      * @param timeout
      */
-    watchChannel(channel_id_1) {
-        return __awaiter(this, arguments, void 0, function* (channel_id, device_info = {}, timeout = 30000) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-            var _p, _q, _r, _s, _t, _u, _v, _w, _x;
-            (_a = device_info.device_id) !== null && _a !== void 0 ? _a : (device_info.device_id = this.device_id);
-            (_b = device_info.platform) !== null && _b !== void 0 ? _b : (device_info.platform = 'ios');
-            (_c = device_info.bandwidth) !== null && _c !== void 0 ? _c : (device_info.bandwidth = null);
-            (_d = device_info.extra) !== null && _d !== void 0 ? _d : (device_info.extra = {});
-            (_e = (_p = device_info.extra).deviceId) !== null && _e !== void 0 ? _e : (_p.deviceId = '00000000-0000-0000-0000-000000000000');
-            (_f = (_q = device_info.extra).width) !== null && _f !== void 0 ? _f : (_q.width = 640);
-            (_g = (_r = device_info.extra).height) !== null && _g !== void 0 ? _g : (_r.height = 480);
-            (_h = (_s = device_info.extra).deviceModel) !== null && _h !== void 0 ? _h : (_s.deviceModel = 'iPhone15,3');
-            (_j = (_t = device_info.extra).lang) !== null && _j !== void 0 ? _j : (_t.lang = 'en_US');
-            (_k = (_u = device_info.extra).deviceOS) !== null && _k !== void 0 ? _k : (_u.deviceOS = 'iOS');
-            (_l = (_v = device_info.extra).deviceOSVersion) !== null && _l !== void 0 ? _l : (_v.deviceOSVersion = '18.4.1');
-            (_m = (_w = device_info.extra).limitedAdTracking) !== null && _m !== void 0 ? _m : (_w.limitedAdTracking = 1);
-            (_o = (_x = device_info.extra).deviceMake) !== null && _o !== void 0 ? _o : (_x.deviceMake = 'Apple');
-            const info = yield this.info();
-            const channel = yield this.channel(channel_id);
-            if (info && channel) {
-                try {
-                    const response = yield this.post(`/guide/channels/${channel_id}/watch`, { lh: undefined }, device_info, timeout);
-                    if (response) {
-                        this.session_channels.set(response.token, channel);
-                        return Object.assign(Object.assign({}, response), { expires: new Date(response.expires), channel });
-                    }
-                }
-                catch (_y) {
+    async watchChannel(channel_id, device_info = {}, timeout = 30000) {
+        device_info.device_id ??= this.device_id;
+        device_info.platform ??= 'ios';
+        device_info.bandwidth ??= null;
+        device_info.extra ??= {};
+        device_info.extra.deviceId ??= '00000000-0000-0000-0000-000000000000';
+        device_info.extra.width ??= 640;
+        device_info.extra.height ??= 480;
+        device_info.extra.deviceModel ??= 'iPhone15,3';
+        device_info.extra.lang ??= 'en_US';
+        device_info.extra.deviceOS ??= 'iOS';
+        device_info.extra.deviceOSVersion ??= '18.4.1';
+        device_info.extra.limitedAdTracking ??= 1;
+        device_info.extra.deviceMake ??= 'Apple';
+        const info = await this.info();
+        const channel = await this.channel(channel_id);
+        if (info && channel) {
+            try {
+                const response = await this.post(`/guide/channels/${channel_id}/watch`, { lh: undefined }, device_info, timeout);
+                if (response) {
+                    this.session_channels.set(response.token, channel);
+                    return {
+                        ...response,
+                        expires: new Date(response.expires),
+                        channel
+                    };
                 }
             }
-        });
+            catch {
+            }
+        }
     }
 }
 exports.Tablo = Tablo;