@efffrida/rpc 0.0.13 → 0.0.15

package/src/frida/FridaRpcServer.ts

@@ -0,0 +1,168 @@
+/**
+ * Implements a Frida RPC server protocol for effect using the frida script
+ * exports.
+ *
+ * @since 1.0.0
+ */
+
+import * as RpcMessage from "@effect/rpc/RpcMessage";
+import * as RpcSerialization from "@effect/rpc/RpcSerialization";
+import * as RpcServer from "@effect/rpc/RpcServer";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Mailbox from "effect/Mailbox";
+import * as Predicate from "effect/Predicate";
+
+import * as constants from "../shared/constants.ts";
+
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export const makeProtocolFrida = (
+    options?:
+        | {
+              /** Generates server listener rpc exports for individual clients. */
+              readonly generateExportName?: ((clientId: number) => string) | undefined;
+          }
+        | undefined
+): Effect.Effect<
+    {
+        readonly protocol: RpcServer.Protocol["Type"];
+        readonly rpcExport: () => Promise<number>;
+    },
+    never,
+    RpcSerialization.RpcSerialization
+> =>
+    Effect.gen(function* () {
+        const encoder = new TextEncoder();
+        const disconnects = yield* Mailbox.make<number>();
+        const serialization = yield* RpcSerialization.RpcSerialization;
+
+        let clientId = 0;
+        const clientIds = new Set<number>();
+        const clients = new Map<number, { readonly write: (bytes: RpcMessage.FromServerEncoded) => void }>();
+
+        let writeRequest!: (clientId: number, message: RpcMessage.FromClientEncoded) => Effect.Effect<void>;
+        const exportName = options?.generateExportName ?? constants.generateServerExportNameForClient;
+
+        // Listen for new clients on the main rpc export
+        const rpcExport = Effect.gen(function* () {
+            const id = clientId++;
+            const parser = serialization.unsafeMake();
+
+            const writeRaw = (data: string | Uint8Array): void => {
+                const transformed = typeof data === "string" ? encoder.encode(data) : data;
+                return send({ clientId: id }, (transformed as Uint8Array<ArrayBuffer>).buffer);
+            };
+            const write = (response: RpcMessage.FromServerEncoded): void => {
+                try {
+                    const encoded = parser.encode(response);
+                    if (Predicate.isNotUndefined(encoded)) return writeRaw(encoded);
+                } catch (cause) {
+                    const encoded = parser.encode(RpcMessage.ResponseDefectEncoded(cause))!;
+                    return writeRaw(encoded);
+                }
+            };
+
+            clientIds.add(id);
+            clients.set(id, { write });
+
+            const onMessage = (data: string | Uint8Array): Effect.Effect<void, never, never> => {
+                try {
+                    const decoded = parser.decode(data) as ReadonlyArray<RpcMessage.FromClientEncoded>;
+                    if (decoded.length === 0) return Effect.void;
+                    let i = 0;
+                    return Effect.whileLoop({
+                        while: () => i < decoded.length,
+                        body() {
+                            const message = decoded[i++];
+                            return writeRequest(id, message);
+                        },
+                        step: Function.constVoid,
+                    });
+                } catch (cause) {
+                    return Effect.sync(() => writeRaw(parser.encode(RpcMessage.ResponseDefectEncoded(cause))!));
+                }
+            };
+
+            rpc.exports[exportName(clientId)] = (data: string | Uint8Array): Promise<void> =>
+                Effect.runPromise(onMessage(data));
+
+            return clientId;
+        });
+
+        const protocol = yield* RpcServer.Protocol.make((writeRequest_) => {
+            writeRequest = writeRequest_;
+            return Effect.succeed({
+                disconnects,
+                send: (clientId, response) => {
+                    const client = clients.get(clientId);
+                    if (!client) return Effect.void;
+                    return Effect.sync(() => client.write(response));
+                },
+                end(clientId) {
+                    clientIds.delete(clientId); // TODO: Is this required?
+                    clients.delete(clientId); // TODO: Is this required?
+                    const exportName = options?.generateExportName ?? constants.generateServerExportNameForClient;
+                    delete rpc.exports[exportName(clientId)];
+                    return Effect.void;
+                },
+                clientIds: Effect.sync(() => clientIds),
+                initialMessage: Effect.succeedNone,
+                supportsAck: true,
+                supportsTransferables: false,
+                supportsSpanPropagation: true,
+            });
+        });
+
+        return {
+            protocol,
+            rpcExport: () => Effect.runPromise(rpcExport),
+        };
+    });
+
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export const makeProtocolFridaWithExport = (
+    options?:
+        | {
+              /**
+               * Name for the main rpc export that all clients start by
+               * connecting to.
+               */
+              readonly exportName?: string | undefined;
+
+              /** Generates server listener rpc exports for individual clients. */
+              readonly generateExportName?: ((clientId: number) => string) | undefined;
+          }
+        | undefined
+): Effect.Effect<RpcServer.Protocol["Type"], never, RpcSerialization.RpcSerialization> =>
+    Effect.gen(function* () {
+        const { protocol, rpcExport } = yield* makeProtocolFrida({ generateExportName: options?.generateExportName });
+        rpc.exports[options?.exportName ?? constants.defaultServerMainExportName] = rpcExport;
+        return protocol;
+    });
+
+/**
+ * @since 1.0.0
+ * @category Layer
+ */
+export const layerProtocolFrida = (
+    options?:
+        | {
+              /**
+               * Name for the main rpc export that all clients start by
+               * connecting to.
+               */
+              readonly exportName?: string | undefined;
+
+              /** Generates server listener rpc exports for individual clients. */
+              readonly generateExportName?: ((clientId: number) => string) | undefined;
+          }
+        | undefined
+): Layer.Layer<RpcServer.Protocol, never, RpcSerialization.RpcSerialization> =>
+    Layer.effect(RpcServer.Protocol, makeProtocolFridaWithExport(options));

