@mercuryo-ai/magicpay-cli 0.1.0

package/dist/commands/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/commands/extract.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACxB,MAAM,0BAA0B,CAAC;AAGlC,YAAY,EAAE,aAAa,EAAE,CAAC;AAO9B,wBAAsB,OAAO,CAC3B,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,CAAC,CAOxB"}

package/dist/commands/extract.js

@@ -0,0 +1,14 @@
+import { extract as extractPrimitive, } from '@mercuryo-ai/agentbrowse';
+import { saveMagicPaySession } from '../workflow-state.js';
+async function ensureAssistiveRuntime() {
+    const { ensureMagicPayAgentbrowseAssistiveRuntime } = await import('../agentbrowse-assistive.js');
+    ensureMagicPayAgentbrowseAssistiveRuntime();
+}
+export async function extract(session, schema, scopeRef) {
+    await ensureAssistiveRuntime();
+    const result = await extractPrimitive(session, schema, scopeRef);
+    if (result.success || result.staleScope === true) {
+        saveMagicPaySession(session);
+    }
+    return result;
+}

package/dist/commands/fill-secret.d.ts

@@ -0,0 +1,10 @@
+import { type MagicPaySession } from '../workflow-state.js';
+export type FillSecretResult = ({
+    success: true;
+} & Record<string, unknown>) | ({
+    success: false;
+    error: string;
+    outcomeType?: string;
+} & Record<string, unknown>);
+export declare function fillSecret(session: MagicPaySession, fillRef: string, requestId: string): Promise<FillSecretResult>;
+//# sourceMappingURL=fill-secret.d.ts.map

package/dist/commands/fill-secret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fill-secret.d.ts","sourceRoot":"","sources":["../../src/commands/fill-secret.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAuB,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEjF,MAAM,MAAM,gBAAgB,GACxB,CAAC;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC7C,CAAC;IACC,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAsGjC,wBAAsB,UAAU,CAC9B,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,gBAAgB,CAAC,CAse3B"}

package/dist/commands/fill-secret.js

