@storyteller-platform/ghost-story 0.0.1

package/dist/recognition/AmazonTranscribeSTT.cjs

@@ -0,0 +1,188 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AmazonTranscribeSTT_exports = {};
+__export(AmazonTranscribeSTT_exports, {
+  languageCodeDefaultDialects: () => languageCodeDefaultDialects,
+  recognize: () => recognize
+});
+module.exports = __toCommonJS(AmazonTranscribeSTT_exports);
+var import_client_transcribe_streaming = require("@aws-sdk/client-transcribe-streaming");
+var import_audio = require("../audio/index.cjs");
+const wordCharacterRegExp = new RegExp("\\p{L}|\\p{N}", "u");
+async function recognize(input, languageCode, options) {
+  const timing = options.timing;
+  const source = (0, import_audio.isAudioSource)(input) ? input : (0, import_audio.normalizeToAudioSource)(input, options.inputFormat);
+  const resolvedLanguageCode = resolveLanguageCode(languageCode);
+  let audioStream;
+  let runConversion = null;
+  const conversionNeeded = source.format !== "flac" && source.format !== "opus";
+  timing == null ? void 0 : timing.setMetadata("conversionRequired", conversionNeeded);
+  timing == null ? void 0 : timing.setMetadata("targetFormat", conversionNeeded ? "flac" : source.format);
+  if (!conversionNeeded) {
+    audioStream = (0, import_audio.toReadStream)(source);
+  } else {
+    const conversion = (0, import_audio.createStreamingConversion)(source, {
+      targetFormat: "flac",
+      sampleRate: 16e3,
+      channels: 1
+    });
+    audioStream = conversion.stream;
+    runConversion = conversion.start;
+  }
+  const streamingTranscribeSdk = await import("@aws-sdk/client-transcribe-streaming");
+  const client = new streamingTranscribeSdk.TranscribeStreamingClient({
+    region: options.region,
+    credentials: {
+      accessKeyId: options.accessKeyId,
+      secretAccessKey: options.secretAccessKey
+    }
+  });
+  const params = {
+    LanguageCode: resolvedLanguageCode,
+    MediaEncoding: "flac",
+    MediaSampleRateHertz: 16e3,
+    AudioStream: createAsyncIterableFromStream(audioStream)
+  };
+  const command = new streamingTranscribeSdk.StartStreamTranscriptionCommand(
+    params
+  );
+  const [response] = await (timing == null ? void 0 : timing.timeAsync("upload", async () => {
+    var _a;
+    const conversionPromise = runConversion == null ? void 0 : runConversion();
+    const resp = await client.send(command);
+    let transcript2 = "";
+    let events2 = [];
+    if (!resp.TranscriptResultStream) {
+      throw new Error("No transcript result stream");
+    }
+    for await (const event of resp.TranscriptResultStream) {
+      if (!event.TranscriptEvent) continue;
+      const results = (_a = event.TranscriptEvent.Transcript) == null ? void 0 : _a.Results;
+      if (!(results == null ? void 0 : results.length) || !results[0]) continue;
+      const firstResult = results[0];
+      const alternatives = firstResult.Alternatives;
+      if (!(alternatives == null ? void 0 : alternatives.length)) continue;
+      const firstAlternative = alternatives[0];
+      if (firstResult.IsPartial === false && (firstAlternative == null ? void 0 : firstAlternative.Items) && firstAlternative.Transcript) {
+        events2 = [...events2, ...firstAlternative.Items];
+        transcript2 += " " + firstAlternative.Transcript;
+      }
+    }
+    await conversionPromise;
+    return [{ transcript: transcript2, events: events2 }];
+  })) ?? [{ transcript: "", events: [] }];
+  const transcript = response.transcript.replace(/ +/g, " ").trim();
+  const events = response.events;
+  const timeline = [];
+  for (const event of events) {
+    const text = event.Content;
+    if (!text || !wordCharacterRegExp.test(text)) continue;
+    const startTime = event.StartTime ?? 0;
+    const endTime = event.EndTime ?? 0;
+    const confidence = event.Confidence ?? 0;
+    const lastEntry = timeline[timeline.length - 1];
+    if (lastEntry && startTime) {
+      lastEntry.endTime = startTime;
+    }
+    timeline.push({
+      type: "word",
+      text,
+      startTime,
+      endTime,
+      confidence
+    });
+  }
+  return { transcript, timeline };
+}
+async function* createAsyncIterableFromStream(stream) {
+  for await (const chunk of stream) {
+    yield { AudioEvent: { AudioChunk: chunk } };
+  }
+}
+function resolveLanguageCode(languageCode) {
+  if (languageCode in import_client_transcribe_streaming.LanguageCode) {
+    return languageCode;
+  }
+  if (languageCode.length === 2) {
+    const matchingDialect = languageCodeDefaultDialects.find(
+      (value) => value.startsWith(languageCode)
+    );
+    if (matchingDialect) {
+      return matchingDialect;
+    }
+  }
+  throw new Error(
+    `Language code ${languageCode} is not supported by Amazon Transcribe`
+  );
+}
+const languageCodeDefaultDialects = [
+  "af-ZA",
+  "ar-SA",
+  "ca-ES",
+  "cs-CZ",
+  "da-DK",
+  "de-DE",
+  "el-GR",
+  "en-US",
+  "es-ES",
+  "eu-ES",
+  "fa-IR",
+  "fi-FI",
+  "fr-FR",
+  "gl-ES",
+  "he-IL",
+  "hi-IN",
+  "hr-HR",
+  "id-ID",
+  "it-IT",
+  "ja-JP",
+  "ko-KR",
+  "lv-LV",
+  "ms-MY",
+  "nl-NL",
+  "no-NO",
+  "pl-PL",
+  "pt-BR",
+  "ro-RO",
+  "ru-RU",
+  "sk-SK",
+  "so-SO",
+  "sr-RS",
+  "sv-SE",
+  "th-TH",
+  "tl-PH",
+  "uk-UA",
+  "vi-VN",
+  "zh-CN"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  languageCodeDefaultDialects,
+  recognize
+});

