@envelop/persisted-operations 1.0.0 → 2.1.0-alpha-e8998c9.0

package/README.md

@@ -12,50 +12,99 @@ yarn add @envelop/persisted-operations
 
 ## Usage Example
 
+The most basic implementation can use an in-memory JS `Map` wrapper with a `Store` object:
+
 ```ts
 import { envelop } from '@envelop/core';
-import { usePersistedOperations } from '@envelop/persisted-operations';
+import { usePersistedOperations, InMemoryStore } from '@envelop/persisted-operations';
+
+// You can retrieve the store in any way (e.g. from a remote source) and implement it with a simple Map / Key->Value
+const myData = new Map();
+myData.set('persisted_1', parse(`query { ... }`));
+myData.set('persisted_2', 'query { ... }'));
+
+const store = new InMemoryStore({
+  initialData: myData,
+})
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
     usePersistedOperations({
       store: myStore,
-      onlyPersistedOperations: true, // Change to false, to allow regular operations in addition
     }),
   ],
 });
 ```
 
-Store implementation is based on 2 simple functions, you can connect to any data store that holds your Key => Value data.
+Now, when running operations through your GraphQL server, you can use a key instead of a query language:
+
+```json
+{
+  "query": "persisted_1",
+  "variables": {}
+}
+```
 
-Here's a simple example for an in-memory store:
+You can also provide a function to retrieve the operation id from a custom property available in your context / incoming request:
 
 ```ts
-import { PersistedOperationsStore } from '@envelop/persisted-operations';
+usePersistedOperations({
+  store: myStore,
+  extractOperationId: (context) => context.request.body.operationId // get id from custom property in body object
+}),
+```
+
+## Usage Example with built-in JsonFileStore
+
+```ts
+import { usePersistedOperations, JsonFileStore } from '@envelop/persisted-operations';
+
+const persistedOperationsStore = new JsonFilesStore();
+const filePath = resolve(process.cwd(), 'assets/client1PersistedOperations.json');
 
-// You can implement `data` in any custom way, and even fetch it from a remote store.
-const data: Record<string, DocumentNode> = {
-  persisted_1: parse(`query`),
-};
+// sync
+persistedOperationsStore.loadFromFileSync(filePath); // load and parse persisted-operations files
 
-export const myStore: PersistedOperationsStore = {
-  canHandle: key => key && key.startsWith('persisted_'),
-  get: key => data[key],
-};
+// or async
+await persistedOperationsStore.loadFromFile(filePath); // load and parse persisted-operations files
+
+const getEnveloped = envelop({
+  plugins: [
+    // ... other plugins ...
+    usePersistedOperations({
+      store: persistedOperationsStore,
+    }),
+  ],
+});
 ```
 
-Now, when running operations through your GraphQL server, you can use a key instead of a query language:
+## Multiple Stores
 