package/src/frida/index.ts

@@ -0,0 +1,19 @@
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * Implements a Frida RPC client protocol for effect using the frida script
+ * exports.
+ *
+ * @since 1.0.0
+ */
+export * as FridaRpcClient from "./FridaRpcClient.ts"
+
+/**
+ * Implements a Frida RPC server protocol for effect using the frida script
+ * exports.
+ *
+ * @since 1.0.0
+ */
+export * as FridaRpcServer from "./FridaRpcServer.ts"

package/src/node/FridaRpcClient.ts

@@ -0,0 +1,120 @@
+/**
+ * Implements a Frida RPC client protocol for effect using the frida script
+ * exports.
+ *
+ * @since 1.0.0
+ */
+
+import type * as RpcMessage from "@effect/rpc/RpcMessage";
+import type * as FridaSessionError from "@efffrida/frida-tools/FridaSessionError";
+import type * as Scope from "effect/Scope";
+
+import * as RpcClient from "@effect/rpc/RpcClient";
+import * as RpcSerialization from "@effect/rpc/RpcSerialization";
+import * as FridaScript from "@efffrida/frida-tools/FridaScript";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as ParseResult from "effect/ParseResult";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+
+import * as shared from "../shared/constants.ts";
+
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export const makeProtocolFrida = (
+    options?: { readonly exportName?: string | undefined } | undefined
+): Effect.Effect<
+    RpcClient.Protocol["Type"],
+    FridaSessionError.FridaSessionError,
+    RpcSerialization.RpcSerialization | FridaScript.FridaScript | Scope.Scope
+> =>
+    RpcClient.Protocol.make(
+        Effect.fnUntraced(function* (writeResponse) {
+            const script = yield* FridaScript.FridaScript;
+            const serialization = yield* RpcSerialization.RpcSerialization;
+
+            const encoder = new TextEncoder();
+            const parser = serialization.unsafeMake();
+            const exportName = options?.exportName ?? shared.defaultServerMainExportName;
+
+            /**
+             * Obtain a client id from the frida script export, this will allow
+             * us to filter future messages for ours since the script channels
+             * are shared.
+             */
+            const clientId = yield* Effect.catchIf(
+                script.callExport(exportName, Schema.Number)(),
+                ParseResult.isParseError,
+                () => Effect.dieMessage("Failed to obtain client ID from Frida script export")
+            );
+
+            const isClientId = Predicate.compose(Predicate.isNumber, (id) => id === clientId);
+            const receivingPredicate = Predicate.compose(
+                Predicate.isUnknown,
+                Predicate.struct({ clientId: isClientId })
+            );
+
+            /**
+             * Start listening for responses to our requests, decode them, and
+             * send the responses back to the implementation.
+             */
+            yield* script.stream.pipe(
+                Stream.filterMap((unfiltered) => {
+                    if (receivingPredicate(unfiltered.message)) return unfiltered.data;
+                    else return Option.none<Buffer<ArrayBufferLike>>();
+                }),
+                Stream.runForEach((filtered) => {
+                    try {
+                        const responses = parser.decode(filtered) as Array<RpcMessage.FromServerEncoded>;
+                        if (responses.length === 0) return Effect.void;
+                        let i = 0;
+                        return Effect.whileLoop({
+                            while: () => i < responses.length,
+                            body: () => writeResponse(responses[i++]),
+                            step: Function.constVoid,
+                        });
+                    } catch (defect) {
+                        return writeResponse({ _tag: "Defect", defect });
+                    }
+                }),
+                Effect.interruptible,
+                Effect.forkScoped
+            );
+
+            /**
+             * Sending messages is as simple as encoding them, then posting them
+             * to the frida side tagged with our client id so it knows where to
+             * send them back to.
+             */
+            const send = Effect.fnUntraced(function* (message: RpcMessage.FromClientEncoded) {
+                const encoded = parser.encode(message);
+                if (Predicate.isUndefined(encoded)) return;
+                const transformed = typeof encoded === "string" ? encoder.encode(encoded) : encoded;
+                script.script.post({ clientId }, Buffer.from(transformed));
+            });
+
+            return {
+                send,
+                supportsAck: true,
+                supportsTransferables: false,
+            };
+        })
+    );
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerProtocolFrida = (
+    options?: { readonly exportName?: string | undefined } | undefined
+): Layer.Layer<
+    RpcClient.Protocol,
+    FridaSessionError.FridaSessionError,
+    RpcSerialization.RpcSerialization | FridaScript.FridaScript
+> => Layer.scoped(RpcClient.Protocol, makeProtocolFrida(options));