package/dist/recognition/AmazonTranscribeSTT.d.cts

@@ -0,0 +1,21 @@
+import { AudioFormat } from '../audio/AudioFormat.cjs';
+import { RawAudioInput, AudioSource } from '../audio/AudioSource.cjs';
+import { Timeline } from '../utilities/Timeline.cjs';
+import { Timing } from '../utilities/Timing.cjs';
+import 'node:fs';
+import 'node:stream';
+
+interface AmazonTranscribeOptions {
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    inputFormat?: AudioFormat | undefined;
+    timing?: Timing | undefined;
+}
+declare function recognize(input: RawAudioInput | AudioSource, languageCode: string, options: AmazonTranscribeOptions): Promise<{
+    transcript: string;
+    timeline: Timeline;
+}>;
+declare const languageCodeDefaultDialects: string[];
+
+export { type AmazonTranscribeOptions, languageCodeDefaultDialects, recognize };

package/dist/recognition/AmazonTranscribeSTT.d.ts

@@ -0,0 +1,21 @@
+import { AudioFormat } from '../audio/AudioFormat.js';
+import { RawAudioInput, AudioSource } from '../audio/AudioSource.js';
+import { Timeline } from '../utilities/Timeline.js';
+import { Timing } from '../utilities/Timing.js';
+import 'node:fs';
+import 'node:stream';
+
+interface AmazonTranscribeOptions {
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    inputFormat?: AudioFormat | undefined;
+    timing?: Timing | undefined;
+}
+declare function recognize(input: RawAudioInput | AudioSource, languageCode: string, options: AmazonTranscribeOptions): Promise<{
+    transcript: string;
+    timeline: Timeline;
+}>;
+declare const languageCodeDefaultDialects: string[];
+
+export { type AmazonTranscribeOptions, languageCodeDefaultDialects, recognize };

