@trpc/server 11.0.0-alpha-tmp-export-from-main.211 → 11.0.0-alpha-tmp-export-from-main-nuke-core.229

package/dist/initTRPC-dcdfb896.mjs

@@ -0,0 +1,376 @@
+import { d as createFlatProxy } from './createProxy-f7ba8b4d.mjs';
+import { d as defaultFormatter, g as getDataTransformer, a as defaultTransformer, b as createRouterFactory, m as mergeRouters, e as createCallerFactory } from './router-5a3e1181.mjs';
+import { T as TRPCError, g as getTRPCErrorFromUnknown } from './TRPCError-54f51dec.mjs';
+import { i as isObject, m as mergeWithoutOverrides, b as isServerDefault } from './rootConfig-7d3e1fc8.mjs';
+
+/** @internal */ const middlewareMarker = 'middlewareMarker';
+/**
+ * @internal
+ */ function createMiddlewareFactory() {
+    function createMiddlewareInner(middlewares) {
+        return {
+            _middlewares: middlewares,
+            unstable_pipe (middlewareBuilderOrFn) {
+                const pipedMiddleware = '_middlewares' in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [
+                    middlewareBuilderOrFn
+                ];
+                return createMiddlewareInner([
+                    ...middlewares,
+                    ...pipedMiddleware
+                ]);
+            }
+        };
+    }
+    function createMiddleware(fn) {
+        return createMiddlewareInner([
+            fn
+        ]);
+    }
+    return createMiddleware;
+}
+/**
+ * Create a standalone middleware
+ * @link https://trpc.io/docs/v11/server/middlewares#experimental-standalone-middlewares
+ */ const experimental_standaloneMiddleware = ()=>({
+        create: createMiddlewareFactory()
+    });
+/**
+ * @internal
+ * Please note, `trpc-openapi` uses this function.
+ */ function createInputMiddleware(parse) {
+    const inputMiddleware = async function inputValidatorMiddleware(opts) {
+        let parsedInput;
+        const rawInput = await opts.getRawInput();
+        try {
+            parsedInput = await parse(rawInput);
+        } catch (cause) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                cause
+            });
+        }
+        // Multiple input parsers
+        const combinedInput = isObject(opts.input) && isObject(parsedInput) ? {
+            ...opts.input,
+            ...parsedInput
+        } : parsedInput;
+        return opts.next({
+            input: combinedInput
+        });
+    };
+    inputMiddleware._type = 'input';
+    return inputMiddleware;
+}
+/**
+ * @internal
+ */ function createOutputMiddleware(parse) {
+    const outputMiddleware = async function outputValidatorMiddleware({ next  }) {
+        const result = await next();
+        if (!result.ok) {
+            // pass through failures without validating
+            return result;
+        }
+        try {
+            const data = await parse(result.data);
+            return {
+                ...result,
+                data
+            };
+        } catch (cause) {
+            throw new TRPCError({
+                message: 'Output validation failed',
+                code: 'INTERNAL_SERVER_ERROR',
+                cause
+            });
+        }
+    };
+    outputMiddleware._type = 'output';
+    return outputMiddleware;
+}
+
+// zod / @decs/typeschema
+function getParseFn(procedureParser) {
+    const parser = procedureParser;
+    if (typeof parser === 'function') {
+        // ParserCustomValidatorEsque
+        return parser;
+    }
+    if (typeof parser.parseAsync === 'function') {
+        // ParserZodEsque
+        return parser.parseAsync.bind(parser);
+    }
+    if (typeof parser.parse === 'function') {
+        // ParserZodEsque
+        // ParserValibotEsque (<= v0.12.X)
+        return parser.parse.bind(parser);
+    }
+    if (typeof parser.validateSync === 'function') {
+        // ParserYupEsque
+        return parser.validateSync.bind(parser);
+    }
+    if (typeof parser.create === 'function') {
+        // ParserSuperstructEsque
+        return parser.create.bind(parser);
+    }
+    if (typeof parser.assert === 'function') {
+        // ParserScaleEsque
+        return (value)=>{
+            parser.assert(value);
+            return value;
+        };
+    }
+    throw new Error('Could not find a validator fn');
+}
+
+/** @internal */ const unsetMarker = Symbol('unsetMarker');
+function createNewBuilder(def1, def2) {
+    const { middlewares =[] , inputs , meta , ...rest } = def2;
+    // TODO: maybe have a fn here to warn about calls
+    return createBuilder({
+        ...mergeWithoutOverrides(def1, rest),
+        inputs: [
+            ...def1.inputs,
+            ...inputs ?? []
+        ],
+        middlewares: [
+            ...def1.middlewares,
+            ...middlewares
+        ],
+        meta: def1.meta && meta ? {
+            ...def1.meta,
+            ...meta
+        } : meta ?? def1.meta
+    });
+}
+function createBuilder(initDef = {}) {
+    const _def = {
+        procedure: true,
+        inputs: [],
+        middlewares: [],
+        ...initDef
+    };
+    const builder = {
+        _def,
+        input (input) {
+            const parser = getParseFn(input);
+            return createNewBuilder(_def, {
+                inputs: [
+                    input
+                ],
+                middlewares: [
+                    createInputMiddleware(parser)
+                ]
+            });
+        },
+        output (output) {
+            const parser = getParseFn(output);
+            return createNewBuilder(_def, {
+                output,
+                middlewares: [
+                    createOutputMiddleware(parser)
+                ]
+            });
+        },
+        meta (meta) {
+            return createNewBuilder(_def, {
+                meta
+            });
+        },
+        use (middlewareBuilderOrFn) {
+            // Distinguish between a middleware builder and a middleware function
+            const middlewares = '_middlewares' in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [
+                middlewareBuilderOrFn
+            ];
+            return createNewBuilder(_def, {
+                middlewares: middlewares
+            });
+        },
+        query (resolver) {
+            return createResolver({
+                ..._def,
+                type: 'query'
+            }, resolver);
+        },
+        mutation (resolver) {
+            return createResolver({
+                ..._def,
+                type: 'mutation'
+            }, resolver);
+        },
+        subscription (resolver) {
+            return createResolver({
+                ..._def,
+                type: 'subscription'
+            }, resolver);
+        }
+    };
+    return builder;
+}
+function createResolver(_def, resolver) {
+    const finalBuilder = createNewBuilder(_def, {
+        resolver,
+        middlewares: [
+            async function resolveMiddleware(opts) {
+                const data = await resolver(opts);
+                return {
+                    marker: middlewareMarker,
+                    ok: true,
+                    data,
+                    ctx: opts.ctx
+                };
+            }
+        ]
+    });
+    return createProcedureCaller(finalBuilder._def);
+}
+const codeblock = `
+This is a client-only function.
+If you want to call this function on the server, see https://trpc.io/docs/v11/server/server-side-calls
+`.trim();
+function createProcedureCaller(_def) {
+    async function procedure(opts) {
+        // is direct server-side call
+        if (!opts || !('getRawInput' in opts)) {
+            throw new Error(codeblock);
+        }
+        // run the middlewares recursively with the resolver as the last one
+        async function callRecursive(callOpts = {
+            index: 0,
+            ctx: opts.ctx
+        }) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const middleware = _def.middlewares[callOpts.index];
+                const result = await middleware({
+                    ctx: callOpts.ctx,
+                    type: opts.type,
+                    path: opts.path,
+                    getRawInput: callOpts.getRawInput ?? opts.getRawInput,
+                    meta: _def.meta,
+                    input: callOpts.input,
+                    next (_nextOpts) {
+                        const nextOpts = _nextOpts;
+                        return callRecursive({
+                            index: callOpts.index + 1,
+                            ctx: nextOpts && 'ctx' in nextOpts ? {
+                                ...callOpts.ctx,
+                                ...nextOpts.ctx
+                            } : callOpts.ctx,
+                            input: nextOpts && 'input' in nextOpts ? nextOpts.input : callOpts.input,
+                            getRawInput: nextOpts && 'getRawInput' in nextOpts ? nextOpts.getRawInput : callOpts.getRawInput
+                        });
+                    }
+                });
+                return result;
+            } catch (cause) {
+                return {
+                    ok: false,
+                    error: getTRPCErrorFromUnknown(cause),
+                    marker: middlewareMarker
+                };
+            }
+        }
+        // there's always at least one "next" since we wrap this.resolver in a middleware
+        const result = await callRecursive();
+        if (!result) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'No result from middlewares - did you forget to `return next()`?'
+            });
+        }
+        if (!result.ok) {
+            // re-throw original error
+            throw result.error;
+        }
+        return result.data;
+    }
+    procedure._def = _def;
+    // FIXME typecast shouldn't be needed - fixittt
+    return procedure;
+}
+
+/**
+ * TODO: This can be improved:
+ * - We should be able to chain `.meta()`/`.context()` only once
+ * - Simplify typings
+ * - Doesn't need to be a class but it doesn't really hurt either
+ */ class TRPCBuilder {
+    /**
+   * Add a context shape as a generic to the root object
+   * @link https://trpc.io/docs/v11/server/context
+   */ context() {
+        return new TRPCBuilder();
+    }
+    /**
+   * Add a meta shape as a generic to the root object
+   * @link https://trpc.io/docs/v11/quickstart
+   */ meta() {
+        return new TRPCBuilder();
+    }
+    /**
+   * Create the root object
+   * @link https://trpc.io/docs/v11/server/routers#initialize-trpc
+   */ create(options) {
+        return createTRPCInner()(options);
+    }
+}
+/**
+ * Builder to initialize the tRPC root object - use this exactly once per backend
+ * @link https://trpc.io/docs/v11/quickstart
+ */ const initTRPC = new TRPCBuilder();
+function createTRPCInner() {
+    return function initTRPCInner(runtime) {
+        const errorFormatter = runtime?.errorFormatter ?? defaultFormatter;
+        const transformer = getDataTransformer(runtime?.transformer ?? defaultTransformer);
+        const config = {
+            transformer,
+            isDev: runtime?.isDev ?? // eslint-disable-next-line @typescript-eslint/dot-notation
+            globalThis.process?.env?.['NODE_ENV'] !== 'production',
+            allowOutsideOfServer: runtime?.allowOutsideOfServer ?? false,
+            errorFormatter,
+            isServer: runtime?.isServer ?? isServerDefault,
+            /**
+       * @internal
+       */ $types: createFlatProxy((key)=>{
+                throw new Error(`Tried to access "$types.${key}" which is not available at runtime`);
+            })
+        };
+        {
+            // Server check
+            const isServer = runtime?.isServer ?? isServerDefault;
+            if (!isServer && runtime?.allowOutsideOfServer !== true) {
+                throw new Error(`You're trying to use @trpc/server in a non-server environment. This is not supported by default.`);
+            }
+        }
+        return {
+            /**
+       * These are just types, they can't be used
+       * @internal
+       */ _config: config,
+            /**
+       * Builder object for creating procedures
+       * @link https://trpc.io/docs/v11/server/procedures
+       */ procedure: createBuilder({
+                meta: runtime?.defaultMeta
+            }),
+            /**
+       * Create reusable middlewares
+       * @link https://trpc.io/docs/v11/server/middlewares
+       */ middleware: createMiddlewareFactory(),
+            /**
+       * Create a router
+       * @link https://trpc.io/docs/v11/server/routers
+       */ router: createRouterFactory(config),
+            /**
+       * Merge Routers
+       * @link https://trpc.io/docs/v11/server/merging-routers
+       */ mergeRouters,
+            /**
+       * Create a server-side caller for a router
+       * @link https://trpc.io/docs/v11/server/server-side-calls
+       */ createCallerFactory: createCallerFactory()
+        };
+    };
+}
+
+export { createOutputMiddleware as a, createBuilder as b, createInputMiddleware as c, experimental_standaloneMiddleware as e, initTRPC as i, middlewareMarker as m, unsetMarker as u };

