@utiliread/http 1.18.0 → 1.19.1

package/plugins/json/src/index.ts

@@ -1,124 +1,143 @@
-import { HttpBuilder, HttpBuilderOfT, Mapping } from "@utiliread/http";
-import type {
-  InfinitePaginationResult,
-  PaginationResult,
-} from "@utiliread/http";
-import { deserialize, serialize } from "@utiliread/json";
-
-// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
-declare module "@utiliread/http" {
-  interface HttpBuilder {
-    withJson(content: any): this;
-
-    expectJson<T>(typeOrMapper?: Mapping.TypeOrMapper<T>): HttpBuilderOfT<T>;
-    expectJsonArray<T>(
-      typeOrMapper: Mapping.TypeOrMapper<T>,
-    ): HttpBuilderOfT<T[]>;
-    expectJsonNullableArray<T>(
-      typeOrMapper: Mapping.TypeOrMapper<T>,
-    ): HttpBuilderOfT<(T | null)[]>;
-    expectJsonPaginationResult<T>(
-      typeOrMapper: Mapping.TypeOrMapper<T>,
-    ): HttpBuilderOfT<PaginationResult<T>>;
-    expectJsonInfinitePaginationResult<T>(
-      typeOrMapper: Mapping.TypeOrMapper<T>,
-    ): HttpBuilderOfT<InfinitePaginationResult<T>>;
-  }
-  interface HttpBuilderOfT<T> {
-    withJson(content: any): this;
-  }
-}
-
-HttpBuilder.prototype.withJson = function (this: HttpBuilder, content: any) {
-  this.message.content = serialize(content);
-  this.message.contentType = "application/json";
-  return this;
-};
-
-HttpBuilderOfT.prototype.withJson = function <T>(
-  this: HttpBuilderOfT<T>,
-  content: any,
-) {
-  this.message.content = serialize(content);
-  this.message.contentType = "application/json";
-  return this;
-};
-
-HttpBuilder.prototype.expectJson = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: Mapping.TypeOrMapper<T>,
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.rawResponse
-      .json()
-      .then((x) => Mapping.getMapper(deserialize, typeOrMapper)(x));
-  });
-};
-
-HttpBuilder.prototype.expectJsonArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper: Mapping.TypeOrMapper<T>,
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.rawResponse.json().then((x: any[]) => {
-      const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
-      return x.map(itemFactory);
-    });
-  });
-};
-
-HttpBuilder.prototype.expectJsonNullableArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper: Mapping.TypeOrMapper<T>,
-): HttpBuilderOfT<(T | null)[]> {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.rawResponse.json().then((x: any[]) => {
-      const itemFactory = Mapping.getNullableMapper(deserialize, typeOrMapper);
-      return x.map(itemFactory);
-    });
-  });
-};
-
-HttpBuilder.prototype.expectJsonPaginationResult = function <T>(
-  this: HttpBuilder,
-  typeOrMapper: Mapping.TypeOrMapper<T>,
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.rawResponse.json().then((x: PaginationResult<any>) => {
-      const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
-      return {
-        meta: {
-          pageCount: x.meta.pageCount,
-          pageSize: x.meta.pageSize,
-          totalItems: x.meta.totalItems,
-        },
-        data: x.data.map(itemFactory),
-      };
-    });
-  });
-};
-
-HttpBuilder.prototype.expectJsonInfinitePaginationResult = function <T>(
-  this: HttpBuilder,
-  typeOrMapper: Mapping.TypeOrMapper<T>,
-) {
-  this.message.headers.set("Accept", "application/json");
-  return this.useHandler((response) => {
-    return response.rawResponse
-      .json()
-      .then((x: InfinitePaginationResult<any>) => {
-        const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
-        return {
-          meta: {
-            pageSize: x.meta.pageSize,
-            continuationToken: x.meta.continuationToken,
-          },
-          data: x.data.map(itemFactory),
-        };
-      });
-  });
-};
+import {
+  HttpBuilder,
+  HttpBuilderOfT,
+  getMapper,
+  getNullableMapper,
+} from "@utiliread/http";
+import type {
+  InfinitePaginationResult,
+  PaginationResult,
+  TypeOrMapper,
+} from "@utiliread/http";
+import { deserialize, serialize } from "@utiliread/json";
+
+// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
+declare module "@utiliread/http" {
+  interface HttpBuilder {
+    withJson(content: any): this;
+
+    expectJson<T>(
+      typeOrMapper?: import("@utiliread/http").TypeOrMapper<T>
+    ): import("@utiliread/http").HttpBuilderOfT<T>;
+    expectJsonArray<T>(
+      typeOrMapper: import("@utiliread/http").TypeOrMapper<T>
+    ): import("@utiliread/http").HttpBuilderOfT<T[]>;
+    expectJsonNullableArray<T>(
+      typeOrMapper: import("@utiliread/http").TypeOrMapper<T>
+    ): import("@utiliread/http").HttpBuilderOfT<(T | null)[]>;
+    expectJsonPaginationResult<T>(
+      typeOrMapper: import("@utiliread/http").TypeOrMapper<T>
+    ): import("@utiliread/http").HttpBuilderOfT<
+      import("@utiliread/http").PaginationResult<T>
+    >;
+    expectJsonInfinitePaginationResult<T>(
+      typeOrMapper: import("@utiliread/http").TypeOrMapper<T>
+    ): import("@utiliread/http").HttpBuilderOfT<
+      import("@utiliread/http").InfinitePaginationResult<T>
+    >;
+  }
+  interface HttpBuilderOfT<T> {
+    withJson(content: any): this;
+  }
+}
+
+HttpBuilder.prototype.withJson = function (this: HttpBuilder, content: any) {
+  this.message.content = serialize(content);
+  this.message.contentType = "application/json";
+  return this;
+};
+
+HttpBuilderOfT.prototype.withJson = function <T>(
+  this: HttpBuilderOfT<T>,
+  content: any
+) {
+  this.message.content = serialize(content);
+  this.message.contentType = "application/json";
+  return this;
+};
+
+HttpBuilder.prototype.expectJson = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    const promise = response.rawResponse
+      .json()
+      .then((x) => getMapper(deserialize, typeOrMapper)(x));
+    return promise;
+  });
+};
+
+HttpBuilder.prototype.expectJsonArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    const promise = response.rawResponse.json().then((x: any[]) => {
+      const itemFactory = getMapper(deserialize, typeOrMapper);
+      return x.map(itemFactory);
+    });
+    return promise;
+  });
+};
+
+HttpBuilder.prototype.expectJsonNullableArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper: TypeOrMapper<T>
+): HttpBuilderOfT<(T | null)[]> {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    const promise = response.rawResponse.json().then((x: any[]) => {
+      const itemFactory = getNullableMapper(deserialize, typeOrMapper);
+      return x.map(itemFactory);
+    });
+    return promise;
+  });
+};
+
+HttpBuilder.prototype.expectJsonPaginationResult = function <T>(
+  this: HttpBuilder,
+  typeOrMapper: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    const promise = response.rawResponse
+      .json()
+      .then((x: PaginationResult<any>) => {
+        const itemFactory = getMapper(deserialize, typeOrMapper);
+        return {
+          meta: {
+            pageCount: x.meta.pageCount,
+            pageSize: x.meta.pageSize,
+            totalItems: x.meta.totalItems,
+          },
+          data: x.data.map(itemFactory),
+        };
+      });
+    return promise;
+  });
+};
+
+HttpBuilder.prototype.expectJsonInfinitePaginationResult = function <T>(
+  this: HttpBuilder,
+  typeOrMapper: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/json");
+  return this.useHandler((response) => {
+    const promise = response.rawResponse
+      .json()
+      .then((x: InfinitePaginationResult<any>) => {
+        const itemFactory = getMapper(deserialize, typeOrMapper);
+        return {
+          meta: {
+            pageSize: x.meta.pageSize,
+            continuationToken: x.meta.continuationToken,
+          },
+          data: x.data.map(itemFactory),
+        };
+      });
+    return promise;
+  });
+};

