request-iframe 0.0.1

package/library/core/server.js

@@ -0,0 +1,338 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RequestIframeServerImpl = void 0;
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/es.object.entries.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _utils = require("../utils");
+var _pathMatch = require("../utils/path-match");
+var _request = require("./request");
+var _response = require("./response");
+var _message = require("../message");
+var _cache = require("../utils/cache");
+var _constants = require("../constants");
+/**
+ * Middleware item (contains path matcher and middleware function)
+ */
+
+/**
+ * Pending acknowledgment
+ */
+
+/**
+ * Server configuration options
+ */
+
+/**
+ * RequestIframeServer implementation
+ * Uses shared MessageDispatcher (backed by MessageChannel) to listen for and send messages
+ */
+class RequestIframeServerImpl {
+  constructor(options) {
+    var _options$ackTimeout, _options$versionValid;
+    (0, _defineProperty2.default)(this, "handlers", new Map());
+    (0, _defineProperty2.default)(this, "middlewares", []);
+    /** Responses waiting for client acknowledgment */
+    (0, _defineProperty2.default)(this, "pendingAcks", new Map());
+    /** List of functions to unregister handlers */
+    (0, _defineProperty2.default)(this, "unregisterFns", []);
+    /** Whether it is open */
+    (0, _defineProperty2.default)(this, "_isOpen", false);
+    this.ackTimeout = (_options$ackTimeout = options === null || options === void 0 ? void 0 : options.ackTimeout) !== null && _options$ackTimeout !== void 0 ? _options$ackTimeout : _constants.DefaultTimeout.SERVER_ACK;
+    this.versionValidator = (_options$versionValid = options === null || options === void 0 ? void 0 : options.versionValidator) !== null && _options$versionValid !== void 0 ? _options$versionValid : _utils.isCompatibleVersion;
+
+    // Get or create shared channel and create dispatcher
+    var channel = (0, _cache.getOrCreateMessageChannel)(options === null || options === void 0 ? void 0 : options.secretKey);
+    this.dispatcher = new _message.MessageDispatcher(channel);
+
+    // Auto-open by default
+    this.open();
+  }
+
+  /**
+   * Open message processing (register message handlers)
+   */
+  open() {
+    if (this._isOpen) return;
+    this._isOpen = true;
+    this.registerHandlers();
+  }
+
+  /**
+   * Close message processing (unregister message handlers, but don't release channel)
+   */
+  close() {
+    if (!this._isOpen) return;
+    this._isOpen = false;
+
+    // Unregister all handlers
+    this.unregisterFns.forEach(fn => fn());
+    this.unregisterFns.length = 0;
+  }
+
+  /**
+   * Whether it is open
+   */
+  get isOpen() {
+    return this._isOpen;
+  }
+
+  /**
+   * Register message handlers
+   */
+  registerHandlers() {
+    var handlerOptions = {
+      versionValidator: this.versionValidator,
+      onVersionError: this.handleVersionError.bind(this)
+    };
+
+    // Handle REQUEST messages
+    this.unregisterFns.push(this.dispatcher.registerHandler(_constants.MessageType.REQUEST, (data, context) => this.handleRequest(data, context), handlerOptions));
+
+    // Handle PING messages
+    this.unregisterFns.push(this.dispatcher.registerHandler(_constants.MessageType.PING, (data, context) => this.handlePing(data, context), handlerOptions));
+
+    // Handle RECEIVED messages (for confirming response delivery)
+    this.unregisterFns.push(this.dispatcher.registerHandler(_constants.MessageType.RECEIVED, data => this.handleReceived(data), handlerOptions));
+  }
+
+  /**
+   * Handle protocol version error
+   */
+  handleVersionError(data, context, version) {
+    if (!context.source) return;
+
+    // Send protocol version incompatibility error
+    this.dispatcher.sendMessage(context.source, context.origin, _constants.MessageType.ERROR, data.requestId, {
+      path: data.path,
+      status: _constants.HttpStatus.BAD_REQUEST,
+      statusText: _constants.Messages.PROTOCOL_VERSION_UNSUPPORTED,
+      error: {
+        message: (0, _constants.formatMessage)(_constants.Messages.PROTOCOL_VERSION_TOO_LOW, version, _constants.ProtocolVersion.MIN_SUPPORTED),
+        code: _constants.ErrorCode.PROTOCOL_UNSUPPORTED
+      }
+    });
+  }
+
+  /**
+   * Handle ping message
+   */
+  handlePing(data, context) {
+    if (!context.source) return;
+    this.dispatcher.sendMessage(context.source, context.origin, _constants.MessageType.PONG, data.requestId);
+  }
+
+  /**
+   * Handle received acknowledgment
+   */
+  handleReceived(data) {
+    var pending = this.pendingAcks.get(data.requestId);
+    if (pending) {
+      clearTimeout(pending.timeoutId);
+      this.pendingAcks.delete(data.requestId);
+      pending.resolve(true);
+    }
+  }
+
+  /** Get secretKey */
+  get secretKey() {
+    return this.dispatcher.secretKey;
+  }
+
+  /** Get the underlying MessageDispatcher */
+  get messageDispatcher() {
+    return this.dispatcher;
+  }
+
+  /**
+   * Handle request
+   */
+  handleRequest(data, context) {
+    if (!data.path) return;
+    if (!context.source) return;
+    var targetWindow = context.source;
+    var targetOrigin = context.origin;
+
+    // Send ACK immediately via dispatcher
+    this.dispatcher.sendMessage(targetWindow, targetOrigin, _constants.MessageType.ACK, data.requestId, {
+      path: data.path
+    });
+    var handlerFn = this.handlers.get(data.path);
+    if (!handlerFn) {
+      this.dispatcher.sendMessage(targetWindow, targetOrigin, _constants.MessageType.ERROR, data.requestId, {
+        path: data.path,
+        error: {
+          message: _constants.Messages.METHOD_NOT_FOUND,
+          code: _constants.ErrorCode.METHOD_NOT_FOUND
+        },
+        status: _constants.HttpStatus.NOT_FOUND,
+        statusText: _constants.HttpStatusText[_constants.HttpStatus.NOT_FOUND]
+      });
+      return;
+    }
+
+    // Create response object with channel reference
+    var res = new _response.ServerResponseImpl(data.requestId, data.path || '', data.secretKey, targetWindow, targetOrigin, this.dispatcher.getChannel());
+
+    // Register callback waiting for client acknowledgment
+    this.registerPendingAck(data.requestId, received => {
+      res._triggerAck(received);
+    }, () => {
+      res._triggerAck(false);
+    });
+
+    // Create request object
+    var req = new _request.ServerRequestImpl(data, context, res);
+
+    // Execute middleware chain
+    this.runMiddlewares(req, res, () => {
+      var result = handlerFn(req, res);
+      if (result instanceof Promise) {
+        // Async task
+        this.dispatcher.sendMessage(targetWindow, targetOrigin, _constants.MessageType.ASYNC, data.requestId, {
+          path: data.path
+        });
+        result.then(value => {
+          if (!res._sent && value !== undefined) {
+            res.send(value);
+          } else if (!res._sent) {
+            this.dispatcher.sendMessage(targetWindow, targetOrigin, _constants.MessageType.ERROR, data.requestId, {
+              path: data.path,
+              error: {
+                message: _constants.Messages.NO_RESPONSE_SENT,
+                code: _constants.ErrorCode.NO_RESPONSE
+              },
+              status: _constants.HttpStatus.INTERNAL_SERVER_ERROR,
+              statusText: _constants.HttpStatusText[_constants.HttpStatus.INTERNAL_SERVER_ERROR],
+              headers: res.headers
+            });
+          }
+        }).catch(err => {
+          if (!res._sent) {
+            this.dispatcher.sendMessage(targetWindow, targetOrigin, _constants.MessageType.ERROR, data.requestId, {
+              path: data.path,
+              error: {
+                message: err && err.message || _constants.Messages.REQUEST_FAILED,
+                code: err && err.code || _constants.ErrorCode.REQUEST_ERROR
+              },
+              status: res.statusCode || _constants.HttpStatus.INTERNAL_SERVER_ERROR,
+              statusText: _constants.HttpStatusText[_constants.HttpStatus.INTERNAL_SERVER_ERROR],
+              headers: res.headers
+            });
+          }
+        });
+      } else {
+        // Synchronous processing
+        if (!res._sent && result !== undefined) {
+          res.send(result);
+        }
+      }
+    });
+  }
+
+  /**
+   * Register pending acknowledgment response
+   */
+  registerPendingAck(requestId, resolve, reject) {
+    var timeoutId = setTimeout(() => {
+      this.pendingAcks.delete(requestId);
+      resolve(false);
+    }, this.ackTimeout);
+    this.pendingAcks.set(requestId, {
+      resolve,
+      reject,
+      timeoutId
+    });
+  }
+  use(pathOrMiddleware, middleware) {
+    if (typeof pathOrMiddleware === 'function') {
+      this.middlewares.push({
+        matcher: null,
+        middleware: pathOrMiddleware
+      });
+    } else if (middleware) {
+      this.middlewares.push({
+        matcher: pathOrMiddleware,
+        middleware
+      });
+    }
+  }
+  on(path, handler) {
+    this.handlers.set(this.dispatcher.prefixPath(path), handler);
+  }
+  runMiddlewares(req, res, finalHandler) {
+    var path = req.path;
+    var index = 0;
+    var next = () => {
+      if (res._sent) {
+        return;
+      }
+      while (index < this.middlewares.length) {
+        var item = this.middlewares[index++];
+        if (item.matcher === null || (0, _pathMatch.matchPath)(path, item.matcher)) {
+          try {
+            var result = item.middleware(req, res, next);
+            if (result instanceof Promise) {
+              result.catch(err => {
+                if (!res._sent) {
+                  res.status(_constants.HttpStatus.INTERNAL_SERVER_ERROR).send({
+                    error: err.message || _constants.Messages.MIDDLEWARE_ERROR
+                  });
+                }
+              });
+            }
+            return;
+          } catch (err) {
+            if (!res._sent) {
+              res.status(_constants.HttpStatus.INTERNAL_SERVER_ERROR).send({
+                error: (err === null || err === void 0 ? void 0 : err.message) || _constants.Messages.MIDDLEWARE_ERROR
+              });
+            }
+            return;
+          }
+        }
+      }
+      if (index >= this.middlewares.length) {
+        finalHandler();
+      }
+    };
+    next();
+  }
+  off(path) {
+    this.handlers.delete(this.dispatcher.prefixPath(path));
+  }
+  map(handlers) {
+    Object.entries(handlers).forEach(([path, h]) => {
+      this.on(path, h);
+    });
+  }
+
+  /**
+   * Destroy (close and release channel reference)
+   */
+  destroy() {
+    // Close first
+    this.close();
+
+    // Clean up pending
+    this.pendingAcks.forEach(pending => clearTimeout(pending.timeoutId));
+    this.pendingAcks.clear();
+
+    // Clean up handlers
+    this.handlers.clear();
+    this.middlewares.length = 0;
+
+    // Destroy dispatcher and release channel reference
+    this.dispatcher.destroy();
+    (0, _cache.releaseMessageChannel)(this.dispatcher.getChannel());
+  }
+}
+exports.RequestIframeServerImpl = RequestIframeServerImpl;