package/dist/recognition/AmazonTranscribeSTT.js

@@ -0,0 +1,160 @@
+import {
+  LanguageCode
+} from "@aws-sdk/client-transcribe-streaming";
+import {
+  createStreamingConversion,
+  isAudioSource,
+  normalizeToAudioSource,
+  toReadStream
+} from "../audio/index.js";
+const wordCharacterRegExp = new RegExp("\\p{L}|\\p{N}", "u");
+async function recognize(input, languageCode, options) {
+  const timing = options.timing;
+  const source = isAudioSource(input) ? input : normalizeToAudioSource(input, options.inputFormat);
+  const resolvedLanguageCode = resolveLanguageCode(languageCode);
+  let audioStream;
+  let runConversion = null;
+  const conversionNeeded = source.format !== "flac" && source.format !== "opus";
+  timing == null ? void 0 : timing.setMetadata("conversionRequired", conversionNeeded);
+  timing == null ? void 0 : timing.setMetadata("targetFormat", conversionNeeded ? "flac" : source.format);
+  if (!conversionNeeded) {
+    audioStream = toReadStream(source);
+  } else {
+    const conversion = createStreamingConversion(source, {
+      targetFormat: "flac",
+      sampleRate: 16e3,
+      channels: 1
+    });
+    audioStream = conversion.stream;
+    runConversion = conversion.start;
+  }
+  const streamingTranscribeSdk = await import("@aws-sdk/client-transcribe-streaming");
+  const client = new streamingTranscribeSdk.TranscribeStreamingClient({
+    region: options.region,
+    credentials: {
+      accessKeyId: options.accessKeyId,
+      secretAccessKey: options.secretAccessKey
+    }
+  });
+  const params = {
+    LanguageCode: resolvedLanguageCode,
+    MediaEncoding: "flac",
+    MediaSampleRateHertz: 16e3,
+    AudioStream: createAsyncIterableFromStream(audioStream)
+  };
+  const command = new streamingTranscribeSdk.StartStreamTranscriptionCommand(
+    params
+  );
+  const [response] = await (timing == null ? void 0 : timing.timeAsync("upload", async () => {
+    var _a;
+    const conversionPromise = runConversion == null ? void 0 : runConversion();
+    const resp = await client.send(command);
+    let transcript2 = "";
+    let events2 = [];
+    if (!resp.TranscriptResultStream) {
+      throw new Error("No transcript result stream");
+    }
+    for await (const event of resp.TranscriptResultStream) {
+      if (!event.TranscriptEvent) continue;
+      const results = (_a = event.TranscriptEvent.Transcript) == null ? void 0 : _a.Results;
+      if (!(results == null ? void 0 : results.length) || !results[0]) continue;
+      const firstResult = results[0];
+      const alternatives = firstResult.Alternatives;
+      if (!(alternatives == null ? void 0 : alternatives.length)) continue;
+      const firstAlternative = alternatives[0];
+      if (firstResult.IsPartial === false && (firstAlternative == null ? void 0 : firstAlternative.Items) && firstAlternative.Transcript) {
+        events2 = [...events2, ...firstAlternative.Items];
+        transcript2 += " " + firstAlternative.Transcript;
+      }
+    }
+    await conversionPromise;
+    return [{ transcript: transcript2, events: events2 }];
+  })) ?? [{ transcript: "", events: [] }];
+  const transcript = response.transcript.replace(/ +/g, " ").trim();
+  const events = response.events;
+  const timeline = [];
+  for (const event of events) {
+    const text = event.Content;
+    if (!text || !wordCharacterRegExp.test(text)) continue;
+    const startTime = event.StartTime ?? 0;
+    const endTime = event.EndTime ?? 0;
+    const confidence = event.Confidence ?? 0;
+    const lastEntry = timeline[timeline.length - 1];
+    if (lastEntry && startTime) {
+      lastEntry.endTime = startTime;
+    }
+    timeline.push({
+      type: "word",
+      text,
+      startTime,
+      endTime,
+      confidence
+    });
+  }
+  return { transcript, timeline };
+}
+async function* createAsyncIterableFromStream(stream) {
+  for await (const chunk of stream) {
+    yield { AudioEvent: { AudioChunk: chunk } };
+  }
+}
+function resolveLanguageCode(languageCode) {
+  if (languageCode in LanguageCode) {
+    return languageCode;
+  }
+  if (languageCode.length === 2) {
+    const matchingDialect = languageCodeDefaultDialects.find(
+      (value) => value.startsWith(languageCode)
+    );
+    if (matchingDialect) {
+      return matchingDialect;
+    }
+  }
+  throw new Error(
+    `Language code ${languageCode} is not supported by Amazon Transcribe`
+  );
+}
+const languageCodeDefaultDialects = [
+  "af-ZA",
+  "ar-SA",
+  "ca-ES",
+  "cs-CZ",
+  "da-DK",
+  "de-DE",
+  "el-GR",
+  "en-US",
+  "es-ES",
+  "eu-ES",
+  "fa-IR",
+  "fi-FI",
+  "fr-FR",
+  "gl-ES",
+  "he-IL",
+  "hi-IN",
+  "hr-HR",
+  "id-ID",
+  "it-IT",
+  "ja-JP",
+  "ko-KR",
+  "lv-LV",
+  "ms-MY",
+  "nl-NL",
+  "no-NO",
+  "pl-PL",
+  "pt-BR",
+  "ro-RO",
+  "ru-RU",
+  "sk-SK",
+  "so-SO",
+  "sr-RS",
+  "sv-SE",
+  "th-TH",
+  "tl-PH",
+  "uk-UA",
+  "vi-VN",
+  "zh-CN"
+];
+export {
+  languageCodeDefaultDialects,
+  recognize
+};