package/plugins/json/tsconfig.json

@@ -1,8 +1,7 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "../../dist/esm/json"
+    "rootDir": "src"
   },
   "include": ["./src/*.ts"]
 }

package/plugins/jsonpatch/node_modules/@utiliread/http/package.json

@@ -1,4 +1,4 @@
 {
     "name": "@utiliread/http",
-    "types": "../../../../../dist/esm/index.d.ts"
+    "types": "../../../../../dist/index.d.ts"
 }

package/plugins/jsonpatch/package.json

@@ -0,0 +1,16 @@
+{
+  "source": "src/index.ts",
+  "main": "./../../dist/jsonpatch.js",
+  "module": "./../../dist/jsonpatch.mjs",
+  "types": "./../../dist/jsonpatch.d.ts",
+  "alias": {
+    "@utiliread/http": false
+  },
+  "dependencies": {
+    "@utiliread/http": "file:../../"
+  },
+  "peerDependencies": {
+    "@utiliread/json": "file:../../node_modules/@utiliread/json",
+    "@utiliread/jsonpatch": "file:../../node_modules/@utiliread/jsonpatch"
+  }
+}

package/plugins/jsonpatch/src/index.ts

@@ -1,31 +1,32 @@
-import { HttpBuilder, HttpBuilderOfT } from "@utiliread/http";
-import { serialize } from "@utiliread/json";
-import type { Operation } from "@utiliread/jsonpatch";
-
-// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
-declare module "@utiliread/http" {
-  interface HttpBuilder {
-    withJsonPatch(operations: Operation[]): this;
-  }
-  interface HttpBuilderOfT<T> {
-    withJsonPatch(operations: Operation[]): this;
-  }
-}
-
-HttpBuilder.prototype.withJsonPatch = function (
-  this: HttpBuilder,
-  operations: Operation[],
-) {
-  this.message.content = serialize(operations);
-  this.message.contentType = "application/json-patch+json";
-  return this;
-};
-
-HttpBuilderOfT.prototype.withJsonPatch = function <T>(
-  this: HttpBuilderOfT<T>,
-  operations: Operation[],
-) {
-  this.message.content = serialize(operations);
-  this.message.contentType = "application/json-patch+json";
-  return this;
-};
+import { HttpBuilder, HttpBuilderOfT } from "@utiliread/http";
+
+import type { Operation } from "@utiliread/jsonpatch";
+import { serialize } from "@utiliread/json";
+
+// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
+declare module "@utiliread/http" {
+  interface HttpBuilder {
+    withJsonPatch(operations: import("@utiliread/jsonpatch").Operation[]): this;
+  }
+  interface HttpBuilderOfT<T> {
+    withJsonPatch(operations: import("@utiliread/jsonpatch").Operation[]): this;
+  }
+}
+
+HttpBuilder.prototype.withJsonPatch = function (
+  this: HttpBuilder,
+  operations: Operation[],
+) {
+  this.message.content = serialize(operations);
+  this.message.contentType = "application/json-patch+json";
+  return this;
+};
+
+HttpBuilderOfT.prototype.withJsonPatch = function <T>(
+  this: HttpBuilderOfT<T>,
+  operations: Operation[],
+) {
+  this.message.content = serialize(operations);
+  this.message.contentType = "application/json-patch+json";
+  return this;
+};