@@ -0,0 +1,483 @@
+import { prepareProtectedFillFromClaim } from '@mercuryo-ai/magicpay-sdk/agentbrowse';
+import { describeSecretRequestStatus, evaluateSecretRequestForFill, resolveCatalogHost, } from '@mercuryo-ai/magicpay-sdk/core';
+import { buildProtectedExposureArtifacts as buildProtectedExposureArtifactsFromFill, fillProtectedForm, } from '@mercuryo-ai/agentbrowse/protected-fill';
+import { getFillableForm } from '../fillable-form-state.js';
+import { exportRunStepToOtlpHttpJsonBestEffort } from '../otel-exporter.js';
+import { activateProtectedExposure } from '../protected-exposure.js';
+import { serializeSecretRequestContext } from '../request-output.js';
+import { finishRunStep, startRunStep } from '../run-store.js';
+import { getMagicPayClient } from '../secret-backend.js';
+import { getSecretCatalog, getSecretRequestSnapshot, saveSecretRequestSnapshot } from '../secret-state.js';
+import { observe } from './observe.js';
+import { getResolvedSubmitTarget, submitForm } from './submit-form.js';
+import { saveMagicPaySession } from '../workflow-state.js';
+function withFillableFormPresence(fillableForm, payload) {
+    return {
+        ...payload,
+        fillableFormPresence: fillableForm.presence ?? 'present',
+    };
+}
+function failureForUnfulfilledRequest(fillableForm, request, fillRef, requestId) {
+    const statusContract = describeSecretRequestStatus(request.status, request.requestType);
+    return {
+        success: false,
+        ...withFillableFormPresence(fillableForm, {
+            error: 'secret_request_not_ready',
+            ...(statusContract.outcomeType ? { outcomeType: statusContract.outcomeType } : {}),
+            message: request.status === 'pending'
+                ? 'Protected fill is waiting for user approval in MagicPay.'
+                : statusContract.message,
+            reason: statusContract.reason,
+            fillRef,
+            requestId,
+            ...serializeSecretRequestContext(request),
+            requestStatus: request.status,
+            nextAction: statusContract.nextAction ?? 'poll-secret',
+        }),
+    };
+}
+function markRequestClaimed(session, request, claimedAt) {
+    const nextRequest = saveSecretRequestSnapshot(session, {
+        ...request,
+        claimedAt,
+        updatedAt: claimedAt,
+    });
+    if (session.currentRequestId === request.requestId) {
+        session.currentRequestId = undefined;
+        session.lastKnownStatus = 'in_progress';
+    }
+    saveMagicPaySession(session);
+    return nextRequest;
+}
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error && typeof error === 'object') {
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return Object.prototype.toString.call(error);
+        }
+    }
+    return String(error);
+}
+function buildSuccessfulFillPayload(fillableForm, request, fillRef, requestId, filledFields) {
+    return withFillableFormPresence(fillableForm, {
+        fillRef,
+        requestId,
+        ...serializeSecretRequestContext(request),
+        requestStatus: request.status,
+        filledFields,
+    });
+}
+async function ensureAssistiveRuntime() {
+    const { ensureMagicPayAgentbrowseAssistiveRuntime } = await import('../agentbrowse-assistive.js');
+    ensureMagicPayAgentbrowseAssistiveRuntime();
+}
+export async function fillSecret(session, fillRef, requestId) {
+    const step = session.activeRunId
+        ? startRunStep({
+            runId: session.activeRunId,
+            command: 'fill-secret',
+            input: {
+                fillRef,
+                requestId,
+            },
+            refs: {
+                pageRef: session.runtime?.currentPageRef,
+                fillRef,
+                requestId,
+            },
+            protectedStep: true,
+        })
+        : null;
+    const finalizeStep = async (result) => {
+        if (step) {
+            finishRunStep({
+                runId: step.runId,
+                stepId: step.stepId,
+                success: result.success,
+                ...('outcomeType' in result && typeof result.outcomeType === 'string'
+                    ? { outcomeType: result.outcomeType }
+                    : {}),
+                ...('message' in result && typeof result.message === 'string'
+                    ? { message: result.message }
+                    : {}),
+                ...('reason' in result && typeof result.reason === 'string'
+                    ? { reason: result.reason }
+                    : {}),
+            });
+            await exportRunStepToOtlpHttpJsonBestEffort(step.runId, step.stepId);
+        }
+        return result;
+    };
+    try {
+        if (!session.intentSessionId) {
+            return finalizeStep({
+                success: false,
+                error: 'workflow_session_required',
+                outcomeType: 'blocked',
+                message: 'Protected fill was not started because no active workflow session is bound to this browser.',
+                reason: 'Run `magicpay start-session` first so MagicPay has a workflow session for protected requests.',
+                fillRef,
+                requestId,
+            });
+        }
+        const fillableForm = getFillableForm(session, fillRef);
+        if (!fillableForm) {
+            return finalizeStep({
+                success: false,
+                error: 'unknown_fill_ref',
+                outcomeType: 'blocked',
+                message: 'Protected fill was not started because the requested fill reference is unknown.',
+                reason: 'The provided fillRef does not match any currently observed protected fill target.',
+                fillRef,
+                requestId,
+            });
+        }
+        if (fillableForm.presence === 'absent') {
+            return finalizeStep({
+                success: false,
+                ...withFillableFormPresence(fillableForm, {
+                    error: 'fillable_form_absent',
+                    outcomeType: 'blocked',
+                    message: 'Protected fill was not started because the requested fill target is no longer present on the page.',
+                    reason: 'MagicPay CLI already observed this protected fill target as absent, so a new observe pass is required before protected fill can continue.',
+                    fillRef,
+                    requestId,
+                }),
+            });
+        }
+        const client = getMagicPayClient();
+        const latestRequest = getSecretRequestSnapshot(session, requestId);
+        if (!latestRequest) {
+            return finalizeStep({
+                success: false,
+                error: 'secret_request_not_found',
+                outcomeType: 'blocked',
+                message: 'Protected fill was not started because the requested secret request does not exist.',
+                reason: 'Run `magicpay request-secret` and `magicpay poll-secret` first so the latest request state is cached locally.',
+                fillRef,
+                requestId,
+            });
+        }
+        const pageState = session.runtime?.pages?.[fillableForm.pageRef];
+        const observedHost = pageState?.url ? resolveCatalogHost(pageState.url) : null;
+        const fillReadiness = evaluateSecretRequestForFill(latestRequest, {
+            fillRef,
+            observedHost,
+            observedScopeRef: fillableForm.scopeRef,
+        });
+        if (fillReadiness.kind === 'fill_mismatch') {
+            return finalizeStep({
+                success: false,
+                ...withFillableFormPresence(fillableForm, {
+                    error: 'secret_request_fill_mismatch',
+                    outcomeType: 'blocked',
+                    message: 'Protected fill was blocked because the approved secret request belongs to a different fill target.',
+                    reason: `The approved request belongs to fillRef ${fillReadiness.requestFillRef}, not ${fillRef}.`,
+                    fillRef,
+                    requestId,
+                    ...serializeSecretRequestContext(latestRequest),
+                    requestFillRef: fillReadiness.requestFillRef,
+                    requestStatus: latestRequest.status,
+                    nextAction: 'reobserve',
+                }),
+            });
+        }
+        if (fillReadiness.kind === 'already_claimed') {
+            return finalizeStep({
+                success: false,
+                ...withFillableFormPresence(fillableForm, {
+                    error: 'secret_request_already_claimed',
+                    outcomeType: 'blocked',
+                    message: 'Protected fill could not continue because this one-time secret request was already claimed earlier.',
+                    reason: 'Secret values can only be claimed once for this request, so MagicPay CLI needs a new request before it can fill again.',
+                    fillRef,
+                    requestId,
+                    ...serializeSecretRequestContext(latestRequest),
+                    requestStatus: latestRequest.status,
+                    nextAction: 'request-secret',
+                }),
+            });
+        }
+        if (fillReadiness.kind === 'not_ready') {
+            return finalizeStep(failureForUnfulfilledRequest(fillableForm, latestRequest, fillRef, requestId));
+        }
+        if (fillReadiness.kind === 'context_mismatch') {
+            return finalizeStep({
+                success: false,
+                ...withFillableFormPresence(fillableForm, {
+                    error: 'secret_request_context_mismatch',
+                    outcomeType: 'blocked',
+                    message: 'Protected fill was blocked because the page or protected surface no longer matches the approved request context.',
+                    reason: 'The current page host or protected surface no longer matches the context that was approved for this request.',
+                    fillRef,
+                    requestId,
+                    ...serializeSecretRequestContext(latestRequest),
+                    requestStatus: latestRequest.status,
+                    nextAction: 'reobserve',
+                    requestReusable: true,
+                    mismatchReasons: fillReadiness.mismatchReasons,
+                    ...(fillReadiness.expectedHost ? { expectedHost: fillReadiness.expectedHost } : {}),
+                    ...(fillReadiness.observedHost ? { observedHost: fillReadiness.observedHost } : {}),
+                    ...(fillReadiness.expectedScopeRef
+                        ? { expectedScopeRef: fillReadiness.expectedScopeRef }
+                        : {}),
+                    ...(fillReadiness.observedScopeRef
+                        ? { observedScopeRef: fillReadiness.observedScopeRef }
+                        : {}),
+                }),
+            });
+        }
+        let claimedAt = new Date().toISOString();
+        let claimStoredSecretRef = latestRequest.storedSecretRef;
+        let claimKind = latestRequest.kind;
+        const claim = await client.secrets.claim(session.intentSessionId, requestId);
+        if (!claim.success) {
+            if (claim.kind === 'not_fulfilled') {
+                return finalizeStep(failureForUnfulfilledRequest(fillableForm, latestRequest, fillRef, requestId));
+            }
+            if (claim.kind === 'already_claimed') {
+                return finalizeStep({
+                    success: false,
+                    ...withFillableFormPresence(fillableForm, {
+                        error: 'secret_request_already_claimed',
+                        outcomeType: 'blocked',
+                        message: 'Protected fill could not continue because this one-time secret request was already claimed earlier.',
+                        reason: 'Secret values can only be claimed once for this request, so MagicPay CLI needs a new request before it can fill again.',
+                        fillRef,
+                        requestId,
+                        ...serializeSecretRequestContext(latestRequest),
+                        requestStatus: latestRequest.status,
+                        nextAction: 'request-secret',
+                    }),
+                });
+            }
+            return finalizeStep({
+                success: false,
+                ...withFillableFormPresence(fillableForm, {
+                    error: 'secret_claim_failed',
+                    outcomeType: 'blocked',
+                    message: 'Protected fill could not continue because MagicPay CLI failed to claim the one-time secret payload.',
+                    reason: claim.reason,
+                    fillRef,
+                    requestId,
+                    ...serializeSecretRequestContext(latestRequest),
+                    requestStatus: latestRequest.status,
+                    nextAction: 'ask-user',
+                }),
+            });
+        }
+        claimedAt = claim.result.issuedAt;
+        claimStoredSecretRef = claim.result.secret.storedSecretRef ?? claimStoredSecretRef;
+        claimKind = claim.result.secret.kind ?? claimKind;
+        const claimedRequest = markRequestClaimed(session, latestRequest, claimedAt);
+        const persistedRequest = claimStoredSecretRef || claimKind
+            ? saveSecretRequestSnapshot(session, {
+                ...claimedRequest,
+                ...(claimStoredSecretRef ? { storedSecretRef: claimStoredSecretRef } : {}),
+                ...(claimKind ? { kind: claimKind } : {}),
+            })
+            : claimedRequest;
+        saveMagicPaySession(session);
+        const preparedFill = prepareProtectedFillFromClaim({
+            fillableForm,
+            catalog: observedHost ? getSecretCatalog(session, observedHost) : null,
+            claim: claim.result,
+            request: {
+                storedSecretRef: claimStoredSecretRef ?? latestRequest.storedSecretRef,
+            },
+        });
+        const { fillableForm: executableForm } = preparedFill;
+        const protectedExposureArtifacts = buildProtectedExposureArtifactsFromFill({
+            session,
+            fillableForm: executableForm,
+            protectedValues: preparedFill.protectedValues,
+            fieldPolicies: preparedFill.fieldPolicies,
+        });
+        await ensureAssistiveRuntime();
+        const browserFill = await fillProtectedForm({
+            session,
+            fillableForm: executableForm,
+            protectedValues: preparedFill.protectedValues,
+            fieldPolicies: preparedFill.fieldPolicies,
+        });
+        if (!browserFill.success) {
+            return finalizeStep({
+                success: false,
+                ...withFillableFormPresence(fillableForm, {
+                    error: browserFill.error,
+                    outcomeType: 'blocked',
+                    message: browserFill.message,
+                    reason: browserFill.reason,
+                    fillRef,
+                    requestId,
+                    ...serializeSecretRequestContext(persistedRequest),
+                    requestStatus: persistedRequest.status,
+                    requestReusable: false,
+                    nextAction: 'ask-user',
+                }),
+            });
+        }
+        saveMagicPaySession(session);
+        if (browserFill.execution.kind === 'success') {
+            activateProtectedExposure(session, fillableForm, requestId, 'protected_fill_success', protectedExposureArtifacts);
+            saveMagicPaySession(session);
+            const successfulFillPayload = buildSuccessfulFillPayload(fillableForm, persistedRequest, fillRef, requestId, browserFill.execution.filledFields);
+            const postFillObserve = await observe(session);
+            if (!postFillObserve.success) {
+                return finalizeStep({
+                    success: true,
+                    outcomeType: 'filled',
+                    ...successfulFillPayload,
+                    autoSubmitAttempted: false,
+                    autoSubmitSkippedReason: 'post_fill_observe_failed',
+                    postFillObserve,
+                    nextAction: 'ask-user',
+                    message: 'Protected fill completed successfully, but MagicPay could not refresh the page after fill, so automatic submit was skipped.',
+                    reason: postFillObserve.reason,
+                });
+            }
+            const refreshedSubmitTarget = getResolvedSubmitTarget(session, fillRef);
+            if (!refreshedSubmitTarget) {
+                return finalizeStep({
+                    success: true,
+                    outcomeType: 'filled',
+                    ...successfulFillPayload,
+                    autoSubmitAttempted: false,
+                    autoSubmitSkippedReason: 'submit_target_not_found_after_fill',
+                    postFillObserve,
+                    nextAction: 'ask-user',
+                    message: 'Protected fill completed successfully, but no live submit control was found after refresh, so automatic submit was skipped.',
+                    reason: 'MagicPay refreshed the page after protected fill but still could not resolve one live submit target for the protected form.',
+                });
+            }
+            const submitResult = await submitForm(session, fillRef);
+            if (!submitResult.success) {
+                return finalizeStep({
+                    success: false,
+                    error: submitResult.error,
+                    outcomeType: submitResult.outcomeType,
+                    ...successfulFillPayload,
+                    autoSubmitAttempted: true,
+                    submitTarget: refreshedSubmitTarget,
+                    postFillObserve,
+                    submitResult,
+                    nextAction: submitResult.nextAction,
+                    message: submitResult.message,
+                    reason: submitResult.reason,
+                });
+            }
+            const postSubmitObserve = await observe(session);
+            if (!postSubmitObserve.success) {
+                return finalizeStep({
+                    success: true,
+                    outcomeType: 'submitted',
+                    ...successfulFillPayload,
+                    autoSubmitAttempted: true,
+                    submitTarget: refreshedSubmitTarget,
+                    postFillObserve,
+                    submitResult,
+                    postSubmitObserve,
+                    nextAction: 'ask-user',
+                    message: 'Protected fill completed successfully, MagicPay submitted the form, but the follow-up observe did not complete.',
+                    reason: postSubmitObserve.reason,
+                });
+            }
+            return finalizeStep({
+                success: true,
+                outcomeType: 'submitted',
+                ...successfulFillPayload,
+                autoSubmitAttempted: true,
+                submitTarget: refreshedSubmitTarget,
+                postFillObserve,
+                submitResult,
+                postSubmitObserve,
+                message: 'Protected fill completed successfully, MagicPay submitted the form, and post-submit observe captured the updated page state.',
+                reason: 'MagicPay refreshed the page after protected fill, resolved a live submit control, submitted the protected form, and observed the resulting page state.',
+            });
+        }
+        if (browserFill.execution.kind === 'binding_stale') {
+            activateProtectedExposure(session, fillableForm, requestId, 'protected_fill_binding_stale', protectedExposureArtifacts);
+            saveMagicPaySession(session);
+            return finalizeStep({
+                success: false,
+                ...withFillableFormPresence(fillableForm, {
+                    error: 'secret_fill_binding_stale',
+                    outcomeType: 'binding_stale',
+                    message: 'Protected fill was blocked because the stored field bindings are no longer valid on the page.',
+                    fillRef,
+                    requestId,
+                    ...serializeSecretRequestContext(persistedRequest),
+                    requestStatus: persistedRequest.status,
+                    nextAction: 'reobserve',
+                    requestReusable: false,
+                    targetRef: browserFill.execution.targetRef,
+                    fieldKeys: browserFill.execution.fieldKeys,
+                    reason: browserFill.execution.reason,
+                    attempts: browserFill.execution.attempts,
+                }),
+            });
+        }
+        if (browserFill.execution.kind === 'validation_failed') {
+            activateProtectedExposure(session, fillableForm, requestId, 'protected_fill_validation_failed', protectedExposureArtifacts);
+            saveMagicPaySession(session);
+            return finalizeStep({
+                success: false,
+                ...withFillableFormPresence(fillableForm, {
+                    error: 'secret_validation_failed',
+                    outcomeType: 'blocked',
+                    message: 'Protected fill stopped because the stored data did not pass client-side validation.',
+                    reason: 'Protected execution reported client-side validation errors for one or more filled fields.',
+                    fillRef,
+                    requestId,
+                    ...serializeSecretRequestContext(persistedRequest),
+                    requestStatus: persistedRequest.status,
+                    executionResult: 'validation_failed',
+                    nextAction: 'ask-user',
+                    manualOverrideAllowed: true,
+                    requestReusable: false,
+                    filledFields: browserFill.execution.filledFields,
+                    fieldErrors: browserFill.execution.fieldErrors,
+                }),
+            });
+        }
+        activateProtectedExposure(session, fillableForm, requestId, 'protected_fill_unexpected_error', protectedExposureArtifacts);
+        saveMagicPaySession(session);
+        return finalizeStep({
+            success: false,
+            ...withFillableFormPresence(fillableForm, {
+                error: 'protected_fill_execution_failed',
+                outcomeType: 'blocked',
+                message: 'Protected fill failed during protected execution, so this claimed request must not be reused.',
+                fillRef,
+                requestId,
+                ...serializeSecretRequestContext(persistedRequest),
+                requestStatus: persistedRequest.status,
+                requestReusable: false,
+                nextAction: 'ask-user',
+                reason: browserFill.execution.reason,
+            }),
+        });
+    }
+    catch (error) {
+        if (step) {
+            finishRunStep({
+                runId: step.runId,
+                stepId: step.stepId,
+                success: false,
+                outcomeType: 'secret_fill_failed',
+                message: 'Protected fill failed.',
+                reason: formatUnknownError(error),
+            });
+            await exportRunStepToOtlpHttpJsonBestEffort(step.runId, step.stepId);
+        }
+        throw error;
+    }
+}