package/library/index.d.ts

@@ -0,0 +1,16 @@
+export { requestIframeClient, clearRequestIframeClientCache } from './api/client';
+export { requestIframeServer, clearRequestIframeServerCache } from './api/server';
+export { RequestIframeClientImpl } from './core/client';
+export { RequestIframeServerImpl } from './core/server';
+export { RequestIframeClientServer } from './core/server-client';
+export { MessageChannel, ChannelType, MessageDispatcher } from './message';
+export type { MessageContext, MessageHandlerFn, MessageTypeMatcher, VersionValidator, HandlerOptions, ChannelType as ChannelTypeValue } from './message';
+export { getOrCreateMessageChannel, releaseMessageChannel, clearMessageChannelCache, } from './utils/cache';
+export { ServerRequestImpl } from './core/request';
+export { ServerResponseImpl } from './core/response';
+export { IframeWritableStream, IframeReadableStream, IframeFileWritableStream, IframeFileReadableStream, isIframeReadableStream, isIframeFileStream } from './stream';
+export type { StreamType, StreamState, StreamChunk, WritableStreamOptions, ReadableStreamOptions, FileWritableStreamOptions, FileReadableStreamOptions, StreamBindContext, IIframeWritableStream, IIframeReadableStream, IIframeFileReadableStream, StreamMessageData } from './stream';
+export * from './types';
+export { InterceptorManager, RequestInterceptorManager, ResponseInterceptorManager } from './interceptors';
+export * from './constants';
+//# sourceMappingURL=index.d.ts.map

