ngx-kel-agent 0.4.10 → 0.5.3

package/esm2020/lib/wsjtx.service.mjs

@@ -0,0 +1,251 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./agent-message.service";
+export class WsjtxService {
+    constructor(messages) {
+        this.messages = messages;
+        /** Whether we're getting any messages from WSJT-X. */
+        this.connected$ = new BehaviorSubject(false);
+        /** Subject for listening to WSJT-X "Heartbeat" messages. */
+        this.heartbeat$ = new ReplaySubject(1);
+        /** Subject for listening to WSJT-X "Status" messages. */
+        this.status$ = new ReplaySubject(1);
+        /** Subject for listening to WSJT-X "Decode" messages. */
+        this.decode$ = new Subject();
+        /** Subject for listening to WSJT-X "Clear" messages. */
+        this.clear$ = new Subject();
+        /** Subject for listening to WSJT-X "QsoLogged" messages. */
+        this.qsoLogged$ = new Subject();
+        /** Subject for listening to WSJT-X "Close" messages. */
+        this.close$ = new Subject();
+        /** Subject for listening to WSJT-X "WsprDecode" messages. */
+        this.wsprDecode$ = new Subject();
+        /** Subject for listening to WSJT-X "LoggedAdif" messages. */
+        this.loggedAdif$ = new Subject();
+        this.wsjtxId = 'WSJT-X';
+        this.setupBehaviors();
+    }
+    setupBehaviors() {
+        this.messages.rxMessage$.subscribe((msg) => this.handleMessage(msg));
+        // if we haven't heard from WSJT-X in 15 seconds, consider it "down"
+        this.connected$
+            .pipe(debounceTime(15000))
+            .subscribe(() => this.connected$.next(false));
+        // When WSJT-X announces it's closing, set it to "down" immediately
+        this.close$.subscribe(() => {
+            this.connected$.next(false);
+        });
+        // When WSJT-X goes down, clear its persistent message subjects
+        this.connected$.subscribe((isUp) => {
+            if (!isUp) {
+                this.heartbeat$.next(null);
+                this.status$.next(null);
+            }
+        });
+    }
+    handleMessage(msg) {
+        if (!msg.wsjtx) {
+            return;
+        }
+        this.connected$.next(true);
+        this.wsjtxId = msg.wsjtx.payload.id;
+        switch (msg.wsjtx.type) {
+            case 'HeartbeatMessage':
+                this.heartbeat$.next(msg.wsjtx.payload);
+                return;
+            case 'StatusMessage':
+                this.status$.next(msg.wsjtx.payload);
+                return;
+            case 'DecodeMessage':
+                this.decode$.next(msg.wsjtx.payload);
+                return;
+            case 'ClearMessage':
+                this.clear$.next(msg.wsjtx.payload);
+                return;
+            case 'QsoLoggedMessage':
+                this.qsoLogged$.next(msg.wsjtx.payload);
+                return;
+            case 'CloseMessage':
+                this.close$.next(msg.wsjtx.payload);
+                return;
+            case 'WSPRDecodeMessage':
+                this.wsprDecode$.next(msg.wsjtx.payload);
+                return;
+            case 'LoggedAdifMessage':
+                this.loggedAdif$.next(msg.wsjtx.payload);
+                return;
+        }
+    }
+    /** Send a command to WSJT-X to clear the Band Activity window. */
+    clearBandActivity() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'ClearMessage',
+                payload: { id: this.wsjtxId, window: 0 },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to clear the Rx Frequency window. */
+    clearRxFreqWindow() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'ClearMessage',
+                payload: { id: this.wsjtxId, window: 1 },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to clear the Band Activity and Rx Frequency windows. */
+    clearAll() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'ClearMessage',
+                payload: { id: this.wsjtxId, window: 2 },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to replay messages. Useful for a fresh client that wants to hear
+     * previous WSJT-X decodes. */
+    replay() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'ReplayMessage',
+                payload: { id: this.wsjtxId },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to halt any transmissions immediately. */
+    haltTxNow() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'HaltTxMessage',
+                payload: { id: this.wsjtxId, autoTxOnly: false },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to stop auto-transmitting after finishing the current round. */
+    haltTxAfterCurrent() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'HaltTxMessage',
+                payload: { id: this.wsjtxId, autoTxOnly: true },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to reply to the given decode. The message must include CQ or QRZ. */
+    reply(decode) {
+        const wsMsg = {
+            wsjtx: {
+                type: 'ReplyMessage',
+                payload: {
+                    id: decode.id,
+                    time: decode.time,
+                    snr: decode.snr,
+                    deltaTime: decode.deltaTime,
+                    deltaFrequency: decode.deltaFrequency,
+                    mode: decode.mode,
+                    message: decode.message,
+                    lowConfidence: decode.lowConfidence,
+                },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to reply to the given decode. The message must include CQ or QRZ. */
+    highlightCallsign(highlightMsg) {
+        highlightMsg.id = this.wsjtxId;
+        const wsMsg = {
+            wsjtx: {
+                type: 'HighlightCallsignMessage',
+                payload: highlightMsg,
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /**
+     * Send a command to WSJT-X to transmit the given free text. If the text is too long to be
+     * encoded in a single message, it may be silently truncated. */
+    sendFreeText(freeText) {
+        freeText.id = this.wsjtxId;
+        const wsMsg = {
+            wsjtx: {
+                type: 'FreeTextMessage',
+                payload: freeText,
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to set the local station's Maidenhead grid. This is temporary,
+     * lasting only as long as WSJT-X is running. */
+    setLocation(grid) {
+        const wsMsg = {
+            wsjtx: {
+                type: 'LocationMessage',
+                payload: {
+                    id: this.wsjtxId,
+                    location: grid,
+                },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to switch to the named configuration. */
+    switchConfiguration(configName) {
+        const wsMsg = {
+            wsjtx: {
+                type: 'SwitchConfigurationMessage',
+                payload: {
+                    id: this.wsjtxId,
+                    configurationName: configName,
+                },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to set the given configuration parameters. */
+    configure(config) {
+        config.id = this.wsjtxId;
+        const wsMsg = {
+            wsjtx: {
+                type: 'ConfigureMessage',
+                payload: config,
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Given a decode message, format a string the same way as displayed in the WSJT-X Band
+     * Activity/Rx Frequency windows. */
+    static formatDecode(msg) {
+        const timeStr = this.formatTime(msg.time);
+        return `${timeStr} ${msg.snr.toString().padStart(3)} ${msg.deltaTime
+            .toFixed(1)
+            .padStart(4)} ${msg.deltaFrequency.toString().padStart(4)} ~  ${msg.message}`;
+    }
+    /** Given a time in milliseconds since midnight UTC, format as HHMMSS. */
+    static formatTime(time) {
+        const secondsSinceMidnight = Math.floor(time / 1000);
+        const hours = Math.floor(secondsSinceMidnight / 3600);
+        const secondsSinceHour = secondsSinceMidnight - hours * 3600;
+        const minutes = Math.floor(secondsSinceHour / 60);
+        const seconds = secondsSinceHour - minutes * 60;
+        return `${hours.toString().padStart(2, '0')}${minutes
+            .toString()
+            .padStart(2, '0')}${seconds.toString().padStart(2, '0')}`;
+    }
+}
+WsjtxService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: WsjtxService, deps: [{ token: i1.AgentMessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+WsjtxService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: WsjtxService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: WsjtxService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AgentMessageService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wsjtx.service.js","sourceRoot":"","sources":["../../../../projects/ngx-kel-agent/src/lib/wsjtx.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';\nimport {\n  WsjtxClear,\n  WsjtxClose,\n  WsjtxConfigure,\n  WsjtxDecode,\n  WsjtxFreeText,\n  WsjtxHaltTx,\n  WsjtxHeartbeat,\n  WsjtxHighlightCallsign,\n  WsjtxLocation,\n  WsjtxLoggedAdif,\n  WsjtxQsoLogged,\n  WsjtxReplay,\n  WsjtxReply,\n  WsjtxStatus,\n  WsjtxSwitchConfiguration,\n  WsjtxWsprDecode,\n} from './wsjtx-messages';\nimport { debounceTime } from 'rxjs/operators';\nimport { AgentMessageService } from './agent-message.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class WsjtxService {\n  /** Whether we're getting any messages from WSJT-X. */\n  public readonly connected$ = new BehaviorSubject<boolean>(false);\n  /** Subject for listening to WSJT-X \"Heartbeat\" messages. */\n  public readonly heartbeat$ = new ReplaySubject<WsjtxHeartbeat | null>(1);\n  /** Subject for listening to WSJT-X \"Status\" messages. */\n  public readonly status$ = new ReplaySubject<WsjtxStatus | null>(1);\n  /** Subject for listening to WSJT-X \"Decode\" messages. */\n  public readonly decode$ = new Subject<WsjtxDecode>();\n  /** Subject for listening to WSJT-X \"Clear\" messages. */\n  public readonly clear$ = new Subject<WsjtxClear>();\n  /** Subject for listening to WSJT-X \"QsoLogged\" messages. */\n  public readonly qsoLogged$ = new Subject<WsjtxQsoLogged>();\n  /** Subject for listening to WSJT-X \"Close\" messages. */\n  public readonly close$ = new Subject<WsjtxClose>();\n  /** Subject for listening to WSJT-X \"WsprDecode\" messages. */\n  public readonly wsprDecode$ = new Subject<WsjtxWsprDecode>();\n  /** Subject for listening to WSJT-X \"LoggedAdif\" messages. */\n  public readonly loggedAdif$ = new Subject<WsjtxLoggedAdif>();\n\n  private wsjtxId: string = 'WSJT-X';\n\n  constructor(private messages: AgentMessageService) {\n    this.setupBehaviors();\n  }\n\n  private setupBehaviors(): void {\n    this.messages.rxMessage$.subscribe((msg) => this.handleMessage(msg));\n    // if we haven't heard from WSJT-X in 15 seconds, consider it \"down\"\n    this.connected$\n      .pipe(debounceTime(15000))\n      .subscribe(() => this.connected$.next(false));\n    // When WSJT-X announces it's closing, set it to \"down\" immediately\n    this.close$.subscribe(() => {\n      this.connected$.next(false);\n    });\n    // When WSJT-X goes down, clear its persistent message subjects\n    this.connected$.subscribe((isUp) => {\n      if (!isUp) {\n        this.heartbeat$.next(null);\n        this.status$.next(null);\n      }\n    });\n  }\n\n  private handleMessage(msg: any): void {\n    if (!msg.wsjtx) {\n      return;\n    }\n    this.connected$.next(true);\n    this.wsjtxId = msg.wsjtx.payload.id;\n    switch (msg.wsjtx.type) {\n      case 'HeartbeatMessage':\n        this.heartbeat$.next(msg.wsjtx.payload as WsjtxHeartbeat);\n        return;\n      case 'StatusMessage':\n        this.status$.next(msg.wsjtx.payload as WsjtxStatus);\n        return;\n      case 'DecodeMessage':\n        this.decode$.next(msg.wsjtx.payload as WsjtxDecode);\n        return;\n      case 'ClearMessage':\n        this.clear$.next(msg.wsjtx.payload as WsjtxClear);\n        return;\n      case 'QsoLoggedMessage':\n        this.qsoLogged$.next(msg.wsjtx.payload as WsjtxQsoLogged);\n        return;\n      case 'CloseMessage':\n        this.close$.next(msg.wsjtx.payload as WsjtxClose);\n        return;\n      case 'WSPRDecodeMessage':\n        this.wsprDecode$.next(msg.wsjtx.payload as WsjtxWsprDecode);\n        return;\n      case 'LoggedAdifMessage':\n        this.loggedAdif$.next(msg.wsjtx.payload as WsjtxLoggedAdif);\n        return;\n    }\n  }\n\n  /** Send a command to WSJT-X to clear the Band Activity window. */\n  public clearBandActivity() {\n    const wsMsg = {\n      wsjtx: {\n        type: 'ClearMessage',\n        payload: <WsjtxClear>{ id: this.wsjtxId, window: 0 },\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /** Send a command to WSJT-X to clear the Rx Frequency window. */\n  public clearRxFreqWindow() {\n    const wsMsg = {\n      wsjtx: {\n        type: 'ClearMessage',\n        payload: <WsjtxClear>{ id: this.wsjtxId, window: 1 },\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /** Send a command to WSJT-X to clear the Band Activity and Rx Frequency windows. */\n  public clearAll() {\n    const wsMsg = {\n      wsjtx: {\n        type: 'ClearMessage',\n        payload: <WsjtxClear>{ id: this.wsjtxId, window: 2 },\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /** Send a command to WSJT-X to replay messages. Useful for a fresh client that wants to hear\n   * previous WSJT-X decodes. */\n  public replay() {\n    const wsMsg = {\n      wsjtx: {\n        type: 'ReplayMessage',\n        payload: <WsjtxReplay>{ id: this.wsjtxId },\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /** Send a command to WSJT-X to halt any transmissions immediately. */\n  public haltTxNow() {\n    const wsMsg = {\n      wsjtx: {\n        type: 'HaltTxMessage',\n        payload: <WsjtxHaltTx>{ id: this.wsjtxId, autoTxOnly: false },\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /** Send a command to WSJT-X to stop auto-transmitting after finishing the current round. */\n  public haltTxAfterCurrent() {\n    const wsMsg = {\n      wsjtx: {\n        type: 'HaltTxMessage',\n        payload: <WsjtxHaltTx>{ id: this.wsjtxId, autoTxOnly: true },\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /** Send a command to WSJT-X to reply to the given decode. The message must include CQ or QRZ. */\n  public reply(decode: WsjtxDecode) {\n    const wsMsg = {\n      wsjtx: {\n        type: 'ReplyMessage',\n        payload: <WsjtxReply>{\n          id: decode.id,\n          time: decode.time,\n          snr: decode.snr,\n          deltaTime: decode.deltaTime,\n          deltaFrequency: decode.deltaFrequency,\n          mode: decode.mode,\n          message: decode.message,\n          lowConfidence: decode.lowConfidence,\n        },\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /** Send a command to WSJT-X to reply to the given decode. The message must include CQ or QRZ. */\n  public highlightCallsign(highlightMsg: WsjtxHighlightCallsign) {\n    highlightMsg.id = this.wsjtxId;\n    const wsMsg = {\n      wsjtx: {\n        type: 'HighlightCallsignMessage',\n        payload: highlightMsg,\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /**\n   * Send a command to WSJT-X to transmit the given free text. If the text is too long to be\n   * encoded in a single message, it may be silently truncated. */\n  public sendFreeText(freeText: WsjtxFreeText) {\n    freeText.id = this.wsjtxId;\n    const wsMsg = {\n      wsjtx: {\n        type: 'FreeTextMessage',\n        payload: freeText,\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /** Send a command to WSJT-X to set the local station's Maidenhead grid. This is temporary,\n   * lasting only as long as WSJT-X is running. */\n  public setLocation(grid: string) {\n    const wsMsg = {\n      wsjtx: {\n        type: 'LocationMessage',\n        payload: <WsjtxLocation>{\n          id: this.wsjtxId,\n          location: grid,\n        },\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /** Send a command to WSJT-X to switch to the named configuration. */\n  public switchConfiguration(configName: string) {\n    const wsMsg = {\n      wsjtx: {\n        type: 'SwitchConfigurationMessage',\n        payload: <WsjtxSwitchConfiguration>{\n          id: this.wsjtxId,\n          configurationName: configName,\n        },\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /** Send a command to WSJT-X to set the given configuration parameters. */\n  public configure(config: WsjtxConfigure) {\n    config.id = this.wsjtxId;\n    const wsMsg = {\n      wsjtx: {\n        type: 'ConfigureMessage',\n        payload: config,\n      },\n    };\n    this.messages.txMessage$.next(wsMsg);\n  }\n\n  /** Given a decode message, format a string the same way as displayed in the WSJT-X Band\n   * Activity/Rx Frequency windows. */\n  public static formatDecode(msg: WsjtxDecode): string {\n    const timeStr = this.formatTime(msg.time);\n    return `${timeStr} ${msg.snr.toString().padStart(3)} ${msg.deltaTime\n      .toFixed(1)\n      .padStart(4)} ${msg.deltaFrequency.toString().padStart(4)} ~  ${\n      msg.message\n    }`;\n  }\n\n  /** Given a time in milliseconds since midnight UTC, format as HHMMSS. */\n  public static formatTime(time: number) {\n    const secondsSinceMidnight = Math.floor(time / 1000);\n    const hours = Math.floor(secondsSinceMidnight / 3600);\n    const secondsSinceHour = secondsSinceMidnight - hours * 3600;\n    const minutes = Math.floor(secondsSinceHour / 60);\n    const seconds = secondsSinceHour - minutes * 60;\n    return `${hours.toString().padStart(2, '0')}${minutes\n      .toString()\n      .padStart(2, '0')}${seconds.toString().padStart(2, '0')}`;\n  }\n}\n"]}

package/esm2020/public-api.mjs

@@ -2,7 +2,11 @@
  * Public API Surface of ngx-kel-agent
  */
 export * from './lib/agent.service';
-export * from './lib/messages';
+export * from './lib/agent-message.service';
+export * from './lib/hamlib-messages';
+export * from './lib/hamlib.service';
+export * from './lib/wsjtx-messages';
+export * from './lib/wsjtx.service';
 // export * from './lib/ngx-kel-agent.component';
 // export * from './lib/ngx-kel-agent.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1rZWwtYWdlbnQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsaURBQWlEO0FBQ2pELDhDQUE4QyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygbmd4LWtlbC1hZ2VudFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2FnZW50LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbWVzc2FnZXMnO1xuLy8gZXhwb3J0ICogZnJvbSAnLi9saWIvbmd4LWtlbC1hZ2VudC5jb21wb25lbnQnO1xuLy8gZXhwb3J0ICogZnJvbSAnLi9saWIvbmd4LWtlbC1hZ2VudC5tb2R1bGUnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1rZWwtYWdlbnQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxpREFBaUQ7QUFDakQsOENBQThDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuZ3gta2VsLWFnZW50XG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvYWdlbnQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9hZ2VudC1tZXNzYWdlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvaGFtbGliLW1lc3NhZ2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2hhbWxpYi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dzanR4LW1lc3NhZ2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dzanR4LnNlcnZpY2UnO1xuLy8gZXhwb3J0ICogZnJvbSAnLi9saWIvbmd4LWtlbC1hZ2VudC5jb21wb25lbnQnO1xuLy8gZXhwb3J0ICogZnJvbSAnLi9saWIvbmd4LWtlbC1hZ2VudC5tb2R1bGUnO1xuIl19