package/dist/commands/find-form.d.ts

@@ -0,0 +1,57 @@
+import type { BrowserSessionState } from '@mercuryo-ai/agentbrowse';
+import { type ResolvedSubmitTarget } from './submit-form.js';
+export type FindFormPurpose = 'auto' | 'login' | 'identity' | 'payment_card';
+type FindFormView = {
+    fillRef: string;
+    scopeRef?: string;
+    purpose: string;
+    presence: 'present' | 'unknown';
+    observedAt: string;
+    fields: Array<{
+        fieldKey: string;
+        targetRef: string;
+        label?: string;
+        required?: boolean;
+        valueHint?: string;
+    }>;
+    storedSecretCandidates: Array<{
+        storedSecretRef: string;
+        kind: string;
+        scope: string;
+        displayName: string;
+        matchConfidence: 'high' | 'medium' | 'low';
+        intentRequired: boolean;
+    }>;
+    submit?: ResolvedSubmitTarget;
+};
+export type FindFormResult = {
+    success: true;
+    outcomeType: 'form_found';
+    pageRef: string;
+    url: string;
+    title: string;
+    host?: string;
+    purpose: string;
+    formCount: number;
+    selectedFillRef: string;
+    selectionReason: string;
+    nextAction: 'request-secret';
+    forms: FindFormView[];
+} | {
+    success: false;
+    outcomeType: 'blocked';
+    error: 'browser_connection_failed' | 'page_resolution_failed' | 'protected_form_not_found' | 'protected_form_ambiguous';
+    message: string;
+    reason: string;
+    pageRef?: string;
+    url?: string;
+    title?: string;
+    purpose?: string;
+    forms?: FindFormView[];
+    nextAction: 'attach' | 'ask-user';
+};
+export declare function findForm(session: BrowserSessionState, options?: {
+    purpose?: FindFormPurpose;
+}): Promise<FindFormResult>;
+export {};
+//# sourceMappingURL=find-form.d.ts.map