package/dist/{nodeHTTPRequestHandler-55f05150.js → nodeHTTPRequestHandler-71a3f758.js}

@@ -1,12 +1,13 @@
 'use strict';
 
-var core = require('@trpc/core');
+require('./rootConfig-ccd626d6.js');
+var resolveHTTPResponse = require('./resolveHTTPResponse-104460bf.js');
+var batchStreamFormatter = require('./batchStreamFormatter-1971db27.js');
 var adapters_nodeHttp_contentType_json_index = require('./adapters/node-http/content-type/json/index.js');
 
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
  *
- * Do **not** import from `@trpc/core`
  * @example
  * ```ts
  * import type { AnyTRPCRouter } from '@trpc/server'
@@ -63,7 +64,7 @@ async function nodeHTTPRequestHandler(opts) {
                 const vary = opts.res.getHeader('Vary');
                 opts.res.setHeader('Vary', vary ? 'trpc-batch-mode, ' + vary : 'trpc-batch-mode');
                 isStream = true;
-                formatter = core.getBatchStreamFormatter();
+                formatter = batchStreamFormatter.getBatchStreamFormatter();
                 opts.res.flushHeaders();
             }
         };
@@ -79,7 +80,7 @@ async function nodeHTTPRequestHandler(opts) {
                 opts.res.flush?.();
             }
         };
-        await core.resolveHTTPResponse({
+        await resolveHTTPResponse.resolveHTTPResponse({
             batching: opts.batching,
             responseMeta: opts.responseMeta,
             path: opts.path,

package/dist/{nodeHTTPRequestHandler-2d5c8791.mjs → nodeHTTPRequestHandler-c5d1d163.mjs}

@@ -1,10 +1,11 @@
-import { resolveHTTPResponse, getBatchStreamFormatter } from '@trpc/core';
+import './rootConfig-7d3e1fc8.mjs';
+import { r as resolveHTTPResponse } from './resolveHTTPResponse-eb29e5cf.mjs';
+import { g as getBatchStreamFormatter } from './batchStreamFormatter-378277dc.mjs';
 import { nodeHTTPJSONContentTypeHandler } from './adapters/node-http/content-type/json/index.mjs';
 
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
  *
- * Do **not** import from `@trpc/core`
  * @example
  * ```ts
  * import type { AnyTRPCRouter } from '@trpc/server'