package/dist/recognition/AzureCognitiveServicesSTT.cjs

@@ -0,0 +1,124 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AzureCognitiveServicesSTT_exports = {};
+__export(AzureCognitiveServicesSTT_exports, {
+  recognize: () => recognize
+});
+module.exports = __toCommonJS(AzureCognitiveServicesSTT_exports);
+var SpeechSDK = __toESM(require("microsoft-cognitiveservices-speech-sdk"), 1);
+var import_audio = require("../audio/index.cjs");
+async function recognize(input, options, languageCode) {
+  const timing = options.timing;
+  const source = (0, import_audio.isAudioSource)(input) ? input : (0, import_audio.normalizeToAudioSource)(input, options.inputFormat);
+  const conversionNeeded = source.format !== "wav";
+  timing == null ? void 0 : timing.setMetadata("conversionRequired", conversionNeeded);
+  timing == null ? void 0 : timing.setMetadata("targetFormat", "wav");
+  const doPrepare = () => (0, import_audio.prepareWavForService)(source, { sampleRate: 16e3, channels: 1 });
+  const prepared = timing ? await timing.timeAsync("conversion", doPrepare) : await doPrepare();
+  try {
+    const doRecognition = () => runRecognition(
+      prepared.source,
+      options.subscriptionKey,
+      options.serviceRegion,
+      languageCode,
+      options.profanity ?? SpeechSDK.ProfanityOption.Raw
+    );
+    const result = timing ? await timing.timeAsync("upload", doRecognition) : await doRecognition();
+    const transcript = result.text;
+    const resultObject = JSON.parse(result.json);
+    const bestResult = resultObject.NBest[0];
+    const timeline = [];
+    for (const wordEntry of (bestResult == null ? void 0 : bestResult.Words) ?? []) {
+      const text = wordEntry.Word;
+      const startTime = wordEntry.Offset / 1e7;
+      const endTime = (wordEntry.Offset + wordEntry.Duration) / 1e7;
+      timeline.push({ type: "word", text, startTime, endTime });
+    }
+    return { transcript, timeline };
+  } finally {
+    await prepared.cleanup();
+  }
+}
+async function runRecognition(source, subscriptionKey, serviceRegion, languageCode, profanity) {
+  const audioFormat = SpeechSDK.AudioStreamFormat.getWaveFormat(
+    16e3,
+    16,
+    1,
+    SpeechSDK.AudioFormatTag.PCM
+  );
+  const pushStream = SpeechSDK.AudioInputStream.createPushStream(audioFormat);
+  const readable = (0, import_audio.toReadStream)(source);
+  const streamPromise = new Promise((resolve, reject) => {
+    readable.on("data", (chunk) => {
+      const arrayBuffer = new ArrayBuffer(chunk.length);
+      const view = new Uint8Array(arrayBuffer);
+      chunk.copy(view);
+      pushStream.write(arrayBuffer);
+    }).on("end", () => {
+      pushStream.close();
+      resolve();
+    }).on("error", (err) => {
+      pushStream.close();
+      reject(err);
+    });
+  });
+  const recognitionPromise = new Promise(
+    (resolve, reject) => {
+      const audioConfig = SpeechSDK.AudioConfig.fromStreamInput(pushStream);
+      const speechConfig = SpeechSDK.SpeechConfig.fromSubscription(
+        subscriptionKey,
+        serviceRegion
+      );
+      speechConfig.speechRecognitionLanguage = languageCode;
+      speechConfig.setProfanity(profanity);
+      speechConfig.requestWordLevelTimestamps();
+      speechConfig.outputFormat = SpeechSDK.OutputFormat.Detailed;
+      const recognizer = new SpeechSDK.SpeechRecognizer(
+        speechConfig,
+        audioConfig
+      );
+      recognizer.recognizeOnceAsync(
+        (result) => {
+          recognizer.close();
+          resolve(result);
+        },
+        (error) => {
+          recognizer.close();
+          reject(new Error(error));
+        }
+      );
+    }
+  );
+  await streamPromise;
+  return recognitionPromise;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  recognize
+});