-```json
-{
-  "query": "persisted_1",
-  "variables": {}
-}
+The `store` parameter accepts both a `Store` instance, or a function. If you need to support multiple stores (based on incoming GraphQL operation/HTTP request), you can provide a function to toggle between the stores, based on your needs:
+
+```ts
+const getEnveloped = envelop({
+  plugins: [
+    // ... other plugins ...
+    usePersistedOperations({
+      store: context => {
+        if (context.req.headers['user-agent'].includes('Android')) {
+          return mobileClientsStore;
+        }
+
+        return defaultStore;
+      },
+    }),
+  ],
+});
+
+// later, pass the initial context
+const proxyFns = getEnveloped({ req });
 ```
 
 ## With Relay
 
 If you are using Relay, you can leverage `relay-compiler` feature for hashing and and creating the store for you, during build.
 
-You can [read more about this feature here](https://relay.dev/docs/v2.0.0/persisted-queries/). After building your hashes, you can use `queryMap.json` as your store.
+You can [read more about this feature here](https://relay.dev/docs/guides/persisted-queries/). After building your hashes, you can use `queryMap.json` as your store.

package/index.d.ts

@@ -1,40 +1,6 @@
-import { Plugin } from '@envelop/types';
-import { DocumentNode, GraphQLError } from 'graphql';
-export declare class NonPersistedOperationError extends GraphQLError {
-}
-export interface PersistedOperationsStore {
-    /**
-     * Check if the provided string content can be handled by the store or not.
-     * @param idOrSdl persisted id/hash, or SDL, provided for `parse`
-     */
-    canHandle(idOrSdl: string): boolean;
-    /**
-     * Transfroms a hash/id into a DocumentNode or SDL string.
-     * Prefer returning `DocumentNode` if available to avoid additional parsing phase.
-     * Return `null` in case of a store miss.
-     * @param id
-     */
-    get(id: string): string | DocumentNode | null;
-}
-export declare type UsePersistedOperationsOptions = {
-    /**
-     * Set to `false` to allow running operations that are not available in the store.
-     * Set to `true` to allow running only persisted operations.
-     */
-    onlyPersistedOperations: boolean;
-    /**
-     * The store to use. You can implement any custom store that loads the data from any source.
-     */
-    store: PersistedOperationsStore;
-    /**
-     * Writes operation id to the context (enabled by default)
-     */
-    writeToContext?: boolean;
-};
-declare const symbolInContext: unique symbol;
-declare type PluginContext<TOptions extends Partial<UsePersistedOperationsOptions>> = TOptions['writeToContext'] extends true ? {
-    [symbolInContext]: string;
-} : {};
-export declare function readOperationId<TOptions extends UsePersistedOperationsOptions>(context: PluginContext<TOptions>): string;
-export declare const usePersistedOperations: <TOptions extends UsePersistedOperationsOptions>(options: TOptions) => Plugin<PluginContext<TOptions>>;
-export {};
+export * from './types';
+export * from './utils';
+export * from './stores/aggregated-store';
+export * from './stores/inmemory-store';
+export * from './stores/json-file-store';
+export * from './plugin';

package/index.js

@@ -2,45 +2,109 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+const fs = require('fs');
 const graphql = require('graphql');
 
-class NonPersistedOperationError extends graphql.GraphQLError {
+function operationIdFromSource(source) {
+    return typeof source === 'string' && source.length && source.indexOf('{') === -1 ? source : undefined;
 }
-const symbolInContext = Symbol('operationId');
+
+class AggregatedStore {
+    constructor(stores) {
+        this.stores = stores;
+    }
+    get(operationId) {
+        for (const store of this.stores) {
+            const item = store.get(operationId);
+            if (item) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+}
+
+class InMemoryStore {
+    constructor(options) {
+        var _a;
+        this.storeData = (_a = options === null || options === void 0 ? void 0 : options.initialData) !== null && _a !== void 0 ? _a : new Map();
+    }
+    get(operationId) {
+        return this.storeData.get(operationId) || undefined;
+    }
+    prime(operationId, document) {
+        this.storeData.set(operationId, document);
+    }
+    clear(operationId) {
+        this.storeData.delete(operationId);
+    }
+}
+
+class JsonFileStore {
+    constructor() {
+        this.storeData = null;
+    }
+    get(operationId) {
+        if (!this.storeData) {
+            return undefined;
+        }
+        return this.storeData.get(operationId) || undefined;
+    }
+    loadFromFileSync(path) {
+        const data = JSON.parse(fs.readFileSync(path, 'utf-8'));
+        this.storeData = new Map(Object.entries(data));
+    }
+    async loadFromFile(path) {
+        const data = JSON.parse(await fs.promises.readFile(path, 'utf-8'));
+        this.storeData = new Map(Object.entries(data));
+    }
+}
+
+const DEFAULT_OPTIONS = {
+    onlyPersisted: false,
+};
+const contextProperty = Symbol('persistedOperationId');
 function readOperationId(context) {
-    return context[symbolInContext];
+    return context[contextProperty];
 }
-const usePersistedOperations = (options) => {
-    const writeToContext = options.writeToContext !== false;
+const usePersistedOperations = (rawOptions) => {
+    const options = {
+        ...DEFAULT_OPTIONS,
+        ...(rawOptions || {}),
+    };
     return {
-        onParse({ params, setParsedDocument, extendContext }) {
-            if (typeof params.source === 'string') {
-                if (options.store.canHandle(params.source)) {
-                    const rawResult = options.store.get(params.source);
-                    if (rawResult) {
-                        const result = typeof rawResult === 'string' ? graphql.parse(rawResult) : rawResult;
-                        if (writeToContext) {
-                            extendContext({
-                                [symbolInContext]: params.source,
-                            });
-                        }
-                        setParsedDocument(result);
-                    }
-                    else {
-                        throw new NonPersistedOperationError(`The operation hash "${params.source}" is not valid`);
-                    }
-                }
-                else {
-                    if (options.onlyPersistedOperations) {
-                        throw new graphql.GraphQLError(`Failed to handle GraphQL persisted operation.`);
-                    }
+        onParse({ context, params, extendContext, setParsedDocument }) {
+            const operationId = options.extractOperationId ? options.extractOperationId(context) : operationIdFromSource(params.source);
+            if (!operationId) {
+                if (options.onlyPersisted) {
+                    throw new graphql.GraphQLError('Must provide operation id');
                 }
+                return;
+            }
+            const store = typeof options.store === 'function' ? options.store(context) : options.store;
+            if (!store) {
+                throw new graphql.GraphQLError('Must provide store for persisted-operations!');
+            }
+            const rawResult = store.get(operationId);
+            if (rawResult) {
+                const document = typeof rawResult === 'string' ? graphql.parse(rawResult) : rawResult;
+                extendContext({ [contextProperty]: operationId });
+                setParsedDocument(document);
+                return;
+            }
+            if (options.onlyPersisted) {
+                // we want to throw an error only when "onlyPersisted" is true, otherwise we let execution continue normally
+                throw new graphql.GraphQLError(`Unable to match operation with id '${operationId}'`);
             }
+            // if we reach this stage we could not retrieve a persisted operation and we didn't throw any error as onlyPersisted is false
+            // hence we let operation continue assuming consumer is not passing an operation id, but a plain query string, with current request.
         },
     };
 };
 
-exports.NonPersistedOperationError = NonPersistedOperationError;
+exports.AggregatedStore = AggregatedStore;
+exports.InMemoryStore = InMemoryStore;
+exports.JsonFileStore = JsonFileStore;
+exports.operationIdFromSource = operationIdFromSource;
 exports.readOperationId = readOperationId;
 exports.usePersistedOperations = usePersistedOperations;
-//# sourceMappingURL=index.js.map

package/index.mjs

@@ -1,40 +1,101 @@
+import { readFileSync, promises } from 'fs';
 import { GraphQLError, parse } from 'graphql';
 
-class NonPersistedOperationError extends GraphQLError {
+function operationIdFromSource(source) {
+    return typeof source === 'string' && source.length && source.indexOf('{') === -1 ? source : undefined;
 }
-const symbolInContext = Symbol('operationId');
+
+class AggregatedStore {
+    constructor(stores) {
+        this.stores = stores;
+    }
+    get(operationId) {
+        for (const store of this.stores) {
+            const item = store.get(operationId);
+            if (item) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+}
+
+class InMemoryStore {
+    constructor(options) {
+        var _a;
+        this.storeData = (_a = options === null || options === void 0 ? void 0 : options.initialData) !== null && _a !== void 0 ? _a : new Map();
+    }
+    get(operationId) {
+        return this.storeData.get(operationId) || undefined;
+    }
+    prime(operationId, document) {
+        this.storeData.set(operationId, document);
+    }
+    clear(operationId) {
+        this.storeData.delete(operationId);
+    }
+}
+
+class JsonFileStore {
+    constructor() {
+        this.storeData = null;
+    }
+    get(operationId) {
+        if (!this.storeData) {
+            return undefined;
+        }
+        return this.storeData.get(operationId) || undefined;
+    }
+    loadFromFileSync(path) {
+        const data = JSON.parse(readFileSync(path, 'utf-8'));
+        this.storeData = new Map(Object.entries(data));
+    }
+    async loadFromFile(path) {
+        const data = JSON.parse(await promises.readFile(path, 'utf-8'));
+        this.storeData = new Map(Object.entries(data));
+    }
+}
+
+const DEFAULT_OPTIONS = {
+    onlyPersisted: false,
+};
+const contextProperty = Symbol('persistedOperationId');
 function readOperationId(context) {
-    return context[symbolInContext];
+    return context[contextProperty];
 }
-const usePersistedOperations = (options) => {
-    const writeToContext = options.writeToContext !== false;
+const usePersistedOperations = (rawOptions) => {
+    const options = {
+        ...DEFAULT_OPTIONS,
+        ...(rawOptions || {}),
+    };
     return {
-        onParse({ params, setParsedDocument, extendContext }) {
-            if (typeof params.source === 'string') {
-                if (options.store.canHandle(params.source)) {
-                    const rawResult = options.store.get(params.source);
-                    if (rawResult) {
-                        const result = typeof rawResult === 'string' ? parse(rawResult) : rawResult;
-                        if (writeToContext) {
-                            extendContext({
-                                [symbolInContext]: params.source,
-                            });
-                        }
-                        setParsedDocument(result);
-                    }
-                    else {
-                        throw new NonPersistedOperationError(`The operation hash "${params.source}" is not valid`);
-                    }
-                }
-                else {
-                    if (options.onlyPersistedOperations) {
-                        throw new GraphQLError(`Failed to handle GraphQL persisted operation.`);
-                    }
+        onParse({ context, params, extendContext, setParsedDocument }) {
+            const operationId = options.extractOperationId ? options.extractOperationId(context) : operationIdFromSource(params.source);
+            if (!operationId) {
+                if (options.onlyPersisted) {
+                    throw new GraphQLError('Must provide operation id');
                 }
+                return;
+            }
+            const store = typeof options.store === 'function' ? options.store(context) : options.store;
+            if (!store) {
+                throw new GraphQLError('Must provide store for persisted-operations!');
+            }
+            const rawResult = store.get(operationId);
+            if (rawResult) {
+                const document = typeof rawResult === 'string' ? parse(rawResult) : rawResult;
+                extendContext({ [contextProperty]: operationId });
+                setParsedDocument(document);
+                return;
+            }
+            if (options.onlyPersisted) {
+                // we want to throw an error only when "onlyPersisted" is true, otherwise we let execution continue normally
+                throw new GraphQLError(`Unable to match operation with id '${operationId}'`);
             }
+            // if we reach this stage we could not retrieve a persisted operation and we didn't throw any error as onlyPersisted is false
+            // hence we let operation continue assuming consumer is not passing an operation id, but a plain query string, with current request.
         },
     };
 };
 
-export { NonPersistedOperationError, readOperationId, usePersistedOperations };
-//# sourceMappingURL=index.mjs.map
+export { AggregatedStore, InMemoryStore, JsonFileStore, operationIdFromSource, readOperationId, usePersistedOperations };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@envelop/persisted-operations",
-  "version": "1.0.0",
+  "version": "2.1.0-alpha-e8998c9.0",
   "sideEffects": false,
   "peerDependencies": {
-    "graphql": "^14.0.0 || ^15.0.0"
+    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "repository": {
     "type": "git",

package/plugin.d.ts

@@ -0,0 +1,25 @@
+import { Plugin, DefaultContext } from '@envelop/types';
+import { PersistedOperationsFunctionStore, PersistedOperationsStore } from './types';
+export declare type UsePersistedOperationsOptions<ContextType = DefaultContext> = {
+    /**
+     * Set to `false` to allow running operations that are not available in the store.
+     * Set to `true` to allow running only persisted operations.
+     */
+    onlyPersisted?: boolean;
+    /**
+     * The store to use. You can implement a store that loads data from any source.
+     * You can even support multiple stores and implement a function that returns one of those stores based on context values.
+     */
+    store: PersistedOperationsStore | PersistedOperationsFunctionStore<ContextType>;
+    /**
+     * Function that returns the operation id, e.g. by retrieving it from cusotm properties within context
+     */
+    extractOperationId?: (context: Readonly<ContextType>) => string | undefined;
+};
+declare const contextProperty: unique symbol;
+export declare type PersistedOperationPluginContext = {
+    [contextProperty]: string;
+};
+export declare function readOperationId(context: PersistedOperationPluginContext): string;
+export declare const usePersistedOperations: (rawOptions: UsePersistedOperationsOptions) => Plugin<PersistedOperationPluginContext>;
+export {};

package/stores/aggregated-store.d.ts

@@ -0,0 +1,7 @@
+import { DocumentNode } from 'graphql';
+import { PersistedOperationsStore } from '../types';
+export declare class AggregatedStore implements PersistedOperationsStore {
+    private stores;
+    constructor(stores: PersistedOperationsStore[]);
+    get(operationId: string): string | DocumentNode | undefined;
+}

package/stores/inmemory-store.d.ts

@@ -0,0 +1,12 @@
+import { DocumentNode } from 'graphql';
+import { PersistedOperationsStore } from '../types';
+export declare type InMemoryStoreDataMap = Map<string, DocumentNode | string>;
+export declare class InMemoryStore implements PersistedOperationsStore {
+    private storeData;
+    constructor(options?: {
+        initialData?: InMemoryStoreDataMap;
+    });
+    get(operationId: string): string | DocumentNode | undefined;
+    prime(operationId: string, document: string | DocumentNode): void;
+    clear(operationId: string): void;
+}

package/stores/json-file-store.d.ts

@@ -0,0 +1,9 @@
+import { DocumentNode } from 'graphql';
+import { PersistedOperationsStore } from '../types';
+export declare type JsonFileStoreDataMap = Map<string, DocumentNode | string>;
+export declare class JsonFileStore implements PersistedOperationsStore {
+    private storeData;
+    get(operationId: string): string | DocumentNode | undefined;
+    loadFromFileSync(path: string): void;
+    loadFromFile(path: string): Promise<void>;
+}

package/types.d.ts

@@ -0,0 +1,12 @@
+import { DefaultContext } from '@envelop/core';
+import { DocumentNode } from 'graphql';
+export interface PersistedOperationsStore {
+    /**
+     * Transfroms a hash/id into a DocumentNode or SDL string.
+     * Prefer returning `DocumentNode` if available to avoid additional parsing phase.
+     * Return `null` in case of a store miss.
+     * @param operationId
+     */
+    get(operationId: string): string | DocumentNode | undefined;
+}
+export declare type PersistedOperationsFunctionStore<ContextType = DefaultContext> = (context: Readonly<ContextType>) => PersistedOperationsStore;

package/utils.d.ts

@@ -0,0 +1,2 @@
+import { Source } from 'graphql';
+export declare function operationIdFromSource(source: string | Source): string | undefined;

package/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../dist/plugins/persisted-operations/src/index.js"],"sourcesContent":["import { GraphQLError, parse } from 'graphql';\nexport class NonPersistedOperationError extends GraphQLError {\n}\nconst symbolInContext = Symbol('operationId');\nexport function readOperationId(context) {\n    return context[symbolInContext];\n}\nexport const usePersistedOperations = (options) => {\n    const writeToContext = options.writeToContext !== false;\n    return {\n        onParse({ params, setParsedDocument, extendContext }) {\n            if (typeof params.source === 'string') {\n                if (options.store.canHandle(params.source)) {\n                    const rawResult = options.store.get(params.source);\n                    if (rawResult) {\n                        const result = typeof rawResult === 'string' ? parse(rawResult) : rawResult;\n                        if (writeToContext) {\n                            extendContext({\n                                [symbolInContext]: params.source,\n                            });\n                        }\n                        setParsedDocument(result);\n                    }\n                    else {\n                        throw new NonPersistedOperationError(`The operation hash \"${params.source}\" is not valid`);\n                    }\n                }\n                else {\n                    if (options.onlyPersistedOperations) {\n                        throw new GraphQLError(`Failed to handle GraphQL persisted operation.`);\n                    }\n                }\n            }\n        },\n    };\n};\n//# sourceMappingURL=index.js.map"],"names":["GraphQLError","parse"],"mappings":";;;;;;AACO,MAAM,0BAA0B,SAASA,oBAAY,CAAC;AAC7D,CAAC;AACD,MAAM,eAAe,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;AACvC,SAAS,eAAe,CAAC,OAAO,EAAE;AACzC,IAAI,OAAO,OAAO,CAAC,eAAe,CAAC,CAAC;AACpC,CAAC;AACW,MAAC,sBAAsB,GAAG,CAAC,OAAO,KAAK;AACnD,IAAI,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,KAAK,KAAK,CAAC;AAC5D,IAAI,OAAO;AACX,QAAQ,OAAO,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,aAAa,EAAE,EAAE;AAC9D,YAAY,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,QAAQ,EAAE;AACnD,gBAAgB,IAAI,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;AAC5D,oBAAoB,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACvE,oBAAoB,IAAI,SAAS,EAAE;AACnC,wBAAwB,MAAM,MAAM,GAAG,OAAO,SAAS,KAAK,QAAQ,GAAGC,aAAK,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;AACpG,wBAAwB,IAAI,cAAc,EAAE;AAC5C,4BAA4B,aAAa,CAAC;AAC1C,gCAAgC,CAAC,eAAe,GAAG,MAAM,CAAC,MAAM;AAChE,6BAA6B,CAAC,CAAC;AAC/B,yBAAyB;AACzB,wBAAwB,iBAAiB,CAAC,MAAM,CAAC,CAAC;AAClD,qBAAqB;AACrB,yBAAyB;AACzB,wBAAwB,MAAM,IAAI,0BAA0B,CAAC,CAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC;AACnH,qBAAqB;AACrB,iBAAiB;AACjB,qBAAqB;AACrB,oBAAoB,IAAI,OAAO,CAAC,uBAAuB,EAAE;AACzD,wBAAwB,MAAM,IAAID,oBAAY,CAAC,CAAC,6CAA6C,CAAC,CAAC,CAAC;AAChG,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT,KAAK,CAAC;AACN;;;;;;"}