package/dist/{nodeHTTPRequestHandler-7691fc79.js → nodeHTTPRequestHandler-f60f0b99.js}

@@ -1,4 +1,6 @@
-import { resolveHTTPResponse, getBatchStreamFormatter } from '@trpc/core';
+import './rootConfig-52aed7d7.js';
+import { r as resolveHTTPResponse } from './resolveHTTPResponse-6a85f0a7.js';
+import { g as getBatchStreamFormatter } from './batchStreamFormatter-4375dc8b.js';
 import { nodeHTTPJSONContentTypeHandler } from './adapters/node-http/content-type/json/index.js';
 
 const defaultJSONContentTypeHandler = nodeHTTPJSONContentTypeHandler();

package/dist/observable/index.d.ts

@@ -0,0 +1,5 @@
+export type { inferObservableValue } from './observable';
+export { isObservable, observable, observableToPromise } from './observable';
+export { map, share, tap } from './operators';
+export type { Observable, Observer, TeardownLogic, Unsubscribable, UnsubscribeFn, } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/observable/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAC9C,YAAY,EACV,UAAU,EACV,QAAQ,EACR,aAAa,EACb,cAAc,EACd,aAAa,GACd,MAAM,SAAS,CAAC"}

package/dist/observable/index.js

@@ -0,0 +1,110 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var observable = require('../observable-25f4098f.js');
+
+function map(project) {
+    return (originalObserver)=>{
+        return {
+            subscribe (observer) {
+                let index = 0;
+                const subscription = originalObserver.subscribe({
+                    next (value) {
+                        observer.next?.(project(value, index++));
+                    },
+                    error (error) {
+                        observer.error?.(error);
+                    },
+                    complete () {
+                        observer.complete?.();
+                    }
+                });
+                return subscription;
+            }
+        };
+    };
+}
+function share(_opts) {
+    return (originalObserver)=>{
+        let refCount = 0;
+        let subscription = null;
+        const observers = [];
+        function startIfNeeded() {
+            if (subscription) {
+                return;
+            }
+            subscription = originalObserver.subscribe({
+                next (value) {
+                    for (const observer of observers){
+                        observer.next?.(value);
+                    }
+                },
+                error (error) {
+                    for (const observer of observers){
+                        observer.error?.(error);
+                    }
+                },
+                complete () {
+                    for (const observer of observers){
+                        observer.complete?.();
+                    }
+                }
+            });
+        }
+        function resetIfNeeded() {
+            // "resetOnRefCountZero"
+            if (refCount === 0 && subscription) {
+                const _sub = subscription;
+                subscription = null;
+                _sub.unsubscribe();
+            }
+        }
+        return {
+            subscribe (observer) {
+                refCount++;
+                observers.push(observer);
+                startIfNeeded();
+                return {
+                    unsubscribe () {
+                        refCount--;
+                        resetIfNeeded();
+                        const index = observers.findIndex((v)=>v === observer);
+                        if (index > -1) {
+                            observers.splice(index, 1);
+                        }
+                    }
+                };
+            }
+        };
+    };
+}
+function tap(observer) {
+    return (originalObserver)=>{
+        return {
+            subscribe (observer2) {
+                return originalObserver.subscribe({
+                    next (v) {
+                        observer.next?.(v);
+                        observer2.next?.(v);
+                    },
+                    error (v) {
+                        observer.error?.(v);
+                        observer2.error?.(v);
+                    },
+                    complete () {
+                        observer.complete?.();
+                        observer2.complete?.();
+                    }
+                });
+            }
+        };
+    };
+}
+
+exports.isObservable = observable.isObservable;
+exports.observable = observable.observable;
+exports.observableToPromise = observable.observableToPromise;
+exports.map = map;
+exports.share = share;
+exports.tap = tap;