package/src/node/FridaRpcServer.ts

@@ -0,0 +1,134 @@
+/**
+ * Implements a Frida RPC server protocol for effect using the frida script
+ * exports.
+ *
+ * @since 1.0.0
+ */
+
+import type * as Scope from "effect/Scope";
+
+import * as RpcMessage from "@effect/rpc/RpcMessage";
+import * as RpcSerialization from "@effect/rpc/RpcSerialization";
+import * as RpcServer from "@effect/rpc/RpcServer";
+import * as FridaScript from "@efffrida/frida-tools/FridaScript";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Mailbox from "effect/Mailbox";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as String from "effect/String";
+import * as Tuple from "effect/Tuple";
+
+import * as constants from "../shared/constants.ts";
+import * as predicates from "../shared/predicates.ts";
+
+/**
+ * @since 1.0.0
+ * @category Protocol
+ */
+export const makeProtocolFrida = (): Effect.Effect<
+    unknown,
+    never,
+    FridaScript.FridaScript | RpcSerialization.RpcSerialization | Scope.Scope
+> =>
+    Effect.gen(function* () {
+        const encoder = new TextEncoder();
+        const script = yield* FridaScript.FridaScript;
+        const serialization = yield* RpcSerialization.RpcSerialization;
+
+        let clientId = 0;
+        const clientIds = new Set<number>();
+        const parser = serialization.unsafeMake();
+        const disconnects = yield* Mailbox.make<number>();
+
+        let writeRequest!: (clientId: number, message: RpcMessage.FromClientEncoded) => Effect.Effect<void>;
+
+        // Listen for new clients
+        yield* script.stream.pipe(
+            Stream.filterMap(({ message }) => {
+                if (predicates.newClientPredicate(message)) {
+                    const stripPrefix = String.replace(constants.nodeRpcClientConnectionRequestMessagePrefix, "");
+                    return Option.some(stripPrefix(message));
+                } else {
+                    return Option.none();
+                }
+            }),
+            Stream.runForEach((exportName) => {
+                const id = clientId++;
+                clientIds.add(id);
+                return script.callExport(exportName, Schema.Void)(clientId++);
+            }),
+            Stream.tapError(Console.error),
+            Stream.runDrain,
+            Effect.forkScoped
+        );
+
+        // Listen for messages from connected clients
+        yield* script.stream.pipe(
+            Stream.filterMap(({ data: maybeData, message }) => {
+                if (predicates.isTaggedForAnyClient(message)) {
+                    return Option.map(maybeData, (data) => Tuple.make(message.clientId, data));
+                } else {
+                    return Option.none();
+                }
+            }),
+            Stream.runForEach(([clientId, data]) => {
+                try {
+                    const decoded = parser.decode(data) as ReadonlyArray<RpcMessage.FromClientEncoded>;
+                    if (decoded.length === 0) return Effect.void;
+                    let i = 0;
+                    return Effect.whileLoop({
+                        while: () => i < decoded.length,
+                        body() {
+                            const message = decoded[i++];
+                            return writeRequest(clientId, message);
+                        },
+                        step: Function.constVoid,
+                    });
+                } catch (cause) {
+                    return Effect.sync(() => {
+                        const encoded = parser.encode(RpcMessage.ResponseDefectEncoded(cause))!;
+                        const transformed = typeof encoded === "string" ? encoder.encode(encoded) : encoded;
+                        script.script.post({ clientId }, Buffer.from(transformed));
+                    });
+                }
+            }),
+            Stream.tapError(Console.error),
+            Stream.runDrain,
+            Effect.forkScoped
+        );
+
+        return yield* RpcServer.Protocol.make((_writeRequest) => {
+            writeRequest = _writeRequest;
+            return Effect.succeed({
+                disconnects,
+                send: (clientId, response) => {
+                    const writeRaw = (data: string | Uint8Array) => {
+                        const transformed = typeof data === "string" ? encoder.encode(data) : data;
+                        script.script.post({ clientId }, Buffer.from(transformed));
+                        return Effect.void;
+                    };
+
+                    try {
+                        const encoded = parser.encode(response);
+                        if (Predicate.isNotUndefined(encoded)) return writeRaw(encoded);
+                        else return Effect.void;
+                    } catch (cause) {
+                        const encoded = parser.encode(RpcMessage.ResponseDefectEncoded(cause))!;
+                        return writeRaw(encoded);
+                    }
+                },
+                end(_clientId) {
+                    return Effect.void;
+                },
+                clientIds: Effect.sync(() => clientIds),
+                initialMessage: Effect.succeedNone,
+                supportsAck: true,
+                supportsTransferables: false,
+                supportsSpanPropagation: true,
+            });
+        });
+    });

