botframework-webchat 4.13.0 → 4.14.2

package/lib/renderMarkdown.js

@@ -78,7 +78,10 @@ function render(markdown, _ref) {
       iconTokens[0].attrJoin('class', 'webchat__markdown__external-link-icon');
       tokens.splice.apply(tokens, [index + 2, 0].concat((0, _toConsumableArray2.default)(iconTokens)));
     }
-  }).render(markdown);
+  }).render(markdown); // The signature from "sanitize-html" module is not correct.
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+
   return (0, _sanitizeHtml.default)(html, SANITIZE_HTML_OPTIONS);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/renderWebChat.d.ts

@@ -0,0 +1,3 @@
+import { ComponentType } from 'react';
+export default function renderWebChat(ReactWebChat: ComponentType<any>, props: any, element: HTMLElement): void;
+//# sourceMappingURL=renderWebChat.d.ts.map

package/lib/renderWebChat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderWebChat.d.ts","sourceRoot":"","sources":["../src/renderWebChat.tsx"],"names":[],"mappings":"AAAA,OAAc,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAG7C,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,YAAY,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,CAE9G"}

package/lib/renderWebChat.js

@@ -14,4 +14,4 @@ var _reactDom = _interopRequireDefault(require("react-dom"));
 function renderWebChat(ReactWebChat, props, element) {
   _reactDom.default.render( /*#__PURE__*/_react.default.createElement(ReactWebChat, props), element);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9yZW5kZXJXZWJDaGF0LmpzIl0sIm5hbWVzIjpbInJlbmRlcldlYkNoYXQiLCJSZWFjdFdlYkNoYXQiLCJwcm9wcyIsImVsZW1lbnQiLCJSZWFjdERPTSIsInJlbmRlciJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUE7O0FBQ0E7O0FBRWUsU0FBU0EsYUFBVCxDQUF1QkMsWUFBdkIsRUFBcUNDLEtBQXJDLEVBQTRDQyxPQUE1QyxFQUFxRDtBQUNsRUMsb0JBQVNDLE1BQVQsZUFBZ0IsNkJBQUMsWUFBRCxFQUFrQkgsS0FBbEIsQ0FBaEIsRUFBNkNDLE9BQTdDO0FBQ0QiLCJzb3VyY2VSb290IjoiYnVuZGxlOi8vLyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCBmcm9tICdyZWFjdCc7XG5pbXBvcnQgUmVhY3RET00gZnJvbSAncmVhY3QtZG9tJztcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gcmVuZGVyV2ViQ2hhdChSZWFjdFdlYkNoYXQsIHByb3BzLCBlbGVtZW50KSB7XG4gIFJlYWN0RE9NLnJlbmRlcig8UmVhY3RXZWJDaGF0IHsuLi5wcm9wc30gLz4sIGVsZW1lbnQpO1xufVxuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9yZW5kZXJXZWJDaGF0LnRzeCJdLCJuYW1lcyI6WyJyZW5kZXJXZWJDaGF0IiwiUmVhY3RXZWJDaGF0IiwicHJvcHMiLCJlbGVtZW50IiwiUmVhY3RET00iLCJyZW5kZXIiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBOztBQUNBOztBQUVlLFNBQVNBLGFBQVQsQ0FBdUJDLFlBQXZCLEVBQXlEQyxLQUF6RCxFQUFxRUMsT0FBckUsRUFBaUc7QUFDOUdDLG9CQUFTQyxNQUFULGVBQWdCLDZCQUFDLFlBQUQsRUFBa0JILEtBQWxCLENBQWhCLEVBQTZDQyxPQUE3QztBQUNEIiwic291cmNlUm9vdCI6ImJ1bmRsZTovLy8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUmVhY3QsIHsgQ29tcG9uZW50VHlwZSB9IGZyb20gJ3JlYWN0JztcbmltcG9ydCBSZWFjdERPTSBmcm9tICdyZWFjdC1kb20nO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiByZW5kZXJXZWJDaGF0KFJlYWN0V2ViQ2hhdDogQ29tcG9uZW50VHlwZTxhbnk+LCBwcm9wczogYW55LCBlbGVtZW50OiBIVE1MRWxlbWVudCk6IHZvaWQge1xuICBSZWFjdERPTS5yZW5kZXIoPFJlYWN0V2ViQ2hhdCB7Li4ucHJvcHN9IC8+LCBlbGVtZW50KTtcbn1cbiJdfQ==

package/lib/speech/CustomAudioInputStream.d.ts

@@ -0,0 +1,94 @@
+import { AudioInputStream } from 'microsoft-cognitiveservices-speech-sdk';
+import { AudioSourceEvent, EventSource } from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common/Exports';
+import { AudioStreamFormatImpl } from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/sdk/Audio/AudioStreamFormat';
+import { connectivity as Connectivity, ISpeechConfigAudioDevice, type as Type } from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common.speech/Exports';
+import { DeferredPromise } from 'p-defer-es5';
+declare type AudioStreamNode = {
+    detach: () => Promise<void>;
+    id: () => string;
+    read: () => Promise<StreamChunk<ArrayBuffer>>;
+};
+declare type DeviceInfo = {
+    connectivity?: Connectivity | 'Bluetooth' | 'Wired' | 'WiFi' | 'Cellular' | 'InBuilt' | 'Unknown';
+    manufacturer?: string;
+    model?: string;
+    type?: Type | 'Phone' | 'Speaker' | 'Car' | 'Headset' | 'Thermostat' | 'Microphones' | 'Deskphone' | 'RemoteControl' | 'Unknown' | 'File' | 'Stream';
+};
+declare type Format = {
+    bitsPerSample: number;
+    channels: number;
+    samplesPerSec: number;
+};
+declare type NormalizedOptions = Required<Omit<Options, 'debug'>> & {
+    debug: boolean;
+};
+declare type Options = {
+    debug?: true;
+    id?: string;
+};
+declare type StreamChunk<T> = {
+    isEnd: boolean;
+    buffer: T;
+    timeReceived: number;
+};
+declare const SYMBOL_DEVICE_INFO_DEFERRED: unique symbol;
+declare const SYMBOL_EVENTS: unique symbol;
+declare const SYMBOL_FORMAT_DEFERRED: unique symbol;
+declare const SYMBOL_OPTIONS: unique symbol;
+declare abstract class CustomAudioInputStream extends AudioInputStream {
+    constructor(options?: Options);
+    [SYMBOL_DEVICE_INFO_DEFERRED]: DeferredPromise<DeviceInfo>;
+    [SYMBOL_EVENTS]: EventSource<AudioSourceEvent>;
+    [SYMBOL_FORMAT_DEFERRED]: DeferredPromise<AudioStreamFormatImpl>;
+    [SYMBOL_OPTIONS]: NormalizedOptions;
+    /** Gets the event source for listening to events. */
+    get events(): EventSource<AudioSourceEvent>;
+    /** Gets the format of the audio stream. */
+    get format(): Promise<AudioStreamFormatImpl>;
+    /** Gets the ID of this audio stream. */
+    id(): string;
+    /** Emits an event. */
+    protected onEvent(event: AudioSourceEvent): void;
+    /** Emits an `AudioSourceInitializingEvent`. */
+    protected emitInitializing(): void;
+    /** Emits an `AudioSourceReadyEvent`. */
+    protected emitReady(): void;
+    /** Emits an `AudioSourceErrorEvent`. */
+    protected emitError(error: Error): void;
+    /** Emits an `AudioStreamNodeAttachingEvent`. */
+    protected emitNodeAttaching(audioNodeId: string): void;
+    /** Emits an `AudioStreamNodeAttachedEvent`. */
+    protected emitNodeAttached(audioNodeId: string): void;
+    /** Emits an `AudioStreamNodeErrorEvent`. */
+    protected emitNodeError(audioNodeId: string, error: Error): void;
+    /** Emits an `AudioStreamNodeDetachedEvent`. */
+    protected emitNodeDetached(audioNodeId: string): void;
+    /** Emits an `AudioSourceOffEvent`. */
+    protected emitOff(): void;
+    close(): void;
+    turnOn(): void;
+    detach(): void;
+    /** Log the message to console if `debug` is set to `true`. */
+    private debug;
+    /** Implements this function. When called, it should start recording and return an `IAudioStreamNode`. */
+    protected abstract performAttach(audioNodeId: string): Promise<{
+        audioStreamNode: AudioStreamNode;
+        deviceInfo: DeviceInfo;
+        format: Format;
+    }>;
+    /** Attaches the device by returning an audio node. */
+    attach(audioNodeId: string): Promise<AudioStreamNode>;
+    /**
+     * Implements this function. When called, it should stop recording. This is called before the `IAudioStreamNode.detach` function.
+     *
+     * Note: when using with Direct Line Speech, this function is never called.
+     */
+    protected performTurnOff(): Promise<void>;
+    /** Turn off the audio device. This is called before detaching from the graph. */
+    turnOff(): Promise<void>;
+    /** Gets the device information. */
+    get deviceInfo(): Promise<ISpeechConfigAudioDevice>;
+}
+export default CustomAudioInputStream;
+export type { AudioStreamNode, DeviceInfo, Format, Options };
+//# sourceMappingURL=CustomAudioInputStream.d.ts.map

package/lib/speech/CustomAudioInputStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomAudioInputStream.d.ts","sourceRoot":"","sources":["../../src/speech/CustomAudioInputStream.ts"],"names":[],"mappings":"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"}

package/lib/speech/CustomAudioInputStream.js

@@ -0,0 +1,416 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _microsoftCognitiveservicesSpeechSdk = require("microsoft-cognitiveservices-speech-sdk");
+
+var _Exports = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common/Exports");
+
+var _AudioStreamFormat = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/src/sdk/Audio/AudioStreamFormat");
+
+var _Exports2 = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common.speech/Exports");
+
+var _uuid = require("uuid");
+
+var _pDeferEs = _interopRequireDefault(require("p-defer-es5"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var SYMBOL_DEVICE_INFO_DEFERRED = Symbol('deviceInfoDeferred');
+var SYMBOL_EVENTS = Symbol('events');
+var SYMBOL_FORMAT_DEFERRED = Symbol('formatDeferred');
+var SYMBOL_OPTIONS = Symbol('options'); // Speech SDK quirks: Only 2 lifecycle functions are actually used.
+//                    They are: attach() and turnOff().
+//                    Others are not used, including: blob(), close(), detach(), turnOn().
+
+var CustomAudioInputStream = /*#__PURE__*/function (_AudioInputStream) {
+  (0, _inherits2.default)(CustomAudioInputStream, _AudioInputStream);
+
+  var _super = _createSuper(CustomAudioInputStream);
+
+  function CustomAudioInputStream() {
+    var _this;
+
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2.default)(this, CustomAudioInputStream);
+    _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), SYMBOL_DEVICE_INFO_DEFERRED, void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), SYMBOL_EVENTS, void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), SYMBOL_FORMAT_DEFERRED, void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), SYMBOL_OPTIONS, void 0);
+    var normalizedOptions = {
+      debug: options.debug || false,
+      id: options.id || (0, _uuid.v4)().replace(/\x2D/g, '')
+    };
+    _this[SYMBOL_DEVICE_INFO_DEFERRED] = (0, _pDeferEs.default)();
+    _this[SYMBOL_EVENTS] = new _Exports.EventSource();
+    _this[SYMBOL_FORMAT_DEFERRED] = (0, _pDeferEs.default)();
+    _this[SYMBOL_OPTIONS] = normalizedOptions;
+    return _this;
+  }
+
+  (0, _createClass2.default)(CustomAudioInputStream, [{
+    key: "events",
+    get:
+    /** Gets the event source for listening to events. */
+    // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+    function get() {
+      return this[SYMBOL_EVENTS];
+    }
+    /** Gets the format of the audio stream. */
+    // Speech SDK quirks: `AudioStreamFormatImpl` is internal implementation while `AudioStreamFormat` is public.
+    //                    It is weird to expose `AudioStreamFormatImpl` instead of `AudioStreamFormat`.
+    // Speech SDK quirks: It is weird to return a `Promise` in a property.
+    // Speech SDK quirks: In normal speech recognition, getter of "format" is called only after "attach".
+    //                    But in Direct Line Speech, it is called before "attach".
+    // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+
+  }, {
+    key: "format",
+    get: function get() {
+      this.debug('Getting "format".');
+      return this[SYMBOL_FORMAT_DEFERRED].promise;
+    }
+    /** Gets the ID of this audio stream. */
+
+  }, {
+    key: "id",
+    value: function id() {
+      return this[SYMBOL_OPTIONS].id;
+    }
+    /** Emits an event. */
+    // Speech SDK quirks: In JavaScript, onXxx means "listen to event XXX".
+    //                    Instead, in Speech SDK, it means "emit event XXX".
+
+  }, {
+    key: "onEvent",
+    value: function onEvent(event) {
+      this[SYMBOL_EVENTS].onEvent(event);
+
+      _Exports.Events.instance.onEvent(event);
+    }
+    /** Emits an `AudioSourceInitializingEvent`. */
+
+  }, {
+    key: "emitInitializing",
+    value: function emitInitializing() {
+      this.debug('Emitting "AudioSourceInitializingEvent".');
+      this.onEvent(new _Exports.AudioSourceInitializingEvent(this.id()));
+    }
+    /** Emits an `AudioSourceReadyEvent`. */
+
+  }, {
+    key: "emitReady",
+    value: function emitReady() {
+      this.debug('Emitting "AudioSourceReadyEvent".');
+      this.onEvent(new _Exports.AudioSourceReadyEvent(this.id()));
+    }
+    /** Emits an `AudioSourceErrorEvent`. */
+    // Speech SDK quirks: Since "turnOn" is never called and "turnOff" does not work in Direct Line Speech, the "source error" event is not emitted at all.
+    //                    Instead, we only emit "node error" event.
+
+  }, {
+    key: "emitError",
+    value: function emitError(error) {
+      this.debug('Emitting "AudioSourceErrorEvent".', {
+        error: error
+      }); // Speech SDK quirks: "error" is a string, instead of object of type "Error".
+
+      this.onEvent(new _Exports.AudioSourceErrorEvent(this.id(), error.message));
+    }
+    /** Emits an `AudioStreamNodeAttachingEvent`. */
+
+  }, {
+    key: "emitNodeAttaching",
+    value: function emitNodeAttaching(audioNodeId) {
+      this.debug("Emitting \"AudioStreamNodeAttachingEvent\" for node \"".concat(audioNodeId, "\"."));
+      this.onEvent(new _Exports.AudioStreamNodeAttachingEvent(this.id(), audioNodeId));
+    }
+    /** Emits an `AudioStreamNodeAttachedEvent`. */
+
+  }, {
+    key: "emitNodeAttached",
+    value: function emitNodeAttached(audioNodeId) {
+      this.debug("Emitting \"AudioStreamNodeAttachedEvent\" for node \"".concat(audioNodeId, "\"."));
+      this.onEvent(new _Exports.AudioStreamNodeAttachedEvent(this.id(), audioNodeId));
+    }
+    /** Emits an `AudioStreamNodeErrorEvent`. */
+
+  }, {
+    key: "emitNodeError",
+    value: function emitNodeError(audioNodeId, error) {
+      this.debug("Emitting \"AudioStreamNodeErrorEvent\" for node \"".concat(audioNodeId, "\"."), {
+        error: error
+      }); // Speech SDK quirks: "error" is a string, instead of object of type "Error".
+
+      this.onEvent(new _Exports.AudioStreamNodeErrorEvent(this.id(), audioNodeId, error.message));
+    }
+    /** Emits an `AudioStreamNodeDetachedEvent`. */
+
+  }, {
+    key: "emitNodeDetached",
+    value: function emitNodeDetached(audioNodeId) {
+      this.debug('Emitting "AudioStreamNodeDetachedEvent".');
+      this.onEvent(new _Exports.AudioStreamNodeDetachedEvent(this.id(), audioNodeId));
+    }
+    /** Emits an `AudioSourceOffEvent`. */
+
+  }, {
+    key: "emitOff",
+    value: function emitOff() {
+      this.debug('Emitting "AudioSourceOffEvent".');
+      this.onEvent(new _Exports.AudioSourceOffEvent(this.id()));
+    } // Speech SDK quirks: Although "close" is marked as abstract, it is never called in our observations.
+    // ESLint: Speech SDK requires this function, but we are not implementing it.
+    // eslint-disable-next-line class-methods-use-this
+
+  }, {
+    key: "close",
+    value: function close() {
+      this.debug('Callback for "close".');
+      throw new Error('Not implemented');
+    } // Speech SDK quirks: Although "turnOn" is implemented in Speech SDK Push/PullAudioInputStream, it is never called in our observations.
+
+  }, {
+    key: "turnOn",
+    value: function turnOn() {
+      this.debug('Callback for "turnOn".');
+      throw new Error('Not implemented');
+    } // Speech SDK quirks: Although "detach" is implemented in Speech SDK Push/PullAudioInputStream, it is never called in our observations.
+
+  }, {
+    key: "detach",
+    value: function detach() {
+      this.debug('Callback for "detach".');
+      throw new Error('Not implemented');
+    }
+    /** Log the message to console if `debug` is set to `true`. */
+
+  }, {
+    key: "debug",
+    value: function debug(message) {
+      var _console;
+
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      // ESLint: For debugging, will only log when "debug" is set to "true".
+      // eslint-disable-next-line no-console
+      this[SYMBOL_OPTIONS].debug && (_console = console).info.apply(_console, ["CustomAudioInputStream: ".concat(message)].concat(args));
+    }
+    /** Implements this function. When called, it should start recording and return an `IAudioStreamNode`. */
+
+  }, {
+    key: "attach",
+    value:
+    /** Attaches the device by returning an audio node. */
+    function attach(audioNodeId) {
+      var _this2 = this;
+
+      this.debug("Callback for \"attach\" with \"".concat(audioNodeId, "\"."));
+      this.emitNodeAttaching(audioNodeId);
+      return Promise.resolve().then( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+        var _yield$_this2$perform, audioStreamNode, deviceInfo, format;
+
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _this2.emitInitializing();
+
+                _context2.prev = 1;
+                _context2.next = 4;
+                return _this2.performAttach(audioNodeId);
+
+              case 4:
+                _yield$_this2$perform = _context2.sent;
+                audioStreamNode = _yield$_this2$perform.audioStreamNode;
+                deviceInfo = _yield$_this2$perform.deviceInfo;
+                format = _yield$_this2$perform.format;
+
+                // Although only getter of "format" is called before "attach" (in Direct Line Speech),
+                // we are handling both "deviceInfo" and "format" in similar way for uniformity.
+                _this2[SYMBOL_DEVICE_INFO_DEFERRED].resolve(deviceInfo);
+
+                _this2[SYMBOL_FORMAT_DEFERRED].resolve(new _AudioStreamFormat.AudioStreamFormatImpl(format.samplesPerSec, format.bitsPerSample, format.channels));
+
+                _this2.emitReady();
+
+                _this2.emitNodeAttached(audioNodeId);
+
+                return _context2.abrupt("return", {
+                  detach: function () {
+                    var _detach = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+                      return _regenerator.default.wrap(function _callee$(_context) {
+                        while (1) {
+                          switch (_context.prev = _context.next) {
+                            case 0:
+                              _this2.debug("Detaching audio node \"".concat(audioNodeId, "\"."));
+
+                              _context.next = 3;
+                              return audioStreamNode.detach();
+
+                            case 3:
+                              // Speech SDK quirks: Since "turnOff" is not called in Direct Line Speech, we will emit event "source off" here instead.
+                              _this2.emitOff();
+
+                              _this2.emitNodeDetached(audioNodeId);
+
+                            case 5:
+                            case "end":
+                              return _context.stop();
+                          }
+                        }
+                      }, _callee);
+                    }));
+
+                    function detach() {
+                      return _detach.apply(this, arguments);
+                    }
+
+                    return detach;
+                  }(),
+                  id: function id() {
+                    return audioStreamNode.id();
+                  },
+                  read: function read() {
+                    _this2.debug('Reading');
+
+                    return audioStreamNode.read();
+                  }
+                });
+
+              case 15:
+                _context2.prev = 15;
+                _context2.t0 = _context2["catch"](1);
+
+                _this2.emitNodeError(audioNodeId, _context2.t0);
+
+                throw _context2.t0;
+
+              case 19:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, null, [[1, 15]]);
+      })));
+    }
+    /**
+     * Implements this function. When called, it should stop recording. This is called before the `IAudioStreamNode.detach` function.
+     *
+     * Note: when using with Direct Line Speech, this function is never called.
+     */
+    // ESLint: We are not implementing this function because it is not called by Direct Line Speech.
+    // eslint-disable-next-line class-methods-use-this
+
+  }, {
+    key: "performTurnOff",
+    value: function performTurnOff() {
+      // ESLint: "return" is required by TypeScript
+      // eslint-disable-next-line no-useless-return
+      return;
+    }
+    /** Turn off the audio device. This is called before detaching from the graph. */
+    // Speech SDK quirks: It is confused to have both "turnOff" and "detach". "turnOff" is called before "detach".
+    //                    Why don't we put all logics at "detach"?
+    // Speech SDK quirks: Direct Line Speech never call "turnOff". "Source off" event need to be emitted during "detach" instead.
+    //                    Also, custom implementation should be done at "detach" instead, such as ending and closing output streams.
+
+  }, {
+    key: "turnOff",
+    value: function () {
+      var _turnOff = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                this.debug("Callback for \"turnOff\".");
+                _context3.next = 3;
+                return this.performTurnOff();
+
+              case 3:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function turnOff() {
+        return _turnOff.apply(this, arguments);
+      }
+
+      return turnOff;
+    }()
+    /** Gets the device information. */
+    // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+
+  }, {
+    key: "deviceInfo",
+    get: function get() {
+      this.debug("Getting \"deviceInfo\".");
+      return Promise.all([this[SYMBOL_DEVICE_INFO_DEFERRED].promise, this[SYMBOL_FORMAT_DEFERRED].promise]).then(function (_ref2) {
+        var _ref3 = (0, _slicedToArray2.default)(_ref2, 2),
+            _ref3$ = _ref3[0],
+            connectivity = _ref3$.connectivity,
+            manufacturer = _ref3$.manufacturer,
+            model = _ref3$.model,
+            type = _ref3$.type,
+            _ref3$2 = _ref3[1],
+            bitsPerSample = _ref3$2.bitsPerSample,
+            channels = _ref3$2.channels,
+            samplesPerSec = _ref3$2.samplesPerSec;
+
+        return {
+          bitspersample: bitsPerSample,
+          channelcount: channels,
+          connectivity: typeof connectivity === 'string' ? _Exports2.connectivity[connectivity] : connectivity || _Exports2.connectivity.Unknown,
+          manufacturer: manufacturer || '',
+          model: model || '',
+          samplerate: samplesPerSec,
+          type: typeof type === 'string' ? _Exports2.type[type] : type || _Exports2.type.Unknown
+        };
+      });
+    }
+  }]);
+  return CustomAudioInputStream;
+}(_microsoftCognitiveservicesSpeechSdk.AudioInputStream);
+
+var _default = CustomAudioInputStream;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/speech/CustomAudioInputStream.ts"],"names":["SYMBOL_DEVICE_INFO_DEFERRED","Symbol","SYMBOL_EVENTS","SYMBOL_FORMAT_DEFERRED","SYMBOL_OPTIONS","CustomAudioInputStream","options","normalizedOptions","debug","id","replace","EventSource","promise","event","onEvent","Events","instance","AudioSourceInitializingEvent","AudioSourceReadyEvent","error","AudioSourceErrorEvent","message","audioNodeId","AudioStreamNodeAttachingEvent","AudioStreamNodeAttachedEvent","AudioStreamNodeErrorEvent","AudioStreamNodeDetachedEvent","AudioSourceOffEvent","Error","args","console","info","emitNodeAttaching","Promise","resolve","then","emitInitializing","performAttach","audioStreamNode","deviceInfo","format","AudioStreamFormatImpl","samplesPerSec","bitsPerSample","channels","emitReady","emitNodeAttached","detach","emitOff","emitNodeDetached","read","emitNodeError","performTurnOff","all","connectivity","manufacturer","model","type","bitspersample","channelcount","Connectivity","Unknown","samplerate","Type","AudioInputStream"],"mappings":"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","sourceRoot":"bundle:///","sourcesContent":["import { AudioInputStream } from 'microsoft-cognitiveservices-speech-sdk';\n\nimport {\n  AudioSourceErrorEvent,\n  AudioSourceEvent,\n  AudioSourceInitializingEvent,\n  AudioSourceOffEvent,\n  AudioSourceReadyEvent,\n  AudioStreamNodeAttachedEvent,\n  AudioStreamNodeAttachingEvent,\n  AudioStreamNodeDetachedEvent,\n  AudioStreamNodeErrorEvent,\n  Events,\n  EventSource\n} from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common/Exports';\n\nimport { AudioStreamFormatImpl } from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/sdk/Audio/AudioStreamFormat';\n\nimport {\n  connectivity as Connectivity,\n  ISpeechConfigAudioDevice,\n  type as Type\n} from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common.speech/Exports';\n\nimport { v4 } from 'uuid';\nimport createDeferred, { DeferredPromise } from 'p-defer-es5';\n\ntype AudioStreamNode = {\n  detach: () => Promise<void>;\n  id: () => string;\n  read: () => Promise<StreamChunk<ArrayBuffer>>;\n};\n\ntype DeviceInfo = {\n  connectivity?: Connectivity | 'Bluetooth' | 'Wired' | 'WiFi' | 'Cellular' | 'InBuilt' | 'Unknown';\n  manufacturer?: string;\n  model?: string;\n  type?:\n    | Type\n    | 'Phone'\n    | 'Speaker'\n    | 'Car'\n    | 'Headset'\n    | 'Thermostat'\n    | 'Microphones'\n    | 'Deskphone'\n    | 'RemoteControl'\n    | 'Unknown'\n    | 'File'\n    | 'Stream';\n};\n\ntype Format = {\n  bitsPerSample: number;\n  channels: number;\n  samplesPerSec: number;\n};\n\ntype NormalizedOptions = Required<Omit<Options, 'debug'>> & {\n  debug: boolean;\n};\n\ntype Options = {\n  debug?: true;\n  id?: string;\n};\n\ntype StreamChunk<T> = {\n  isEnd: boolean;\n  buffer: T;\n  timeReceived: number;\n};\n\nconst SYMBOL_DEVICE_INFO_DEFERRED = Symbol('deviceInfoDeferred');\nconst SYMBOL_EVENTS = Symbol('events');\nconst SYMBOL_FORMAT_DEFERRED = Symbol('formatDeferred');\nconst SYMBOL_OPTIONS = Symbol('options');\n\n// Speech SDK quirks: Only 2 lifecycle functions are actually used.\n//                    They are: attach() and turnOff().\n//                    Others are not used, including: blob(), close(), detach(), turnOn().\nabstract class CustomAudioInputStream extends AudioInputStream {\n  constructor(options: Options = {}) {\n    super();\n\n    const normalizedOptions: NormalizedOptions = {\n      debug: options.debug || false,\n      id: options.id || v4().replace(/-/gu, '')\n    };\n\n    this[SYMBOL_DEVICE_INFO_DEFERRED] = createDeferred<DeviceInfo>();\n    this[SYMBOL_EVENTS] = new EventSource<AudioSourceEvent>();\n    this[SYMBOL_FORMAT_DEFERRED] = createDeferred<AudioStreamFormatImpl>();\n    this[SYMBOL_OPTIONS] = normalizedOptions;\n  }\n\n  [SYMBOL_DEVICE_INFO_DEFERRED]: DeferredPromise<DeviceInfo>;\n  [SYMBOL_EVENTS]: EventSource<AudioSourceEvent>;\n  [SYMBOL_FORMAT_DEFERRED]: DeferredPromise<AudioStreamFormatImpl>;\n  [SYMBOL_OPTIONS]: NormalizedOptions;\n\n  /** Gets the event source for listening to events. */\n  // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)\n  get events(): EventSource<AudioSourceEvent> {\n    return this[SYMBOL_EVENTS];\n  }\n\n  /** Gets the format of the audio stream. */\n  // Speech SDK quirks: `AudioStreamFormatImpl` is internal implementation while `AudioStreamFormat` is public.\n  //                    It is weird to expose `AudioStreamFormatImpl` instead of `AudioStreamFormat`.\n  // Speech SDK quirks: It is weird to return a `Promise` in a property.\n  // Speech SDK quirks: In normal speech recognition, getter of \"format\" is called only after \"attach\".\n  //                    But in Direct Line Speech, it is called before \"attach\".\n  // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)\n  get format(): Promise<AudioStreamFormatImpl> {\n    this.debug('Getting \"format\".');\n\n    return this[SYMBOL_FORMAT_DEFERRED].promise;\n  }\n\n  /** Gets the ID of this audio stream. */\n  id(): string {\n    return this[SYMBOL_OPTIONS].id;\n  }\n\n  /** Emits an event. */\n  // Speech SDK quirks: In JavaScript, onXxx means \"listen to event XXX\".\n  //                    Instead, in Speech SDK, it means \"emit event XXX\".\n  protected onEvent(event: AudioSourceEvent): void {\n    this[SYMBOL_EVENTS].onEvent(event);\n    Events.instance.onEvent(event);\n  }\n\n  /** Emits an `AudioSourceInitializingEvent`. */\n  protected emitInitializing(): void {\n    this.debug('Emitting \"AudioSourceInitializingEvent\".');\n    this.onEvent(new AudioSourceInitializingEvent(this.id()));\n  }\n\n  /** Emits an `AudioSourceReadyEvent`. */\n  protected emitReady(): void {\n    this.debug('Emitting \"AudioSourceReadyEvent\".');\n    this.onEvent(new AudioSourceReadyEvent(this.id()));\n  }\n\n  /** Emits an `AudioSourceErrorEvent`. */\n  // Speech SDK quirks: Since \"turnOn\" is never called and \"turnOff\" does not work in Direct Line Speech, the \"source error\" event is not emitted at all.\n  //                    Instead, we only emit \"node error\" event.\n  protected emitError(error: Error): void {\n    this.debug('Emitting \"AudioSourceErrorEvent\".', { error });\n\n    // Speech SDK quirks: \"error\" is a string, instead of object of type \"Error\".\n    this.onEvent(new AudioSourceErrorEvent(this.id(), error.message));\n  }\n\n  /** Emits an `AudioStreamNodeAttachingEvent`. */\n  protected emitNodeAttaching(audioNodeId: string): void {\n    this.debug(`Emitting \"AudioStreamNodeAttachingEvent\" for node \"${audioNodeId}\".`);\n    this.onEvent(new AudioStreamNodeAttachingEvent(this.id(), audioNodeId));\n  }\n\n  /** Emits an `AudioStreamNodeAttachedEvent`. */\n  protected emitNodeAttached(audioNodeId: string): void {\n    this.debug(`Emitting \"AudioStreamNodeAttachedEvent\" for node \"${audioNodeId}\".`);\n    this.onEvent(new AudioStreamNodeAttachedEvent(this.id(), audioNodeId));\n  }\n\n  /** Emits an `AudioStreamNodeErrorEvent`. */\n  protected emitNodeError(audioNodeId: string, error: Error): void {\n    this.debug(`Emitting \"AudioStreamNodeErrorEvent\" for node \"${audioNodeId}\".`, { error });\n\n    // Speech SDK quirks: \"error\" is a string, instead of object of type \"Error\".\n    this.onEvent(new AudioStreamNodeErrorEvent(this.id(), audioNodeId, error.message));\n  }\n\n  /** Emits an `AudioStreamNodeDetachedEvent`. */\n  protected emitNodeDetached(audioNodeId: string): void {\n    this.debug('Emitting \"AudioStreamNodeDetachedEvent\".');\n    this.onEvent(new AudioStreamNodeDetachedEvent(this.id(), audioNodeId));\n  }\n\n  /** Emits an `AudioSourceOffEvent`. */\n  protected emitOff(): void {\n    this.debug('Emitting \"AudioSourceOffEvent\".');\n    this.onEvent(new AudioSourceOffEvent(this.id()));\n  }\n\n  // Speech SDK quirks: Although \"close\" is marked as abstract, it is never called in our observations.\n  // ESLint: Speech SDK requires this function, but we are not implementing it.\n  // eslint-disable-next-line class-methods-use-this\n  close(): void {\n    this.debug('Callback for \"close\".');\n\n    throw new Error('Not implemented');\n  }\n\n  // Speech SDK quirks: Although \"turnOn\" is implemented in Speech SDK Push/PullAudioInputStream, it is never called in our observations.\n  turnOn(): void {\n    this.debug('Callback for \"turnOn\".');\n\n    throw new Error('Not implemented');\n  }\n\n  // Speech SDK quirks: Although \"detach\" is implemented in Speech SDK Push/PullAudioInputStream, it is never called in our observations.\n  detach(): void {\n    this.debug('Callback for \"detach\".');\n\n    throw new Error('Not implemented');\n  }\n\n  /** Log the message to console if `debug` is set to `true`. */\n  private debug(message, ...args) {\n    // ESLint: For debugging, will only log when \"debug\" is set to \"true\".\n    // eslint-disable-next-line no-console\n    this[SYMBOL_OPTIONS].debug && console.info(`CustomAudioInputStream: ${message}`, ...args);\n  }\n\n  /** Implements this function. When called, it should start recording and return an `IAudioStreamNode`. */\n  protected abstract performAttach(audioNodeId: string): Promise<{\n    audioStreamNode: AudioStreamNode;\n    deviceInfo: DeviceInfo;\n    format: Format;\n  }>;\n\n  /** Attaches the device by returning an audio node. */\n  attach(audioNodeId: string): Promise<AudioStreamNode> {\n    this.debug(`Callback for \"attach\" with \"${audioNodeId}\".`);\n\n    this.emitNodeAttaching(audioNodeId);\n\n    return Promise.resolve().then<AudioStreamNode>(async () => {\n      this.emitInitializing();\n\n      try {\n        const { audioStreamNode, deviceInfo, format } = await this.performAttach(audioNodeId);\n\n        // Although only getter of \"format\" is called before \"attach\" (in Direct Line Speech),\n        // we are handling both \"deviceInfo\" and \"format\" in similar way for uniformity.\n        this[SYMBOL_DEVICE_INFO_DEFERRED].resolve(deviceInfo);\n        this[SYMBOL_FORMAT_DEFERRED].resolve(\n          new AudioStreamFormatImpl(format.samplesPerSec, format.bitsPerSample, format.channels)\n        );\n\n        this.emitReady();\n        this.emitNodeAttached(audioNodeId);\n\n        return {\n          detach: async () => {\n            this.debug(`Detaching audio node \"${audioNodeId}\".`);\n\n            await audioStreamNode.detach();\n\n            // Speech SDK quirks: Since \"turnOff\" is not called in Direct Line Speech, we will emit event \"source off\" here instead.\n            this.emitOff();\n            this.emitNodeDetached(audioNodeId);\n          },\n          id: () => audioStreamNode.id(),\n          read: () => {\n            this.debug('Reading');\n\n            return audioStreamNode.read();\n          }\n        };\n      } catch (error) {\n        this.emitNodeError(audioNodeId, error);\n\n        throw error;\n      }\n    });\n  }\n\n  /**\n   * Implements this function. When called, it should stop recording. This is called before the `IAudioStreamNode.detach` function.\n   *\n   * Note: when using with Direct Line Speech, this function is never called.\n   */\n\n  // ESLint: We are not implementing this function because it is not called by Direct Line Speech.\n  // eslint-disable-next-line class-methods-use-this\n  protected performTurnOff(): Promise<void> {\n    // ESLint: \"return\" is required by TypeScript\n    // eslint-disable-next-line no-useless-return\n    return;\n  }\n\n  /** Turn off the audio device. This is called before detaching from the graph. */\n  // Speech SDK quirks: It is confused to have both \"turnOff\" and \"detach\". \"turnOff\" is called before \"detach\".\n  //                    Why don't we put all logics at \"detach\"?\n  // Speech SDK quirks: Direct Line Speech never call \"turnOff\". \"Source off\" event need to be emitted during \"detach\" instead.\n  //                    Also, custom implementation should be done at \"detach\" instead, such as ending and closing output streams.\n  async turnOff(): Promise<void> {\n    this.debug(`Callback for \"turnOff\".`);\n\n    await this.performTurnOff();\n  }\n\n  /** Gets the device information. */\n  // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)\n  get deviceInfo(): Promise<ISpeechConfigAudioDevice> {\n    this.debug(`Getting \"deviceInfo\".`);\n\n    return Promise.all([this[SYMBOL_DEVICE_INFO_DEFERRED].promise, this[SYMBOL_FORMAT_DEFERRED].promise]).then(\n      ([{ connectivity, manufacturer, model, type }, { bitsPerSample, channels, samplesPerSec }]) => ({\n        bitspersample: bitsPerSample,\n        channelcount: channels,\n        connectivity:\n          typeof connectivity === 'string' ? Connectivity[connectivity] : connectivity || Connectivity.Unknown,\n        manufacturer: manufacturer || '',\n        model: model || '',\n        samplerate: samplesPerSec,\n        type: typeof type === 'string' ? Type[type] : type || Type.Unknown\n      })\n    );\n  }\n}\n\nexport default CustomAudioInputStream;\n\nexport type { AudioStreamNode, DeviceInfo, Format, Options };\n"]}

package/lib/speech/bytesPerSample.d.ts

@@ -0,0 +1,2 @@
+export default function bytesPerSample(settings: MediaTrackSettings): number;
+//# sourceMappingURL=bytesPerSample.d.ts.map

package/lib/speech/bytesPerSample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytesPerSample.d.ts","sourceRoot":"","sources":["../../src/speech/bytesPerSample.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,QAAQ,EAAE,kBAAkB,UAGlE"}