package/dist/observable/index.mjs

@@ -0,0 +1,101 @@
+export { i as isObservable, o as observable, a as observableToPromise } from '../observable-bf75028f.mjs';
+
+function map(project) {
+    return (originalObserver)=>{
+        return {
+            subscribe (observer) {
+                let index = 0;
+                const subscription = originalObserver.subscribe({
+                    next (value) {
+                        observer.next?.(project(value, index++));
+                    },
+                    error (error) {
+                        observer.error?.(error);
+                    },
+                    complete () {
+                        observer.complete?.();
+                    }
+                });
+                return subscription;
+            }
+        };
+    };
+}
+function share(_opts) {
+    return (originalObserver)=>{
+        let refCount = 0;
+        let subscription = null;
+        const observers = [];
+        function startIfNeeded() {
+            if (subscription) {
+                return;
+            }
+            subscription = originalObserver.subscribe({
+                next (value) {
+                    for (const observer of observers){
+                        observer.next?.(value);
+                    }
+                },
+                error (error) {
+                    for (const observer of observers){
+                        observer.error?.(error);
+                    }
+                },
+                complete () {
+                    for (const observer of observers){
+                        observer.complete?.();
+                    }
+                }
+            });
+        }
+        function resetIfNeeded() {
+            // "resetOnRefCountZero"
+            if (refCount === 0 && subscription) {
+                const _sub = subscription;
+                subscription = null;
+                _sub.unsubscribe();
+            }
+        }
+        return {
+            subscribe (observer) {
+                refCount++;
+                observers.push(observer);
+                startIfNeeded();
+                return {
+                    unsubscribe () {
+                        refCount--;
+                        resetIfNeeded();
+                        const index = observers.findIndex((v)=>v === observer);
+                        if (index > -1) {
+                            observers.splice(index, 1);
+                        }
+                    }
+                };
+            }
+        };
+    };
+}
+function tap(observer) {
+    return (originalObserver)=>{
+        return {
+            subscribe (observer2) {
+                return originalObserver.subscribe({
+                    next (v) {
+                        observer.next?.(v);
+                        observer2.next?.(v);
+                    },
+                    error (v) {
+                        observer.error?.(v);
+                        observer2.error?.(v);
+                    },
+                    complete () {
+                        observer.complete?.();
+                        observer2.complete?.();
+                    }
+                });
+            }
+        };
+    };
+}
+
+export { map, share, tap };

