speechstate 2.0.0-beta.9 → 2.0.1

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "speechstate",
-  "version": "2.0.0-beta.9",
+  "version": "2.0.1",
   "license": "GPL-3.0",
   "homepage": "http://localhost/speechstate",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["/dist"],
+  "files": [
+    "/dist"
+  ],
   "dependencies": {
     "@statelyai/inspect": "^0.2.3",
     "microsoft-cognitiveservices-speech-sdk": "^1.31.0",
@@ -18,10 +20,17 @@
     "test": "jest --silent=false"
   },
   "eslintConfig": {
-    "extends": ["react-app", "react-app/jest"]
+    "extends": [
+      "react-app",
+      "react-app/jest"
+    ]
   },
   "browserslist": {
-    "production": [">0.2%", "not dead", "not op_mini all"],
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
     "development": [
       "last 1 chrome version",
       "last 1 firefox version",

package/README.plantuml

@@ -1,3 +0,0 @@
-@startuml
-Bob -> Alice : Hello World!
-@enduml

package/dist/asr.d.ts

@@ -1,117 +0,0 @@
-/// <reference types="webspeechapi" />
-import { RecogniseParameters, Hypothesis, AzureSpeechCredentials, AzureLanguageCredentials } from "./types";
-interface MySpeechRecognition extends SpeechRecognition {
-    new (): any;
-}
-interface MySpeechGrammarList extends SpeechGrammarList {
-    new (): any;
-}
-type ASREvent = {
-    type: "READY";
-    value: {
-        wsaASR: MySpeechRecognition;
-        wsaGrammarList: MySpeechGrammarList;
-    };
-} | {
-    type: "ERROR";
-} | {
-    type: "NOINPUT";
-} | {
-    type: "CONTROL";
-} | {
-    type: "START";
-    value?: RecogniseParameters;
-} | {
-    type: "STARTED";
-    value: {
-        wsaASRinstance: MySpeechRecognition;
-    };
-} | {
-    type: "STARTSPEECH";
-} | {
-    type: "RECOGNISED";
-} | {
-    type: "RESULT";
-    value: Hypothesis[];
-};
-interface ASRContext extends ASRInit {
-    azureAuthorizationToken?: string;
-    wsaASR?: MySpeechRecognition;
-    wsaASRinstance?: MySpeechRecognition;
-    wsaGrammarList?: MySpeechGrammarList;
-    result?: Hypothesis[];
-    nluResult?: any;
-    params?: RecogniseParameters;
-}
-interface ASRInit {
-    asrDefaultCompleteTimeout: number;
-    asrDefaultNoInputTimeout: number;
-    locale: string;
-    audioContext: AudioContext;
-    azureCredentials: string | AzureSpeechCredentials;
-    speechRecognitionEndpointId?: string;
-    azureLanguageCredentials?: AzureLanguageCredentials;
-}
-export declare const asrMachine: import("xstate").StateMachine<ASRContext, ASREvent, {
-    [x: string]: import("xstate").ActorRef<import("xstate").CallbackSnapshot<{}>, import("xstate").EventObject> | import("xstate").ActorRef<import("xstate").PromiseSnapshot<string, any>, {
-        [k: string]: unknown;
-        type: string;
-    }> | import("xstate").ActorRef<import("xstate").CallbackSnapshot<any>, import("xstate").EventObject> | import("xstate").ActorRef<import("xstate").PromiseSnapshot<any, AzureLanguageCredentials & {
-        query: string;
-    }>, {
-        [k: string]: unknown;
-        type: string;
-    }>;
-}, {
-    src: "getToken";
-    logic: import("xstate").PromiseActorLogic<string, any>;
-    id: string;
-} | {
-    src: "ponyfill";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {}>;
-    id: string;
-} | {
-    src: "recStart";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, any>;
-    id: string;
-} | {
-    src: "nluPromise";
-    logic: import("xstate").PromiseActorLogic<any, AzureLanguageCredentials & {
-        query: string;
-    }>;
-    id: string;
-}, {
-    type: "recStop";
-    params: unknown;
-}, {
-    type: string;
-    params: {};
-}, string, "GetToken" | "Ready" | "Fail" | "Ponyfill" | "Pause" | {
-    Recognising?: "WaitForRecogniser" | "NoInput" | "InProgress" | "Match" | "NLURequest";
-}, string, ASRInit, {}, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, ASREvent, {
-    src: "getToken";
-    logic: import("xstate").PromiseActorLogic<string, any>;
-    id: string;
-} | {
-    src: "ponyfill";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {}>;
-    id: string;
-} | {
-    src: "recStart";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, any>;
-    id: string;
-} | {
-    src: "nluPromise";
-    logic: import("xstate").PromiseActorLogic<any, AzureLanguageCredentials & {
-        query: string;
-    }>;
-    id: string;
-}, {
-    type: "recStop";
-    params: unknown;
-}, {
-    type: string;
-    params: {};
-}, string, string>>;
-export {};
-//# sourceMappingURL=asr.d.ts.map

package/dist/asr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asr.d.ts","sourceRoot":"","sources":["../src/asr.ts"],"names":[],"mappings":";AAcA,OAAO,EACL,mBAAmB,EACnB,UAAU,EACV,sBAAsB,EACtB,wBAAwB,EACzB,MAAM,SAAS,CAAC;AAEjB,UAAU,mBAAoB,SAAQ,iBAAiB;IACrD,YAAO;CACR;AACD,UAAU,mBAAoB,SAAQ,iBAAiB;IACrD,YAAO;CACR;AAED,KAAK,QAAQ,GACT;IACE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE;QACL,MAAM,EAAE,mBAAmB,CAAC;QAC5B,cAAc,EAAE,mBAAmB,CAAC;KACrC,CAAC;CACH,GACD;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IACE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,mBAAmB,CAAC;CAC7B,GACD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE;QAAE,cAAc,EAAE,mBAAmB,CAAA;KAAE,CAAA;CAAE,GACnE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,UAAU,EAAE,CAAA;CAAE,CAAC;AAE5C,UAAU,UAAW,SAAQ,OAAO;IAClC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,cAAc,CAAC,EAAE,mBAAmB,CAAC;IACrC,cAAc,CAAC,EAAE,mBAAmB,CAAC;IACrC,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC;IACtB,SAAS,CAAC,EAAE,GAAG,CAAC;IAChB,MAAM,CAAC,EAAE,mBAAmB,CAAC;CAC9B;AAED,UAAU,OAAO;IACf,yBAAyB,EAAE,MAAM,CAAC;IAClC,wBAAwB,EAAE,MAAM,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,EAAE,MAAM,GAAG,sBAAsB,CAAC;IAClD,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,wBAAwB,CAAC,EAAE,wBAAwB,CAAC;CACrD;AAED,eAAO,MAAM,UAAU;;;;;eAiF8C,MAAM;;;;;;;;;;;;;;;;;;;;eAAN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;eAAN,MAAM;;;;;;;;;mBA6RzE,CAAC"}

package/dist/asr.js

@@ -1,354 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asrMachine = void 0;
-const xstate_1 = require("xstate");
-const getToken_1 = require("./getToken");
-const SpeechToText_1 = require("web-speech-cognitive-services/lib/SpeechServices/SpeechToText");
-const REGION = "northeurope";
-exports.asrMachine = (0, xstate_1.setup)({
-    types: {
-        context: {},
-        events: {},
-        input: {},
-    },
-    actions: {
-        recStop: ({ context }) => {
-            context.wsaASRinstance.abort();
-            console.debug("[ASR] stopped");
-        },
-    },
-    actors: {
-        getToken: getToken_1.getToken,
-        ponyfill: (0, xstate_1.fromCallback)(({ sendBack, input }) => {
-            const { SpeechGrammarList, SpeechRecognition } = (0, SpeechToText_1.default)({
-                audioContext: input.audioContext,
-                speechRecognitionEndpointId: input
-                    .speechRecognitionEndpointId,
-                credentials: {
-                    region: REGION, // TODO
-                    authorizationToken: input.azureAuthorizationToken,
-                },
-            });
-            sendBack({
-                type: "READY",
-                value: {
-                    wsaASR: SpeechRecognition,
-                    wsaGrammarList: SpeechGrammarList,
-                },
-            });
-            console.debug("[ASR] READY", input);
-        }),
-        recStart: (0, xstate_1.fromCallback)(({ sendBack, input }) => {
-            let asr = new input.wsaASR();
-            asr.grammars = new input.wsaGrammarList();
-            asr.grammars.phrases = input.phrases || [];
-            asr.lang = input.locale;
-            asr.continuous = true;
-            asr.interimResults = true;
-            asr.onresult = function (event) {
-                if (event.results[event.results.length - 1].isFinal) {
-                    const transcript = event.results
-                        .map((x) => x[0].transcript.replace(/\.$/, ""))
-                        .join(" ");
-                    const confidence = event.results
-                        .map((x) => x[0].confidence)
-                        .reduce((a, b) => a + b) / event.results.length;
-                    const res = [
-                        {
-                            utterance: transcript,
-                            confidence: confidence,
-                        },
-                    ];
-                    sendBack({
-                        type: "RESULT",
-                        value: res,
-                    });
-                    console.debug("[ASR] RESULT (pre-final)", res);
-                }
-                else {
-                    sendBack({ type: "STARTSPEECH" });
-                }
-            };
-            asr.addEventListener("start", () => {
-                sendBack({ type: "STARTED", value: { wsaASRinstance: asr } });
-            });
-            // receive((event) => {
-            //   console.debug("bla");
-            //   if (event.type === "STOP") {
-            //     asr.abort();
-            //   }
-            // });
-            asr.start();
-        }),
-        nluPromise: (0, xstate_1.fromPromise)(({ input }) => __awaiter(void 0, void 0, void 0, function* () {
-            const response = yield fetch(new Request(input.endpoint, {
-                method: "POST",
-                headers: {
-                    "Ocp-Apim-Subscription-Key": input.key,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    kind: "Conversation",
-                    analysisInput: {
-                        conversationItem: {
-                            id: "PARTICIPANT_ID_HERE",
-                            text: input.query,
-                            modality: "text",
-                            language: "en-US", // TODO
-                            participantId: "PARTICIPANT_ID_HERE",
-                        },
-                    },
-                    parameters: {
-                        projectName: input.projectName,
-                        verbose: true,
-                        deploymentName: input.deploymentName,
-                        stringIndexType: "TextElement_V8",
-                    },
-                }),
-            }));
-            return response.json();
-        })),
-    },
-}).createMachine({
-    id: "asr",
-    context: ({ input }) => ({
-        asrDefaultCompleteTimeout: input.asrDefaultCompleteTimeout || 0,
-        asrDefaultNoInputTimeout: input.asrDefaultNoInputTimeout || 5000,
-        locale: input.locale || "en-US",
-        audioContext: input.audioContext,
-        azureCredentials: input.azureCredentials,
-        azureLanguageCredentials: input.azureLanguageCredentials,
-        speechRecognitionEndpointId: input.speechRecognitionEndpointId,
-    }),
-    initial: "GetToken",
-    on: {
-        READY: {
-            target: ".Ready",
-            actions: [
-                (0, xstate_1.assign)({
-                    wsaASR: ({ event }) => event.value.wsaASR,
-                    wsaGrammarList: ({ event }) => event.value.wsaGrammarList,
-                }),
-                (0, xstate_1.sendParent)({ type: "ASR_READY" }),
-            ],
-        },
-    },
-    states: {
-        Fail: {},
-        Ready: {
-            on: {
-                START: {
-                    target: "Recognising",
-                    actions: (0, xstate_1.assign)({ params: ({ event }) => event.value || {} }),
-                },
-            },
-        },
-        Recognising: {
-            initial: "WaitForRecogniser",
-            invoke: {
-                id: "recStart",
-                input: ({ context }) => ({
-                    wsaASR: context.wsaASR,
-                    wsaGrammarList: context.wsaGrammarList,
-                    locale: context.locale,
-                    phrases: (context.params || {}).hints || [],
-                }),
-                src: "recStart",
-            },
-            exit: "recStop",
-            on: {
-                RESULT: {
-                    actions: [
-                        (0, xstate_1.assign)({
-                            result: ({ event }) => event.value,
-                        }),
-                        (0, xstate_1.cancel)("completeTimeout"),
-                    ],
-                    target: ".Match",
-                },
-                RECOGNISED: [
-                    {
-                        target: ".NLURequest",
-                        guard: ({ context }) => !!(context.params.nlu && context.azureLanguageCredentials),
-                    },
-                    {
-                        target: "Ready",
-                        actions: [
-                            (0, xstate_1.sendParent)(({ context }) => ({
-                                type: "RECOGNISED",
-                                value: context.result,
-                            })),
-                        ],
-                    },
-                ],
-                CONTROL: {
-                    target: "Pause",
-                },
-                STOP: {
-                    target: "Ready",
-                },
-                NOINPUT: {
-                    actions: (0, xstate_1.sendParent)({ type: "ASR_NOINPUT" }),
-                    target: "Ready",
-                },
-            },
-            states: {
-                WaitForRecogniser: {
-                    on: {
-                        STARTED: {
-                            target: "NoInput",
-                            actions: [
-                                (0, xstate_1.assign)({
-                                    wsaASRinstance: ({ event }) => event.value.wsaASRinstance,
-                                }),
-                                (0, xstate_1.sendParent)({ type: "ASR_STARTED" }),
-                            ],
-                        },
-                    },
-                },
-                NoInput: {
-                    entry: [
-                        (0, xstate_1.raise)({ type: "NOINPUT" }, {
-                            delay: ({ context }) => (context.params || {}).noInputTimeout ||
-                                context.asrDefaultNoInputTimeout,
-                            id: "timeout",
-                        }),
-                    ],
-                    on: {
-                        STARTSPEECH: {
-                            target: "InProgress",
-                            actions: (0, xstate_1.cancel)("completeTimeout"),
-                        },
-                    },
-                    exit: [(0, xstate_1.cancel)("timeout")],
-                },
-                InProgress: {
-                    entry: () => console.debug("[ASR] in progress"),
-                },
-                Match: {
-                    entry: [
-                        ({ context }) => console.debug("RECOGNISED will be sent in (ms)", (context.params || {}).completeTimeout ||
-                            context.asrDefaultCompleteTimeout),
-                        (0, xstate_1.raise)({ type: "RECOGNISED" }, {
-                            delay: ({ context }) => (context.params || {}).completeTimeout ||
-                                context.asrDefaultCompleteTimeout,
-                            id: "completeTimeout",
-                        }),
-                    ],
-                },
-                NLURequest: {
-                    invoke: {
-                        src: "nluPromise",
-                        input: ({ context }) => {
-                            let c;
-                            typeof context.params.nlu === "boolean"
-                                ? (c = context.azureLanguageCredentials)
-                                : (c = context.params.nlu);
-                            return {
-                                endpoint: c.endpoint,
-                                key: c.key,
-                                projectName: c.projectName,
-                                deploymentName: c.deploymentName,
-                                query: context.result[0].utterance,
-                            };
-                        },
-                        onDone: [
-                            {
-                                actions: [
-                                    ({ event }) => console.error("[ASR] no NLU prediction", event.output),
-                                    (0, xstate_1.sendParent)(({ context }) => ({
-                                        type: "RECOGNISED",
-                                        value: context.result,
-                                    })),
-                                ],
-                                target: "#asr.Ready",
-                                guard: ({ event }) => !(event.output.result || {}).prediction,
-                            },
-                            {
-                                actions: [
-                                    ({ event }) => console.debug("[ASR] NLU result", event.output.result.prediction),
-                                    (0, xstate_1.sendParent)(({ context, event }) => ({
-                                        type: "RECOGNISED",
-                                        value: context.result,
-                                        nluValue: event.output.result.prediction,
-                                    })),
-                                ],
-                                target: "#asr.Ready",
-                            },
-                        ],
-                        onError: {
-                            actions: [
-                                ({ event }) => console.error("[ASR]", event.error),
-                                (0, xstate_1.sendParent)(({ context }) => ({
-                                    type: "RECOGNISED",
-                                    value: context.result,
-                                })),
-                            ],
-                            target: "#asr.Ready",
-                        },
-                    },
-                },
-            },
-        },
-        Pause: {
-            entry: (0, xstate_1.sendParent)({ type: "ASR_PAUSED" }),
-            on: {
-                CONTROL: {
-                    target: "Recognising",
-                    //       ///// todo? reset noInputTimeout
-                    //       // actions: assign({
-                    //       //   params: {
-                    //       //     noInputTimeout: ({ context }) =>
-                    //       //       context.asrDefaultNoInputTimeout,
-                    //       //     completeTimeout: 0,
-                    //       //     locale: "0",
-                    //       //     hints: [""],
-                    //       //   },
-                    //       // }),} },
-                },
-            },
-        },
-        GetToken: {
-            invoke: {
-                id: "getAuthorizationToken",
-                input: ({ context }) => ({
-                    credentials: context.azureCredentials,
-                }),
-                src: "getToken",
-                onDone: {
-                    target: "Ponyfill",
-                    actions: [
-                        (0, xstate_1.assign)(({ event }) => {
-                            return { azureAuthorizationToken: event.output };
-                        }),
-                    ],
-                },
-                onError: {
-                    actions: ({ event }) => console.error("[ASR]", event.error),
-                    target: "Fail",
-                },
-            },
-        },
-        Ponyfill: {
-            invoke: {
-                id: "ponyASR",
-                src: "ponyfill",
-                input: ({ context }) => ({
-                    audioContext: context.audioContext,
-                    azureAuthorizationToken: context.azureAuthorizationToken,
-                    locale: context.locale,
-                    speechRecognitionEndpointId: context.speechRecognitionEndpointId,
-                }),
-            },
-        },
-    },
-});

package/dist/getToken.d.ts

@@ -1,2 +0,0 @@
-export declare const getToken: import("xstate").PromiseActorLogic<string, any>;
-//# sourceMappingURL=getToken.d.ts.map

package/dist/getToken.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getToken.d.ts","sourceRoot":"","sources":["../src/getToken.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ,iDAanB,CAAC"}

package/dist/getToken.js

@@ -1,26 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getToken = void 0;
-const xstate_1 = require("xstate");
-exports.getToken = (0, xstate_1.fromPromise)(({ input }) => __awaiter(void 0, void 0, void 0, function* () {
-    if (typeof input.credentials === "string") {
-        return fetch(new Request(input.credentials)).then((data) => data.text());
-    }
-    else {
-        return fetch(new Request(input.credentials.endpoint, {
-            method: "POST",
-            headers: {
-                "Ocp-Apim-Subscription-Key": input.credentials.key,
-            },
-        })).then((data) => data.text());
-    }
-}));

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export { speechstate } from "./speechstate";
-export { AzureCredentials, Settings, Hypothesis, Agenda, RecogniseParameters, } from "./types";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EACL,gBAAgB,EAChB,QAAQ,EACR,UAAU,EACV,MAAM,EACN,mBAAmB,GACpB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.speechstate = void 0;
-var speechstate_1 = require("./speechstate");
-Object.defineProperty(exports, "speechstate", { enumerable: true, get: function () { return speechstate_1.speechstate; } });

package/dist/speechstate.d.ts

@@ -1,48 +0,0 @@
-import { Settings, Agenda, Hypothesis, RecogniseParameters } from "./types";
-interface SSContext {
-    settings: Settings;
-    audioContext?: AudioContext;
-    asrRef?: any;
-    ttsRef?: any;
-}
-/** events sent to the spawned `speechstate` machine **/
-type SSEventExtIn = {
-    type: "PREPARE";
-} | {
-    type: "CONTROL";
-} | {
-    type: "STOP";
-} | {
-    type: "SPEAK";
-    value: Agenda;
-} | {
-    type: "LISTEN";
-    value: RecogniseParameters;
-};
-/** for sendParent, not type-checked */
-type SSEventExtOut = {
-    type: "ASR_NOINPUT";
-} | {
-    type: "ASRTTS_READY";
-} | {
-    type: "ASR_STARTED";
-} | {
-    type: "TTS_STARTED";
-} | {
-    type: "SPEAK_COMPLETE";
-} | {
-    type: "RECOGNISED";
-    value: Hypothesis[];
-    nluValue?: any;
-};
-type SSEventIntIn = {
-    type: "TTS_READY";
-} | {
-    type: "ASR_READY";
-} | {
-    type: "TTS_ERROR";
-};
-type SSEvent = SSEventIntIn | SSEventExtIn | SSEventExtOut;
-declare const speechstate: import("xstate").StateMachine<SSContext, SSEvent, Record<string, import("xstate").AnyActorRef>, import("xstate").ProvidedActor, import("xstate").ParameterizedObject, import("xstate").ParameterizedObject, string, import("xstate").StateValue, string, Settings, {}, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, SSEvent, import("xstate").ProvidedActor, import("xstate").ParameterizedObject, import("xstate").ParameterizedObject, string, string>>;
-export { speechstate };
-//# sourceMappingURL=speechstate.d.ts.map

package/dist/speechstate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"speechstate.d.ts","sourceRoot":"","sources":["../src/speechstate.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAC5E,UAAU,SAAS;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,MAAM,CAAC,EAAE,GAAG,CAAC;CACd;AAED,wDAAwD;AACxD,KAAK,YAAY,GACb;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,mBAAmB,CAAA;CAAE,CAAC;AAEnD,uCAAuC;AACvC,KAAK,aAAa,GACd;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,GAC1B;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,UAAU,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,GAAG,CAAA;CAAE,CAAC;AAEhE,KAAK,YAAY,GACb;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC;AAE1B,KAAK,OAAO,GAAG,YAAY,GAAG,YAAY,GAAG,aAAa,CAAC;AAE3D,QAAA,MAAM,WAAW,odAuQhB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/speechstate.js

@@ -1,247 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.speechstate = void 0;
-const xstate_1 = require("xstate");
-const tts_1 = require("./tts");
-const asr_1 = require("./asr");
-const speechstate = (0, xstate_1.createMachine)({
-    types: {},
-    context: ({ input }) => ({
-        settings: input,
-    }),
-    id: "speechstate",
-    type: "parallel",
-    states: {
-        AsrTtsSpawner: {
-            initial: "Idle",
-            states: {
-                Idle: { on: { PREPARE: "CreateAudioContext" } },
-                CreateAudioContext: {
-                    invoke: {
-                        id: "createAudioContext",
-                        src: "audioContext",
-                        onDone: {
-                            target: "Spawn",
-                            actions: (0, xstate_1.assign)({ audioContext: ({ event }) => event.output }),
-                        },
-                    },
-                },
-                Spawn: {
-                    entry: [
-                        (0, xstate_1.assign)({
-                            ttsRef: ({ context, spawn }) => {
-                                return spawn(tts_1.ttsMachine, {
-                                    input: {
-                                        ttsDefaultVoice: context.settings.ttsDefaultVoice,
-                                        audioContext: context.audioContext,
-                                        azureCredentials: context.settings.azureCredentials,
-                                    },
-                                });
-                            },
-                        }),
-                        (0, xstate_1.assign)({
-                            asrRef: ({ context, spawn }) => {
-                                return spawn(asr_1.asrMachine, {
-                                    input: {
-                                        asrDefaultCompleteTimeout: context.settings.asrDefaultCompleteTimeout,
-                                        asrDefaultNoInputTimeout: context.settings.asrDefaultNoInputTimeout,
-                                        locale: context.settings.locale,
-                                        audioContext: context.audioContext,
-                                        azureCredentials: context.settings.azureCredentials,
-                                        azureLanguageCredentials: context.settings.azureLanguageCredentials,
-                                        speechRecognitionEndpointId: context.settings.speechRecognitionEndpointId,
-                                    },
-                                });
-                            },
-                        }),
-                    ],
-                    after: {
-                        300000: {
-                            target: "Spawn",
-                        },
-                    },
-                },
-            },
-        },
-        AsrTtsManager: {
-            initial: "Initialize",
-            on: {
-                TTS_READY: {
-                    actions: () => console.debug("[TTS→SpSt] TTS_READY"),
-                    target: ".PreReady",
-                },
-                ASR_READY: {
-                    actions: () => console.debug("[ASR→SpSt] ASR_READY"),
-                    target: ".PreReady",
-                },
-                // ASR_ERROR not implemented
-                TTS_ERROR: {
-                    actions: () => console.error("[TTS→SpSt] TTS_ERROR"),
-                    target: ".Fail",
-                },
-                ASR_NOINPUT: {
-                    actions: [
-                        () => console.debug("[ASR→SpSt] NOINPUT"),
-                        (0, xstate_1.sendParent)({ type: "ASR_NOINPUT" }),
-                    ],
-                    target: ".Ready",
-                },
-            },
-            states: {
-                Initialize: {},
-                PreReady: {
-                    on: {
-                        TTS_READY: {
-                            actions: () => console.debug("[TTS→SpSt] TTS_READY"),
-                            target: "Ready",
-                        },
-                        ASR_READY: {
-                            actions: () => console.debug("[ASR→SpSt] ASR_READY"),
-                            target: "Ready",
-                        },
-                    },
-                },
-                Ready: {
-                    initial: "Idle",
-                    entry: [
-                        () => console.debug("[SpSt] All ready"),
-                        (0, xstate_1.sendParent)({ type: "ASRTTS_READY" }),
-                    ],
-                    states: {
-                        Idle: {
-                            on: {
-                                LISTEN: { target: "WaitForRecogniser" },
-                                SPEAK: [
-                                    {
-                                        target: "Speaking",
-                                    },
-                                ],
-                            },
-                        },
-                        Speaking: {
-                            entry: [
-                                ({ event }) => console.debug("[SpSt→TTS] SPEAK", event.value),
-                                ({ context, event }) => context.ttsRef.send({
-                                    type: "SPEAK",
-                                    value: event.value,
-                                }),
-                            ],
-                            on: {
-                                CONTROL: {
-                                    actions: [
-                                        () => console.debug("[SpSt→TTS] CONTROL"),
-                                        ({ context }) => context.ttsRef.send({
-                                            type: "CONTROL",
-                                        }),
-                                    ],
-                                },
-                                STOP: {
-                                    actions: [
-                                        () => console.debug("[SpSt→TTS] STOP"),
-                                        ({ context }) => context.ttsRef.send({
-                                            type: "STOP",
-                                        }),
-                                    ],
-                                },
-                                TTS_STARTED: {
-                                    actions: [
-                                        () => console.debug("[TTS→SpSt] TTS_STARTED"),
-                                        (0, xstate_1.sendParent)({ type: "TTS_STARTED" }),
-                                    ],
-                                },
-                                SPEAK_COMPLETE: {
-                                    target: "Idle",
-                                    actions: [
-                                        () => console.debug("[TTS→SpSt] SPEAK_COMPLETE"),
-                                        (0, xstate_1.sendParent)({ type: "SPEAK_COMPLETE" }),
-                                    ],
-                                },
-                            },
-                        },
-                        WaitForRecogniser: {
-                            entry: [
-                                ({ event }) => console.debug("[SpSt→ASR] START", event.value),
-                                ({ context, event }) => context.asrRef.send({
-                                    type: "START",
-                                    value: event.value,
-                                }),
-                            ],
-                            on: {
-                                ASR_STARTED: {
-                                    target: "Recognising",
-                                    actions: [
-                                        () => console.debug("[ASR→SpSt] ASR_STARTED"),
-                                        (0, xstate_1.sendParent)({ type: "ASR_STARTED" }),
-                                    ],
-                                },
-                            },
-                        },
-                        Recognising: {
-                            on: {
-                                CONTROL: {
-                                    actions: [
-                                        () => console.debug("[SpSt→ASR] CONTROL"),
-                                        ({ context }) => context.asrRef.send({
-                                            type: "CONTROL",
-                                        }),
-                                    ],
-                                },
-                                STOP: {
-                                    target: "Idle",
-                                    actions: [
-                                        () => console.debug("[SpSt→ASR] STOP"),
-                                        ({ context }) => context.asrRef.send({
-                                            type: "STOP",
-                                        }),
-                                    ],
-                                },
-                                RECOGNISED: {
-                                    actions: [
-                                        ({ event }) => console.debug("[ASR→SpSt] RECOGNISED", event.value, event.nluValue),
-                                        (0, xstate_1.sendParent)(({ event }) => ({
-                                            type: "RECOGNISED",
-                                            value: event.value,
-                                            nluValue: event.nluValue,
-                                        })),
-                                    ],
-                                    target: "Idle",
-                                },
-                            },
-                        },
-                    },
-                },
-                Fail: {},
-            },
-        },
-    },
-}, {
-    actors: {
-        audioContext: (0, xstate_1.fromPromise)(() => {
-            const audioContext = new (window.AudioContext ||
-                window.webkitAudioContext)();
-            navigator.mediaDevices
-                .getUserMedia({ audio: true })
-                .then(function (stream) {
-                audioContext.createMediaStreamSource(stream);
-            });
-            return audioContext;
-        }),
-    },
-    actions: {
-    //   logRecResult: ({ event }) => {
-    //     console.log("U>", (event as any).value[0]["utterance"], {
-    //       confidence: (event as any).value[0]["confidence"],
-    //     });
-    //   },
-    //   logAgenda: ({ context, event }) => {
-    //     console.log("S>", (event as any).value, {
-    //       passivity: `${context.tdmPassivity ?? "∞"} ms`,
-    //       speechCompleteTimeout: `${
-    //         context.tdmSpeechCompleteTimeout ||
-    //         context.settings.completeTimeout
-    //       } ms`,
-    //     });
-    //   },
-    },
-});
-exports.speechstate = speechstate;

package/dist/tts.d.ts

@@ -1,42 +0,0 @@
-import { AzureCredentials, Agenda } from "./types";
-interface MySpeechSynthesisUtterance extends SpeechSynthesisUtterance {
-    new (s: string): any;
-}
-interface TTSInit {
-    audioContext: AudioContext;
-    azureCredentials: string | AzureCredentials;
-    ttsDefaultVoice: string;
-}
-interface TTSContext extends TTSInit {
-    azureAuthorizationToken?: string;
-    ttsLexicon?: string;
-    wsaTTS?: SpeechSynthesis;
-    wsaVoice?: SpeechSynthesisVoice;
-    wsaUtt?: MySpeechSynthesisUtterance;
-    agenda?: Agenda;
-}
-type TTSEvent = {
-    type: "PREPARE";
-} | {
-    type: "CONTROL";
-} | {
-    type: "STOP";
-} | {
-    type: "READY";
-    value: {
-        wsaTTS: SpeechSynthesis;
-        wsaUtt: MySpeechSynthesisUtterance;
-    };
-} | {
-    type: "ERROR";
-} | {
-    type: "SPEAK";
-    value: Agenda;
-} | {
-    type: "TTS_STARTED";
-} | {
-    type: "SPEAK_COMPLETE";
-};
-export declare const ttsMachine: import("xstate").StateMachine<TTSContext, TTSEvent, Record<string, import("xstate").AnyActorRef>, import("xstate").ProvidedActor, import("xstate").ParameterizedObject, import("xstate").ParameterizedObject, string, import("xstate").StateValue, string, TTSInit, {}, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, TTSEvent, import("xstate").ProvidedActor, import("xstate").ParameterizedObject, import("xstate").ParameterizedObject, string, string>>;
-export {};
-//# sourceMappingURL=tts.d.ts.map

package/dist/tts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tts.d.ts","sourceRoot":"","sources":["../src/tts.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEnD,UAAU,0BAA2B,SAAQ,wBAAwB;IACnE,KAAK,CAAC,EAAE,MAAM,OAAE;CACjB;AAED,UAAU,OAAO;IACf,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,EAAE,MAAM,GAAG,gBAAgB,CAAC;IAC5C,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,UAAW,SAAQ,OAAO;IAClC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,MAAM,CAAC,EAAE,0BAA0B,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,KAAK,QAAQ,GACT;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IACE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE;QACL,MAAM,EAAE,eAAe,CAAC;QACxB,MAAM,EAAE,0BAA0B,CAAC;KACpC,CAAC;CACH,GACD;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE/B,eAAO,MAAM,UAAU,sdA+KtB,CAAC"}

package/dist/tts.js

@@ -1,182 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ttsMachine = void 0;
-const xstate_1 = require("xstate");
-const getToken_1 = require("./getToken");
-const TextToSpeech_1 = require("web-speech-cognitive-services/lib/SpeechServices/TextToSpeech");
-const REGION = "northeurope";
-exports.ttsMachine = (0, xstate_1.createMachine)({
-    id: "tts",
-    types: {},
-    context: ({ input }) => ({
-        ttsDefaultVoice: input.ttsDefaultVoice || "en-US-DavisNeural",
-        audioContext: input.audioContext,
-        azureCredentials: input.azureCredentials,
-    }),
-    initial: "GetToken",
-    on: {
-        READY: {
-            target: ".Ready",
-            actions: [
-                (0, xstate_1.assign)({
-                    wsaTTS: ({ event }) => event.value.wsaTTS,
-                    wsaUtt: ({ event }) => event.value.wsaUtt,
-                }),
-                (0, xstate_1.sendParent)({ type: "TTS_READY" }),
-            ],
-        },
-        ERROR: { actions: (0, xstate_1.sendParent)({ type: "TTS_ERROR" }) },
-    },
-    states: {
-        Ready: {
-            initial: "Idle",
-            states: {
-                Idle: {
-                    on: {
-                        SPEAK: {
-                            target: "Speaking",
-                            actions: (0, xstate_1.assign)({ agenda: ({ event }) => event.value }),
-                        },
-                    },
-                },
-                Speaking: {
-                    initial: "Go",
-                    on: {
-                        STOP: {
-                            target: "Idle",
-                        },
-                        TTS_STARTED: {
-                            actions: (0, xstate_1.sendParent)({ type: "TTS_STARTED" }),
-                        },
-                        SPEAK_COMPLETE: {
-                            target: "Idle",
-                        },
-                    },
-                    exit: (0, xstate_1.sendParent)({ type: "SPEAK_COMPLETE" }),
-                    states: {
-                        Go: {
-                            invoke: {
-                                src: "start",
-                                input: ({ context }) => ({
-                                    wsaTTS: context.wsaTTS,
-                                    wsaUtt: context.wsaUtt,
-                                    ttsLexicon: context.ttsLexicon,
-                                    voice: context.agenda.voice || context.ttsDefaultVoice,
-                                    // streamURL: context.agenda.streamURL,
-                                    utterance: context.agenda.utterance,
-                                }),
-                            },
-                            on: {
-                                CONTROL: "Paused",
-                            },
-                            exit: "ttsStop",
-                        },
-                        Paused: {
-                            on: {
-                                CONTROL: "Go",
-                            },
-                        },
-                    },
-                },
-            },
-        },
-        Fail: {},
-        GetToken: {
-            invoke: {
-                id: "getAuthorizationToken",
-                input: ({ context }) => ({
-                    credentials: context.azureCredentials,
-                }),
-                src: "getToken",
-                onDone: {
-                    target: "Ponyfill",
-                    actions: [
-                        (0, xstate_1.assign)(({ event }) => {
-                            return { azureAuthorizationToken: event.output };
-                        }),
-                    ],
-                },
-                onError: {
-                    actions: ({ event }) => console.error("[TTS] getToken error", event),
-                    target: "Fail",
-                },
-            },
-        },
-        Ponyfill: {
-            invoke: {
-                id: "ponyTTS",
-                src: "ponyfill",
-                input: ({ context }) => ({
-                    audioContext: context.audioContext,
-                    azureAuthorizationToken: context.azureAuthorizationToken,
-                }),
-            },
-        },
-    },
-}, {
-    actions: {
-        ttsStop: ({ context }) => {
-            context.wsaTTS.cancel();
-        },
-    },
-    actors: {
-        getToken: getToken_1.getToken,
-        ponyfill: (0, xstate_1.fromCallback)(({ sendBack, input }) => {
-            const ponyfill = (0, TextToSpeech_1.default)({
-                audioContext: input.audioContext,
-                credentials: {
-                    region: REGION, // TODO
-                    authorizationToken: input.azureAuthorizationToken,
-                },
-            });
-            const { speechSynthesis, SpeechSynthesisUtterance } = ponyfill;
-            const tts = speechSynthesis;
-            const ttsUtterance = SpeechSynthesisUtterance;
-            tts.addEventListener("voiceschanged", () => {
-                const voices = tts.getVoices();
-                if (voices.length > 0) {
-                    console.debug("[TTS] READY");
-                    sendBack({
-                        type: "READY",
-                        value: { wsaTTS: tts, wsaUtt: ttsUtterance },
-                    });
-                }
-                else {
-                    console.error("[TTS] No voices available");
-                    sendBack({ type: "ERROR" });
-                }
-            });
-        }),
-        start: (0, xstate_1.fromCallback)(({ sendBack, input }) => {
-            if (["", " "].includes(input.utterance)) {
-                console.debug("[TTS] SPEAK: ", input.utterance);
-                input.wsaTTS.speak("");
-            }
-            else {
-                console.debug("[TTS] SPEAK: ", input.utterance);
-                const content = wrapSSML(input.utterance, input.voice, input.ttsLexicon, 1); // todo speech rate;
-                const utterance = new input.wsaUtt(content);
-                utterance.addEventListener("start", () => {
-                    sendBack({ type: "TTS_STARTED" });
-                    console.debug("[TTS] TTS_STARTED");
-                });
-                utterance.addEventListener("end", () => {
-                    sendBack({ type: "SPEAK_COMPLETE" });
-                    console.debug("[TTS] SPEAK_COMPLETE");
-                });
-                input.wsaTTS.speak(utterance);
-            }
-        }),
-    },
-});
-const wrapSSML = (text, voice, lexicon, speechRate) => {
-    let content = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="http://www.w3.org/2001/mstts" xml:lang="en-US"><voice name="${voice}">`;
-    if (lexicon) {
-        content = content + `<lexicon uri="${lexicon}"/>`;
-    }
-    content =
-        content +
-            `<prosody rate="${speechRate}">` +
-            `${text}</prosody></voice></speak>`;
-    return content;
-};

package/dist/types.d.ts

@@ -1,41 +0,0 @@
-export interface AzureSpeechCredentials {
-    endpoint: string;
-    key: string;
-}
-/**
- * @deprecated use `AzureSpeechCredentials` instead
- */
-export interface AzureCredentials extends AzureSpeechCredentials {
-}
-export interface AzureLanguageCredentials {
-    endpoint: string;
-    key: string;
-    projectName: string;
-    deploymentName: string;
-}
-export interface Settings {
-    locale?: string;
-    azureCredentials: string | AzureCredentials | AzureSpeechCredentials;
-    azureLanguageCredentials?: AzureLanguageCredentials;
-    asrDefaultCompleteTimeout?: number;
-    asrDefaultNoInputTimeout?: number;
-    ttsDefaultVoice?: string;
-    speechRecognitionEndpointId?: string;
-}
-export interface Agenda {
-    utterance: string;
-    voice?: string;
-    stream?: ReadableStream<string>;
-}
-export interface Hypothesis {
-    utterance: string;
-    confidence: number;
-}
-export interface RecogniseParameters {
-    noInputTimeout?: number;
-    completeTimeout?: number;
-    locale?: string;
-    hints?: string[];
-    nlu?: boolean | AzureLanguageCredentials;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,sBAAsB;CAAG;AAEnE,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,QAAQ;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,MAAM,GAAG,gBAAgB,GAAG,sBAAsB,CAAC;IACrE,wBAAwB,CAAC,EAAE,wBAAwB,CAAC;IACpD,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,MAAM,WAAW,MAAM;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,GAAG,CAAC,EAAE,OAAO,GAAG,wBAAwB,CAAC;CAC1C"}

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });