@forgerock/davinci-client 0.0.0-beta-20250414111925 → 0.0.0-beta-20250414113129

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/device.store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../device-client/src/index.ts"],"names":[],"mappings":"AAMA,cAAc,uBAAuB,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+export * from './lib/device.store.js';
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../device-client/src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,uBAAuB,CAAC"}

package/dist/src/lib/authorize.utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Define the options for the authorization URL
+ * @param clientId The client ID of the application
+ * @param redirectUri The redirect URI of the application
+ * @param responseType The response type of the authorization request
+ * @param scope The scope of the authorization request
+ */
+export interface GetAuthorizationUrlOptions {
+    clientId: string;
+    login: 'redirect';
+    redirectUri: string;
+    responseType: string;
+    scope: string;
+}
+/**
+ * @function createAuthorizeUrl - Create authorization URL for initial call to DaVinci
+ * @param baseUrl {string}
+ * @param options {GetAuthorizationUrlOptions}
+ * @returns {Promise<string>} - the authorization URL
+ */
+export declare function createAuthorizeUrl(authorizeUrl: string, options: GetAuthorizationUrlOptions): Promise<string>;
+//# sourceMappingURL=authorize.utils.d.ts.map

package/dist/src/lib/authorize.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorize.utils.d.ts","sourceRoot":"","sources":["../../../src/lib/authorize.utils.ts"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,UAAU,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,MAAM,CAAC,CAkCjB"}

package/dist/src/lib/authorize.utils.js

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+/**
+ * Import the PKCE and ResponseType utilities from the JavaScript SDK
+ */
+import { PKCE, ResponseType } from '@forgerock/javascript-sdk';
+import { generateAndStoreAuthUrlValues } from '@forgerock/javascript-sdk/src/oauth2-client/state-pkce';
+/**
+ * @function createAuthorizeUrl - Create authorization URL for initial call to DaVinci
+ * @param baseUrl {string}
+ * @param options {GetAuthorizationUrlOptions}
+ * @returns {Promise<string>} - the authorization URL
+ */
+export async function createAuthorizeUrl(authorizeUrl, options) {
+    /**
+     * Generate state and verifier for PKCE
+     */
+    const baseUrl = new URL(authorizeUrl).origin;
+    const [authorizeUrlOptions, storeOptions] = generateAndStoreAuthUrlValues({
+        clientId: options.clientId,
+        login: options.login,
+        // this type fails when module resolution is Node16
+        // Probably because the javascript-sdk is set to bundler
+        // so we need to make this correct with .js extensions if possible
+        serverConfig: { baseUrl },
+        responseType: ResponseType.Code,
+    });
+    const challenge = await PKCE.createChallenge(authorizeUrlOptions.verifier);
+    const requestParams = new URLSearchParams({
+        code_challenge: challenge,
+        code_challenge_method: 'S256',
+        client_id: options.clientId,
+        redirect_uri: options.redirectUri,
+        response_mode: 'pi.flow',
+        response_type: options.responseType,
+        scope: options.scope,
+        state: authorizeUrlOptions.state,
+    });
+    const url = new URL(`${authorizeUrl}?${requestParams.toString()}`);
+    storeOptions();
+    return url.toString();
+}
+//# sourceMappingURL=authorize.utils.js.map

package/dist/src/lib/authorize.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorize.utils.js","sourceRoot":"","sources":["../../../src/lib/authorize.utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;;GAEG;AACH,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,6BAA6B,EAAE,MAAM,wDAAwD,CAAC;AAiBvG;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,YAAoB,EACpB,OAAmC;IAEnC;;OAEG;IACH,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC;IAE7C,MAAM,CAAC,mBAAmB,EAAE,YAAY,CAAC,GAAG,6BAA6B,CAAC;QACxE,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,mDAAmD;QACnD,wDAAwD;QACxD,kEAAkE;QAClE,YAAY,EAAE,EAAE,OAAO,EAAE;QACzB,YAAY,EAAE,YAAY,CAAC,IAAI;KAChC,CAAC,CAAC;IAEH,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAE3E,MAAM,aAAa,GAAG,IAAI,eAAe,CAAC;QACxC,cAAc,EAAE,SAAS;QACzB,qBAAqB,EAAE,MAAM;QAC7B,SAAS,EAAE,OAAO,CAAC,QAAQ;QAC3B,YAAY,EAAE,OAAO,CAAC,WAAW;QACjC,aAAa,EAAE,SAAS;QACxB,aAAa,EAAE,OAAO,CAAC,YAAY;QACnC,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,KAAK,EAAE,mBAAmB,CAAC,KAAK;KACjC,CAAC,CAAC;IAEH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,GAAG,YAAY,IAAI,aAAa,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IAEnE,YAAY,EAAE,CAAC;IAEf,OAAO,GAAG,CAAC,QAAQ,EAAE,CAAC;AACxB,CAAC"}

package/dist/src/lib/client.store.d.ts

