@marcoappio/marco-config 2.0.492 → 2.0.493

package/dist/zero/mutators/draftMutators/draftMutators.js

@@ -1,7 +1,57 @@
-import { MutationError } from '../../../types';
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../schemas';
+import { DRAFT_ATTACHMENT_UPLOAD_STATUSES, DRAFT_STATUSES, DRAFT_TYPES, MutationError } from '../../../types';
 import { stringPatch } from '../../../utils';
-export const createDraftMutators = (authData) => ({
-    cancelSend: async (tx, args) => {
+import { defineMutator } from '../../../zero/mutators/defineMutator';
+const draftStatusSchema = v.picklist(DRAFT_STATUSES);
+const draftTypeSchema = v.picklist(DRAFT_TYPES);
+const draftBodySchema = v.object({
+    bcc: v.array(marcoSchemas.string.email()),
+    cc: v.array(marcoSchemas.string.email()),
+    content: v.pipe(v.string(), v.maxLength(384000)),
+    subject: marcoSchemas.string.nullable(),
+    to: v.array(marcoSchemas.string.email()),
+});
+const draftAttachmentSchema = v.object({
+    fileName: marcoSchemas.string.required(),
+    id: marcoSchemas.string.required(),
+    mimeType: marcoSchemas.string.required(),
+    status: v.picklist(DRAFT_ATTACHMENT_UPLOAD_STATUSES),
+    totalSize: marcoSchemas.number.positiveInteger(),
+});
+const draftScheduleSchema = v.union([
+    v.object({
+        id: marcoSchemas.string.required(),
+        kind: v.literal('IMMEDIATE'),
+        undoMs: marcoSchemas.number.positiveInteger(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }),
+    v.object({
+        id: marcoSchemas.string.required(),
+        kind: v.literal('SCHEDULED'),
+        scheduledFor: marcoSchemas.number.positiveInteger(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }),
+]);
+const draftModelSchema = v.object({
+    accountId: marcoSchemas.string.required(),
+    attachments: v.array(draftAttachmentSchema),
+    body: draftBodySchema,
+    error: marcoSchemas.string.nullable(),
+    from: marcoSchemas.string.email(),
+    fromName: marcoSchemas.string.nullable(),
+    id: marcoSchemas.string.required(),
+    referencedMessageId: marcoSchemas.string.nullable(),
+    scheduledFor: v.nullable(marcoSchemas.number.positiveInteger()),
+    status: draftStatusSchema,
+    type: draftTypeSchema,
+    updatedAt: marcoSchemas.number.positiveInteger(),
+});
+export const draftMutators = {
+    cancelSend: defineMutator(v.object({
+        id: marcoSchemas.string.required(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }), async ({ tx, args }) => {
         const draft = await tx.query.draft.where('id', args.id).one().run();
         if (!draft) {
             throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -15,8 +65,12 @@ export const createDraftMutators = (authData) => ({
             status: 'DRAFT',
             updatedAt: args.updatedAt,
         });
-    },
-    createAttachment: async (tx, args) => {
+    }),
+    createAttachment: defineMutator(v.object({
+        attachment: draftAttachmentSchema,
+        id: marcoSchemas.string.required(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }), async ({ tx, args }) => {
         await tx.mutate.draftAttachment.insert({
             draftId: args.id,
             fileName: args.attachment.fileName,
@@ -29,11 +83,8 @@ export const createDraftMutators = (authData) => ({
             id: args.id,
             updatedAt: args.updatedAt,
         });
-    },
-    createDraft: async (tx, args) => {
-        if (!authData) {
-            throw new Error(MutationError.AUTHENTICATION_REQUIRED);
-        }
+    }),
+    createDraft: defineMutator(draftModelSchema, async ({ tx, ctx: { userId }, args }) => {
         await tx.mutate.draft.insert({
             accountId: args.accountId,
             body: {
@@ -53,7 +104,7 @@ export const createDraftMutators = (authData) => ({
             subject: args.body.subject,
             type: args.type,
             updatedAt: args.updatedAt,
-            userId: authData.sub,
+            userId,
         });
         for (const attachment of args.attachments) {
             await tx.mutate.draftAttachment.insert({
@@ -65,8 +116,12 @@ export const createDraftMutators = (authData) => ({
                 totalSize: attachment.totalSize,
             });
         }
-    },
-    deleteAttachment: async (tx, args) => {
+    }),
+    deleteAttachment: defineMutator(v.object({
+        attachmentId: marcoSchemas.string.required(),
+        id: marcoSchemas.string.required(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }), async ({ tx, args }) => {
         await tx.mutate.draftAttachment.delete({
             id: args.attachmentId,
         });
@@ -74,13 +129,15 @@ export const createDraftMutators = (authData) => ({
             id: args.id,
             updatedAt: args.updatedAt,
         });
-    },
-    deleteDraft: async (tx, args) => {
+    }),
+    deleteDraft: defineMutator(v.object({
+        id: marcoSchemas.string.required(),
+    }), async ({ tx, args }) => {
         await tx.mutate.draft.delete({
             id: args.id,
         });
-    },
-    scheduleSend: async (tx, args) => {
+    }),
+    scheduleSend: defineMutator(draftScheduleSchema, async ({ tx, args }) => {
         if (args.kind === 'IMMEDIATE') {
             await tx.mutate.draft.update({
                 id: args.id,
@@ -97,8 +154,12 @@ export const createDraftMutators = (authData) => ({
                 updatedAt: args.updatedAt,
             });
         }
-    },
-    setContent: async (tx, args) => {
+    }),
+    setContent: defineMutator(v.object({
+        id: marcoSchemas.string.required(),
+        patch: marcoSchemas.drafts.contentPatch.patch(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }), async ({ tx, args }) => {
         const draft = await tx.query.draft.where('id', args.id).one().run();
         if (!draft) {
             throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -111,8 +172,12 @@ export const createDraftMutators = (authData) => ({
             id: args.id,
             updatedAt: args.updatedAt,
         });
-    },
-    setEnvelope: async (tx, args) => {
+    }),
+    setEnvelope: defineMutator(v.object({
+        envelope: v.omit(draftBodySchema, ['content']),
+        id: marcoSchemas.string.required(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }), async ({ tx, args }) => {
         const draft = await tx.query.draft.where('id', args.id).one().run();
         if (!draft) {
             throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -128,8 +193,15 @@ export const createDraftMutators = (authData) => ({
             subject: args.envelope.subject,
             updatedAt: args.updatedAt,
         });
-    },
-    setFrom: async (tx, args) => {
+    }),
+    setFrom: defineMutator(v.object({
+        accountId: marcoSchemas.string.required(),
+        aliasId: marcoSchemas.string.required(),
+        from: marcoSchemas.string.email(),
+        fromName: marcoSchemas.string.nullable(),
+        id: marcoSchemas.string.required(),
+        updatedAt: marcoSchemas.number.positiveInteger(),
+    }), async ({ tx, args }) => {
         await tx.mutate.draft.update({
             accountId: args.accountId,
             fromAliasId: args.aliasId,
@@ -138,5 +210,5 @@ export const createDraftMutators = (authData) => ({
             id: args.id,
             updatedAt: args.updatedAt,
         });
-    },
-});
+    }),
+};

package/dist/zero/mutators/index.d.ts

@@ -1,3 +1,4 @@
+export { defineMutator, type MarcoZeroContext } from './defineMutator';
 export type { MarcoZeroMutators } from './mutators';
-export { createMutators, ZeroMutatorValidationError } from './mutators';
+export { mutators } from './mutators';
 //# sourceMappingURL=index.d.ts.map

package/dist/zero/mutators/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zero/mutators/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zero/mutators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACtE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/dist/zero/mutators/index.js

@@ -1 +1,2 @@
-export { createMutators, ZeroMutatorValidationError } from './mutators';
+export { defineMutator } from './defineMutator';
+export { mutators } from './mutators';

package/dist/zero/mutators/mutators.d.ts

@@ -1,18 +1,439 @@
-import * as v from 'valibot';
-import type { MutatorMap } from '../../types';
-import { type ZeroMutatorSchemas } from '../../zero/mutatorSchemas';
-export type AuthData = {
-    sub: string;
-};
-export declare class ZeroMutatorValidationError extends Error {
-    readonly issues: ReturnType<typeof v.flatten>;
-    constructor(issues: ReturnType<typeof v.flatten>);
-}
-export type MarcoZeroMutators = {
-    account: MutatorMap<ZeroMutatorSchemas['account']>;
-    draft: MutatorMap<ZeroMutatorSchemas['draft']>;
-    thread: MutatorMap<ZeroMutatorSchemas['thread']>;
-    user: MutatorMap<ZeroMutatorSchemas['user']>;
-};
-export declare const createMutators: (authData?: AuthData) => MarcoZeroMutators;
+export { defineMutator, type MarcoZeroContext } from './defineMutator';
+export declare const mutators: import("@rocicorp/zero").MutatorRegistry<{
+    readonly account: {
+        createAccount: import("@rocicorp/zero").MutatorDefinition<{
+            aliasId: string;
+            color: string;
+            emailAddress: string;
+            id: string;
+        }, {
+            aliasId: string;
+            color: string;
+            emailAddress: string;
+            id: string;
+        }, import("./defineMutator").MarcoZeroContext>;
+        createAlias: import("@rocicorp/zero").MutatorDefinition<{
+            accountId: string;
+            alias: {
+                emailAddress: string;
+                id: string;
+                name: string | null;
+            };
+        }, {
+            accountId: string;
+            alias: {
+                emailAddress: string;
+                id: string;
+                name: string | null;
+            };
+        }, import("./defineMutator").MarcoZeroContext>;
+        deleteAccount: import("@rocicorp/zero").MutatorDefinition<{
+            id: string;
+        }, {
+            id: string;
+        }, import("./defineMutator").MarcoZeroContext>;
+        deleteAlias: import("@rocicorp/zero").MutatorDefinition<{
+            accountId: string;
+            aliasId: string;
+        }, {
+            accountId: string;
+            aliasId: string;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setAliasName: import("@rocicorp/zero").MutatorDefinition<{
+            accountId: string;
+            aliasId: string;
+            displayName: string | null;
+        }, {
+            accountId: string;
+            aliasId: string;
+            displayName: string | null;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setAliasPrimary: import("@rocicorp/zero").MutatorDefinition<{
+            accountId: string;
+            aliasId: string;
+        }, {
+            accountId: string;
+            aliasId: string;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setConnectionConfigImapRaw: import("@rocicorp/zero").MutatorDefinition<{
+            connectionConfig: {
+                imapHost: string;
+                imapPassword: string;
+                imapPort: number;
+                imapSocketType: "STARTTLS" | "SSL";
+                imapUser: string;
+                smtpHost: string;
+                smtpPassword: string;
+                smtpPort: number;
+                smtpSocketType: "STARTTLS" | "SSL";
+                smtpUser: string;
+            };
+            id: string;
+        }, {
+            connectionConfig: {
+                imapHost: string;
+                imapPassword: string;
+                imapPort: number;
+                imapSocketType: "STARTTLS" | "SSL";
+                imapUser: string;
+                smtpHost: string;
+                smtpPassword: string;
+                smtpPort: number;
+                smtpSocketType: "STARTTLS" | "SSL";
+                smtpUser: string;
+            };
+            id: string;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setConnectionConfigOauth: import("@rocicorp/zero").MutatorDefinition<{
+            connectionConfig: {
+                code: string;
+                provider: "GOOGLE" | "OUTLOOK";
+                user: string;
+            };
+            id: string;
+        }, {
+            connectionConfig: {
+                code: string;
+                provider: "GOOGLE" | "OUTLOOK";
+                user: string;
+            };
+            id: string;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setSettings: import("@rocicorp/zero").MutatorDefinition<{
+            color?: string | null | undefined;
+            displayName?: string | null | undefined;
+            id: string;
+        }, {
+            color?: string | null | undefined;
+            displayName?: string | null | undefined;
+            id: string;
+        }, import("./defineMutator").MarcoZeroContext>;
+    };
+    readonly draft: {
+        cancelSend: import("@rocicorp/zero").MutatorDefinition<{
+            id: string;
+            updatedAt: number;
+        }, {
+            id: string;
+            updatedAt: number;
+        }, import("./defineMutator").MarcoZeroContext>;
+        createAttachment: import("@rocicorp/zero").MutatorDefinition<{
+            attachment: {
+                fileName: string;
+                id: string;
+                mimeType: string;
+                status: "PENDING" | "COMPLETE" | "FAILED";
+                totalSize: number;
+            };
+            id: string;
+            updatedAt: number;
+        }, {
+            attachment: {
+                fileName: string;
+                id: string;
+                mimeType: string;
+                status: "PENDING" | "COMPLETE" | "FAILED";
+                totalSize: number;
+            };
+            id: string;
+            updatedAt: number;
+        }, import("./defineMutator").MarcoZeroContext>;
+        createDraft: import("@rocicorp/zero").MutatorDefinition<{
+            accountId: string;
+            attachments: {
+                fileName: string;
+                id: string;
+                mimeType: string;
+                status: "PENDING" | "COMPLETE" | "FAILED";
+                totalSize: number;
+            }[];
+            body: {
+                bcc: string[];
+                cc: string[];
+                content: string;
+                subject: string | null;
+                to: string[];
+            };
+            error: string | null;
+            from: string;
+            fromName: string | null;
+            id: string;
+            referencedMessageId: string | null;
+            scheduledFor: number | null;
+            status: "DRAFT" | "SEND_REQUESTED" | "SEND_CONFIRMED" | "SEND_FAILED";
+            type: "NEW" | "REPLY" | "FORWARD";
+            updatedAt: number;
+        }, {
+            accountId: string;
+            attachments: {
+                fileName: string;
+                id: string;
+                mimeType: string;
+                status: "PENDING" | "COMPLETE" | "FAILED";
+                totalSize: number;
+            }[];
+            body: {
+                bcc: string[];
+                cc: string[];
+                content: string;
+                subject: string | null;
+                to: string[];
+            };
+            error: string | null;
+            from: string;
+            fromName: string | null;
+            id: string;
+            referencedMessageId: string | null;
+            scheduledFor: number | null;
+            status: "DRAFT" | "SEND_REQUESTED" | "SEND_CONFIRMED" | "SEND_FAILED";
+            type: "NEW" | "REPLY" | "FORWARD";
+            updatedAt: number;
+        }, import("./defineMutator").MarcoZeroContext>;
+        deleteAttachment: import("@rocicorp/zero").MutatorDefinition<{
+            attachmentId: string;
+            id: string;
+            updatedAt: number;
+        }, {
+            attachmentId: string;
+            id: string;
+            updatedAt: number;
+        }, import("./defineMutator").MarcoZeroContext>;
+        deleteDraft: import("@rocicorp/zero").MutatorDefinition<{
+            id: string;
+        }, {
+            id: string;
+        }, import("./defineMutator").MarcoZeroContext>;
+        scheduleSend: import("@rocicorp/zero").MutatorDefinition<{
+            id: string;
+            kind: "IMMEDIATE";
+            undoMs: number;
+            updatedAt: number;
+        } | {
+            id: string;
+            kind: "SCHEDULED";
+            scheduledFor: number;
+            updatedAt: number;
+        }, {
+            id: string;
+            kind: "IMMEDIATE";
+            undoMs: number;
+            updatedAt: number;
+        } | {
+            id: string;
+            kind: "SCHEDULED";
+            scheduledFor: number;
+            updatedAt: number;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setContent: import("@rocicorp/zero").MutatorDefinition<{
+            id: string;
+            patch: {
+                index: number;
+                type: "INSERTION" | "DELETION";
+                value: string;
+            }[];
+            updatedAt: number;
+        }, {
+            id: string;
+            patch: {
+                index: number;
+                type: "INSERTION" | "DELETION";
+                value: string;
+            }[];
+            updatedAt: number;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setEnvelope: import("@rocicorp/zero").MutatorDefinition<{
+            envelope: {
+                bcc: string[];
+                cc: string[];
+                to: string[];
+                subject: string | null;
+            };
+            id: string;
+            updatedAt: number;
+        }, {
+            envelope: {
+                bcc: string[];
+                cc: string[];
+                to: string[];
+                subject: string | null;
+            };
+            id: string;
+            updatedAt: number;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setFrom: import("@rocicorp/zero").MutatorDefinition<{
+            accountId: string;
+            aliasId: string;
+            from: string;
+            fromName: string | null;
+            id: string;
+            updatedAt: number;
+        }, {
+            accountId: string;
+            aliasId: string;
+            from: string;
+            fromName: string | null;
+            id: string;
+            updatedAt: number;
+        }, import("./defineMutator").MarcoZeroContext>;
+    };
+    readonly thread: {
+        addLabel: import("@rocicorp/zero").MutatorDefinition<{
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+            labelPath: string;
+        }, {
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+            labelPath: string;
+        }, import("./defineMutator").MarcoZeroContext>;
+        delete: import("@rocicorp/zero").MutatorDefinition<{
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+        }, {
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+        }, import("./defineMutator").MarcoZeroContext>;
+        removeLabel: import("@rocicorp/zero").MutatorDefinition<{
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+            labelPath: string;
+        }, {
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+            labelPath: string;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setArchive: import("@rocicorp/zero").MutatorDefinition<{
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+        }, {
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+        }, import("./defineMutator").MarcoZeroContext>;
+        setFlagged: import("@rocicorp/zero").MutatorDefinition<{
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+            flagged: boolean;
+        }, {
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+            flagged: boolean;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setInbox: import("@rocicorp/zero").MutatorDefinition<{
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+        }, {
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+        }, import("./defineMutator").MarcoZeroContext>;
+        setSeen: import("@rocicorp/zero").MutatorDefinition<{
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+            seen: boolean;
+        }, {
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+            seen: boolean;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setSpam: import("@rocicorp/zero").MutatorDefinition<{
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+        }, {
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+        }, import("./defineMutator").MarcoZeroContext>;
+        setTrash: import("@rocicorp/zero").MutatorDefinition<{
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+        }, {
+            accounts: {
+                [x: string]: {
+                    threadIds: string[];
+                };
+            };
+        }, import("./defineMutator").MarcoZeroContext>;
+    };
+    readonly user: {
+        deleteSettingsPushNotificationToken: import("@rocicorp/zero").MutatorDefinition<{
+            id: string;
+            token: string;
+        }, {
+            id: string;
+            token: string;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setSettingsName: import("@rocicorp/zero").MutatorDefinition<{
+            id: string;
+            name: string | null;
+        }, {
+            id: string;
+            name: string | null;
+        }, import("./defineMutator").MarcoZeroContext>;
+        setSettingsPushNotificationToken: import("@rocicorp/zero").MutatorDefinition<{
+            id: string;
+            pushNotificationToken: {
+                createdAt: number;
+                id: string;
+                token: string;
+            };
+        }, {
+            id: string;
+            pushNotificationToken: {
+                createdAt: number;
+                id: string;
+                token: string;
+            };
+        }, import("./defineMutator").MarcoZeroContext>;
+    };
+}, import("@rocicorp/zero").Schema>;
+export type MarcoZeroMutators = typeof mutators;
 //# sourceMappingURL=mutators.d.ts.map

package/dist/zero/mutators/mutators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutators.d.ts","sourceRoot":"","sources":["../../../src/zero/mutators/mutators.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,KAAK,EAAkD,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACrG,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,mCAAmC,CAAA;AAQ/F,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AA8BD,qBAAa,0BAA2B,SAAQ,KAAK;IACvC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;gBAApC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;CAG1D;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAA;IAClD,KAAK,EAAE,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAA;IAC9C,MAAM,EAAE,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAA;IAChD,IAAI,EAAE,UAAU,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAA;CAC7C,CAAA;AAED,eAAO,MAAM,cAAc,cAAe,QAAQ,KAAG,iBAKnD,CAAA"}
+{"version":3,"file":"mutators.d.ts","sourceRoot":"","sources":["../../../src/zero/mutators/mutators.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,aAAa,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAEtE,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAKnB,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,OAAO,QAAQ,CAAA"}