package/plugins/jsonpatch/tsconfig.json

@@ -1,8 +1,7 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "../../dist/esm/jsonpatch"
+    "rootDir": "src"
   },
   "include": ["./src/*.ts"]
 }

package/plugins/msgpack/node_modules/@utiliread/http/package.json

@@ -1,4 +1,4 @@
 {
     "name": "@utiliread/http",
-    "types": "../../../../../dist/esm/index.d.ts"
+    "types": "../../../../../dist/index.d.ts"
 }

package/plugins/msgpack/package.json

@@ -0,0 +1,16 @@
+{
+  "source": "src/index.ts",
+  "main": "./../../dist/msgpack.js",
+  "module": "./../../dist/msgpack.mjs",
+  "types": "./../../dist/msgpack.d.ts",
+  "alias": {
+    "@utiliread/http": false
+  },
+  "dependencies": {
+    "@utiliread/http": "file:../../"
+  },
+  "peerDependencies": {
+    "@msgpack/msgpack": "file:../../node_modules/@msgpack/msgpack",
+    "@utiliread/msgpack": "file:../../node_modules/@utiliread/msgpack"
+  }
+}

package/plugins/msgpack/src/index.ts

@@ -1,67 +1,60 @@
-import {
-  HttpBuilder,
-  HttpBuilderOfT,
-  HttpResponse,
-  Mapping,
-} from "@utiliread/http";
-import { decodeArrayStream, decodeAsync } from "@msgpack/msgpack";
-
-import { deserialize } from "@utiliread/msgpack";
-
-// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
-declare module "@utiliread/http" {
-  interface HttpBuilder {
-    expectMessagePack<T>(
-      typeOrMapper?: Mapping.TypeOrMapper<T>,
-    ): HttpBuilderOfT<T>;
-    expectMessagePackArray<T>(
-      typeOrMapper?: Mapping.TypeOrMapper<T>,
-    ): HttpBuilderOfT<T[]>;
-    streamMessagePackArray<T>(
-      typeOrMapper?: Mapping.TypeOrMapper<T>,
-    ): HttpBuilderOfT<AsyncGenerator<T, void, unknown>>;
-  }
-}
-
-HttpBuilder.prototype.expectMessagePack = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: Mapping.TypeOrMapper<T>,
-) {
-  this.message.headers.set("Accept", "application/x-msgpack");
-  return this.useHandler(async (response) => {
-    const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
-    const decoded = await decodeAsync(response.rawResponse.body!);
-    return itemFactory(decoded);
-  });
-};
-
-HttpBuilder.prototype.expectMessagePackArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: Mapping.TypeOrMapper<T>,
-) {
-  this.message.headers.set("Accept", "application/x-msgpack");
-  return this.useHandler(async (response) => {
-    const items: T[] = [];
-    const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
-    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
-      items.push(itemFactory(item));
-    }
-    return items;
-  });
-};
-
-HttpBuilder.prototype.streamMessagePackArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: Mapping.TypeOrMapper<T>,
-) {
-  this.message.headers.set("Accept", "application/x-msgpack");
-
-  async function* handler(response: HttpResponse) {
-    const itemFactory = Mapping.getMapper(deserialize, typeOrMapper);
-    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
-      yield itemFactory(item);
-    }
-  }
-
-  return this.useHandler((response) => Promise.resolve(handler(response)));
-};
+import { HttpBuilder, HttpResponse, TypeOrMapper, getMapper } from "@utiliread/http";
+import { decodeArrayStream, decodeAsync } from "@msgpack/msgpack";
+
+import { deserialize } from "@utiliread/msgpack";
+
+// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
+declare module "@utiliread/http" {
+  interface HttpBuilder {
+    expectMessagePack<T>(typeOrMapper?: import("@utiliread/http").TypeOrMapper<T>): import("@utiliread/http").HttpBuilderOfT<T>;
+    expectMessagePackArray<T>(
+      typeOrMapper?: import("@utiliread/http").TypeOrMapper<T>,
+    ): import("@utiliread/http").HttpBuilderOfT<T[]>;
+    streamMessagePackArray<T>(
+      typeOrMapper?: import("@utiliread/http").TypeOrMapper<T>,
+    ): import("@utiliread/http").HttpBuilderOfT<AsyncGenerator<T, void, unknown>>;
+  }
+}
+
+HttpBuilder.prototype.expectMessagePack = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: TypeOrMapper<T>,
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+  return this.useHandler(async (response) => {
+    const itemFactory = getMapper(deserialize, typeOrMapper);
+    const decoded = await decodeAsync(response.rawResponse.body!);
+    return itemFactory(decoded);
+  });
+};
+
+HttpBuilder.prototype.expectMessagePackArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: TypeOrMapper<T>,
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+  return this.useHandler(async (response) => {
+    const items: T[] = [];
+    const itemFactory = getMapper(deserialize, typeOrMapper);
+    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
+      items.push(itemFactory(item));
+    }
+    return items;
+  });
+};
+
+HttpBuilder.prototype.streamMessagePackArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: TypeOrMapper<T>,
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+
+  async function* handler(response: HttpResponse) {
+    const itemFactory = getMapper(deserialize, typeOrMapper);
+    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
+      yield itemFactory(item);
+    }
+  }
+
+  return this.useHandler((response) => Promise.resolve(handler(response)));
+};