package/dist/recognition/AzureCognitiveServicesSTT.d.cts

@@ -0,0 +1,21 @@
+import * as SpeechSDK from 'microsoft-cognitiveservices-speech-sdk';
+import { AudioFormat } from '../audio/AudioFormat.cjs';
+import { RawAudioInput, AudioSource } from '../audio/AudioSource.cjs';
+import { Timeline } from '../utilities/Timeline.cjs';
+import { Timing } from '../utilities/Timing.cjs';
+import 'node:fs';
+import 'node:stream';
+
+interface AzureSTTOptions {
+    subscriptionKey: string;
+    serviceRegion: string;
+    profanity?: SpeechSDK.ProfanityOption | undefined;
+    inputFormat?: AudioFormat | undefined;
+    timing?: Timing | undefined;
+}
+declare function recognize(input: RawAudioInput | AudioSource, options: AzureSTTOptions, languageCode: string): Promise<{
+    transcript: string;
+    timeline: Timeline;
+}>;
+
+export { type AzureSTTOptions, recognize };

package/dist/recognition/AzureCognitiveServicesSTT.d.ts

@@ -0,0 +1,21 @@
+import * as SpeechSDK from 'microsoft-cognitiveservices-speech-sdk';
+import { AudioFormat } from '../audio/AudioFormat.js';
+import { RawAudioInput, AudioSource } from '../audio/AudioSource.js';
+import { Timeline } from '../utilities/Timeline.js';
+import { Timing } from '../utilities/Timing.js';
+import 'node:fs';
+import 'node:stream';
+
+interface AzureSTTOptions {
+    subscriptionKey: string;
+    serviceRegion: string;
+    profanity?: SpeechSDK.ProfanityOption | undefined;
+    inputFormat?: AudioFormat | undefined;
+    timing?: Timing | undefined;
+}
+declare function recognize(input: RawAudioInput | AudioSource, options: AzureSTTOptions, languageCode: string): Promise<{
+    transcript: string;
+    timeline: Timeline;
+}>;
+
+export { type AzureSTTOptions, recognize };

