speechstate 2.0.1 → 2.0.3

package/dist/asr.d.ts

@@ -0,0 +1,121 @@
+/// <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").EventObject> | import("xstate").ActorRef<import("xstate").PromiseSnapshot<string, any>, {
+        [k: string]: unknown;
+        type: string;
+    }, import("xstate").EventObject> | import("xstate").ActorRef<import("xstate").CallbackSnapshot<any>, import("xstate").EventObject, import("xstate").EventObject> | import("xstate").ActorRef<import("xstate").PromiseSnapshot<any, AzureLanguageCredentials & {
+        query: string;
+    }>, {
+        [k: string]: unknown;
+        type: string;
+    }, import("xstate").EventObject>;
+}, import("xstate").Values<{
+    getToken: {
+        src: "getToken";
+        logic: import("xstate").PromiseActorLogic<string, any>;
+        id: string;
+    };
+    ponyfill: {
+        src: "ponyfill";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {}>;
+        id: string;
+    };
+    recStart: {
+        src: "recStart";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, any>;
+        id: string;
+    };
+    nluPromise: {
+        src: "nluPromise";
+        logic: import("xstate").PromiseActorLogic<any, AzureLanguageCredentials & {
+            query: string;
+        }>;
+        id: string;
+    };
+}>, {
+    type: "recStop";
+    params: unknown;
+}, never, never, "GetToken" | "Ready" | "Fail" | "Ponyfill" | "Pause" | {
+    Recognising?: "WaitForRecogniser" | "NoInput" | "InProgress" | "Match" | "NLURequest";
+}, string, ASRInit, {}, import("xstate").EventObject, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, ASREvent, import("xstate").Values<{
+    getToken: {
+        src: "getToken";
+        logic: import("xstate").PromiseActorLogic<string, any>;
+        id: string;
+    };
+    ponyfill: {
+        src: "ponyfill";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {}>;
+        id: string;
+    };
+    recStart: {
+        src: "recStart";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, any>;
+        id: string;
+    };
+    nluPromise: {
+        src: "nluPromise";
+        logic: import("xstate").PromiseActorLogic<any, AzureLanguageCredentials & {
+            query: string;
+        }>;
+        id: string;
+    };
+}>, {
+    type: "recStop";
+    params: unknown;
+}, never, never, string, import("xstate").EventObject>>;
+export {};
+//# sourceMappingURL=asr.d.ts.map

package/dist/asr.d.ts.map

@@ -0,0 +1 @@
+{"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;;;;;;;;;;;;;;;;;;;;;;;;mBAAN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAN,MAAM;;;;;;;uDA6RzE,CAAC"}

package/dist/asr.js

@@ -0,0 +1,354 @@
+"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

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

package/dist/getToken.d.ts.map

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

package/dist/getToken.js

@@ -0,0 +1,26 @@
+"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

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

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,5 @@
+"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

@@ -0,0 +1,48 @@
+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").EventObject, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, SSEvent, import("xstate").ProvidedActor, import("xstate").ParameterizedObject, import("xstate").ParameterizedObject, string, string, import("xstate").EventObject>>;
+export { speechstate };
+//# sourceMappingURL=speechstate.d.ts.map

package/dist/speechstate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"speechstate.d.ts","sourceRoot":"","sources":["../src/speechstate.ts"],"names":[],"mappings":"AAUA,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,ghBAqThB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}