package/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","sources":["../../../dist/plugins/persisted-operations/src/index.js"],"sourcesContent":["import { GraphQLError, parse } from 'graphql';\nexport class NonPersistedOperationError extends GraphQLError {\n}\nconst symbolInContext = Symbol('operationId');\nexport function readOperationId(context) {\n    return context[symbolInContext];\n}\nexport const usePersistedOperations = (options) => {\n    const writeToContext = options.writeToContext !== false;\n    return {\n        onParse({ params, setParsedDocument, extendContext }) {\n            if (typeof params.source === 'string') {\n                if (options.store.canHandle(params.source)) {\n                    const rawResult = options.store.get(params.source);\n                    if (rawResult) {\n                        const result = typeof rawResult === 'string' ? parse(rawResult) : rawResult;\n                        if (writeToContext) {\n                            extendContext({\n                                [symbolInContext]: params.source,\n                            });\n                        }\n                        setParsedDocument(result);\n                    }\n                    else {\n                        throw new NonPersistedOperationError(`The operation hash \"${params.source}\" is not valid`);\n                    }\n                }\n                else {\n                    if (options.onlyPersistedOperations) {\n                        throw new GraphQLError(`Failed to handle GraphQL persisted operation.`);\n                    }\n                }\n            }\n        },\n    };\n};\n//# sourceMappingURL=index.js.map"],"names":[],"mappings":";;AACO,MAAM,0BAA0B,SAAS,YAAY,CAAC;AAC7D,CAAC;AACD,MAAM,eAAe,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;AACvC,SAAS,eAAe,CAAC,OAAO,EAAE;AACzC,IAAI,OAAO,OAAO,CAAC,eAAe,CAAC,CAAC;AACpC,CAAC;AACW,MAAC,sBAAsB,GAAG,CAAC,OAAO,KAAK;AACnD,IAAI,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,KAAK,KAAK,CAAC;AAC5D,IAAI,OAAO;AACX,QAAQ,OAAO,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,aAAa,EAAE,EAAE;AAC9D,YAAY,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,QAAQ,EAAE;AACnD,gBAAgB,IAAI,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;AAC5D,oBAAoB,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACvE,oBAAoB,IAAI,SAAS,EAAE;AACnC,wBAAwB,MAAM,MAAM,GAAG,OAAO,SAAS,KAAK,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;AACpG,wBAAwB,IAAI,cAAc,EAAE;AAC5C,4BAA4B,aAAa,CAAC;AAC1C,gCAAgC,CAAC,eAAe,GAAG,MAAM,CAAC,MAAM;AAChE,6BAA6B,CAAC,CAAC;AAC/B,yBAAyB;AACzB,wBAAwB,iBAAiB,CAAC,MAAM,CAAC,CAAC;AAClD,qBAAqB;AACrB,yBAAyB;AACzB,wBAAwB,MAAM,IAAI,0BAA0B,CAAC,CAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC;AACnH,qBAAqB;AACrB,iBAAiB;AACjB,qBAAqB;AACrB,oBAAoB,IAAI,OAAO,CAAC,uBAAuB,EAAE;AACzD,wBAAwB,MAAM,IAAI,YAAY,CAAC,CAAC,6CAA6C,CAAC,CAAC,CAAC;AAChG,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT,KAAK,CAAC;AACN;;;;"}