@@ -0,0 +1,351 @@
+/**
+ * Import the DaVinciRequest types
+ */
+import type { DaVinciConfig } from './config.types.js';
+import type { DaVinciAction, DaVinciRequest, OutgoingQueryParams, StartOptions } from './davinci.types.js';
+import type { SingleValueCollectors, IdpCollector, MultiSelectCollector } from './collector.types.js';
+import type { InitFlow, Updater, Validator } from './client.types.js';
+import type { RequestMiddleware } from './effects/request.effect.types.js';
+/**
+ * Create a client function that returns a set of methods
+ * to interact with and normalize the DaVinci API.
+ *
+ * @function davinciClient - returns an "observable" client for DaVinci flows
+ * @param {ConfigurationOptions} options - the configuration options for the client
+ * @returns {Observable} - an observable client for DaVinci flows
+ */
+export declare function davinci({ config, requestMiddleware, }: {
+    config: DaVinciConfig;
+    requestMiddleware?: RequestMiddleware[];
+}): Promise<{
+    subscribe: (listener: () => void) => import("@reduxjs/toolkit").Unsubscribe;
+    /**
+     * Social Login Handler
+     * Use this as part of an event when clicking on
+     * a social login button. Pass in the collector responsible
+     * for the social login being started.
+     *
+     * This method will save the `continueUrl`
+     * and then replace the window with the authenticate
+     * url from the collector
+     *
+     * Can return an error when no continue url is found
+     * or no authenticate url is found in the collectors
+     *
+     * @method: externalIdp
+     * @param collector IdpCollector
+     * @returns {function}
+     */
+    externalIdp: (collector: IdpCollector) => () => void | import("./client.types.js").InternalErrorResponse;
+    /**
+     * @method flow - Method for initiating a new flow, different than current flow
+     * @param {DaVinciAction} action - the action to initiate the flow
+     * @returns {function} - an async function to call the flow
+     */
+    flow: (action: DaVinciAction) => InitFlow;
+    /**
+     * @method next - Method for initiating the next node in the current flow
+     * @param {DaVinciRequest} args - the arguments to pass to the next
+     * @returns {Promise} - a promise that resolves to the next node
+     */
+    next: (args?: DaVinciRequest) => Promise<import("./node.types.js").ContinueNode | import("./node.types.js").ErrorNode | import("./node.types.js").FailureNode | import("./node.types.js").StartNode | import("./node.types.js").SuccessNode | {
+        error: string;
+        cache: null;
+        client: {
+            status: "start";
+        };
+        server: {
+            status: "start";
+        };
+        status: "start";
+    }>;
+    /**
+     * @method: resume - Resume a social login flow when returned to application
+     * @returns unknown
+     */
+    resume: ({ continueToken }: {
+        continueToken: string;
+    }) => Promise<import("./node.types.js").ContinueNode | import("./node.types.js").ErrorNode | import("./node.types.js").FailureNode | import("./node.types.js").StartNode | import("./node.types.js").SuccessNode>;
+    /**
+     * @method start - Method for initiating a DaVinci flow
+     * @returns {Promise} - a promise that initiates a DaVinci flow and returns a node
+     */
+    start: <QueryParams extends OutgoingQueryParams = OutgoingQueryParams>(options?: StartOptions<QueryParams> | undefined) => Promise<import("./node.types.js").ContinueNode | import("./node.types.js").ErrorNode | import("./node.types.js").FailureNode | import("./node.types.js").StartNode | import("./node.types.js").SuccessNode>;
+    /**
+     * @method update - Exclusive method for updating the current node with user provided values
+     * @param {SingleValueCollector} collector - the collector to update
+     * @returns {function} - a function to call for updating collector value
+     */
+    update: (collector: SingleValueCollectors | MultiSelectCollector) => Updater;
+    /**
+     * @method validate - Method for validating the value against validation rules
+     * @param {SingleValueCollector} collector - the collector to validate
+     * @returns {function} - a function to call for validating collector value
+     * @throws {Error} - if the collector is not a SingleValueCollector
+     */
+    validate: (collector: SingleValueCollectors) => Validator;
+    /**
+     * @method client - Selector to get the node.client from state
+     * @returns {Node.client} - the client property from the current node
+     */
+    getClient: () => {
+        action: string;
+        collectors: import("./node.types.js").Collectors[];
+        description?: string;
+        name?: string;
+        status: "continue";
+    } | {
+        action: string;
+        collectors: import("./node.types.js").Collectors[];
+        description?: string;
+        name?: string;
+        status: "error";
+    } | {
+        status: "failure";
+    } | {
+        status: "start";
+    } | {
+        authorization?: {
+            code?: string;
+            state?: string;
+        };
+        status: "success";
+    } | null;
+    /**
+     * @method collectors - Selector to get the collectors from state
+     * @returns {Collector[]} - The collectors from the current node in state
+     */
+    getCollectors: () => import("./node.types.js").Collectors[];
+    getError: () => import("./node.types.js").DaVinciError | null;
+    getErrorCollectors: () => import("./node.types.js").CollectorErrors[];
+    /**
+     * @method node - Selector to get the node from state
+     * @returns {Node} - the current node from state
+     */
+    getNode: () => import("./node.types.js").ContinueNode | import("./node.types.js").ErrorNode | import("./node.types.js").FailureNode | import("./node.types.js").StartNode | import("./node.types.js").SuccessNode;
+    /**
+     * @method server - Selector to get the node.server from state
+     * @returns {Node.server} - the server property from the current node
+     */
+    getServer: () => {
+        _links?: import("./davinci.types.js").Links;
+        id?: string;
+        interactionId?: string;
+        interactionToken?: string;
+        href?: string;
+        eventName?: string;
+        status: "continue";
+    } | {
+        _links?: import("./davinci.types.js").Links;
+        eventName?: string;
+        id?: string;
+        interactionId?: string;
+        interactionToken?: string;
+        status: "error";
+    } | {
+        _links?: import("./davinci.types.js").Links;
+        eventName?: string;
+        href?: string;
+        id?: string;
+        interactionId?: string;
+        interactionToken?: string;
+        status: "failure";
+    } | {
+        status: "start";
+    } | {
+        _links?: import("./davinci.types.js").Links;
+        eventName?: string;
+        id?: string;
+        interactionId?: string;
+        interactionToken?: string;
+        href?: string;
+        session?: string;
+        status: "success";
+    } | null;
+    /**
+     * Utilities to help query cached responses from server
+     */
+    cache: {
+        getLatestResponse: () => ((state: import("@reduxjs/toolkit/query").RootState<{
+            flow: import("@reduxjs/toolkit/query").MutationDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci">;
+            next: import("@reduxjs/toolkit/query").MutationDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci">;
+            start: import("@reduxjs/toolkit/query").MutationDefinition<StartOptions<OutgoingQueryParams> | undefined, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci">;
+            resume: import("@reduxjs/toolkit/query").QueryDefinition<{
+                continueToken: string;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci">;
+        }, never, "davinci">) => ({
+            requestId?: undefined;
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            data?: undefined;
+            error?: undefined;
+            endpointName?: string;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+        } & Omit<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "data" | "fulfilledTimeStamp"> & Required<Pick<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "data" | "fulfilledTimeStamp">> & {
+            error: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+        } & {
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        } & {
+            data?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+        } & Omit<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "error"> & Required<Pick<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "error">> & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) | {
+            error: {
+                message: string;
+                type: string;
+            };
+        };
+        getResponseWithId: (requestId: string) => ((state: import("@reduxjs/toolkit/query").RootState<{
+            flow: import("@reduxjs/toolkit/query").MutationDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci">;
+            next: import("@reduxjs/toolkit/query").MutationDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci">;
+            start: import("@reduxjs/toolkit/query").MutationDefinition<StartOptions<OutgoingQueryParams> | undefined, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci">;
+            resume: import("@reduxjs/toolkit/query").QueryDefinition<{
+                continueToken: string;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci">;
+        }, never, "davinci">) => ({
+            requestId?: undefined;
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            data?: undefined;
+            error?: undefined;
+            endpointName?: string;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+        } & Omit<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "data" | "fulfilledTimeStamp"> & Required<Pick<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "data" | "fulfilledTimeStamp">> & {
+            error: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+        } & {
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        } & {
+            data?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+        } & Omit<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "error"> & Required<Pick<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "error">> & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) | {
+            error: {
+                message: string;
+                type: string;
+            };
+        };
+    };
+}>;
+//# sourceMappingURL=client.store.d.ts.map

package/dist/src/lib/client.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.store.d.ts","sourceRoot":"","sources":["../../../src/lib/client.store.ts"],"names":[],"mappings":"AAeA;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,mBAAmB,EACnB,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,qBAAqB,EACrB,YAAY,EACZ,oBAAoB,EACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAAC,EAC5B,MAAM,EACN,iBAAiB,GAClB,EAAE;IACD,MAAM,EAAE,aAAa,CAAC;IACtB,iBAAiB,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACzC;;IAyBG;;;;;;;;;;;;;;;;OAgBG;6BACsB,YAAY;IAQrC;;;;OAIG;mBACY,aAAa,KAAG,QAAQ;IAkBvC;;;;OAIG;kBACiB,cAAc;;;;;;;;;;;IAclC;;;OAGG;gCAC+B;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE;IAQ3D;;;OAGG;YACW,WAAW,SAAS,mBAAmB,kCACzC,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS;IAMjD;;;;OAIG;wBACiB,qBAAqB,GAAG,oBAAoB,KAAG,OAAO;IA6D1E;;;;;OAKG;0BACmB,qBAAqB,KAAG,SAAS;IAkDvD;;;OAGG;;;;;;;;;;;;;;;;;;;gBA/MC,CAAC;iBACJ,CAAJ;;;;IAiNG;;;OAGG;;;;IAsBH;;;OAGG;;IAKH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAMH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAgB8B,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAc1C"}