botframework-webchat 4.13.0 → 4.15.0

package/src/renderMarkdown.ts

@@ -0,0 +1,140 @@
+/* eslint no-magic-numbers: ["error", { "ignore": [0, 1, 2] }] */
+
+import iterator from 'markdown-it-for-inline';
+import MarkdownIt from 'markdown-it';
+import markdownItAttrs from 'markdown-it-attrs-es5';
+import sanitizeHTML from 'sanitize-html';
+
+const SANITIZE_HTML_OPTIONS = {
+  allowedAttributes: {
+    a: ['aria-label', 'href', 'name', 'rel', 'target', 'title'],
+    img: ['alt', 'class', 'src']
+  },
+  allowedSchemes: ['data', 'http', 'https', 'ftp', 'mailto', 'sip', 'tel'],
+  allowedTags: [
+    'a',
+    'b',
+    'blockquote',
+    'br',
+    'caption',
+    'code',
+    'del',
+    'div',
+    'em',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'hr',
+    'i',
+    'img',
+    'ins',
+    'li',
+    'nl',
+    'ol',
+    'p',
+    'pre',
+    's',
+    'span',
+    'strike',
+    'strong',
+    'table',
+    'tbody',
+    'td',
+    'tfoot',
+    'th',
+    'thead',
+    'tr',
+    'ul'
+  ]
+};
+
+// Put a transparent pixel instead of the "open in new window" icon, so developers can easily modify the icon in CSS.
+const TRANSPARENT_GIF = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
+
+// This is used for parsing Markdown for external links.
+const internalMarkdownIt = new MarkdownIt();
+
+const MARKDOWN_ATTRS_LEFT_DELIMITER = '⟬';
+// Make sure the delimiter is free from any RegExp characters, such as *, ?, etc.
+// IE11 does not support "u" flag and Babel could not remove it. We intentionally omitting the "u" flag here.
+// eslint-disable-next-line security/detect-non-literal-regexp, require-unicode-regexp
+const MARKDOWN_ATTRS_LEFT_DELIMITER_PATTERN = new RegExp(MARKDOWN_ATTRS_LEFT_DELIMITER, 'g');
+
+const MARKDOWN_ATTRS_RIGHT_DELIMITER = '⟭';
+// Make sure the delimiter is free from any RegExp characters, such as *, ?, etc.
+// IE11 does not support "u" flag and Babel could not remove it. We intentionally omitting the "u" flag here.
+// eslint-disable-next-line security/detect-non-literal-regexp, require-unicode-regexp
+const MARKDOWN_ATTRS_RIGHT_DELIMITER_PATTERN = new RegExp(MARKDOWN_ATTRS_RIGHT_DELIMITER, 'g');
+
+export default function render(
+  markdown: string,
+  { markdownRespectCRLF }: { markdownRespectCRLF: boolean },
+  { externalLinkAlt = '' }: { externalLinkAlt?: string } = {}
+): string {
+  if (markdownRespectCRLF) {
+    markdown = markdown.replace(/\n\r|\r\n/gu, carriageReturn => (carriageReturn === '\n\r' ? '\r\n' : '\n\r'));
+  }
+
+  // Related to #3165.
+  // We only support attributes "aria-label" and should leave other attributes as-is.
+  // However, `markdown-it-attrs` remove unrecognized attributes, such as {hello}.
+  // Before passing to `markdown-it-attrs`, we will convert known attributes from {aria-label="..."} into ⟬aria-label="..."⟭ (using white tortoise shell brackets).
+  // Then, we ask `markdown-it-attrs` to only process the new brackets, so it should only try to process things that we allowlisted.
+  // Lastly, we revert tortoise shell brackets back to curly brackets, for unprocessed attributes.
+  markdown = markdown
+    .replace(/\{\s*aria-label()\s*\}/giu, `${MARKDOWN_ATTRS_LEFT_DELIMITER}aria-label${MARKDOWN_ATTRS_RIGHT_DELIMITER}`)
+    .replace(
+      /\{\s*aria-label=("[^"]*"|[^\s}]*)\s*\}/giu,
+      (_, valueInsideQuotes) =>
+        `${MARKDOWN_ATTRS_LEFT_DELIMITER}aria-label=${valueInsideQuotes}${MARKDOWN_ATTRS_RIGHT_DELIMITER}`
+    );
+
+  let html = new MarkdownIt({
+    breaks: false,
+    html: false,
+    linkify: true,
+    typographer: true,
+    xhtmlOut: true
+  })
+    .use(markdownItAttrs, {
+      // `markdown-it-attrs` is added for accessibility and allow bot developers to specify `aria-label`.
+      // We are allowlisting `aria-label` only as it is allowlisted in `sanitize-html`.
+      // Other `aria-*` will be sanitized even we allowlisted here.
+      allowedAttributes: ['aria-label'],
+      leftDelimiter: MARKDOWN_ATTRS_LEFT_DELIMITER,
+      rightDelimiter: MARKDOWN_ATTRS_RIGHT_DELIMITER
+    })
+    .use(iterator, 'url_new_win', 'link_open', (tokens, index) => {
+      const token = tokens[+index];
+
+      token.attrSet('rel', 'noopener noreferrer');
+      token.attrSet('target', '_blank');
+
+      const linkOpenToken = tokens.find(({ type }) => type === 'link_open');
+      const [, href] = linkOpenToken.attrs.find(([name]) => name === 'href');
+
+      // Adds a new icon if the link is http: or https:.
+      // Don't add if it's a phone number, etc.
+      if (/^https?:/iu.test(href)) {
+        externalLinkAlt && token.attrSet('title', externalLinkAlt);
+
+        const iconTokens = internalMarkdownIt.parseInline(`![${externalLinkAlt}](${TRANSPARENT_GIF})`)[0].children;
+
+        iconTokens[0].attrJoin('class', 'webchat__markdown__external-link-icon');
+
+        tokens.splice(index + 2, 0, ...iconTokens);
+      }
+    })
+    .render(markdown);
+
+  // Restore attributes not processed by `markdown-it-attrs`.
+  // TODO: [P2] #2511 After we fixed our polyfill story, we should use "String.prototype.replaceAll" instead of RegExp for replace all occurrences.
+  html = html.replace(MARKDOWN_ATTRS_LEFT_DELIMITER_PATTERN, '{').replace(MARKDOWN_ATTRS_RIGHT_DELIMITER_PATTERN, '}');
+
+  // The signature from "sanitize-html" module is not correct.
+  // @ts-ignore
+  return sanitizeHTML(html, SANITIZE_HTML_OPTIONS);
+}

package/src/renderWebChat.tsx

@@ -0,0 +1,6 @@
+import React, { ComponentType } from 'react';
+import ReactDOM from 'react-dom';
+
+export default function renderWebChat(ReactWebChat: ComponentType<any>, props: any, element: HTMLElement): void {
+  ReactDOM.render(<ReactWebChat {...props} />, element);
+}

package/src/speech/CustomAudioInputStream.ts

@@ -0,0 +1,356 @@
+import { AudioInputStream } from 'microsoft-cognitiveservices-speech-sdk';
+
+import {
+  AudioSourceErrorEvent,
+  AudioSourceEvent,
+  AudioSourceInitializingEvent,
+  AudioSourceOffEvent,
+  AudioSourceReadyEvent,
+  AudioStreamNodeAttachedEvent,
+  AudioStreamNodeAttachingEvent,
+  AudioStreamNodeDetachedEvent,
+  AudioStreamNodeErrorEvent,
+  Events,
+  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 { isForbiddenPropertyName } from 'botframework-webchat-core';
+import { v4 } from 'uuid';
+import createDeferred, { DeferredPromise } from 'p-defer-es5';
+
+type AudioStreamNode = {
+  detach: () => Promise<void>;
+  id: () => string;
+  read: () => Promise<StreamChunk<ArrayBuffer>>;
+};
+
+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';
+};
+
+type Format = {
+  bitsPerSample: number;
+  channels: number;
+  samplesPerSec: number;
+};
+
+type NormalizedOptions = Required<Omit<Options, 'debug'>> & {
+  debug: boolean;
+};
+
+type Options = {
+  debug?: true;
+  id?: string;
+};
+
+type StreamChunk<T> = {
+  isEnd: boolean;
+  buffer: T;
+  timeReceived: number;
+};
+
+const SYMBOL_DEVICE_INFO_DEFERRED = Symbol('deviceInfoDeferred');
+const SYMBOL_EVENTS = Symbol('events');
+const SYMBOL_FORMAT_DEFERRED = Symbol('formatDeferred');
+const 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().
+abstract class CustomAudioInputStream extends AudioInputStream {
+  constructor(options: Options = {}) {
+    super();
+
+    const normalizedOptions: NormalizedOptions = {
+      debug: options.debug || false,
+      id: options.id || v4().replace(/-/gu, '')
+    };
+
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    this[SYMBOL_DEVICE_INFO_DEFERRED] = createDeferred<DeviceInfo>();
+
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    this[SYMBOL_EVENTS] = new EventSource<AudioSourceEvent>();
+
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    this[SYMBOL_FORMAT_DEFERRED] = createDeferred<AudioStreamFormatImpl>();
+
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    this[SYMBOL_OPTIONS] = normalizedOptions;
+  }
+
+  [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. */
+  // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.
+  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+  get events(): EventSource<AudioSourceEvent> {
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    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.
+  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+  get format(): Promise<AudioStreamFormatImpl> {
+    this.debug('Getting "format".');
+
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    return this[SYMBOL_FORMAT_DEFERRED].promise;
+  }
+
+  /** Gets the ID of this audio stream. */
+  id(): string {
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    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".
+  protected onEvent(event: AudioSourceEvent): void {
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    this[SYMBOL_EVENTS].onEvent(event);
+    Events.instance.onEvent(event);
+  }
+
+  /** Emits an `AudioSourceInitializingEvent`. */
+  protected emitInitializing(): void {
+    this.debug('Emitting "AudioSourceInitializingEvent".');
+    this.onEvent(new AudioSourceInitializingEvent(this.id()));
+  }
+
+  /** Emits an `AudioSourceReadyEvent`. */
+  protected emitReady(): void {
+    this.debug('Emitting "AudioSourceReadyEvent".');
+    this.onEvent(new 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.
+  protected emitError(error: Error): void {
+    this.debug('Emitting "AudioSourceErrorEvent".', { error });
+
+    // Speech SDK quirks: "error" is a string, instead of object of type "Error".
+    this.onEvent(new AudioSourceErrorEvent(this.id(), error.message));
+  }
+
+  /** Emits an `AudioStreamNodeAttachingEvent`. */
+  protected emitNodeAttaching(audioNodeId: string): void {
+    this.debug(`Emitting "AudioStreamNodeAttachingEvent" for node "${audioNodeId}".`);
+    this.onEvent(new AudioStreamNodeAttachingEvent(this.id(), audioNodeId));
+  }
+
+  /** Emits an `AudioStreamNodeAttachedEvent`. */
+  protected emitNodeAttached(audioNodeId: string): void {
+    this.debug(`Emitting "AudioStreamNodeAttachedEvent" for node "${audioNodeId}".`);
+    this.onEvent(new AudioStreamNodeAttachedEvent(this.id(), audioNodeId));
+  }
+
+  /** Emits an `AudioStreamNodeErrorEvent`. */
+  protected emitNodeError(audioNodeId: string, error: Error): void {
+    this.debug(`Emitting "AudioStreamNodeErrorEvent" for node "${audioNodeId}".`, { error });
+
+    // Speech SDK quirks: "error" is a string, instead of object of type "Error".
+    this.onEvent(new AudioStreamNodeErrorEvent(this.id(), audioNodeId, error.message));
+  }
+
+  /** Emits an `AudioStreamNodeDetachedEvent`. */
+  protected emitNodeDetached(audioNodeId: string): void {
+    this.debug('Emitting "AudioStreamNodeDetachedEvent".');
+    this.onEvent(new AudioStreamNodeDetachedEvent(this.id(), audioNodeId));
+  }
+
+  /** Emits an `AudioSourceOffEvent`. */
+  protected emitOff(): void {
+    this.debug('Emitting "AudioSourceOffEvent".');
+    this.onEvent(new 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.
+  close(): void {
+    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.
+  turnOn(): void {
+    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.
+  detach(): void {
+    this.debug('Callback for "detach".');
+
+    throw new Error('Not implemented');
+  }
+
+  /** Log the message to console if `debug` is set to `true`. */
+  private debug(message, ...args) {
+    // ESLint: For debugging, will only log when "debug" is set to "true".
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line no-console, security/detect-object-injection
+    this[SYMBOL_OPTIONS].debug && console.info(`CustomAudioInputStream: ${message}`, ...args);
+  }
+
+  /** 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> {
+    this.debug(`Callback for "attach" with "${audioNodeId}".`);
+
+    this.emitNodeAttaching(audioNodeId);
+
+    return Promise.resolve().then<AudioStreamNode>(async () => {
+      this.emitInitializing();
+
+      try {
+        const { audioStreamNode, deviceInfo, format } = await this.performAttach(audioNodeId);
+
+        // 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.
+
+        // False alarm: indexer is a constant of type Symbol.
+        // eslint-disable-next-line security/detect-object-injection
+        this[SYMBOL_DEVICE_INFO_DEFERRED].resolve(deviceInfo);
+
+        // False alarm: indexer is a constant of type Symbol.
+        // eslint-disable-next-line security/detect-object-injection
+        this[SYMBOL_FORMAT_DEFERRED].resolve(
+          new AudioStreamFormatImpl(format.samplesPerSec, format.bitsPerSample, format.channels)
+        );
+
+        this.emitReady();
+        this.emitNodeAttached(audioNodeId);
+
+        return {
+          detach: async () => {
+            this.debug(`Detaching audio node "${audioNodeId}".`);
+
+            await audioStreamNode.detach();
+
+            // Speech SDK quirks: Since "turnOff" is not called in Direct Line Speech, we will emit event "source off" here instead.
+            this.emitOff();
+            this.emitNodeDetached(audioNodeId);
+          },
+          id: () => audioStreamNode.id(),
+          read: () => {
+            this.debug('Reading');
+
+            return audioStreamNode.read();
+          }
+        };
+      } catch (error) {
+        this.emitNodeError(audioNodeId, error);
+
+        throw error;
+      }
+    });
+  }
+
+  /**
+   * 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
+  protected performTurnOff(): Promise<void> {
+    // 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.
+  async turnOff(): Promise<void> {
+    this.debug(`Callback for "turnOff".`);
+
+    await this.performTurnOff();
+  }
+
+  /** Gets the device information. */
+  // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.
+  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+  get deviceInfo(): Promise<ISpeechConfigAudioDevice> {
+    this.debug(`Getting "deviceInfo".`);
+
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    return Promise.all([this[SYMBOL_DEVICE_INFO_DEFERRED].promise, this[SYMBOL_FORMAT_DEFERRED].promise]).then(
+      ([{ connectivity, manufacturer, model, type }, { bitsPerSample, channels, samplesPerSec }]) => ({
+        bitspersample: bitsPerSample,
+        channelcount: channels,
+        connectivity:
+          typeof connectivity === 'string' && !isForbiddenPropertyName(connectivity)
+            ? // Mitigated through denylisting.
+              // eslint-disable-next-line security/detect-object-injection
+              Connectivity[connectivity]
+            : connectivity || Connectivity.Unknown,
+        manufacturer: manufacturer || '',
+        model: model || '',
+        samplerate: samplesPerSec,
+        // Mitigated through denylisting.
+        // eslint-disable-next-line security/detect-object-injection
+        type: typeof type === 'string' && !isForbiddenPropertyName(type) ? Type[type] : type || Type.Unknown
+      })
+    );
+  }
+}
+
+export default CustomAudioInputStream;
+
+export type { AudioStreamNode, DeviceInfo, Format, Options };

package/src/speech/bytesPerSample.ts

@@ -0,0 +1,4 @@
+export default function bytesPerSample(settings: MediaTrackSettings) {
+  // eslint-disable-next-line no-magic-numbers
+  return ((settings.sampleSize as number) >> 3) * (settings.channelCount as number) * (settings.sampleRate as number);
+}

package/src/speech/createAudioConfig.spec.js

@@ -0,0 +1,23 @@
+/* eslint no-empty-function: "off" */
+
+import createAudioConfig from './createAudioConfig';
+
+describe('Verify arguments', () => {
+  test('should not throw if only "attach" is supplied', () => {
+    expect(() => createAudioConfig({ attach: () => {} })).not.toThrow();
+  });
+
+  test('should not throw if both "attach" and "turnOff" are supplied', () => {
+    expect(() => createAudioConfig({ attach: () => {}, turnOff: () => {} })).not.toThrow();
+  });
+
+  test('should throw if "attach" is not supplied', () => {
+    expect(() => createAudioConfig({})).toThrow('"attach" must be a function.');
+  });
+
+  test('should throw if "turnOff" is not a function', () => {
+    expect(() => createAudioConfig({ attach: () => {}, turnOff: '123' })).toThrow(
+      '"turnOff", if defined, must be a function.'
+    );
+  });
+});

package/src/speech/createAudioConfig.ts

@@ -0,0 +1,77 @@
+// TODO: [P2] #3976 We should export this to allow web developers to bring in their own microphone.
+//       For example, it should enable React Native devs to bring in their microphone implementation and use Cognitive Services Speech Services.
+
+import { AudioConfig } from 'microsoft-cognitiveservices-speech-sdk';
+
+import CustomAudioInputStream, { AudioStreamNode, DeviceInfo, Format } from './CustomAudioInputStream';
+
+type AttachFunction = (audioNodeId: string) => Promise<{
+  audioStreamNode: AudioStreamNode;
+  deviceInfo: DeviceInfo;
+  format: Format;
+}>;
+
+type TurnOffFunction = () => Promise<void>;
+
+const SYMBOL_ATTACH = Symbol('attach');
+const SYMBOL_TURN_OFF = Symbol('turnOff');
+
+type CreateAudioConfigOptions = {
+  /** Callback function for attaching the device by returning an audio node. */
+  attach: AttachFunction;
+
+  /** `true` to enable diagnostic information, otherwise, `false`. */
+  debug?: true;
+
+  /**
+   * Callback function for turning off the device before detaching its node from an audio graph.
+   *
+   * Note: this is not called for Direct Line Speech.
+   */
+  turnOff?: TurnOffFunction;
+};
+
+class CreateAudioConfigAudioInputStream extends CustomAudioInputStream {
+  constructor({ attach, debug, turnOff }: CreateAudioConfigOptions) {
+    if (!attach || typeof attach !== 'function') {
+      throw new Error('"attach" must be a function.');
+    }
+
+    if (turnOff && typeof turnOff !== 'function') {
+      throw new Error('"turnOff", if defined, must be a function.');
+    }
+
+    super({ debug });
+
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    this[SYMBOL_ATTACH] = attach;
+
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    this[SYMBOL_TURN_OFF] = turnOff;
+  }
+
+  [SYMBOL_ATTACH]: AttachFunction;
+  [SYMBOL_TURN_OFF]: TurnOffFunction;
+
+  protected performAttach(audioNodeId: string): Promise<{
+    audioStreamNode: AudioStreamNode;
+    deviceInfo: DeviceInfo;
+    format: Format;
+  }> {
+    // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+    return this[SYMBOL_ATTACH](audioNodeId);
+  }
+
+  protected performTurnOff(): Promise<void> {
+    const { [SYMBOL_TURN_OFF]: turnOff } = this;
+
+    return turnOff && turnOff();
+  }
+}
+
+export default function createAudioConfig(options: CreateAudioConfigOptions) {
+  return AudioConfig.fromStreamInput(new CreateAudioConfigAudioInputStream(options));
+}

package/src/speech/createAudioContext.ts

@@ -0,0 +1,16 @@
+/** Creates an AudioContext object. */
+export default function createAudioContext(): AudioContext {
+  if (typeof window.AudioContext !== 'undefined') {
+    return new window.AudioContext();
+
+    // Required by TypeScript.
+    // eslint-disable-next-line dot-notation
+  } else if (typeof window['webkitAudioContext'] !== 'undefined') {
+    // This is for Safari as Web Audio API is still under vendor-prefixed.
+    // eslint-disable-next-line dot-notation
+    return new window['webkitAudioContext']();
+  }
+
+  // TODO: Fix this.
+  throw new Error('This browser does not support Web Audio API.');
+}