package/dist/observable/observable.d.ts

@@ -0,0 +1,13 @@
+import type { Observable, Observer, TeardownLogic } from './types';
+/** @public */
+export type inferObservableValue<TObservable> = TObservable extends Observable<infer TValue, unknown> ? TValue : never;
+/** @public */
+export declare function isObservable(x: unknown): x is Observable<unknown, unknown>;
+/** @public */
+export declare function observable<TValue, TError = unknown>(subscribe: (observer: Observer<TValue, TError>) => TeardownLogic): Observable<TValue, TError>;
+/** @internal */
+export declare function observableToPromise<TValue>(observable: Observable<TValue, unknown>): {
+    promise: Promise<TValue>;
+    abort: () => void;
+};
+//# sourceMappingURL=observable.d.ts.map

package/dist/observable/observable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.d.ts","sourceRoot":"","sources":["../../src/observable/observable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,QAAQ,EAER,aAAa,EAEd,MAAM,SAAS,CAAC;AAMjB,cAAc;AACd,MAAM,MAAM,oBAAoB,CAAC,WAAW,IAAI,WAAW,SAAS,UAAU,CAC5E,MAAM,MAAM,EACZ,OAAO,CACR,GACG,MAAM,GACN,KAAK,CAAC;AAEV,cAAc;AACd,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAE1E;AAED,cAAc;AACd,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,EACjD,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,aAAa,GAC/D,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CA6D5B;AA8BD,gBAAgB;AAChB,wBAAgB,mBAAmB,CAAC,MAAM,EACxC,UAAU,EAAE,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC;;iBAEtB,IAAI;EAkCtB"}