package/src/node/index.ts

@@ -0,0 +1,19 @@
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * Implements a Frida RPC client protocol for effect using the frida script
+ * exports.
+ *
+ * @since 1.0.0
+ */
+export * as FridaRpcClient from "./FridaRpcClient.ts"
+
+/**
+ * Implements a Frida RPC server protocol for effect using the frida script
+ * exports.
+ *
+ * @since 1.0.0
+ */
+export * as FridaRpcServer from "./FridaRpcServer.ts"

package/src/shared/constants.ts

@@ -0,0 +1,11 @@
+export const defaultServerMainExportName = "rpc";
+export const generateServerExportNameForClient = (clientId: number): string =>
+    `@efffrida/rpc/FridaServerRpcListenerForClient/${clientId}`;
+
+let exportIdForClientCallback: number = 0;
+export const generateClientCallbackExportNameForServer = (): string =>
+    `@efffrida/rpc/FridaClientRpcCallback/${exportIdForClientCallback++}`;
+
+export const nodeRpcClientConnectionRequestMessagePrefix = "client id request message";
+export const nodeRpcClientMakeConnectionRequestForServer = (exportName: string) =>
+    `${nodeRpcClientConnectionRequestMessagePrefix}:${exportName}`;

package/src/shared/predicates.ts