package/plugins/msgpack/tsconfig.json

@@ -1,8 +1,7 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "../../dist/esm/msgpack"
+    "rootDir": "src"
   },
   "include": ["./src/*.ts"]
 }

package/src/index.ts

@@ -17,4 +17,4 @@ export * from "./helpers";
 export type { Fetch } from "./http";
 export type { Subscription } from "./event-aggregator";
 export { statusCodes } from "./status-codes";
-export * as Mapping from "./mapping";
+export * from "./mapper";

package/tsconfig.json

@@ -8,7 +8,6 @@
     "strict": true,
     "stripInternal": true,
     "rootDir": "src",
-    "outDir": "dist/esm",
     "lib": ["ES2018", "DOM"],
     "types": ["mocha"]
   },

package/web-test-runner.config.mjs

@@ -1,7 +1,7 @@
-import { esbuildPlugin } from "@web/dev-server-esbuild";
-
-export default {
-    nodeResolve: true,
-    files: ["src/**/*.spec.ts"],
-    plugins: [esbuildPlugin({ ts: true })],
-};
+import { esbuildPlugin } from "@web/dev-server-esbuild";
+
+export default {
+  nodeResolve: true,
+  files: ["src/**/*.spec.ts"],
+  plugins: [esbuildPlugin({ ts: true })],
+};