package/dist/observable/operators.d.ts

@@ -0,0 +1,8 @@
+import type { MonoTypeOperatorFunction, Observer, OperatorFunction } from './types';
+export declare function map<TValueBefore, TError, TValueAfter>(project: (value: TValueBefore, index: number) => TValueAfter): OperatorFunction<TValueBefore, TError, TValueAfter, TError>;
+interface ShareConfig {
+}
+export declare function share<TValue, TError>(_opts?: ShareConfig): MonoTypeOperatorFunction<TValue, TError>;
+export declare function tap<TValue, TError>(observer: Partial<Observer<TValue, TError>>): MonoTypeOperatorFunction<TValue, TError>;
+export {};
+//# sourceMappingURL=operators.d.ts.map

package/dist/observable/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../../src/observable/operators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,QAAQ,EACR,gBAAgB,EAEjB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,GAAG,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EACnD,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,KAAK,WAAW,GAC3D,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,CAoB7D;AAED,UAAU,WAAW;CAAG;AACxB,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,EAClC,KAAK,CAAC,EAAE,WAAW,GAClB,wBAAwB,CAAC,MAAM,EAAE,MAAM,CAAC,CA2D1C;AAED,wBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,EAChC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC1C,wBAAwB,CAAC,MAAM,EAAE,MAAM,CAAC,CAqB1C"}