@@ -0,0 +1,19 @@
+import * as Predicate from "effect/Predicate";
+import * as String from "effect/String";
+
+import * as constants from "./constants.ts";
+
+export const isClientId = (clientId: number) => Predicate.compose(Predicate.isNumber, (id) => id === clientId);
+
+export const isTaggedForClient = (clientId: number) =>
+    Predicate.compose(Predicate.isUnknown, Predicate.struct({ clientId: isClientId(clientId) }));
+
+export const isTaggedForAnyClient = Predicate.compose(
+    Predicate.isUnknown,
+    Predicate.struct({ clientId: Predicate.isNumber })
+);
+
+export const newClientPredicate = Predicate.compose(
+    Predicate.isString,
+    String.startsWith(constants.nodeRpcClientConnectionRequestMessagePrefix)
+);

package/FridaRpcClient/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/FridaRpcClient.js",
-  "module": "../dist/esm/FridaRpcClient.js",
-  "types": "../dist/dts/FridaRpcClient.d.ts"
-}

package/FridaRpcServer/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/FridaRpcServer.js",
-  "module": "../dist/esm/FridaRpcServer.js",
-  "types": "../dist/dts/FridaRpcServer.d.ts"
-}

package/dist/cjs/FridaRpcClient.js

@@ -1,77 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeProtocolFrida = exports.layerProtocolFrida = void 0;
-var RpcClient = _interopRequireWildcard(require("@effect/rpc/RpcClient"));
-var RpcSerialization = _interopRequireWildcard(require("@effect/rpc/RpcSerialization"));
-var FridaScript = _interopRequireWildcard(require("@efffrida/frida-tools/FridaScript"));
-var Effect = _interopRequireWildcard(require("effect/Effect"));
-var Function = _interopRequireWildcard(require("effect/Function"));
-var Layer = _interopRequireWildcard(require("effect/Layer"));
-var Predicate = _interopRequireWildcard(require("effect/Predicate"));
-var Schema = _interopRequireWildcard(require("effect/Schema"));
-var Stream = _interopRequireWildcard(require("effect/Stream"));
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-/**
- * Implements a Frida RPC client protocol for effect using the frida script
- * exports. The reason we don't use the send/recv script channels is because
- * those are shared channels by everybody.
- *
- * @since 1.0.0
- */
-
-/**
- * @since 1.0.0
- * @category Protocol
- */
-const makeProtocolFrida = (script, options) => RpcClient.Protocol.make(Effect.fnUntraced(function* (writeResponse) {
-  const serialization = yield* RpcSerialization.RpcSerialization;
-  const exportName = options?.exportName ?? "rpc";
-  const rpcIsAvailableWhen = options?.rpcIsAvailableWhen;
-  const send = request => {
-    if (request._tag !== "Request") {
-      return Effect.void;
-    }
-    const parser = serialization.unsafeMake();
-    const schema = Schema.Union(Schema.String, Schema.Uint8Array);
-    const encode = Function.compose(parser.encode, Schema.encode(schema));
-    const decode = Function.compose(Schema.decodeUnknownSync(schema), parser.decode);
-    return encode(request).pipe(Effect.flatMap(script.callExport(exportName))).pipe(Effect.orDie).pipe(Effect.flatMap(incoming => {
-      try {
-        const responses = decode(incoming);
-        if (responses.length === 0) return Effect.void;
-        let i = 0;
-        return Effect.whileLoop({
-          while: () => i < responses.length,
-          body: () => writeResponse(responses[i++]),
-          step: Function.constVoid
-        });
-      } catch (defect) {
-        return writeResponse({
-          _tag: "Defect",
-          defect
-        });
-      }
-    }));
-  };
-  if (Predicate.isNotUndefined(rpcIsAvailableWhen)) {
-    yield* script.stream.pipe(Stream.map(({
-      message
-    }) => message)).pipe(Stream.filter(Predicate.isString)).pipe(Stream.takeUntil(rpcIsAvailableWhen)).pipe(Stream.runDrain);
-  }
-  return {
-    send,
-    supportsAck: false,
-    supportsTransferables: false
-  };
-}));
-/**
- * @since 1.0.0
- * @category Layers
- */
-exports.makeProtocolFrida = makeProtocolFrida;
-const layerProtocolFrida = options => Layer.effect(RpcClient.Protocol, Effect.flatMap(FridaScript.FridaScript, script => makeProtocolFrida(script, options)));
-exports.layerProtocolFrida = layerProtocolFrida;
-//# sourceMappingURL=FridaRpcClient.js.map

