@trpc/client 11.0.0-rc.370 → 11.0.0-rc.374

package/dist/links/httpBatchLink.mjs

@@ -1,39 +1,104 @@
-import { createHTTPBatchLink } from './internals/createHTTPBatchLink.mjs';
-import { jsonHttpRequester } from './internals/httpUtils.mjs';
+import { observable } from '@trpc/server/observable';
+import { transformResult } from '@trpc/server/unstable-core-do-not-import';
+import { dataLoader } from '../internals/dataLoader.mjs';
+import { TRPCClientError } from '../TRPCClientError.mjs';
+import { resolveHTTPLinkOptions, getUrl, jsonHttpRequester } from './internals/httpUtils.mjs';
 
-const batchRequester = (requesterOpts)=>{
-    return (batchOps)=>{
-        const path = batchOps.map((op)=>op.path).join(',');
-        const inputs = batchOps.map((op)=>op.input);
-        const { promise , cancel  } = jsonHttpRequester({
-            ...requesterOpts,
-            path,
-            inputs,
-            headers () {
-                if (!requesterOpts.opts.headers) {
-                    return {};
-                }
-                if (typeof requesterOpts.opts.headers === 'function') {
-                    return requesterOpts.opts.headers({
-                        opList: batchOps
+/**
+ * @see https://trpc.io/docs/client/links/httpBatchLink
+ */ function httpBatchLink(opts) {
+    const resolvedOpts = resolveHTTPLinkOptions(opts);
+    const maxURLLength = opts.maxURLLength ?? Infinity;
+    return ()=>{
+        const batchLoader = (type)=>{
+            return {
+                validate (batchOps) {
+                    if (maxURLLength === Infinity) {
+                        // escape hatch for quick calcs
+                        return true;
+                    }
+                    const path = batchOps.map((op)=>op.path).join(',');
+                    const inputs = batchOps.map((op)=>op.input);
+                    const url = getUrl({
+                        ...resolvedOpts,
+                        type,
+                        path,
+                        inputs
+                    });
+                    return url.length <= maxURLLength;
+                },
+                fetch (batchOps) {
+                    const path = batchOps.map((op)=>op.path).join(',');
+                    const inputs = batchOps.map((op)=>op.input);
+                    const requester = jsonHttpRequester({
+                        ...resolvedOpts,
+                        path,
+                        inputs,
+                        type,
+                        headers () {
+                            if (!opts.headers) {
+                                return {};
+                            }
+                            if (typeof opts.headers === 'function') {
+                                return opts.headers({
+                                    opList: batchOps
+                                });
+                            }
+                            return opts.headers;
+                        }
                     });
+                    return {
+                        cancel: requester.cancel,
+                        promise: requester.promise.then((res)=>{
+                            const resJSON = Array.isArray(res.json) ? res.json : batchOps.map(()=>res.json);
+                            const result = resJSON.map((item)=>({
+                                    meta: res.meta,
+                                    json: item
+                                }));
+                            return result;
+                        })
+                    };
                 }
-                return requesterOpts.opts.headers;
-            }
-        });
-        return {
-            promise: promise.then((res)=>{
-                const resJSON = Array.isArray(res.json) ? res.json : batchOps.map(()=>res.json);
-                const result = resJSON.map((item)=>({
-                        meta: res.meta,
-                        json: item
+            };
+        };
+        const query = dataLoader(batchLoader('query'));
+        const mutation = dataLoader(batchLoader('mutation'));
+        const subscription = dataLoader(batchLoader('subscription'));
+        const loaders = {
+            query,
+            subscription,
+            mutation
+        };
+        return ({ op  })=>{
+            return observable((observer)=>{
+                const loader = loaders[op.type];
+                const { promise , cancel  } = loader.load(op);
+                let _res = undefined;
+                promise.then((res)=>{
+                    _res = res;
+                    const transformed = transformResult(res.json, resolvedOpts.transformer.output);
+                    if (!transformed.ok) {
+                        observer.error(TRPCClientError.from(transformed.error, {
+                            meta: res.meta
+                        }));
+                        return;
+                    }
+                    observer.next({
+                        context: res.meta,
+                        result: transformed.result
+                    });
+                    observer.complete();
+                }).catch((err)=>{
+                    observer.error(TRPCClientError.from(err, {
+                        meta: _res?.meta
                     }));
-                return result;
-            }),
-            cancel
+                });
+                return ()=>{
+                    cancel();
+                };
+            });
         };
     };
-};
-const httpBatchLink = createHTTPBatchLink(batchRequester);
+}
 
 export { httpBatchLink };

package/dist/links/httpBatchStreamLink.d.ts

@@ -1,13 +1,16 @@
+import type { AnyRouter } from '@trpc/server';
 import type { AnyRootTypes } from '@trpc/server/unstable-core-do-not-import';
 import type { HTTPBatchLinkOptions } from './HTTPBatchLinkOptions';
-import type { TextDecoderEsque } from './internals/streamingUtils';
+import type { TRPCLink } from './types';
 export type HTTPBatchStreamLinkOptions<TRoot extends AnyRootTypes> = HTTPBatchLinkOptions<TRoot> & {
     /**
-     * Will default to the webAPI `TextDecoder`,
-     * but you can use this option if your client
-     * runtime doesn't provide it.
+     * Maximum number of calls in a single batch request
+     * @default Infinity
      */
-    textDecoder?: TextDecoderEsque;
+    maxItems?: number;
 };
-export declare const unstable_httpBatchStreamLink: <TRouter extends import("@trpc/server/unstable-core-do-not-import").AnyRouter>(opts: HTTPBatchLinkOptions<import("@trpc/server/unstable-core-do-not-import").inferClientTypes<TRouter>>) => import("./types").TRPCLink<TRouter>;
+/**
+ * @see https://trpc.io/docs/client/links/httpBatchStreamLink
+ */
+export declare function unstable_httpBatchStreamLink<TRouter extends AnyRouter>(opts: HTTPBatchStreamLinkOptions<TRouter['_def']['_config']['$types']>): TRPCLink<TRouter>;
 //# sourceMappingURL=httpBatchStreamLink.d.ts.map

package/dist/links/httpBatchStreamLink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"httpBatchStreamLink.d.ts","sourceRoot":"","sources":["../../src/links/httpBatchStreamLink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAE7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAKnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAGnE,MAAM,MAAM,0BAA0B,CAAC,KAAK,SAAS,YAAY,IAC/D,oBAAoB,CAAC,KAAK,CAAC,GAAG;IAC5B;;;;OAIG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC;CAChC,CAAC;AA6CJ,eAAO,MAAM,4BAA4B,iOACH,CAAC"}
+{"version":3,"file":"httpBatchStreamLink.d.ts","sourceRoot":"","sources":["../../src/links/httpBatchStreamLink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,cAAc,CAAC;AAG7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAM7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAQnE,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnD,MAAM,MAAM,0BAA0B,CAAC,KAAK,SAAS,YAAY,IAC/D,oBAAoB,CAAC,KAAK,CAAC,GAAG;IAC5B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEJ;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,SAAS,SAAS,EACpE,IAAI,EAAE,0BAA0B,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAC,GACrE,QAAQ,CAAC,OAAO,CAAC,CA4JnB"}

package/dist/links/httpBatchStreamLink.js

@@ -1,43 +1,141 @@
 'use strict';
 
-var createHTTPBatchLink = require('./internals/createHTTPBatchLink.js');
-var getTextDecoder = require('./internals/getTextDecoder.js');
-var parseJSONStream = require('./internals/parseJSONStream.js');
+var observable = require('@trpc/server/observable');
+var unstableCoreDoNotImport = require('@trpc/server/unstable-core-do-not-import');
+var dataLoader = require('../internals/dataLoader.js');
+var TRPCClientError = require('../TRPCClientError.js');
+var httpUtils = require('./internals/httpUtils.js');
 
-const streamRequester = (requesterOpts)=>{
-    const textDecoder = getTextDecoder.getTextDecoder(requesterOpts.opts.textDecoder);
-    return (batchOps, unitResolver)=>{
-        const path = batchOps.map((op)=>op.path).join(',');
-        const inputs = batchOps.map((op)=>op.input);
-        const { cancel , promise  } = parseJSONStream.streamingJsonHttpRequester({
-            ...requesterOpts,
-            textDecoder,
-            path,
-            inputs,
-            headers () {
-                if (!requesterOpts.opts.headers) {
-                    return {};
-                }
-                if (typeof requesterOpts.opts.headers === 'function') {
-                    return requesterOpts.opts.headers({
-                        opList: batchOps
+/**
+ * @see https://trpc.io/docs/client/links/httpBatchStreamLink
+ */ function unstable_httpBatchStreamLink(opts) {
+    const resolvedOpts = httpUtils.resolveHTTPLinkOptions(opts);
+    const maxURLLength = opts.maxURLLength ?? Infinity;
+    const maxItems = opts.maxItems ?? Infinity;
+    return ()=>{
+        const batchLoader = (type)=>{
+            return {
+                validate (batchOps) {
+                    if (maxURLLength === Infinity && maxItems === Infinity) {
+                        // escape hatch for quick calcs
+                        return true;
+                    }
+                    if (batchOps.length > maxItems) {
+                        return false;
+                    }
+                    const path = batchOps.map((op)=>op.path).join(',');
+                    const inputs = batchOps.map((op)=>op.input);
+                    const url = httpUtils.getUrl({
+                        ...resolvedOpts,
+                        type,
+                        path,
+                        inputs
                     });
+                    return url.length <= maxURLLength;
+                },
+                fetch (batchOps) {
+                    const path = batchOps.map((op)=>op.path).join(',');
+                    const inputs = batchOps.map((op)=>op.input);
+                    const ac = resolvedOpts.AbortController ? new resolvedOpts.AbortController() : null;
+                    const responsePromise = httpUtils.fetchHTTPResponse({
+                        ...resolvedOpts,
+                        type,
+                        contentTypeHeader: 'application/json',
+                        trpcAcceptHeader: 'application/jsonl',
+                        getUrl: httpUtils.getUrl,
+                        getBody: httpUtils.getBody,
+                        inputs,
+                        path,
+                        headers () {
+                            if (!opts.headers) {
+                                return {};
+                            }
+                            if (typeof opts.headers === 'function') {
+                                return opts.headers({
+                                    opList: batchOps
+                                });
+                            }
+                            return opts.headers;
+                        }
+                    }, ac);
+                    return {
+                        promise: responsePromise.then(async (res)=>{
+                            if (!res.body) {
+                                throw new Error('Received response without body');
+                            }
+                            const [head] = await unstableCoreDoNotImport.jsonlStreamConsumer({
+                                from: res.body,
+                                deserialize: resolvedOpts.transformer.output.deserialize
+                            });
+                            const promises = Object.keys(batchOps).map(async (key)=>{
+                                let json = await head[key];
+                                if ('result' in json) {
+                                    /**
+                     * Not very pretty, but we need to unwrap nested data as promises
+                     * Our stream producer will only resolve top-level async values or async values that are directly nested in another async value
+                     */ const result = await Promise.resolve(json.result);
+                                    json = {
+                                        result: {
+                                            data: await Promise.resolve(result.data)
+                                        }
+                                    };
+                                }
+                                return {
+                                    json,
+                                    meta: {
+                                        response: res
+                                    }
+                                };
+                            });
+                            return promises;
+                        }),
+                        cancel () {
+                            ac?.abort();
+                        }
+                    };
                 }
-                return requesterOpts.opts.headers;
-            }
-        }, (index, res)=>{
-            unitResolver(index, res);
-        });
-        return {
-            /**
-       * return an empty array because the batchLoader expects an array of results
-       * but we've already called the `unitResolver` for each of them, there's
-       * nothing left to do here.
-       */ promise: promise.then(()=>[]),
-            cancel
+            };
+        };
+        const query = dataLoader.dataLoader(batchLoader('query'));
+        const mutation = dataLoader.dataLoader(batchLoader('mutation'));
+        const subscription = dataLoader.dataLoader(batchLoader('subscription'));
+        const loaders = {
+            query,
+            subscription,
+            mutation
+        };
+        return ({ op  })=>{
+            return observable.observable((observer)=>{
+                const loader = loaders[op.type];
+                const { promise , cancel  } = loader.load(op);
+                let _res = undefined;
+                promise.then((res)=>{
+                    _res = res;
+                    if ('error' in res.json) {
+                        observer.error(TRPCClientError.TRPCClientError.from(res.json, {
+                            meta: res.meta
+                        }));
+                        return;
+                    } else if ('result' in res.json) {
+                        observer.next({
+                            context: res.meta,
+                            result: res.json.result
+                        });
+                        observer.complete();
+                        return;
+                    }
+                    observer.complete();
+                }).catch((err)=>{
+                    observer.error(TRPCClientError.TRPCClientError.from(err, {
+                        meta: _res?.meta
+                    }));
+                });
+                return ()=>{
+                    cancel();
+                };
+            });
         };
     };
-};
-const unstable_httpBatchStreamLink = createHTTPBatchLink.createHTTPBatchLink(streamRequester);
+}
 
 exports.unstable_httpBatchStreamLink = unstable_httpBatchStreamLink;

package/dist/links/httpBatchStreamLink.mjs

@@ -1,41 +1,139 @@
-import { createHTTPBatchLink } from './internals/createHTTPBatchLink.mjs';
-import { getTextDecoder } from './internals/getTextDecoder.mjs';
-import { streamingJsonHttpRequester } from './internals/parseJSONStream.mjs';
+import { observable } from '@trpc/server/observable';
+import { jsonlStreamConsumer } from '@trpc/server/unstable-core-do-not-import';
+import { dataLoader } from '../internals/dataLoader.mjs';
+import { TRPCClientError } from '../TRPCClientError.mjs';
+import { resolveHTTPLinkOptions, getUrl, fetchHTTPResponse, getBody } from './internals/httpUtils.mjs';
 
-const streamRequester = (requesterOpts)=>{
-    const textDecoder = getTextDecoder(requesterOpts.opts.textDecoder);
-    return (batchOps, unitResolver)=>{
-        const path = batchOps.map((op)=>op.path).join(',');
-        const inputs = batchOps.map((op)=>op.input);
-        const { cancel , promise  } = streamingJsonHttpRequester({
-            ...requesterOpts,
-            textDecoder,
-            path,
-            inputs,
-            headers () {
-                if (!requesterOpts.opts.headers) {
-                    return {};
-                }
-                if (typeof requesterOpts.opts.headers === 'function') {
-                    return requesterOpts.opts.headers({
-                        opList: batchOps
+/**
+ * @see https://trpc.io/docs/client/links/httpBatchStreamLink
+ */ function unstable_httpBatchStreamLink(opts) {
+    const resolvedOpts = resolveHTTPLinkOptions(opts);
+    const maxURLLength = opts.maxURLLength ?? Infinity;
+    const maxItems = opts.maxItems ?? Infinity;
+    return ()=>{
+        const batchLoader = (type)=>{
+            return {
+                validate (batchOps) {
+                    if (maxURLLength === Infinity && maxItems === Infinity) {
+                        // escape hatch for quick calcs
+                        return true;
+                    }
+                    if (batchOps.length > maxItems) {
+                        return false;
+                    }
+                    const path = batchOps.map((op)=>op.path).join(',');
+                    const inputs = batchOps.map((op)=>op.input);
+                    const url = getUrl({
+                        ...resolvedOpts,
+                        type,
+                        path,
+                        inputs
                     });
+                    return url.length <= maxURLLength;
+                },
+                fetch (batchOps) {
+                    const path = batchOps.map((op)=>op.path).join(',');
+                    const inputs = batchOps.map((op)=>op.input);
+                    const ac = resolvedOpts.AbortController ? new resolvedOpts.AbortController() : null;
+                    const responsePromise = fetchHTTPResponse({
+                        ...resolvedOpts,
+                        type,
+                        contentTypeHeader: 'application/json',
+                        trpcAcceptHeader: 'application/jsonl',
+                        getUrl,
+                        getBody,
+                        inputs,
+                        path,
+                        headers () {
+                            if (!opts.headers) {
+                                return {};
+                            }
+                            if (typeof opts.headers === 'function') {
+                                return opts.headers({
+                                    opList: batchOps
+                                });
+                            }
+                            return opts.headers;
+                        }
+                    }, ac);
+                    return {
+                        promise: responsePromise.then(async (res)=>{
+                            if (!res.body) {
+                                throw new Error('Received response without body');
+                            }
+                            const [head] = await jsonlStreamConsumer({
+                                from: res.body,
+                                deserialize: resolvedOpts.transformer.output.deserialize
+                            });
+                            const promises = Object.keys(batchOps).map(async (key)=>{
+                                let json = await head[key];
+                                if ('result' in json) {
+                                    /**
+                     * Not very pretty, but we need to unwrap nested data as promises
+                     * Our stream producer will only resolve top-level async values or async values that are directly nested in another async value
+                     */ const result = await Promise.resolve(json.result);
+                                    json = {
+                                        result: {
+                                            data: await Promise.resolve(result.data)
+                                        }
+                                    };
+                                }
+                                return {
+                                    json,
+                                    meta: {
+                                        response: res
+                                    }
+                                };
+                            });
+                            return promises;
+                        }),
+                        cancel () {
+                            ac?.abort();
+                        }
+                    };
                 }
-                return requesterOpts.opts.headers;
-            }
-        }, (index, res)=>{
-            unitResolver(index, res);
-        });
-        return {
-            /**
-       * return an empty array because the batchLoader expects an array of results
-       * but we've already called the `unitResolver` for each of them, there's
-       * nothing left to do here.
-       */ promise: promise.then(()=>[]),
-            cancel
+            };
+        };
+        const query = dataLoader(batchLoader('query'));
+        const mutation = dataLoader(batchLoader('mutation'));
+        const subscription = dataLoader(batchLoader('subscription'));
+        const loaders = {
+            query,
+            subscription,
+            mutation
+        };
+        return ({ op  })=>{
+            return observable((observer)=>{
+                const loader = loaders[op.type];
+                const { promise , cancel  } = loader.load(op);
+                let _res = undefined;
+                promise.then((res)=>{
+                    _res = res;
+                    if ('error' in res.json) {
+                        observer.error(TRPCClientError.from(res.json, {
+                            meta: res.meta
+                        }));
+                        return;
+                    } else if ('result' in res.json) {
+                        observer.next({
+                            context: res.meta,
+                            result: res.json.result
+                        });
+                        observer.complete();
+                        return;
+                    }
+                    observer.complete();
+                }).catch((err)=>{
+                    observer.error(TRPCClientError.from(err, {
+                        meta: _res?.meta
+                    }));
+                });
+                return ()=>{
+                    cancel();
+                };
+            });
         };
     };
-};
-const unstable_httpBatchStreamLink = createHTTPBatchLink(streamRequester);
+}
 
 export { unstable_httpBatchStreamLink };

package/dist/links/httpLink.d.ts

@@ -1,6 +1,6 @@
 import type { AnyRootTypes, AnyRouter } from '@trpc/server/unstable-core-do-not-import';
-import type { HTTPLinkBaseOptions, Requester } from './internals/httpUtils';
-import type { HTTPHeaders, Operation, TRPCLink } from './types';
+import type { HTTPLinkBaseOptions } from './internals/httpUtils';
+import { type HTTPHeaders, type Operation, type TRPCLink } from './types';
 export type HTTPLinkOptions<TRoot extends AnyRootTypes> = HTTPLinkBaseOptions<TRoot> & {
     /**
      * Headers to be set on outgoing requests or a callback that of said headers
@@ -10,11 +10,8 @@ export type HTTPLinkOptions<TRoot extends AnyRootTypes> = HTTPLinkBaseOptions<TR
         op: Operation;
     }) => HTTPHeaders | Promise<HTTPHeaders>);
 };
-export declare function httpLinkFactory(factoryOpts: {
-    requester: Requester;
-}): <TRouter extends AnyRouter>(opts: HTTPLinkOptions<TRouter['_def']['_config']['$types']>) => TRPCLink<TRouter>;
 /**
- * @link https://trpc.io/docs/v11/client/links/httpLink
+ * @link https://trpc.io/docs/client/links/httpLink
  */
-export declare const httpLink: <TRouter extends AnyRouter>(opts: HTTPLinkOptions<TRouter['_def']['_config']['$types']>) => TRPCLink<TRouter>;
+export declare function httpLink<TRouter extends AnyRouter = AnyRouter>(opts: HTTPLinkOptions<TRouter['_def']['_config']['$types']>): TRPCLink<TRouter>;
 //# sourceMappingURL=httpLink.d.ts.map

package/dist/links/httpLink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"httpLink.d.ts","sourceRoot":"","sources":["../../src/links/httpLink.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EACV,MAAM,0CAA0C,CAAC;AAGlD,OAAO,KAAK,EACV,mBAAmB,EAEnB,SAAS,EACV,MAAM,uBAAuB,CAAC;AAK/B,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEhE,MAAM,MAAM,eAAe,CAAC,KAAK,SAAS,YAAY,IACpD,mBAAmB,CAAC,KAAK,CAAC,GAAG;IAC3B;;;OAGG;IACH,OAAO,CAAC,EACJ,WAAW,GACX,CAAC,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,SAAS,CAAA;KAAE,KAAK,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;CACvE,CAAC;AAEJ,wBAAgB,eAAe,CAAC,WAAW,EAAE;IAAE,SAAS,EAAE,SAAS,CAAA;CAAE,qCAE3D,gBAAgB,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAC,KAC1D,SAAS,OAAO,CAAC,CAwDrB;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,oCA9DX,gBAAgB,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAC,KAC1D,SAAS,OAAO,CA6DqD,CAAC"}
+{"version":3,"file":"httpLink.d.ts","sourceRoot":"","sources":["../../src/links/httpLink.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EACV,MAAM,0CAA0C,CAAC;AAGlD,OAAO,KAAK,EACV,mBAAmB,EAGpB,MAAM,uBAAuB,CAAC;AAQ/B,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,QAAQ,EACd,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,eAAe,CAAC,KAAK,SAAS,YAAY,IACpD,mBAAmB,CAAC,KAAK,CAAC,GAAG;IAC3B;;;OAGG;IACH,OAAO,CAAC,EACJ,WAAW,GACX,CAAC,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,SAAS,CAAA;KAAE,KAAK,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;CACvE,CAAC;AAmCJ;;GAEG;AACH,wBAAgB,QAAQ,CAAC,OAAO,SAAS,SAAS,GAAG,SAAS,EAC5D,IAAI,EAAE,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAC,GAC1D,QAAQ,CAAC,OAAO,CAAC,CAyDnB"}