package/dist/cjs/event-aggregator.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventAggregator = void 0;
-class EventAggregator {
-    constructor() {
-        this.callbacks = [];
-    }
-    get any() {
-        return this.callbacks.length > 0;
-    }
-    subscribe(callback) {
-        this.callbacks.push(callback);
-        return {
-            dispose: () => {
-                const index = this.callbacks.indexOf(callback);
-                if (index >= 0) {
-                    this.callbacks.splice(index, 1);
-                }
-            }
-        };
-    }
-    async publish(...params) {
-        const callbacks = this.callbacks.slice();
-        for (const callback of callbacks) {
-            await Promise.resolve(callback.apply(this, params));
-        }
-    }
-}
-exports.EventAggregator = EventAggregator;
-//# sourceMappingURL=event-aggregator.js.map

package/dist/cjs/event-aggregator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"event-aggregator.js","sourceRoot":"","sources":["../../src/event-aggregator.ts"],"names":[],"mappings":";;;AAEA,MAAa,eAAe;IAA5B;QACY,cAAS,GAAe,EAAE,CAAC;IAwBvC,CAAC;IAtBG,IAAI,GAAG;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;IACrC,CAAC;IAED,SAAS,CAAC,QAAqB;QAC3B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9B,OAAO;YACH,OAAO,EAAE,GAAG,EAAE;gBACV,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;gBAC/C,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;oBACb,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;gBACpC,CAAC;YACL,CAAC;SACJ,CAAA;IACL,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAG,MAAS;QACtB,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACzC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YAC/B,MAAM,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;QACxD,CAAC;IACL,CAAC;CACJ;AAzBD,0CAyBC"}

package/dist/cjs/events.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.events = void 0;
-const http_builder_1 = require("./http-builder");
-function events(action, configure) {
-    return function (...params) {
-        const builder = action(...params);
-        const events = configure(...params);
-        if (events.sent) {
-            builder.onSent(events.sent);
-        }
-        if (builder instanceof http_builder_1.HttpBuilderOfT && events.received) {
-            builder.onReceived(events.received);
-        }
-        return builder;
-    };
-}
-exports.events = events;
-//# sourceMappingURL=events.js.map

package/dist/cjs/events.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/events.ts"],"names":[],"mappings":";;;AAAA,iDAAsE;AAuBtE,SAAgB,MAAM,CACpB,MAA2B,EAC3B,SAAkD;IAElD,OAAO,UAAU,GAAG,MAAS;QAC3B,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,CAAC,CAAC;QACpC,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;YAChB,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;QACD,IAAI,OAAO,YAAY,6BAAc,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;YACzD,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC,CAAC;AACJ,CAAC;AAfD,wBAeC"}