package/dist/cjs/FridaRpcClient.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FridaRpcClient.js","names":["RpcClient","_interopRequireWildcard","require","RpcSerialization","FridaScript","Effect","Function","Layer","Predicate","Schema","Stream","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","makeProtocolFrida","script","options","Protocol","make","fnUntraced","writeResponse","serialization","exportName","rpcIsAvailableWhen","send","request","_tag","void","parser","unsafeMake","schema","Union","String","Uint8Array","encode","compose","decode","decodeUnknownSync","pipe","flatMap","callExport","orDie","incoming","responses","length","whileLoop","while","body","step","constVoid","defect","isNotUndefined","stream","map","message","filter","isString","takeUntil","runDrain","supportsAck","supportsTransferables","exports","layerProtocolFrida","effect"],"sources":["../../src/FridaRpcClient.ts"],"sourcesContent":[null],"mappings":";;;;;;AAWA,IAAAA,SAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAF,uBAAA,CAAAC,OAAA;AACA,IAAAE,WAAA,GAAAH,uBAAA,CAAAC,OAAA;AACA,IAAAG,MAAA,GAAAJ,uBAAA,CAAAC,OAAA;AACA,IAAAI,QAAA,GAAAL,uBAAA,CAAAC,OAAA;AACA,IAAAK,KAAA,GAAAN,uBAAA,CAAAC,OAAA;AACA,IAAAM,SAAA,GAAAP,uBAAA,CAAAC,OAAA;AACA,IAAAO,MAAA,GAAAR,uBAAA,CAAAC,OAAA;AACA,IAAAQ,MAAA,GAAAT,uBAAA,CAAAC,OAAA;AAAuC,SAAAD,wBAAAU,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAZ,uBAAA,YAAAA,CAAAU,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAnBvC;;;;;;;;AAqBA;;;;AAIO,MAAMkB,iBAAiB,GAAGA,CAC7BC,MAA+B,EAC/BC,OAKe,KAEfhC,SAAS,CAACiC,QAAQ,CAACC,IAAI,CACnB7B,MAAM,CAAC8B,UAAU,CAAC,WAAWC,aAAa;EACtC,MAAMC,aAAa,GAAG,OAAOlC,gBAAgB,CAACA,gBAAgB;EAC9D,MAAMmC,UAAU,GAAGN,OAAO,EAAEM,UAAU,IAAI,KAAK;EAC/C,MAAMC,kBAAkB,GAAGP,OAAO,EAAEO,kBAAkB;EAEtD,MAAMC,IAAI,GAAIC,OAAqC,IAAyB;IACxE,IAAIA,OAAO,CAACC,IAAI,KAAK,SAAS,EAAE;MAC5B,OAAOrC,MAAM,CAACsC,IAAI;IACtB;IAEA,MAAMC,MAAM,GAAGP,aAAa,CAACQ,UAAU,EAAE;IACzC,MAAMC,MAAM,GAAGrC,MAAM,CAACsC,KAAK,CAACtC,MAAM,CAACuC,MAAM,EAAEvC,MAAM,CAACwC,UAAU,CAAC;IAC7D,MAAMC,MAAM,GAAG5C,QAAQ,CAAC6C,OAAO,CAACP,MAAM,CAACM,MAAM,EAAEzC,MAAM,CAACyC,MAAM,CAACJ,MAAM,CAAC,CAAC;IACrE,MAAMM,MAAM,GAAG9C,QAAQ,CAAC6C,OAAO,CAAC1C,MAAM,CAAC4C,iBAAiB,CAACP,MAAM,CAAC,EAAEF,MAAM,CAACQ,MAAM,CAAC;IAEhF,OAAOF,MAAM,CAACT,OAAO,CAAC,CACjBa,IAAI,CAACjD,MAAM,CAACkD,OAAO,CAACxB,MAAM,CAACyB,UAAU,CAAClB,UAAU,CAAC,CAAC,CAAC,CACnDgB,IAAI,CAACjD,MAAM,CAACoD,KAAK,CAAC,CAClBH,IAAI,CACDjD,MAAM,CAACkD,OAAO,CAAEG,QAAQ,IAAI;MACxB,IAAI;QACA,MAAMC,SAAS,GAAGP,MAAM,CAACM,QAAQ,CAAwC;QACzE,IAAIC,SAAS,CAACC,MAAM,KAAK,CAAC,EAAE,OAAOvD,MAAM,CAACsC,IAAI;QAC9C,IAAIzB,CAAC,GAAG,CAAC;QACT,OAAOb,MAAM,CAACwD,SAAS,CAAC;UACpBC,KAAK,EAAEA,CAAA,KAAM5C,CAAC,GAAGyC,SAAS,CAACC,MAAM;UACjCG,IAAI,EAAEA,CAAA,KAAM3B,aAAa,CAACuB,SAAS,CAACzC,CAAC,EAAE,CAAC,CAAC;UACzC8C,IAAI,EAAE1D,QAAQ,CAAC2D;SAClB,CAAC;MACN,CAAC,CAAC,OAAOC,MAAM,EAAE;QACb,OAAO9B,aAAa,CAAC;UAAEM,IAAI,EAAE,QAAQ;UAAEwB;QAAM,CAAE,CAAC;MACpD;IACJ,CAAC,CAAC,CACL;EACT,CAAC;EAED,IAAI1D,SAAS,CAAC2D,cAAc,CAAC5B,kBAAkB,CAAC,EAAE;IAC9C,OAAOR,MAAM,CAACqC,MAAM,CACfd,IAAI,CAAC5C,MAAM,CAAC2D,GAAG,CAAC,CAAC;MAAEC;IAAO,CAAE,KAAKA,OAAO,CAAC,CAAC,CAC1ChB,IAAI,CAAC5C,MAAM,CAAC6D,MAAM,CAAC/D,SAAS,CAACgE,QAAQ,CAAC,CAAC,CACvClB,IAAI,CAAC5C,MAAM,CAAC+D,SAAS,CAAClC,kBAAkB,CAAC,CAAC,CAC1Ce,IAAI,CAAC5C,MAAM,CAACgE,QAAQ,CAAC;EAC9B;EAEA,OAAO;IACHlC,IAAI;IACJmC,WAAW,EAAE,KAAK;IAClBC,qBAAqB,EAAE;GAC1B;AACL,CAAC,CAAC,CACL;AAEL;;;;AAAAC,OAAA,CAAA/C,iBAAA,GAAAA,iBAAA;AAIO,MAAMgD,kBAAkB,GAC3B9C,OAKe,IAMfzB,KAAK,CAACwE,MAAM,CACR/E,SAAS,CAACiC,QAAQ,EAClB5B,MAAM,CAACkD,OAAO,CAACnD,WAAW,CAACA,WAAW,EAAG2B,MAAM,IAAKD,iBAAiB,CAACC,MAAM,EAAEC,OAAO,CAAC,CAAC,CAC1F;AAAA6C,OAAA,CAAAC,kBAAA,GAAAA,kBAAA","ignoreList":[]}