package/library/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAClF,OAAO,EAAE,mBAAmB,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAElF,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAEjE,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC3E,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,WAAW,IAAI,gBAAgB,EAChC,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,yBAAyB,EACzB,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACxB,wBAAwB,EACxB,sBAAsB,EACtB,kBAAkB,EACnB,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAElB,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAE3G,cAAc,aAAa,CAAC"}

package/library/index.js

@@ -0,0 +1,211 @@
+"use strict";
+
+require("core-js/modules/web.dom-collections.for-each.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  requestIframeClient: true,
+  clearRequestIframeClientCache: true,
+  requestIframeServer: true,
+  clearRequestIframeServerCache: true,
+  RequestIframeClientImpl: true,
+  RequestIframeServerImpl: true,
+  RequestIframeClientServer: true,
+  MessageChannel: true,
+  ChannelType: true,
+  MessageDispatcher: true,
+  getOrCreateMessageChannel: true,
+  releaseMessageChannel: true,
+  clearMessageChannelCache: true,
+  ServerRequestImpl: true,
+  ServerResponseImpl: true,
+  IframeWritableStream: true,
+  IframeReadableStream: true,
+  IframeFileWritableStream: true,
+  IframeFileReadableStream: true,
+  isIframeReadableStream: true,
+  isIframeFileStream: true,
+  InterceptorManager: true,
+  RequestInterceptorManager: true,
+  ResponseInterceptorManager: true
+};
+Object.defineProperty(exports, "ChannelType", {
+  enumerable: true,
+  get: function get() {
+    return _message.ChannelType;
+  }
+});
+Object.defineProperty(exports, "IframeFileReadableStream", {
+  enumerable: true,
+  get: function get() {
+    return _stream.IframeFileReadableStream;
+  }
+});
+Object.defineProperty(exports, "IframeFileWritableStream", {
+  enumerable: true,
+  get: function get() {
+    return _stream.IframeFileWritableStream;
+  }
+});
+Object.defineProperty(exports, "IframeReadableStream", {
+  enumerable: true,
+  get: function get() {
+    return _stream.IframeReadableStream;
+  }
+});
+Object.defineProperty(exports, "IframeWritableStream", {
+  enumerable: true,
+  get: function get() {
+    return _stream.IframeWritableStream;
+  }
+});
+Object.defineProperty(exports, "InterceptorManager", {
+  enumerable: true,
+  get: function get() {
+    return _interceptors.InterceptorManager;
+  }
+});
+Object.defineProperty(exports, "MessageChannel", {
+  enumerable: true,
+  get: function get() {
+    return _message.MessageChannel;
+  }
+});
+Object.defineProperty(exports, "MessageDispatcher", {
+  enumerable: true,
+  get: function get() {
+    return _message.MessageDispatcher;
+  }
+});
+Object.defineProperty(exports, "RequestIframeClientImpl", {
+  enumerable: true,
+  get: function get() {
+    return _client2.RequestIframeClientImpl;
+  }
+});
+Object.defineProperty(exports, "RequestIframeClientServer", {
+  enumerable: true,
+  get: function get() {
+    return _serverClient.RequestIframeClientServer;
+  }
+});
+Object.defineProperty(exports, "RequestIframeServerImpl", {
+  enumerable: true,
+  get: function get() {
+    return _server2.RequestIframeServerImpl;
+  }
+});
+Object.defineProperty(exports, "RequestInterceptorManager", {
+  enumerable: true,
+  get: function get() {
+    return _interceptors.RequestInterceptorManager;
+  }
+});
+Object.defineProperty(exports, "ResponseInterceptorManager", {
+  enumerable: true,
+  get: function get() {
+    return _interceptors.ResponseInterceptorManager;
+  }
+});
+Object.defineProperty(exports, "ServerRequestImpl", {
+  enumerable: true,
+  get: function get() {
+    return _request.ServerRequestImpl;
+  }
+});
+Object.defineProperty(exports, "ServerResponseImpl", {
+  enumerable: true,
+  get: function get() {
+    return _response.ServerResponseImpl;
+  }
+});
+Object.defineProperty(exports, "clearMessageChannelCache", {
+  enumerable: true,
+  get: function get() {
+    return _cache.clearMessageChannelCache;
+  }
+});
+Object.defineProperty(exports, "clearRequestIframeClientCache", {
+  enumerable: true,
+  get: function get() {
+    return _client.clearRequestIframeClientCache;
+  }
+});
+Object.defineProperty(exports, "clearRequestIframeServerCache", {
+  enumerable: true,
+  get: function get() {
+    return _server.clearRequestIframeServerCache;
+  }
+});
+Object.defineProperty(exports, "getOrCreateMessageChannel", {
+  enumerable: true,
+  get: function get() {
+    return _cache.getOrCreateMessageChannel;
+  }
+});
+Object.defineProperty(exports, "isIframeFileStream", {
+  enumerable: true,
+  get: function get() {
+    return _stream.isIframeFileStream;
+  }
+});
+Object.defineProperty(exports, "isIframeReadableStream", {
+  enumerable: true,
+  get: function get() {
+    return _stream.isIframeReadableStream;
+  }
+});
+Object.defineProperty(exports, "releaseMessageChannel", {
+  enumerable: true,
+  get: function get() {
+    return _cache.releaseMessageChannel;
+  }
+});
+Object.defineProperty(exports, "requestIframeClient", {
+  enumerable: true,
+  get: function get() {
+    return _client.requestIframeClient;
+  }
+});
+Object.defineProperty(exports, "requestIframeServer", {
+  enumerable: true,
+  get: function get() {
+    return _server.requestIframeServer;
+  }
+});
+var _client = require("./api/client");
+var _server = require("./api/server");
+var _client2 = require("./core/client");
+var _server2 = require("./core/server");
+var _serverClient = require("./core/server-client");
+var _message = require("./message");
+var _cache = require("./utils/cache");
+var _request = require("./core/request");
+var _response = require("./core/response");
+var _stream = require("./stream");
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _types[key];
+    }
+  });
+});
+var _interceptors = require("./interceptors");
+var _constants = require("./constants");
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _constants[key];
+    }
+  });
+});