package/dist/recognition/AzureCognitiveServicesSTT.js

@@ -0,0 +1,95 @@
+import * as SpeechSDK from "microsoft-cognitiveservices-speech-sdk";
+import {
+  isAudioSource,
+  normalizeToAudioSource,
+  prepareWavForService,
+  toReadStream
+} from "../audio/index.js";
+async function recognize(input, options, languageCode) {
+  const timing = options.timing;
+  const source = isAudioSource(input) ? input : normalizeToAudioSource(input, options.inputFormat);
+  const conversionNeeded = source.format !== "wav";
+  timing == null ? void 0 : timing.setMetadata("conversionRequired", conversionNeeded);
+  timing == null ? void 0 : timing.setMetadata("targetFormat", "wav");
+  const doPrepare = () => prepareWavForService(source, { sampleRate: 16e3, channels: 1 });
+  const prepared = timing ? await timing.timeAsync("conversion", doPrepare) : await doPrepare();
+  try {
+    const doRecognition = () => runRecognition(
+      prepared.source,
+      options.subscriptionKey,
+      options.serviceRegion,
+      languageCode,
+      options.profanity ?? SpeechSDK.ProfanityOption.Raw
+    );
+    const result = timing ? await timing.timeAsync("upload", doRecognition) : await doRecognition();
+    const transcript = result.text;
+    const resultObject = JSON.parse(result.json);
+    const bestResult = resultObject.NBest[0];
+    const timeline = [];
+    for (const wordEntry of (bestResult == null ? void 0 : bestResult.Words) ?? []) {
+      const text = wordEntry.Word;
+      const startTime = wordEntry.Offset / 1e7;
+      const endTime = (wordEntry.Offset + wordEntry.Duration) / 1e7;
+      timeline.push({ type: "word", text, startTime, endTime });
+    }
+    return { transcript, timeline };
+  } finally {
+    await prepared.cleanup();
+  }
+}
+async function runRecognition(source, subscriptionKey, serviceRegion, languageCode, profanity) {
+  const audioFormat = SpeechSDK.AudioStreamFormat.getWaveFormat(
+    16e3,
+    16,
+    1,
+    SpeechSDK.AudioFormatTag.PCM
+  );
+  const pushStream = SpeechSDK.AudioInputStream.createPushStream(audioFormat);
+  const readable = toReadStream(source);
+  const streamPromise = new Promise((resolve, reject) => {
+    readable.on("data", (chunk) => {
+      const arrayBuffer = new ArrayBuffer(chunk.length);
+      const view = new Uint8Array(arrayBuffer);
+      chunk.copy(view);
+      pushStream.write(arrayBuffer);
+    }).on("end", () => {
+      pushStream.close();
+      resolve();
+    }).on("error", (err) => {
+      pushStream.close();
+      reject(err);
+    });
+  });
+  const recognitionPromise = new Promise(
+    (resolve, reject) => {
+      const audioConfig = SpeechSDK.AudioConfig.fromStreamInput(pushStream);
+      const speechConfig = SpeechSDK.SpeechConfig.fromSubscription(
+        subscriptionKey,
+        serviceRegion
+      );
+      speechConfig.speechRecognitionLanguage = languageCode;
+      speechConfig.setProfanity(profanity);
+      speechConfig.requestWordLevelTimestamps();
+      speechConfig.outputFormat = SpeechSDK.OutputFormat.Detailed;
+      const recognizer = new SpeechSDK.SpeechRecognizer(
+        speechConfig,
+        audioConfig
+      );
+      recognizer.recognizeOnceAsync(
+        (result) => {
+          recognizer.close();
+          resolve(result);
+        },
+        (error) => {
+          recognizer.close();
+          reject(new Error(error));
+        }
+      );
+    }
+  );
+  await streamPromise;
+  return recognitionPromise;
+}
+export {
+  recognize
+};