package/dist/commands/find-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-form.d.ts","sourceRoot":"","sources":["../../src/commands/find-form.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAKpE,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,kBAAkB,CAAC;AAE1B,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,cAAc,CAAC;AAE7E,KAAK,YAAY,GAAG;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,SAAS,GAAG,SAAS,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,KAAK,CAAC;QACZ,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;IACH,sBAAsB,EAAE,KAAK,CAAC;QAC5B,eAAe,EAAE,MAAM,CAAC;QACxB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;QACpB,eAAe,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;QAC3C,cAAc,EAAE,OAAO,CAAC;KACzB,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,oBAAoB,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,cAAc,GACtB;IACE,OAAO,EAAE,IAAI,CAAC;IACd,WAAW,EAAE,YAAY,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB,GACD;IACE,OAAO,EAAE,KAAK,CAAC;IACf,WAAW,EAAE,SAAS,CAAC;IACvB,KAAK,EACD,2BAA2B,GAC3B,wBAAwB,GACxB,0BAA0B,GAC1B,0BAA0B,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;IACvB,UAAU,EAAE,QAAQ,GAAG,UAAU,CAAC;CACnC,CAAC;AA2EN,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,mBAAmB,EAC5B,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,eAAe,CAAA;CAAO,GAC1C,OAAO,CAAC,cAAc,CAAC,CAiFzB"}