package/library/interceptors/index.d.ts

@@ -0,0 +1,41 @@
+import { RequestConfig, Response, InterceptorFunction } from '../types';
+/**
+ * Interceptor manager
+ */
+export declare class InterceptorManager<T> {
+    private handlers;
+    /**
+     * Add interceptor
+     */
+    use(fulfilled: InterceptorFunction<T>, rejected?: (error: any) => any): number;
+    /**
+     * Remove interceptor
+     */
+    eject(id: number): void;
+    /**
+     * Iterate over all interceptors
+     */
+    forEach(fn: (handler: {
+        fulfilled: InterceptorFunction<T>;
+        rejected?: (error: any) => any;
+    }) => void): void;
+}
+/**
+ * Request interceptor manager
+ */
+export declare class RequestInterceptorManager extends InterceptorManager<RequestConfig> {
+}
+/**
+ * Response interceptor manager
+ */
+export declare class ResponseInterceptorManager extends InterceptorManager<Response> {
+}
+/**
+ * Execute request interceptor chain
+ */
+export declare function runRequestInterceptors(interceptors: RequestInterceptorManager, config: RequestConfig): Promise<RequestConfig>;
+/**
+ * Execute response interceptor chain
+ */
+export declare function runResponseInterceptors(interceptors: ResponseInterceptorManager, response: Response): Promise<Response>;
+//# sourceMappingURL=index.d.ts.map

package/library/interceptors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interceptors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,QAAQ,EACR,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAElB;;GAEG;AACH,qBAAa,kBAAkB,CAAC,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAGR;IAER;;OAEG;IACH,GAAG,CACD,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC,EACjC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,GAC7B,MAAM;IAKT;;OAEG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAMvB;;OAEG;IACH,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE;QAAE,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC;QAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAA;KAAE,KAAK,IAAI,GAAG,IAAI;CAO5G;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,kBAAkB,CAAC,aAAa,CAAC;CAAG;AAEnF;;GAEG;AACH,qBAAa,0BAA2B,SAAQ,kBAAkB,CAAC,QAAQ,CAAC;CAAG;AAE/E;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,YAAY,EAAE,yBAAyB,EACvC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,aAAa,CAAC,CAgBxB;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,YAAY,EAAE,0BAA0B,EACxC,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,QAAQ,CAAC,CAgBnB"}